@adonisjs/http-server 7.0.0-0 → 7.0.0-1

package/build/chunk-XX72ATFY.js

@@ -1,4388 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/router/route.ts
-import is from "@sindresorhus/is";
-import Macroable4 from "@poppinss/macroable";
-import Middleware from "@poppinss/middleware";
-import { RuntimeException as RuntimeException2 } from "@poppinss/utils";
-import { moduleCaller, moduleExpression, moduleImporter } from "@adonisjs/fold";
-
-// src/router/factories/use_return_value.ts
-function useReturnValue(ctx) {
-  return function(value) {
-    if (value !== void 0 && // Return value is explicitly defined
-    !ctx.response.hasLazyBody && // Lazy body is not set
-    value !== ctx.response) {
-      ctx.response.send(value);
-    }
-  };
-}
-
-// src/router/executor.ts
-function execute(route, resolver, ctx, errorResponder) {
-  return route.middleware.runner().errorHandler((error) => errorResponder(error, ctx)).finalHandler(async () => {
-    if (typeof route.handler === "function") {
-      return Promise.resolve(route.handler(ctx)).then(useReturnValue(ctx));
-    }
-    return route.handler.handle(resolver, ctx).then(useReturnValue(ctx));
-  }).run(async (middleware, next) => {
-    if (typeof middleware === "function") {
-      return middleware(ctx, next);
-    }
-    return middleware.handle(resolver, ctx, next, middleware.args);
-  });
-}
-
-// src/helpers.ts
-import Cache from "tmp-cache";
-import { InvalidArgumentsException } from "@poppinss/utils";
-
-// src/router/brisk.ts
-import Macroable from "@poppinss/macroable";
-var BriskRoute = class extends Macroable {
-  /**
-   * 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;
-  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
-   */
-  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.
-   */
-  redirect(identifier, params, options) {
-    return this.setHandler(async function redirectsToRoute(ctx) {
-      const redirector = ctx.response.redirect();
-      if (options?.status) {
-        redirector.status(options.status);
-      }
-      return redirector.toRoute(identifier, params || ctx.params, options);
-    });
-  }
-  /**
-   * Redirect request to a fixed URL
-   */
-  redirectToPath(url, options) {
-    return this.setHandler(async function redirectsToPath(ctx) {
-      const redirector = ctx.response.redirect();
-      if (options?.status) {
-        redirector.status(options.status);
-      }
-      return redirector.toPath(url);
-    });
-  }
-};
-
-// src/router/group.ts
-import Macroable3 from "@poppinss/macroable";
-
-// src/router/resource.ts
-import string from "@poppinss/utils/string";
-import Macroable2 from "@poppinss/macroable";
-import { RuntimeException } from "@poppinss/utils";
-var RouteResource = class extends Macroable2 {
-  /**
-   * 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 = [];
-  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 RuntimeException(`Invalid resource name "${resource}"`);
-    }
-  }
-  /**
-   * Converting segments of a resource to snake case to
-   * make the route name.
-   */
-  #getRoutesBaseName() {
-    return this.#resource.split(".").map((token) => string.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 `${string.snakeCase(string.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
-   */
-  only(names) {
-    this.#filter(names, true).forEach((route) => route.markAsDeleted());
-    return this;
-  }
-  /**
-   * Register all routes, except the one's defined
-   */
-  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
-   */
-  apiOnly() {
-    return this.except(["create", "edit"]);
-  }
-  /**
-   * Define matcher for params inside the resource
-   */
-  where(key, matcher) {
-    this.routes.forEach((route) => {
-      route.where(key, matcher);
-    });
-    return this;
-  }
-  tap(actions, callback) {
-    if (typeof actions === "function") {
-      this.routes.forEach((route) => actions(route));
-      return this;
-    }
-    this.#filter(actions, false).forEach((route) => callback(route));
-    return this;
-  }
-  /**
-   * Set the param name for a given resource
-   */
-  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;
-  }
-  /**
-   * Prepend name to all the routes
-   */
-  as(name, normalizeName = true) {
-    name = normalizeName ? string.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 Macroable3 {
-  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]+/)
-   * ```
-   */
-  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')
-   * ```
-   */
-  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')
-   * ```
-   */
-  domain(domain) {
-    this.routes.forEach((route) => this.#updateRouteDomain(route, domain));
-    return this;
-  }
-  /**
-   * Prepend name to the routes name.
-   *
-   * ```ts
-   * Route.group(() => {
-   * }).as('version1')
-   * ```
-   */
-  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())
-   * ```
-   */
-  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 use
-   */
-  middleware(middleware) {
-    return this.use(middleware);
-  }
-};
-
-// src/helpers.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;
-    },
-    {}
-  );
-}
-
-// src/debug.ts
-import { debuglog } from "node:util";
-var debug_default = debuglog("adonisjs:http");
-
-// src/router/route.ts
-var Route = class extends Macroable4 {
-  /**
-   * 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 = [];
-  constructor(app, routerMiddleware, options) {
-    super();
-    this.#app = app;
-    this.#routerMiddleware = routerMiddleware;
-    this.#pattern = options.pattern;
-    this.#methods = options.methods;
-    this.#handler = this.#resolveRouteHandle(options.handler);
-    this.#globalMatchers = options.globalMatchers;
-  }
-  /**
-   * Resolves the route handler string expression to a
-   * handler method object
-   */
-  #resolveRouteHandle(handler) {
-    if (typeof handler === "string") {
-      return {
-        reference: handler,
-        ...moduleExpression(handler, this.#app.appRoot).toHandleMethod()
-      };
-    }
-    if (Array.isArray(handler)) {
-      if (is.class_(handler[0])) {
-        return {
-          reference: handler,
-          ...moduleCaller(handler[0], handler[1] || "handle").toHandleMethod()
-        };
-      }
-      return {
-        reference: handler,
-        ...moduleImporter(handler[0], handler[1] || "handle").toHandleMethod()
-      };
-    }
-    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.
-   */
-  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 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 RuntimeException2(
-          `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);
-    });
-    return middleware;
-  }
-  /**
-   * Returns JSON representation of the route
-   */
-  toJSON() {
-    return {
-      domain: this.#routeDomain,
-      pattern: this.#computePattern(),
-      matchers: this.#getMatchers(),
-      meta: {},
-      name: this.#name,
-      handler: this.#handler,
-      methods: this.#methods,
-      middleware: this.#getMiddlewareForStore(),
-      execute
-    };
-  }
-};
-
-// src/cookies/drivers/plain.ts
-import { base64, MessageBuilder } from "@poppinss/utils";
-function pack(value) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  return base64.urlEncode(new MessageBuilder().build(value));
-}
-function canUnpack(encodedValue) {
-  return typeof encodedValue === "string";
-}
-function unpack(encodedValue) {
-  return new MessageBuilder().verify(base64.urlDecode(encodedValue, "utf-8", false));
-}
-
-// src/cookies/drivers/signed.ts
-function pack2(key, value, encryption) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  return `s:${encryption.verifier.sign(value, void 0, key)}`;
-}
-function canUnpack2(signedValue) {
-  return typeof signedValue === "string" && signedValue.substring(0, 2) === "s:";
-}
-function unpack2(key, signedValue, encryption) {
-  const value = signedValue.slice(2);
-  if (!value) {
-    return null;
-  }
-  return encryption.verifier.unsign(value, key);
-}
-
-// src/cookies/drivers/encrypted.ts
-function pack3(key, value, encryption) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  return `e:${encryption.encrypt(value, void 0, key)}`;
-}
-function canUnpack3(encryptedValue) {
-  return typeof encryptedValue === "string" && encryptedValue.substring(0, 2) === "e:";
-}
-function unpack3(key, encryptedValue, encryption) {
-  const value = encryptedValue.slice(2);
-  if (!value) {
-    return null;
-  }
-  return encryption.decrypt(value, key);
-}
-
-// src/cookies/client.ts
-var CookieClient = class {
-  #encryption;
-  constructor(encryption) {
-    this.#encryption = encryption;
-  }
-  /**
-   * Encrypt a key value pair to be sent in the cookie header
-   */
-  encrypt(key, value) {
-    return pack3(key, value, this.#encryption);
-  }
-  /**
-   * Sign a key value pair to be sent in the cookie header
-   */
-  sign(key, value) {
-    return pack2(key, value, this.#encryption);
-  }
-  /**
-   * Encode a key value pair to be sent in the cookie header
-   */
-  encode(_, value) {
-    return pack(value);
-  }
-  /**
-   * Unsign a signed cookie value
-   */
-  unsign(key, value) {
-    return canUnpack2(value) ? unpack2(key, value, this.#encryption) : null;
-  }
-  /**
-   * Decrypt an encrypted cookie value
-   */
-  decrypt(key, value) {
-    return canUnpack3(value) ? unpack3(key, value, this.#encryption) : null;
-  }
-  /**
-   * Decode an encoded cookie value
-   */
-  decode(_, value) {
-    return canUnpack(value) ? unpack(value) : null;
-  }
-  /**
-   * Parse response cookie
-   */
-  parse(key, value) {
-    if (canUnpack2(value)) {
-      return unpack2(key, value, this.#encryption);
-    }
-    if (canUnpack3(value)) {
-      return unpack3(key, value, this.#encryption);
-    }
-    if (canUnpack(value)) {
-      return unpack(value);
-    }
-  }
-};
-
-// src/request.ts
-import fresh from "fresh";
-import typeIs from "type-is";
-import accepts from "accepts";
-import { isIP } from "node:net";
-import is2 from "@sindresorhus/is";
-import proxyaddr from "proxy-addr";
-import { safeEqual } from "@poppinss/utils";
-import Macroable5 from "@poppinss/macroable";
-import lodash from "@poppinss/utils/lodash";
-import { createId } from "@paralleldrive/cuid2";
-import { parse } from "node:url";
-
-// src/cookies/parser.ts
-import cookie from "cookie";
-var CookieParser = class {
-  #client;
-  /**
-   * A copy of cached cookies, they are cached during a request after
-   * initial decoding, unsigning or decrypting.
-   */
-  #cachedCookies = {
-    signedCookies: {},
-    plainCookies: {},
-    encryptedCookies: {}
-  };
-  /**
-   * An object of key-value pair collected by parsing
-   * the request cookie header.
-   */
-  #cookies;
-  constructor(cookieHeader, encryption) {
-    this.#client = new CookieClient(encryption);
-    this.#cookies = this.#parse(cookieHeader);
-  }
-  /**
-   * Parses the request `cookie` header
-   */
-  #parse(cookieHeader) {
-    if (!cookieHeader) {
-      return {};
-    }
-    return cookie.parse(cookieHeader);
-  }
-  /**
-   * Attempts to decode a cookie by the name. When calling this method,
-   * you are assuming that the cookie was just encoded in the first
-   * place and not signed or encrypted.
-   */
-  decode(key, encoded = true) {
-    const value = this.#cookies[key];
-    if (value === null || value === void 0) {
-      return null;
-    }
-    const cache = this.#cachedCookies.plainCookies;
-    if (cache[key] !== void 0) {
-      return cache[key];
-    }
-    const parsed = encoded ? this.#client.decode(key, value) : value;
-    if (parsed !== null) {
-      cache[key] = parsed;
-    }
-    return parsed;
-  }
-  /**
-   * Attempts to unsign a cookie by the name. When calling this method,
-   * you are assuming that the cookie was signed in the first place.
-   */
-  unsign(key) {
-    const value = this.#cookies[key];
-    if (value === null || value === void 0) {
-      return null;
-    }
-    const cache = this.#cachedCookies.signedCookies;
-    if (cache[key] !== void 0) {
-      return cache[key];
-    }
-    const parsed = this.#client.unsign(key, value);
-    if (parsed !== null) {
-      cache[key] = parsed;
-    }
-    return parsed;
-  }
-  /**
-   * Attempts to decrypt a cookie by the name. When calling this method,
-   * you are assuming that the cookie was encrypted in the first place.
-   */
-  decrypt(key) {
-    const value = this.#cookies[key];
-    if (value === null || value === void 0) {
-      return null;
-    }
-    const cache = this.#cachedCookies.encryptedCookies;
-    if (cache[key] !== void 0) {
-      return cache[key];
-    }
-    const parsed = this.#client.decrypt(key, value);
-    if (parsed !== null) {
-      cache[key] = parsed;
-    }
-    return parsed;
-  }
-  /**
-   * Returns an object of cookies key-value pair. Do note, the
-   * cookies are not decoded, unsigned or decrypted inside this
-   * list.
-   */
-  list() {
-    return this.#cookies;
-  }
-};
-
-// src/request.ts
-var Request = class extends Macroable5 {
-  constructor(request, response, encryption, config, qsParser) {
-    super();
-    this.request = request;
-    this.response = response;
-    this.#qsParser = qsParser;
-    this.#config = config;
-    this.#encryption = encryption;
-    this.parsedUrl = parse(this.request.url, false);
-    this.#parseQueryString();
-  }
-  /**
-   * Query string parser
-   */
-  #qsParser;
-  /**
-   * Encryption module to verify signed URLs and unsign/decrypt
-   * cookies
-   */
-  #encryption;
-  /**
-   * Request config
-   */
-  #config;
-  /**
-   * Request body set using `setBody` method
-   */
-  #requestBody = {};
-  /**
-   * A merged copy of `request body` and `querystring`
-   */
-  #requestData = {};
-  /**
-   * Original merged copy of `request body` and `querystring`.
-   * Further mutation to this object are not allowed
-   */
-  #originalRequestData = {};
-  /**
-   * Parsed query string
-   */
-  #requestQs = {};
-  /**
-   * Raw request body as text
-   */
-  #rawRequestBody;
-  /**
-   * Cached copy of `accepts` fn to do content
-   * negotiation.
-   */
-  #lazyAccepts;
-  /**
-   * Copy of lazily parsed signed and plain cookies.
-   */
-  #cookieParser;
-  /**
-   * Parses copy of the URL with query string as a string and not
-   * object. This is done to build URL's with query string without
-   * stringifying the object
-   */
-  parsedUrl;
-  /**
-   * The ctx will be set by the context itself. It creates a circular
-   * reference
-   */
-  ctx;
-  /**
-   * Parses the query string
-   */
-  #parseQueryString() {
-    if (this.parsedUrl.query) {
-      this.updateQs(this.#qsParser.parse(this.parsedUrl.query));
-      this.#originalRequestData = { ...this.#requestData };
-    }
-  }
-  /**
-   * Initiates the cookie parser lazily
-   */
-  #initiateCookieParser() {
-    if (!this.#cookieParser) {
-      this.#cookieParser = new CookieParser(this.header("cookie"), this.#encryption);
-    }
-  }
-  /**
-   * Lazily initiates the `accepts` module to make sure to parse
-   * the request headers only when one of the content-negotiation
-   * methods are used.
-   */
-  #initiateAccepts() {
-    this.#lazyAccepts = this.#lazyAccepts || accepts(this.request);
-  }
-  /**
-   * Returns the request id from the `x-request-id` header. The
-   * header is untouched, if it already exists.
-   */
-  id() {
-    let requestId = this.header("x-request-id");
-    if (!requestId && this.#config.generateRequestId) {
-      requestId = createId();
-      this.request.headers["x-request-id"] = requestId;
-    }
-    return requestId;
-  }
-  /**
-   * Set initial request body. A copy of the input will be maintained as the original
-   * request body. Since the request body and query string is subject to mutations, we
-   * keep one original reference to flash old data (whenever required).
-   *
-   * This method is supposed to be invoked by the body parser and must be called only
-   * once. For further mutations make use of `updateBody` method.
-   */
-  setInitialBody(body) {
-    if (this.#originalRequestData && Object.isFrozen(this.#originalRequestData)) {
-      throw new Error('Cannot re-set initial body. Use "request.updateBody" instead');
-    }
-    this.updateBody(body);
-    this.#originalRequestData = Object.freeze(lodash.cloneDeep(this.#requestData));
-  }
-  /**
-   * Update the request body with new data object. The `all` property
-   * will be re-computed by merging the query string and request
-   * body.
-   */
-  updateBody(body) {
-    this.#requestBody = body;
-    this.#requestData = { ...this.#requestBody, ...this.#requestQs };
-  }
-  /**
-   * Update the request raw body. Bodyparser sets this when unable to parse
-   * the request body or when request is multipart/form-data.
-   */
-  updateRawBody(rawBody) {
-    this.#rawRequestBody = rawBody;
-  }
-  /**
-   * Update the query string with the new data object. The `all` property
-   * will be re-computed by merging the query and the request body.
-   */
-  updateQs(data) {
-    this.#requestQs = data;
-    this.#requestData = { ...this.#requestBody, ...this.#requestQs };
-  }
-  /**
-   * Returns route params
-   */
-  params() {
-    return this.ctx?.params || {};
-  }
-  /**
-   * Returns the query string object by reference
-   */
-  qs() {
-    return this.#requestQs;
-  }
-  /**
-   * Returns reference to the request body
-   */
-  body() {
-    return this.#requestBody;
-  }
-  /**
-   * Returns reference to the merged copy of request body
-   * and query string
-   */
-  all() {
-    return this.#requestData;
-  }
-  /**
-   * Returns reference to the merged copy of original request
-   * query string and body
-   */
-  original() {
-    return this.#originalRequestData;
-  }
-  /**
-   * Returns the request raw body (if exists), or returns `null`.
-   *
-   * Ideally you must be dealing with the parsed body accessed using [[input]], [[all]] or
-   * [[post]] methods. The `raw` body is always a string.
-   */
-  raw() {
-    return this.#rawRequestBody || null;
-  }
-  /**
-   * Returns value for a given key from the request body or query string.
-   * The `defaultValue` is used when original value is `undefined`.
-   *
-   * @example
-   * ```js
-   * request.input('username')
-   *
-   * // with default value
-   * request.input('username', 'virk')
-   * ```
-   */
-  input(key, defaultValue) {
-    return lodash.get(this.#requestData, key, defaultValue);
-  }
-  /**
-   * Returns value for a given key from route params
-   *
-   * @example
-   * ```js
-   * request.param('id')
-   *
-   * // with default value
-   * request.param('id', 1)
-   * ```
-   */
-  param(key, defaultValue) {
-    return lodash.get(this.params(), key, defaultValue);
-  }
-  /**
-   * Get everything from the request body except the given keys.
-   *
-   * @example
-   * ```js
-   * request.except(['_csrf'])
-   * ```
-   */
-  except(keys) {
-    return lodash.omit(this.#requestData, keys);
-  }
-  /**
-   * Get value for specified keys.
-   *
-   * @example
-   * ```js
-   * request.only(['username', 'age'])
-   * ```
-   */
-  only(keys) {
-    return lodash.pick(this.#requestData, keys);
-  }
-  /**
-   * Returns the HTTP request method. This is the original
-   * request method. For spoofed request method, make
-   * use of [[method]].
-   *
-   * @example
-   * ```js
-   * request.intended()
-   * ```
-   */
-  intended() {
-    return this.request.method;
-  }
-  /**
-   * Returns the request HTTP method by taking method spoofing into account.
-   *
-   * Method spoofing works when all of the following are true.
-   *
-   * 1. `app.http.allowMethodSpoofing` config value is true.
-   * 2. request query string has `_method`.
-   * 3. The [[intended]] request method is `POST`.
-   *
-   * @example
-   * ```js
-   * request.method()
-   * ```
-   */
-  method() {
-    if (this.#config.allowMethodSpoofing && this.intended() === "POST") {
-      return this.input("_method", this.intended()).toUpperCase();
-    }
-    return this.intended();
-  }
-  /**
-   * Returns a copy of headers as an object
-   */
-  headers() {
-    return this.request.headers;
-  }
-  /**
-   * Returns value for a given header key. The default value is
-   * used when original value is `undefined`.
-   */
-  header(key, defaultValue) {
-    key = key.toLowerCase();
-    const headers = this.headers();
-    switch (key) {
-      case "referer":
-      case "referrer":
-        return headers.referrer || headers.referer || defaultValue;
-      default:
-        return headers[key] || defaultValue;
-    }
-  }
-  /**
-   * Returns the ip address of the user. This method is optimize to fetch
-   * ip address even when running your AdonisJs app behind a proxy.
-   *
-   * You can also define your own custom function to compute the ip address by
-   * defining `app.http.getIp` as a function inside the config file.
-   *
-   * ```js
-   * {
-   *   http: {
-   *     getIp (request) {
-   *       // I am using nginx as a proxy server and want to trust 'x-real-ip'
-   *       return request.header('x-real-ip')
-   *     }
-   *   }
-   * }
-   * ```
-   *
-   * You can control the behavior of trusting the proxy values by defining it
-   * inside the `config/app.js` file.
-   *
-   * ```js
-   * {
-   *   http: {
-   *    trustProxy: '127.0.0.1'
-   *   }
-   * }
-   * ```
-   *
-   * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-   */
-  ip() {
-    const ipFn = this.#config.getIp;
-    if (typeof ipFn === "function") {
-      return ipFn(this);
-    }
-    return proxyaddr(this.request, this.#config.trustProxy);
-  }
-  /**
-   * Returns an array of ip addresses from most to least trusted one.
-   * This method is optimize to fetch ip address even when running
-   * your AdonisJs app behind a proxy.
-   *
-   * You can control the behavior of trusting the proxy values by defining it
-   * inside the `config/app.js` file.
-   *
-   * ```js
-   * {
-   *   http: {
-   *    trustProxy: '127.0.0.1'
-   *   }
-   * }
-   * ```
-   *
-   * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-   */
-  ips() {
-    return proxyaddr.all(this.request, this.#config.trustProxy);
-  }
-  /**
-   * Returns the request protocol by checking for the URL protocol or
-   * `X-Forwarded-Proto` header.
-   *
-   * If the `trust` is evaluated to `false`, then URL protocol is returned,
-   * otherwise `X-Forwarded-Proto` header is used (if exists).
-   *
-   * You can control the behavior of trusting the proxy values by defining it
-   * inside the `config/app.js` file.
-   *
-   * ```js
-   * {
-   *   http: {
-   *    trustProxy: '127.0.0.1'
-   *   }
-   * }
-   * ```
-   *
-   * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-   */
-  protocol() {
-    if ("encrypted" in this.request.socket) {
-      return "https";
-    }
-    if (!trustProxy(this.request.socket.remoteAddress, this.#config.trustProxy)) {
-      return this.parsedUrl.protocol || "http";
-    }
-    const forwardedProtocol = this.header("X-Forwarded-Proto");
-    return forwardedProtocol ? forwardedProtocol.split(/\s*,\s*/)[0] : "http";
-  }
-  /**
-   * Returns a boolean telling if request is served over `https`
-   * or not. Check [[protocol]] method to know how protocol is
-   * fetched.
-   */
-  secure() {
-    return this.protocol() === "https";
-  }
-  /**
-   * Returns the request host. If proxy headers are trusted, then
-   * `X-Forwarded-Host` is given priority over the `Host` header.
-   *
-   * You can control the behavior of trusting the proxy values by defining it
-   * inside the `config/app.js` file.
-   *
-   * ```js
-   * {
-   *   http: {
-   *    trustProxy: '127.0.0.1'
-   *   }
-   * }
-   * ```
-   *
-   * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-   */
-  host() {
-    let host = this.header("host");
-    if (trustProxy(this.request.socket.remoteAddress, this.#config.trustProxy)) {
-      host = this.header("X-Forwarded-Host") || host;
-    }
-    if (!host) {
-      return null;
-    }
-    return host;
-  }
-  /**
-   * Returns the request hostname. If proxy headers are trusted, then
-   * `X-Forwarded-Host` is given priority over the `Host` header.
-   *
-   * You can control the behavior of trusting the proxy values by defining it
-   * inside the `config/app.js` file.
-   *
-   * ```js
-   * {
-   *   http: {
-   *    trustProxy: '127.0.0.1'
-   *   }
-   * }
-   * ```
-   *
-   * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-   */
-  hostname() {
-    const host = this.host();
-    if (!host) {
-      return null;
-    }
-    const offset = host[0] === "[" ? host.indexOf("]") + 1 : 0;
-    const index = host.indexOf(":", offset);
-    return index !== -1 ? host.substring(0, index) : host;
-  }
-  /**
-   * Returns an array of subdomains for the given host. An empty array is
-   * returned if [[hostname]] is `null` or is an IP address.
-   *
-   * Also `www` is not considered as a subdomain
-   */
-  subdomains() {
-    const hostname = this.hostname();
-    if (!hostname || isIP(hostname)) {
-      return [];
-    }
-    const offset = this.#config.subdomainOffset;
-    const subdomains = hostname.split(".").reverse().slice(offset);
-    if (subdomains[subdomains.length - 1] === "www") {
-      subdomains.splice(subdomains.length - 1, 1);
-    }
-    return subdomains;
-  }
-  /**
-   * Returns a boolean telling, if request `X-Requested-With === 'xmlhttprequest'`
-   * or not.
-   */
-  ajax() {
-    const xRequestedWith = this.header("X-Requested-With", "");
-    return xRequestedWith.toLowerCase() === "xmlhttprequest";
-  }
-  /**
-   * Returns a boolean telling, if request has `X-Pjax` header
-   * set or not
-   */
-  pjax() {
-    return !!this.header("X-Pjax");
-  }
-  /**
-   * Returns the request relative URL.
-   *
-   * @example
-   * ```js
-   * request.url()
-   *
-   * // include query string
-   * request.url(true)
-   * ```
-   */
-  url(includeQueryString) {
-    const pathname = this.parsedUrl.pathname;
-    return includeQueryString && this.parsedUrl.query ? `${pathname}?${this.parsedUrl.query}` : pathname;
-  }
-  /**
-   * Returns the complete HTTP url by combining
-   * [[protocol]]://[[hostname]]/[[url]]
-   *
-   * @example
-   * ```js
-   * request.completeUrl()
-   *
-   * // include query string
-   * request.completeUrl(true)
-   * ```
-   */
-  completeUrl(includeQueryString) {
-    const protocol = this.protocol();
-    const hostname = this.host();
-    return `${protocol}://${hostname}${this.url(includeQueryString)}`;
-  }
-  /**
-   * Find if the current HTTP request is for the given route or the routes
-   */
-  matchesRoute(routeIdentifier) {
-    if (!this.ctx || !this.ctx.route) {
-      return false;
-    }
-    const route = this.ctx.route;
-    return !!(Array.isArray(routeIdentifier) ? routeIdentifier : [routeIdentifier]).find(
-      (identifier) => {
-        if (route.pattern === identifier || route.name === identifier) {
-          return true;
-        }
-        if (typeof route.handler === "function") {
-          return false;
-        }
-        return route.handler.reference === identifier;
-      }
-    );
-  }
-  /**
-   * Returns the best matching content type of the request by
-   * matching against the given types.
-   *
-   * The content type is picked from the `content-type` header and request
-   * must have body.
-   *
-   * The method response highly depends upon the types array values. Described below:
-   *
-   * | Type(s) | Return value |
-   * |----------|---------------|
-   * | ['json'] | json |
-   * | ['application/*'] | application/json |
-   * | ['vnd+json'] | application/json |
-   *
-   * @example
-   * ```js
-   * const bodyType = request.is(['json', 'xml'])
-   *
-   * if (bodyType === 'json') {
-   *  // process JSON
-   * }
-   *
-   * if (bodyType === 'xml') {
-   *  // process XML
-   * }
-   * ```
-   */
-  is(types) {
-    return typeIs(this.request, types) || null;
-  }
-  /**
-   * Returns the best type using `Accept` header and
-   * by matching it against the given types.
-   *
-   * If nothing is matched, then `null` will be returned
-   *
-   * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-   * docs too.
-   *
-   * @example
-   * ```js
-   * switch (request.accepts(['json', 'html'])) {
-   *   case 'json':
-   *     return response.json(user)
-   *   case 'html':
-   *     return view.render('user', { user })
-   *   default:
-   *     // decide yourself
-   * }
-   * ```
-   */
-  accepts(types) {
-    this.#initiateAccepts();
-    return this.#lazyAccepts.type(types) || null;
-  }
-  /**
-   * Return the types that the request accepts, in the order of the
-   * client's preference (most preferred first).
-   *
-   * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-   * docs too.
-   */
-  types() {
-    this.#initiateAccepts();
-    return this.#lazyAccepts.types();
-  }
-  /**
-   * Returns the best language using `Accept-language` header
-   * and by matching it against the given languages.
-   *
-   * If nothing is matched, then `null` will be returned
-   *
-   * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-   * docs too.
-   *
-   * @example
-   * ```js
-   * switch (request.language(['fr', 'de'])) {
-   *   case 'fr':
-   *     return view.render('about', { lang: 'fr' })
-   *   case 'de':
-   *     return view.render('about', { lang: 'de' })
-   *   default:
-   *     return view.render('about', { lang: 'en' })
-   * }
-   * ```
-   */
-  language(languages) {
-    this.#initiateAccepts();
-    return this.#lazyAccepts.language(languages) || null;
-  }
-  /**
-   * Return the languages that the request accepts, in the order of the
-   * client's preference (most preferred first).
-   *
-   * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-   * docs too.
-   */
-  languages() {
-    this.#initiateAccepts();
-    return this.#lazyAccepts.languages();
-  }
-  /**
-   * Returns the best charset using `Accept-charset` header
-   * and by matching it against the given charsets.
-   *
-   * If nothing is matched, then `null` will be returned
-   *
-   * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-   * docs too.
-   *
-   * @example
-   * ```js
-   * switch (request.charset(['utf-8', 'ISO-8859-1'])) {
-   *   case 'utf-8':
-   *     // make utf-8 friendly response
-   *   case 'ISO-8859-1':
-   *     // make ISO-8859-1 friendly response
-   * }
-   * ```
-   */
-  charset(charsets) {
-    this.#initiateAccepts();
-    return this.#lazyAccepts.charset(charsets) || null;
-  }
-  /**
-   * Return the charsets that the request accepts, in the order of the
-   * client's preference (most preferred first).
-   *
-   * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-   * docs too.
-   */
-  charsets() {
-    this.#initiateAccepts();
-    return this.#lazyAccepts.charsets();
-  }
-  /**
-   * Returns the best encoding using `Accept-encoding` header
-   * and by matching it against the given encodings.
-   *
-   * If nothing is matched, then `null` will be returned
-   *
-   * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-   * docs too.
-   */
-  encoding(encodings) {
-    this.#initiateAccepts();
-    return this.#lazyAccepts.encoding(encodings) || null;
-  }
-  /**
-   * Return the charsets that the request accepts, in the order of the
-   * client's preference (most preferred first).
-   *
-   * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-   * docs too.
-   */
-  encodings() {
-    this.#initiateAccepts();
-    return this.#lazyAccepts.encodings();
-  }
-  /**
-   * Returns a boolean telling if request has body
-   */
-  hasBody() {
-    return typeIs.hasBody(this.request);
-  }
-  /**
-   * Returns a boolean telling if the new response etag evaluates same
-   * as the request header `if-none-match`. In case of `true`, the
-   * server must return `304` response, telling the browser to
-   * use the client cache.
-   *
-   * You won't have to deal with this method directly, since AdonisJs will
-   * handle this for you when `http.etag = true` inside `config/app.js` file.
-   *
-   * However, this is how you can use it manually.
-   *
-   * ```js
-   * const responseBody = view.render('some-view')
-   *
-   * // sets the HTTP etag header for response
-   * response.setEtag(responseBody)
-   *
-   * if (request.fresh()) {
-   *   response.sendStatus(304)
-   * } else {
-   *   response.send(responseBody)
-   * }
-   * ```
-   */
-  fresh() {
-    if (["GET", "HEAD"].indexOf(this.intended()) === -1) {
-      return false;
-    }
-    const status = this.response.statusCode;
-    if (status >= 200 && status < 300 || status === 304) {
-      return fresh(this.headers(), this.response.getHeaders());
-    }
-    return false;
-  }
-  /**
-   * Opposite of [[fresh]]
-   */
-  stale() {
-    return !this.fresh();
-  }
-  /**
-   * Returns all parsed and signed cookies. Signed cookies ensures
-   * that their value isn't tampered.
-   */
-  cookiesList() {
-    this.#initiateCookieParser();
-    return this.#cookieParser.list();
-  }
-  /**
-   * Returns value for a given key from signed cookies. Optional
-   * defaultValue is returned when actual value is undefined.
-   */
-  cookie(key, defaultValue) {
-    this.#initiateCookieParser();
-    return this.#cookieParser.unsign(key) || defaultValue;
-  }
-  /**
-   * Returns value for a given key from signed cookies. Optional
-   * defaultValue is returned when actual value is undefined.
-   */
-  encryptedCookie(key, defaultValue) {
-    this.#initiateCookieParser();
-    return this.#cookieParser.decrypt(key) || defaultValue;
-  }
-  plainCookie(key, defaultValueOrOptions, encoded) {
-    this.#initiateCookieParser();
-    if (is2.object(defaultValueOrOptions)) {
-      return this.#cookieParser.decode(key, defaultValueOrOptions?.encoded) || defaultValueOrOptions.defaultValue;
-    }
-    return this.#cookieParser.decode(key, encoded) || defaultValueOrOptions;
-  }
-  /**
-   * Returns a boolean telling if a signed url as a valid signature
-   * or not.
-   */
-  hasValidSignature(purpose) {
-    const { signature, ...rest } = this.qs();
-    if (!signature) {
-      return false;
-    }
-    const signedUrl = this.#encryption.verifier.unsign(signature, purpose);
-    if (!signedUrl) {
-      return false;
-    }
-    const queryString = this.#qsParser.stringify(rest);
-    return queryString ? safeEqual(signedUrl, `${this.url()}?${queryString}`) : safeEqual(signedUrl, this.url());
-  }
-  /**
-   * Serializes request to JSON format
-   */
-  serialize() {
-    return {
-      id: this.id(),
-      url: this.url(),
-      query: this.parsedUrl.query,
-      body: this.all(),
-      params: this.params(),
-      headers: this.headers(),
-      method: this.method(),
-      protocol: this.protocol(),
-      cookies: this.cookiesList(),
-      hostname: this.hostname(),
-      ip: this.ip(),
-      subdomains: this.ctx?.subdomains || {}
-    };
-  }
-  /**
-   * toJSON copy of the request
-   */
-  toJSON() {
-    return this.serialize();
-  }
-};
-
-// src/redirect.ts
-import { parse as parse2 } from "node:url";
-import encodeUrl from "encodeurl";
-var Redirect = class {
-  /**
-   * A boolean to forward the existing query string
-   */
-  #forwardQueryString = false;
-  /**
-   * The status code for the redirect
-   */
-  #statusCode = 302;
-  /**
-   * A custom query string to forward
-   */
-  #queryString = {};
-  #request;
-  #response;
-  #router;
-  #qs;
-  constructor(request, response, router, qs) {
-    this.#request = request;
-    this.#response = response;
-    this.#router = router;
-    this.#qs = qs;
-  }
-  /**
-   * Sends response by setting require headers
-   */
-  #sendResponse(url, query) {
-    const stringified = this.#qs.stringify(query);
-    url = stringified ? `${url}?${stringified}` : url;
-    debug_default('redirecting to url "%s"', url);
-    this.#response.location(encodeUrl(url));
-    this.#response.safeStatus(this.#statusCode);
-    this.#response.type("text/plain; charset=utf-8");
-    this.#response.send(`Redirecting to ${url}`);
-  }
-  /**
-   * Returns the referrer url
-   */
-  #getReferrerUrl() {
-    let url = this.#request.headers["referer"] || this.#request.headers["referrer"] || "/";
-    return Array.isArray(url) ? url[0] : url;
-  }
-  /**
-   * Set a custom status code.
-   */
-  status(statusCode) {
-    this.#statusCode = statusCode;
-    return this;
-  }
-  /**
-   * Clearing query string values added using the
-   * "withQs" method
-   */
-  clearQs() {
-    this.#forwardQueryString = false;
-    this.#queryString = {};
-    return this;
-  }
-  withQs(name, value) {
-    if (typeof name === "undefined") {
-      this.#forwardQueryString = true;
-      return this;
-    }
-    if (typeof name === "string") {
-      this.#queryString[name] = value;
-      return this;
-    }
-    Object.assign(this.#queryString, name);
-    return this;
-  }
-  /**
-   * Redirect to the previous path.
-   */
-  back() {
-    let query = {};
-    const referrerUrl = this.#getReferrerUrl();
-    const url = parse2(referrerUrl);
-    debug_default('referrer url "%s"', referrerUrl);
-    debug_default('referrer base url "%s"', url.pathname);
-    if (this.#forwardQueryString) {
-      query = this.#qs.parse(url.query || "");
-    }
-    Object.assign(query, this.#queryString);
-    this.#sendResponse(url.pathname || "", query);
-  }
-  /**
-   * Redirect the request using a route identifier.
-   */
-  toRoute(routeIdentifier, params, options) {
-    if (options && options.qs) {
-      this.withQs(options.qs);
-      options.qs = void 0;
-    }
-    const url = this.#router.makeUrl(routeIdentifier, params, options);
-    return this.toPath(url);
-  }
-  /**
-   * Redirect the request using a path.
-   */
-  toPath(url) {
-    let query = {};
-    if (this.#forwardQueryString) {
-      query = this.#qs.parse(parse2(this.#request.url).query || "");
-    }
-    Object.assign(query, this.#queryString);
-    this.#sendResponse(url, query);
-  }
-};
-
-// src/exceptions.ts
-var exceptions_exports = {};
-__export(exceptions_exports, {
-  E_CANNOT_LOOKUP_ROUTE: () => E_CANNOT_LOOKUP_ROUTE,
-  E_HTTP_EXCEPTION: () => E_HTTP_EXCEPTION,
-  E_HTTP_REQUEST_ABORTED: () => E_HTTP_REQUEST_ABORTED,
-  E_ROUTE_NOT_FOUND: () => E_ROUTE_NOT_FOUND
-});
-import { createError, Exception } from "@poppinss/utils";
-var E_ROUTE_NOT_FOUND = createError(
-  "Cannot %s:%s",
-  "E_ROUTE_NOT_FOUND",
-  404
-);
-var E_CANNOT_LOOKUP_ROUTE = createError(
-  'Cannot lookup route "%s"',
-  "E_CANNOT_LOOKUP_ROUTE",
-  500
-);
-var E_HTTP_EXCEPTION = class HttpException extends Exception {
-  body;
-  static code = "E_HTTP_EXCEPTION";
-  /**
-   * This method returns an instance of the exception class
-   */
-  static invoke(body, status, code = "E_HTTP_EXCEPTION") {
-    if (body === null || body === void 0) {
-      const error2 = new this("HTTP Exception", { status, code });
-      error2.body = "Internal server error";
-      return error2;
-    }
-    if (typeof body === "object") {
-      const error2 = new this(body.message || "HTTP Exception", { status, code });
-      error2.body = body;
-      return error2;
-    }
-    const error = new this(body, { status, code });
-    error.body = body;
-    return error;
-  }
-};
-var E_HTTP_REQUEST_ABORTED = class AbortException extends E_HTTP_EXCEPTION {
-  handle(error, ctx) {
-    ctx.response.status(error.status).send(error.body);
-  }
-};
-
-// src/response.ts
-import etag from "etag";
-import vary from "vary";
-import fresh2 from "fresh";
-import mime from "mime-types";
-import destroy from "destroy";
-import { extname } from "node:path";
-import onFinished from "on-finished";
-import json from "@poppinss/utils/json";
-import Macroable6 from "@poppinss/macroable";
-import { createReadStream } from "node:fs";
-import { stat } from "node:fs/promises";
-import { RuntimeException as RuntimeException3 } from "@poppinss/utils";
-import contentDisposition from "content-disposition";
-
-// src/cookies/serializer.ts
-import cookie2 from "cookie";
-import string2 from "@poppinss/utils/string";
-var CookieSerializer = class {
-  #client;
-  constructor(encryption) {
-    this.#client = new CookieClient(encryption);
-  }
-  /**
-   * Serializes the key-value pair to a string, that can be set on the
-   * `Set-Cookie` header.
-   */
-  #serializeAsCookie(key, value, options) {
-    let expires = options?.expires;
-    if (typeof expires === "function") {
-      expires = expires();
-    }
-    let maxAge = options?.maxAge ? string2.seconds.parse(options?.maxAge) : void 0;
-    const parsedOptions = Object.assign({}, options, { maxAge, expires });
-    return cookie2.serialize(key, value, parsedOptions);
-  }
-  /**
-   * Encodes value as a plain cookie. By default, the plain value will be converted
-   * to a string using "JSON.stringify" method and then encoded as a base64 string.
-   *
-   * You can disable encoding of the cookie by setting `options.encoded = false`.
-   *
-   * ```ts
-   *  serializer.encode('name', 'virk')
-   * ```
-   */
-  encode(key, value, options) {
-    const packedValue = options?.encode === false ? value : this.#client.encode(key, value);
-    if (packedValue === null || packedValue === void 0) {
-      return null;
-    }
-    return this.#serializeAsCookie(key, packedValue, options);
-  }
-  /**
-   * Sign a key-value pair to a signed cookie. The signed value has a
-   * verification hash attached to it to detect data tampering.
-   */
-  sign(key, value, options) {
-    const packedValue = this.#client.sign(key, value);
-    if (packedValue === null) {
-      return null;
-    }
-    return this.#serializeAsCookie(key, packedValue, options);
-  }
-  /**
-   * Encrypts a key-value pair to an encrypted cookie.
-   */
-  encrypt(key, value, options) {
-    const packedValue = this.#client.encrypt(key, value);
-    if (packedValue === null) {
-      return null;
-    }
-    return this.#serializeAsCookie(key, packedValue, options);
-  }
-};
-
-// src/response.ts
-var CACHEABLE_HTTP_METHODS = ["GET", "HEAD"];
-var Response = class extends Macroable6 {
-  constructor(request, response, encryption, config, router, qs) {
-    super();
-    this.request = request;
-    this.response = response;
-    this.#qs = qs;
-    this.#config = config;
-    this.#router = router;
-    this.#cookieSerializer = new CookieSerializer(encryption);
-  }
-  /**
-   * Query string parser
-   */
-  #qs;
-  /**
-   * Outgoing headers
-   */
-  #headers = {};
-  /**
-   * Has explicit status been set
-   */
-  #hasExplicitStatus = false;
-  /**
-   * Cookies serializer to serialize the outgoing cookies
-   */
-  #cookieSerializer;
-  /**
-   * Router is used to make the redirect URLs from routes
-   */
-  #router;
-  /**
-   * Response config
-   */
-  #config;
-  /**
-   * Does response has body set that will written to the
-   * response socket at the end of the request
-   */
-  get hasLazyBody() {
-    return !!(this.lazyBody.content || this.lazyBody.fileToStream || this.lazyBody.stream);
-  }
-  /**
-   * Find if the response has non-stream content
-   */
-  get hasContent() {
-    return !!this.lazyBody.content;
-  }
-  /**
-   * Returns true when response body is set using "response.stream"
-   * method
-   */
-  get hasStream() {
-    return !!this.lazyBody.stream;
-  }
-  /**
-   * Returns true when response body is set using "response.download"
-   * or "response.attachment" methods
-   */
-  get hasFileToStream() {
-    return !!this.lazyBody.fileToStream;
-  }
-  /**
-   * Returns the response content. Check if the response
-   * has content using the "hasContent" method
-   */
-  get content() {
-    return this.lazyBody.content;
-  }
-  /**
-   * Returns reference to the stream set using "response.stream"
-   * method
-   */
-  get outgoingStream() {
-    return this.lazyBody.stream?.[0];
-  }
-  /**
-   * Returns reference to the file path set using "response.stream"
-   * method.
-   */
-  get fileToStream() {
-    return this.lazyBody.fileToStream ? {
-      path: this.lazyBody.fileToStream[0],
-      generateEtag: this.lazyBody.fileToStream[1]
-    } : void 0;
-  }
-  /**
-   * Lazy body is used to set the response body. However, do not
-   * write it on the socket immediately unless `response.finish`
-   * is called.
-   */
-  lazyBody = {};
-  /**
-   * The ctx will be set by the context itself. It creates a circular
-   * reference
-   */
-  ctx;
-  /**
-   * Returns a boolean telling if response is finished or not.
-   * Any more attempts to update headers or body will result
-   * in raised exceptions.
-   */
-  get finished() {
-    return this.response.writableFinished;
-  }
-  /**
-   * Returns a boolean telling if response headers has been sent or not.
-   * Any more attempts to update headers will result in raised
-   * exceptions.
-   */
-  get headersSent() {
-    return this.response.headersSent;
-  }
-  /**
-   * Returns a boolean telling if response headers and body is written
-   * or not. When value is `true`, you can feel free to write headers
-   * and body.
-   */
-  get isPending() {
-    return !this.headersSent && !this.finished;
-  }
-  /**
-   * Normalizes header value to a string or an array of string
-   */
-  #castHeaderValue(value) {
-    return Array.isArray(value) ? value.map(String) : String(value);
-  }
-  /**
-   * Ends the response by flushing headers and writing body
-   */
-  #endResponse(body, statusCode) {
-    this.writeHead(statusCode);
-    const res = this.response;
-    res.end(body, null, null);
-  }
-  /**
-   * Returns type for the content body. Only following types are allowed
-   *
-   * - Dates
-   * - Arrays
-   * - Booleans
-   * - Objects
-   * - Strings
-   * - Buffer
-   */
-  #getDataType(content) {
-    if (Buffer.isBuffer(content)) {
-      return "buffer";
-    }
-    if (content instanceof Date) {
-      return "date";
-    }
-    if (content instanceof RegExp) {
-      return "regexp";
-    }
-    const dataType = typeof content;
-    if (dataType === "number" || dataType === "boolean" || dataType === "string" || dataType === "bigint") {
-      return dataType;
-    }
-    if (dataType === "object") {
-      return "object";
-    }
-    throw new RuntimeException3(`Cannot serialize "${dataType}" to HTTP response`);
-  }
-  /**
-   * Writes the body with appropriate response headers. Etag header is set
-   * when `generateEtag` is set to `true`.
-   *
-   * Empty body results in `204`.
-   */
-  writeBody(content, generateEtag, jsonpCallbackName) {
-    const hasEmptyBody = content === null || content === void 0 || content === "";
-    if (hasEmptyBody) {
-      this.safeStatus(204);
-    }
-    const statusCode = this.response.statusCode;
-    if (statusCode && (statusCode < 200 || statusCode === 204 || statusCode === 304)) {
-      this.removeHeader("Content-Type");
-      this.removeHeader("Content-Length");
-      this.removeHeader("Transfer-Encoding");
-      this.#endResponse();
-      return;
-    }
-    if (hasEmptyBody) {
-      this.removeHeader("Content-Length");
-      this.#endResponse();
-      return;
-    }
-    const dataType = this.#getDataType(content);
-    if (dataType === "object") {
-      content = json.safeStringify(content);
-    } else if (dataType === "number" || dataType === "boolean" || dataType === "bigint" || dataType === "regexp") {
-      content = String(content);
-    } else if (dataType === "date") {
-      content = content.toISOString();
-    }
-    if (jsonpCallbackName) {
-      content = content.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-      content = `/**/ typeof ${jsonpCallbackName} === 'function' && ${jsonpCallbackName}(${content});`;
-    }
-    if (generateEtag) {
-      this.setEtag(content);
-    }
-    if (generateEtag && this.fresh()) {
-      this.removeHeader("Content-Type");
-      this.removeHeader("Content-Length");
-      this.removeHeader("Transfer-Encoding");
-      this.#endResponse(null, 304);
-      return;
-    }
-    this.header("Content-Length", Buffer.byteLength(content));
-    if (jsonpCallbackName) {
-      this.header("X-Content-Type-Options", "nosniff");
-      this.safeHeader("Content-Type", "text/javascript; charset=utf-8");
-    } else {
-      switch (dataType) {
-        case "string":
-          const type = /^\s*</.test(content) ? "text/html" : "text/plain";
-          this.safeHeader("Content-Type", `${type}; charset=utf-8`);
-          break;
-        case "number":
-        case "boolean":
-        case "date":
-        case "bigint":
-        case "regexp":
-          this.safeHeader("Content-Type", "text/plain; charset=utf-8");
-          break;
-        case "buffer":
-          this.safeHeader("Content-Type", "application/octet-stream; charset=utf-8");
-          break;
-        case "object":
-          this.safeHeader("Content-Type", "application/json; charset=utf-8");
-          break;
-      }
-    }
-    this.#endResponse(content);
-  }
-  /**
-   * Stream the body to the response and handles cleaning up the stream
-   */
-  streamBody(body, errorCallback) {
-    return new Promise((resolve) => {
-      let finished = false;
-      body.on("error", (error) => {
-        if (finished) {
-          return;
-        }
-        finished = true;
-        destroy(body);
-        this.type("text");
-        if (!this.headersSent) {
-          if (typeof errorCallback === "function") {
-            this.#endResponse(...errorCallback(error));
-          } else {
-            this.#endResponse(
-              error.code === "ENOENT" ? "File not found" : "Cannot process file",
-              error.code === "ENOENT" ? 404 : 500
-            );
-          }
-        } else {
-          this.response.destroy();
-        }
-        resolve();
-      });
-      body.on("end", () => {
-        if (!this.headersSent) {
-          this.#endResponse();
-        }
-        resolve();
-      });
-      onFinished(this.response, () => {
-        finished = true;
-        destroy(body);
-      });
-      this.relayHeaders();
-      body.pipe(this.response);
-    });
-  }
-  /**
-   * Downloads a file by streaming it to the response
-   */
-  async streamFileForDownload(filePath, generateEtag, errorCallback) {
-    try {
-      const stats = await stat(filePath);
-      if (!stats || !stats.isFile()) {
-        throw new TypeError("response.download only accepts path to a file");
-      }
-      this.header("Last-Modified", stats.mtime.toUTCString());
-      this.type(extname(filePath));
-      if (generateEtag) {
-        this.setEtag(stats, true);
-      }
-      if (this.request.method === "HEAD") {
-        this.#endResponse(null, generateEtag && this.fresh() ? 304 : 200);
-        return;
-      }
-      if (generateEtag && this.fresh()) {
-        this.#endResponse(null, 304);
-        return;
-      }
-      this.header("Content-length", stats.size);
-      return this.streamBody(createReadStream(filePath), errorCallback);
-    } catch (error) {
-      this.type("text");
-      this.removeHeader("Etag");
-      if (typeof errorCallback === "function") {
-        this.#endResponse(...errorCallback(error));
-      } else {
-        this.#endResponse(
-          error.code === "ENOENT" ? "File not found" : "Cannot process file",
-          error.code === "ENOENT" ? 404 : 500
-        );
-      }
-    }
-  }
-  /**
-   * Writes headers with the Node.js res object using the
-   * response.setHeader method
-   */
-  relayHeaders() {
-    if (!this.headersSent) {
-      for (let key in this.#headers) {
-        const value = this.#headers[key];
-        if (value) {
-          this.response.setHeader(key, value);
-        }
-      }
-    }
-  }
-  /**
-   * Calls res.writeHead on the Node.js res object.
-   */
-  writeHead(statusCode) {
-    this.response.writeHead(statusCode || this.response.statusCode, this.#headers);
-    return this;
-  }
-  /**
-   * Returns the existing value for a given HTTP response
-   * header.
-   */
-  getHeader(key) {
-    const value = this.#headers[key.toLowerCase()];
-    return value === void 0 ? this.response.getHeader(key) : value;
-  }
-  /**
-   * Get response headers
-   */
-  getHeaders() {
-    return {
-      ...this.response.getHeaders(),
-      ...this.#headers
-    };
-  }
-  /**
-   * Set header on the response. To `append` values to the existing header, we suggest
-   * using [[append]] method.
-   *
-   * If `value` is non existy, then header won't be set.
-   *
-   * @example
-   * ```js
-   * response.header('content-type', 'application/json')
-   * ```
-   */
-  header(key, value) {
-    if (value === null || value === void 0) {
-      return this;
-    }
-    this.#headers[key.toLowerCase()] = this.#castHeaderValue(value);
-    return this;
-  }
-  /**
-   * Append value to an existing header. To replace the value, we suggest using
-   * [[header]] method.
-   *
-   * If `value` is not existy, then header won't be set.
-   *
-   * @example
-   * ```js
-   * response.append('set-cookie', 'username=virk')
-   * ```
-   */
-  append(key, value) {
-    if (value === null || value === void 0) {
-      return this;
-    }
-    key = key.toLowerCase();
-    let existingHeader = this.getHeader(key);
-    let casted = this.#castHeaderValue(value);
-    if (!existingHeader) {
-      this.#headers[key] = casted;
-      return this;
-    }
-    existingHeader = this.#castHeaderValue(existingHeader);
-    casted = Array.isArray(existingHeader) ? existingHeader.concat(casted) : [existingHeader].concat(casted);
-    this.#headers[key] = casted;
-    return this;
-  }
-  /**
-   * Adds HTTP response header, when it doesn't exists already.
-   */
-  safeHeader(key, value) {
-    if (!this.getHeader(key)) {
-      this.header(key, value);
-    }
-    return this;
-  }
-  /**
-   * Removes the existing response header from being sent.
-   */
-  removeHeader(key) {
-    key = key.toLowerCase();
-    this.response.removeHeader(key);
-    if (this.#headers[key]) {
-      delete this.#headers[key.toLowerCase()];
-    }
-    return this;
-  }
-  /**
-   * Returns the status code for the response
-   */
-  getStatus() {
-    return this.response.statusCode;
-  }
-  /**
-   * Set HTTP status code
-   */
-  status(code) {
-    this.#hasExplicitStatus = true;
-    this.response.statusCode = code;
-    return this;
-  }
-  /**
-   * Set's status code only when it's not explictly
-   * set
-   */
-  safeStatus(code) {
-    if (this.#hasExplicitStatus) {
-      return this;
-    }
-    this.response.statusCode = code;
-    return this;
-  }
-  /**
-   * Set response type by looking up for the mime-type using
-   * partial types like file extensions.
-   *
-   * Make sure to read [mime-types](https://www.npmjs.com/package/mime-types) docs
-   * too.
-   *
-   * @example
-   * ```js
-   * response.type('.json') // Content-type: application/json
-   * ```
-   */
-  type(type, charset) {
-    type = charset ? `${type}; charset=${charset}` : type;
-    this.header("Content-Type", mime.contentType(type));
-    return this;
-  }
-  /**
-   * Set the Vary HTTP header
-   */
-  vary(field) {
-    vary(this.response, field);
-    return this;
-  }
-  /**
-   * Set etag by computing hash from the body. This class will set the etag automatically
-   * when `etag = true` in the defined config object.
-   *
-   * Use this function, when you want to compute etag manually for some other resons.
-   */
-  setEtag(body, weak = false) {
-    this.header("Etag", etag(body, { weak }));
-    return this;
-  }
-  /**
-   * Returns a boolean telling if the new response etag evaluates same
-   * as the request header `if-none-match`. In case of `true`, the
-   * server must return `304` response, telling the browser to
-   * use the client cache.
-   *
-   * You won't have to deal with this method directly, since AdonisJs will
-   * handle this for you when `http.etag = true` inside `config/app.js` file.
-   *
-   * However, this is how you can use it manually.
-   *
-   * @example
-   * ```js
-   * const responseBody = view.render('some-view')
-   *
-   * // sets the HTTP etag header for response
-   * response.setEtag(responseBody)
-   *
-   * if (response.fresh()) {
-   *   response.sendStatus(304)
-   * } else {
-   *   response.send(responseBody)
-   * }
-   * ```
-   */
-  fresh() {
-    if (this.request.method && !CACHEABLE_HTTP_METHODS.includes(this.request.method)) {
-      return false;
-    }
-    const status = this.response.statusCode;
-    if (status >= 200 && status < 300 || status === 304) {
-      return fresh2(this.request.headers, this.#headers);
-    }
-    return false;
-  }
-  /**
-   * Returns the response body. Returns null when response
-   * body is a stream
-   */
-  getBody() {
-    if (this.lazyBody.content) {
-      return this.lazyBody.content[0];
-    }
-    return null;
-  }
-  /**
-   * Send the body as response and optionally generate etag. The default value
-   * is read from `config/app.js` file, using `http.etag` property.
-   *
-   * This method buffers the body if `explicitEnd = true`, which is the default
-   * behavior and do not change, unless you know what you are doing.
-   */
-  send(body, generateEtag = this.#config.etag) {
-    this.lazyBody.content = [body, generateEtag];
-  }
-  /**
-   * Alias of [[send]]
-   */
-  json(body, generateEtag = this.#config.etag) {
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Writes response as JSONP. The callback name is resolved as follows, with priority
-   * from top to bottom.
-   *
-   * 1. Explicitly defined as 2nd Param.
-   * 2. Fetch from request query string.
-   * 3. Use the config value `http.jsonpCallbackName` from `config/app.js`.
-   * 4. Fallback to `callback`.
-   *
-   * This method buffers the body if `explicitEnd = true`, which is the default
-   * behavior and do not change, unless you know what you are doing.
-   */
-  jsonp(body, callbackName = this.#config.jsonpCallbackName, generateEtag = this.#config.etag) {
-    this.lazyBody.content = [body, generateEtag, callbackName];
-  }
-  /**
-   * Pipe stream to the response. This method will gracefully destroy
-   * the stream, avoiding memory leaks.
-   *
-   * If `raiseErrors=false`, then this method will self handle all the exceptions by
-   * writing a generic HTTP response. To have more control over the error, it is
-   * recommended to set `raiseErrors=true` and wrap this function inside a
-   * `try/catch` statement.
-   *
-   * Streaming a file from the disk and showing 404 when file is missing.
-   *
-   * @example
-   * ```js
-   * // Errors handled automatically with generic HTTP response
-   * response.stream(fs.createReadStream('file.txt'))
-   *
-   * // Manually handle (note the await call)
-   * try {
-   *   await response.stream(fs.createReadStream('file.txt'))
-   * } catch () {
-   *   response.status(404).send('File not found')
-   * }
-   * ```
-   */
-  stream(body, errorCallback) {
-    if (typeof body.pipe !== "function" || !body.readable || typeof body.read !== "function") {
-      throw new TypeError("response.stream accepts a readable stream only");
-    }
-    this.lazyBody.stream = [body, errorCallback];
-  }
-  /**
-   * Download file by streaming it from the file path. This method will setup
-   * appropriate `Content-type`, `Content-type` and `Last-modified` headers.
-   *
-   * Unexpected stream errors are handled gracefully to avoid memory leaks.
-   *
-   * If `raiseErrors=false`, then this method will self handle all the exceptions by
-   * writing a generic HTTP response. To have more control over the error, it is
-   * recommended to set `raiseErrors=true` and wrap this function inside a
-   * `try/catch` statement.
-   *
-   * @example
-   * ```js
-   * // Errors handled automatically with generic HTTP response
-   * response.download('somefile.jpg')
-   *
-   * // Manually handle (note the await call)
-   * try {
-   *   await response.download('somefile.jpg')
-   * } catch (error) {
-   *   response.status(error.code === 'ENOENT' ? 404 : 500)
-   *   response.send('Cannot process file')
-   * }
-   * ```
-   */
-  download(filePath, generateEtag = this.#config.etag, errorCallback) {
-    this.lazyBody.fileToStream = [filePath, generateEtag, errorCallback];
-  }
-  /**
-   * Download the file by forcing the user to save the file vs displaying it
-   * within the browser.
-   *
-   * Internally calls [[download]]
-   */
-  attachment(filePath, name, disposition, generateEtag, errorCallback) {
-    name = name || filePath;
-    this.header("Content-Disposition", contentDisposition(name, { type: disposition }));
-    return this.download(filePath, generateEtag, errorCallback);
-  }
-  /**
-   * Set the location header.
-   *
-   * @example
-   * ```js
-   * response.location('/login')
-   * ```
-   */
-  location(url) {
-    this.header("Location", url);
-    return this;
-  }
-  redirect(path, forwardQueryString = false, statusCode = 302) {
-    const handler = new Redirect(this.request, this, this.#router, this.#qs);
-    if (forwardQueryString) {
-      handler.withQs();
-    }
-    if (path === "back") {
-      return handler.status(statusCode).back();
-    }
-    if (path) {
-      return handler.status(statusCode).toPath(path);
-    }
-    return handler;
-  }
-  /**
-   * Abort the request with custom body and a status code. 400 is
-   * used when status is not defined
-   */
-  abort(body, status) {
-    throw E_HTTP_REQUEST_ABORTED.invoke(body, status || 400);
-  }
-  /**
-   * Abort the request with custom body and a status code when
-   * passed condition returns `true`
-   */
-  abortIf(condition, body, status) {
-    if (condition) {
-      this.abort(body, status);
-    }
-  }
-  /**
-   * Abort the request with custom body and a status code when
-   * passed condition returns `false`
-   */
-  abortUnless(condition, body, status) {
-    if (!condition) {
-      this.abort(body, status);
-    }
-  }
-  /**
-   * Set signed cookie as the response header. The inline options overrides
-   * all options from the config.
-   */
-  cookie(key, value, options) {
-    options = Object.assign({}, this.#config.cookie, options);
-    const serialized = this.#cookieSerializer.sign(key, value, options);
-    if (!serialized) {
-      return this;
-    }
-    this.append("set-cookie", serialized);
-    return this;
-  }
-  /**
-   * Set encrypted cookie as the response header. The inline options overrides
-   * all options from the config.
-   */
-  encryptedCookie(key, value, options) {
-    options = Object.assign({}, this.#config.cookie, options);
-    const serialized = this.#cookieSerializer.encrypt(key, value, options);
-    if (!serialized) {
-      return this;
-    }
-    this.append("set-cookie", serialized);
-    return this;
-  }
-  /**
-   * Set unsigned cookie as the response header. The inline options overrides
-   * all options from the config.
-   */
-  plainCookie(key, value, options) {
-    options = Object.assign({}, this.#config.cookie, options);
-    const serialized = this.#cookieSerializer.encode(key, value, options);
-    if (!serialized) {
-      return this;
-    }
-    this.append("set-cookie", serialized);
-    return this;
-  }
-  /**
-   * Clear existing cookie.
-   */
-  clearCookie(key, options) {
-    options = Object.assign({}, this.#config.cookie, options);
-    options.expires = /* @__PURE__ */ new Date(1);
-    options.maxAge = -1;
-    const serialized = this.#cookieSerializer.encode(key, "", { ...options, encode: false });
-    this.append("set-cookie", serialized);
-    return this;
-  }
-  /**
-   * Finishes the response by writing the lazy body, when `explicitEnd = true`
-   * and response is already pending.
-   *
-   * Calling this method twice or when `explicitEnd = false` is noop.
-   */
-  finish() {
-    if (!this.isPending) {
-      return;
-    }
-    if (this.content) {
-      this.writeBody(...this.content);
-      return;
-    }
-    if (this.lazyBody.stream) {
-      this.streamBody(...this.lazyBody.stream);
-      return;
-    }
-    if (this.lazyBody.fileToStream) {
-      this.streamFileForDownload(...this.lazyBody.fileToStream);
-      return;
-    }
-    this.#endResponse();
-  }
-  /**
-   * Shorthand method to finish request with "100" status code
-   */
-  continue() {
-    this.status(100);
-    return this.send(null, false);
-  }
-  /**
-   * Shorthand method to finish request with "101" status code
-   */
-  switchingProtocols() {
-    this.status(101);
-    return this.send(null, false);
-  }
-  /**
-   * Shorthand method to finish request with "200" status code
-   */
-  ok(body, generateEtag) {
-    this.status(200);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "201" status code
-   */
-  created(body, generateEtag) {
-    this.status(201);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "202" status code
-   */
-  accepted(body, generateEtag) {
-    this.status(202);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "203" status code
-   */
-  nonAuthoritativeInformation(body, generateEtag) {
-    this.status(203);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "204" status code
-   */
-  noContent() {
-    this.status(204);
-    return this.send(null, false);
-  }
-  /**
-   * Shorthand method to finish request with "205" status code
-   */
-  resetContent() {
-    this.status(205);
-    return this.send(null, false);
-  }
-  /**
-   * Shorthand method to finish request with "206" status code
-   */
-  partialContent(body, generateEtag) {
-    this.status(206);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "300" status code
-   */
-  multipleChoices(body, generateEtag) {
-    this.status(300);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "301" status code
-   */
-  movedPermanently(body, generateEtag) {
-    this.status(301);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "302" status code
-   */
-  movedTemporarily(body, generateEtag) {
-    this.status(302);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "303" status code
-   */
-  seeOther(body, generateEtag) {
-    this.status(303);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "304" status code
-   */
-  notModified(body, generateEtag) {
-    this.status(304);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "305" status code
-   */
-  useProxy(body, generateEtag) {
-    this.status(305);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "307" status code
-   */
-  temporaryRedirect(body, generateEtag) {
-    this.status(307);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "400" status code
-   */
-  badRequest(body, generateEtag) {
-    this.status(400);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "401" status code
-   */
-  unauthorized(body, generateEtag) {
-    this.status(401);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "402" status code
-   */
-  paymentRequired(body, generateEtag) {
-    this.status(402);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "403" status code
-   */
-  forbidden(body, generateEtag) {
-    this.status(403);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "404" status code
-   */
-  notFound(body, generateEtag) {
-    this.status(404);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "405" status code
-   */
-  methodNotAllowed(body, generateEtag) {
-    this.status(405);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "406" status code
-   */
-  notAcceptable(body, generateEtag) {
-    this.status(406);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "407" status code
-   */
-  proxyAuthenticationRequired(body, generateEtag) {
-    this.status(407);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "408" status code
-   */
-  requestTimeout(body, generateEtag) {
-    this.status(408);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "409" status code
-   */
-  conflict(body, generateEtag) {
-    this.status(409);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "401" status code
-   */
-  gone(body, generateEtag) {
-    this.status(410);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "411" status code
-   */
-  lengthRequired(body, generateEtag) {
-    this.status(411);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "412" status code
-   */
-  preconditionFailed(body, generateEtag) {
-    this.status(412);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "413" status code
-   */
-  requestEntityTooLarge(body, generateEtag) {
-    this.status(413);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "414" status code
-   */
-  requestUriTooLong(body, generateEtag) {
-    this.status(414);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "415" status code
-   */
-  unsupportedMediaType(body, generateEtag) {
-    this.status(415);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "416" status code
-   */
-  requestedRangeNotSatisfiable(body, generateEtag) {
-    this.status(416);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "417" status code
-   */
-  expectationFailed(body, generateEtag) {
-    this.status(417);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "422" status code
-   */
-  unprocessableEntity(body, generateEtag) {
-    this.status(422);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "429" status code
-   */
-  tooManyRequests(body, generateEtag) {
-    this.status(429);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "500" status code
-   */
-  internalServerError(body, generateEtag) {
-    this.status(500);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "501" status code
-   */
-  notImplemented(body, generateEtag) {
-    this.status(501);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "502" status code
-   */
-  badGateway(body, generateEtag) {
-    this.status(502);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "503" status code
-   */
-  serviceUnavailable(body, generateEtag) {
-    this.status(503);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "504" status code
-   */
-  gatewayTimeout(body, generateEtag) {
-    this.status(504);
-    return this.send(body, generateEtag);
-  }
-  /**
-   * Shorthand method to finish request with "505" status code
-   */
-  httpVersionNotSupported(body, generateEtag) {
-    this.status(505);
-    return this.send(body, generateEtag);
-  }
-};
-
-// src/router/main.ts
-import is3 from "@sindresorhus/is";
-import { moduleImporter as moduleImporter3 } from "@adonisjs/fold";
-import { RuntimeException as RuntimeException6 } from "@poppinss/utils";
-
-// src/router/store.ts
-import matchit2 from "@poppinss/matchit";
-import lodash2 from "@poppinss/utils/lodash";
-import { RuntimeException as RuntimeException4 } from "@poppinss/utils";
-
-// src/router/parser.ts
-import matchit from "@poppinss/matchit";
-function parseRoutePattern(pattern, matchers) {
-  const tokens = matchit.parse(pattern, matchers);
-  return tokens;
-}
-
-// src/router/store.ts
-var RoutesStore = class {
-  /**
-   * A flag to know if routes for explicit domains
-   * have been registered
-   */
-  usingDomains = false;
-  /**
-   * Tree of registered routes and their matchit tokens
-   */
-  tree = { tokens: [], domains: {} };
-  /**
-   * Returns the domain node for a given domain.
-   */
-  #getDomainNode(domain) {
-    if (!this.tree.domains[domain]) {
-      this.tree.tokens.push(parseRoutePattern(domain));
-      this.tree.domains[domain] = {};
-    }
-    return this.tree.domains[domain];
-  }
-  /**
-   * Returns the method node for a given domain and method.
-   */
-  #getMethodNode(domain, method) {
-    const domainNode = this.#getDomainNode(domain);
-    if (!domainNode[method]) {
-      domainNode[method] = { tokens: [], routes: {}, routeKeys: {} };
-    }
-    return domainNode[method];
-  }
-  /**
-   * Collects route params
-   */
-  #collectRouteParams(route, tokens) {
-    const collectedParams = /* @__PURE__ */ new Set();
-    for (let token of tokens) {
-      if ([1, 3].includes(token.type)) {
-        if (collectedParams.has(token.val)) {
-          throw new RuntimeException4(`Duplicate param "${token.val}" found in "${route.pattern}"`);
-        } else {
-          collectedParams.add(token.val);
-        }
-      }
-    }
-    const params = [...collectedParams];
-    collectedParams.clear();
-    return params;
-  }
-  /**
-   * Register route for a given domain and method
-   */
-  #registerRoute(domain, method, tokens, route) {
-    const methodRoutes = this.#getMethodNode(domain, method);
-    if (methodRoutes.routes[route.pattern]) {
-      throw new RuntimeException4(
-        `Duplicate route found. "${method}: ${route.pattern}" route already exists`
-      );
-    }
-    if (debug_default.enabled) {
-      debug_default("registering route to the store %O", route);
-      debug_default("route middleware %O", route.middleware.all().entries());
-    }
-    methodRoutes.tokens.push(tokens);
-    methodRoutes.routes[route.pattern] = route;
-    methodRoutes.routeKeys[route.pattern] = domain !== "root" ? `${domain}-${method}-${route.pattern}` : `${method}-${route.pattern}`;
-  }
-  /**
-   * Add a route to the store
-   *
-   * ```ts
-   * store.add({
-   *   pattern: 'post/:id',
-   *   methods: ['GET'],
-   *   matchers: {},
-   *   meta: {},
-   *   handler: function handler () {
-   *   }
-   * })
-   * ```
-   */
-  add(route) {
-    if (route.domain !== "root") {
-      this.usingDomains = true;
-    }
-    const tokens = parseRoutePattern(route.pattern, route.matchers);
-    const routeNode = lodash2.merge(
-      { meta: {} },
-      lodash2.pick(route, ["pattern", "handler", "meta", "middleware", "name", "execute"])
-    );
-    routeNode.meta.params = this.#collectRouteParams(routeNode, tokens);
-    route.methods.forEach((method) => {
-      this.#registerRoute(route.domain, method, tokens, routeNode);
-    });
-    return this;
-  }
-  /**
-   * Matches the url, method and optionally domain to pull the matching
-   * route. `null` is returned when unable to match the URL against
-   * registered routes.
-   *
-   * The domain parameter has to be a registered pattern and not the fully
-   * qualified runtime domain. You must call `matchDomain` first to fetch
-   * the pattern for qualified domain
-   */
-  match(url, method, domain) {
-    const domainName = domain?.tokens[0]?.old || "root";
-    const matchedDomain = this.tree.domains[domainName];
-    if (!matchedDomain) {
-      return null;
-    }
-    const matchedMethod = this.tree.domains[domainName][method];
-    if (!matchedMethod) {
-      return null;
-    }
-    const matchedRoute = matchit2.match(url, matchedMethod.tokens);
-    if (!matchedRoute.length) {
-      return null;
-    }
-    const route = matchedMethod.routes[matchedRoute[0].old];
-    return {
-      route,
-      routeKey: matchedMethod.routeKeys[route.pattern],
-      params: matchit2.exec(url, matchedRoute),
-      subdomains: domain?.hostname ? matchit2.exec(domain.hostname, domain.tokens) : {}
-    };
-  }
-  /**
-   * Match hostname against registered domains.
-   */
-  matchDomain(hostname) {
-    if (!hostname || !this.usingDomains) {
-      return [];
-    }
-    return matchit2.match(hostname, this.tree.tokens);
-  }
-};
-
-// src/router/lookup_store/url_builder.ts
-import { RuntimeException as RuntimeException5 } from "@poppinss/utils";
-var UrlBuilder = class {
-  /**
-   * Query string parser
-   */
-  #qsParser;
-  /**
-   * The parameters to apply on the route
-   */
-  #params = {};
-  /**
-   * Query string to append to the route
-   */
-  #qs = {};
-  /**
-   * Should we perform the route lookup or just build the
-   * given pattern as it is.
-   */
-  #shouldPerformLookup = true;
-  /**
-   * BaseURL to append to the constructored URL
-   */
-  #baseUrl;
-  /**
-   * Encryption class for making signed URLs
-   */
-  #encryption;
-  /**
-   * Route finder for finding route pattern
-   */
-  #routeFinder;
-  constructor(encryption, routeFinder, qsParser) {
-    this.#qsParser = qsParser;
-    this.#encryption = encryption;
-    this.#routeFinder = routeFinder;
-  }
-  /**
-   * Raises exception when wildcard values array is missing or
-   * has length of zero.
-   */
-  #ensureHasWildCardValues(pattern, values) {
-    if (!values || !Array.isArray(values) || !values.length) {
-      throw new RuntimeException5(
-        `Cannot make URL for "${pattern}" route. Invalid value provided for wildcard param`
-      );
-    }
-  }
-  /*
-   * Raises exception when value is not defined
-   */
-  #ensureHasParamValue(pattern, param, value) {
-    if (value === void 0 || value === null) {
-      throw new RuntimeException5(
-        `Cannot make URL for "${pattern}" route. Missing value for "${param}" param`
-      );
-    }
-  }
-  /**
-   * Processes the pattern against the params
-   */
-  #processPattern(pattern) {
-    const uriSegments = [];
-    const paramsArray = Array.isArray(this.#params) ? this.#params : null;
-    const paramsObject = !Array.isArray(this.#params) ? this.#params : {};
-    let paramsIndex = 0;
-    const tokens = parseRoutePattern(pattern);
-    for (const token of tokens) {
-      if (token.type === 0) {
-        uriSegments.push(`${token.val}${token.end}`);
-      } else if (token.type === 2) {
-        const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject["*"];
-        this.#ensureHasWildCardValues(pattern, values);
-        uriSegments.push(`${values.join("/")}${token.end}`);
-        break;
-      } else {
-        const paramName = token.val;
-        const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
-        if (token.type === 1) {
-          this.#ensureHasParamValue(pattern, paramName, value);
-        }
-        paramsIndex++;
-        if (value !== void 0 && value !== null) {
-          uriSegments.push(`${value}${token.end}`);
-        }
-      }
-    }
-    return `/${uriSegments.join("/")}`;
-  }
-  /**
-   * Suffix the query string to the URL
-   */
-  #suffixQueryString(url, qs) {
-    if (qs) {
-      const queryString = this.#qsParser.stringify(qs);
-      url = queryString ? `${url}?${queryString}` : url;
-    }
-    return url;
-  }
-  /**
-   * Prefixes base URL to the uri string
-   */
-  #prefixBaseUrl(uri) {
-    return this.#baseUrl ? `${this.#baseUrl}${uri}` : uri;
-  }
-  /**
-   * Prefix a custom base URL to the final URI
-   */
-  prefixUrl(url) {
-    this.#baseUrl = url;
-    return this;
-  }
-  /**
-   * Disable route lookup. Calling this method considers
-   * the "identifier" as the route pattern
-   */
-  disableRouteLookup() {
-    this.#shouldPerformLookup = false;
-    return this;
-  }
-  /**
-   * Append query string to the final URI
-   */
-  qs(queryString) {
-    if (!queryString) {
-      return this;
-    }
-    this.#qs = queryString;
-    return this;
-  }
-  /**
-   * Specify params to apply to the route pattern
-   */
-  params(params) {
-    if (!params) {
-      return this;
-    }
-    this.#params = params;
-    return this;
-  }
-  /**
-   * Generate URL for the given route identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   */
-  make(identifier) {
-    let url;
-    if (this.#shouldPerformLookup) {
-      const route = this.#routeFinder.findOrFail(identifier);
-      url = this.#processPattern(route.pattern);
-    } else {
-      url = this.#processPattern(identifier);
-    }
-    return this.#suffixQueryString(this.#prefixBaseUrl(url), this.#qs);
-  }
-  /**
-   * Generate a signed URL for the given route identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   */
-  makeSigned(identifier, options) {
-    let url;
-    if (this.#shouldPerformLookup) {
-      const route = this.#routeFinder.findOrFail(identifier);
-      url = this.#processPattern(route.pattern);
-    } else {
-      url = this.#processPattern(identifier);
-    }
-    const signature = this.#encryption.verifier.sign(
-      this.#suffixQueryString(url, this.#qs),
-      options?.expiresIn,
-      options?.purpose
-    );
-    const qs = Object.assign({}, this.#qs, { signature });
-    return this.#suffixQueryString(this.#prefixBaseUrl(url), qs);
-  }
-};
-
-// src/router/lookup_store/route_finder.ts
-var RouteFinder = class {
-  #routes;
-  constructor(routes) {
-    this.#routes = routes;
-  }
-  /**
-   * Find a route by indentifier
-   */
-  find(routeIdentifier) {
-    return this.#routes.find(({ name, pattern, handler }) => {
-      if (name === routeIdentifier || pattern === routeIdentifier) {
-        return true;
-      }
-      if (typeof handler === "function") {
-        return false;
-      }
-      return handler.reference === routeIdentifier;
-    }) || null;
-  }
-  /**
-   * Find a route by indentifier or fail
-   */
-  findOrFail(routeIdentifier) {
-    const route = this.find(routeIdentifier);
-    if (!route) {
-      throw new E_CANNOT_LOOKUP_ROUTE([routeIdentifier]);
-    }
-    return route;
-  }
-  /**
-   * Find if a route exists
-   */
-  has(routeIdentifier) {
-    return !!this.find(routeIdentifier);
-  }
-};
-
-// src/router/lookup_store/main.ts
-var LookupStore = class {
-  /**
-   * List of routes grouped by domain
-   */
-  #routes = {};
-  /**
-   * Encryption for making URLs
-   */
-  #encryption;
-  /**
-   * Query string parser for making URLs
-   */
-  #qsParser;
-  constructor(encryption, qsParser) {
-    this.#encryption = encryption;
-    this.#qsParser = qsParser;
-  }
-  /**
-   * Register route JSON payload
-   */
-  register(route) {
-    this.#routes[route.domain] = this.#routes[route.domain] || [];
-    this.#routes[route.domain].push(route);
-  }
-  /**
-   * Returns an instance of the URL builder for making
-   * route URIs
-   */
-  builder() {
-    return this.builderForDomain("root");
-  }
-  /**
-   * Returns an instance of the URL builder for a specific
-   * domain.
-   */
-  builderForDomain(domain) {
-    const routes = this.#routes[domain];
-    return new UrlBuilder(this.#encryption, new RouteFinder(routes || []), this.#qsParser);
-  }
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   */
-  find(routeIdentifier, domain) {
-    const routes = this.#routes[domain || "root"] || [];
-    return new RouteFinder(routes).find(routeIdentifier);
-  }
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   *
-   * An error is raised when unable to find the route.
-   */
-  findOrFail(routeIdentifier, domain) {
-    const routes = this.#routes[domain || "root"] || [];
-    return new RouteFinder(routes).findOrFail(routeIdentifier);
-  }
-  /**
-   * Check if a route exists. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   */
-  has(routeIdentifier, domain) {
-    const routes = this.#routes[domain || "root"] || [];
-    return new RouteFinder(routes).has(routeIdentifier);
-  }
-  toJSON() {
-    return this.#routes;
-  }
-};
-
-// src/router/matchers.ts
-import Macroable7 from "@poppinss/macroable";
-var RouteMatchers = class extends Macroable7 {
-  /**
-   * Enforce value to be a number and also casts it to number data
-   * type
-   */
-  number() {
-    return { match: /^[0-9]+$/, cast: (value) => Number(value) };
-  }
-  /**
-   * Enforce value to be formatted as uuid
-   */
-  uuid() {
-    return {
-      match: /^[0-9a-zA-F]{8}-[0-9a-zA-F]{4}-[0-9a-zA-F]{4}-[0-9a-zA-F]{4}-[0-9a-zA-F]{12}$/,
-      cast: (value) => value.toLowerCase()
-    };
-  }
-  /**
-   * Enforce value to be formatted as slug
-   */
-  slug() {
-    return { match: /^[^\s-_](?!.*?[-_]{2,})([a-z0-9-\\]{1,})[^\s]*[^-_\s]$/ };
-  }
-};
-
-// src/define_middleware.ts
-import { moduleImporter as moduleImporter2 } from "@adonisjs/fold";
-function middlewareReferenceBuilder(name, middleware) {
-  const handler = moduleImporter2(middleware, "handle").toHandleMethod();
-  return function(...args) {
-    return {
-      name,
-      args: args[0],
-      ...handler
-    };
-  };
-}
-function defineNamedMiddleware(collection) {
-  return Object.keys(collection).reduce(
-    (result, key) => {
-      result[key] = middlewareReferenceBuilder(key, collection[key]);
-      return result;
-    },
-    {}
-  );
-}
-
-// src/router/main.ts
-var Router = class extends LookupStore {
-  /**
-   * Application is needed to resolve string based controller expressions
-   */
-  #app;
-  /**
-   * Store with tokenized routes
-   */
-  #store = new RoutesStore();
-  /**
-   * Global matchers to test route params against regular expressions.
-   */
-  #globalMatchers = {};
-  /**
-   * Middleware store to be shared with the routes
-   */
-  #middleware = [];
-  /**
-   * A boolean to tell the router that a group is in
-   * open state right now
-   */
-  #openedGroups = [];
-  /**
-   * Collection of routes, including route resource and route
-   * group. To get a flat list of routes, call `router.toJSON()`
-   */
-  routes = [];
-  /**
-   * A flag to know if routes for explicit domains have been registered.
-   * The boolean is computed after calling the "commit" method.
-   */
-  usingDomains = false;
-  /**
-   * Shortcut methods for commonly used route matchers
-   */
-  matchers = new RouteMatchers();
-  constructor(app, encryption, qsParser) {
-    super(encryption, qsParser);
-    this.#app = app;
-  }
-  /**
-   * Push a give router entity to the list of routes or the
-   * recently opened group.
-   */
-  #pushToRoutes(entity) {
-    const openedGroup = this.#openedGroups[this.#openedGroups.length - 1];
-    if (openedGroup) {
-      openedGroup.routes.push(entity);
-      return;
-    }
-    this.routes.push(entity);
-  }
-  /**
-   * Parses the route pattern
-   */
-  parsePattern(pattern, matchers) {
-    return parseRoutePattern(pattern, matchers);
-  }
-  /**
-   * Define an array of middleware to use on all the routes.
-   * Calling this method multiple times pushes to the
-   * existing list of middleware
-   */
-  use(middleware) {
-    middleware.forEach(
-      (one) => this.#middleware.push(moduleImporter3(one, "handle").toHandleMethod())
-    );
-    return this;
-  }
-  /**
-   * Define a collection of named middleware. The defined collection is
-   * not registered anywhere, but instead converted in a new collection
-   * of functions you can apply on the routes, or router groups.
-   */
-  named(collection) {
-    return defineNamedMiddleware(collection);
-  }
-  /**
-   * Add route for a given pattern and methods
-   */
-  route(pattern, methods, handler) {
-    const route = new Route(this.#app, this.#middleware, {
-      pattern,
-      methods,
-      handler,
-      globalMatchers: this.#globalMatchers
-    });
-    this.#pushToRoutes(route);
-    return route;
-  }
-  /**
-   * Define a route that handles all common HTTP methods
-   */
-  any(pattern, handler) {
-    return this.route(
-      pattern,
-      ["HEAD", "OPTIONS", "GET", "POST", "PUT", "PATCH", "DELETE"],
-      handler
-    );
-  }
-  /**
-   * Define `GET` route
-   */
-  get(pattern, handler) {
-    return this.route(pattern, ["GET", "HEAD"], handler);
-  }
-  /**
-   * Define `POST` route
-   */
-  post(pattern, handler) {
-    return this.route(pattern, ["POST"], handler);
-  }
-  /**
-   * Define `PUT` route
-   */
-  put(pattern, handler) {
-    return this.route(pattern, ["PUT"], handler);
-  }
-  /**
-   * Define `PATCH` route
-   */
-  patch(pattern, handler) {
-    return this.route(pattern, ["PATCH"], handler);
-  }
-  /**
-   * Define `DELETE` route
-   */
-  delete(pattern, handler) {
-    return this.route(pattern, ["DELETE"], handler);
-  }
-  /**
-   * Creates a group of routes. A route group can apply transforms
-   * to routes in bulk
-   */
-  group(callback) {
-    const group = new RouteGroup([]);
-    this.#pushToRoutes(group);
-    this.#openedGroups.push(group);
-    callback();
-    this.#openedGroups.pop();
-    return group;
-  }
-  /**
-   * Registers a route resource with conventional set of routes
-   */
-  resource(resource, controller) {
-    const resourceInstance = new RouteResource(this.#app, this.#middleware, {
-      resource,
-      controller,
-      shallow: false,
-      globalMatchers: this.#globalMatchers
-    });
-    this.#pushToRoutes(resourceInstance);
-    return resourceInstance;
-  }
-  /**
-   * Register a route resource with shallow nested routes.
-   */
-  shallowResource(resource, controller) {
-    const resourceInstance = new RouteResource(this.#app, this.#middleware, {
-      resource,
-      controller,
-      shallow: true,
-      globalMatchers: this.#globalMatchers
-    });
-    this.#pushToRoutes(resourceInstance);
-    return resourceInstance;
-  }
-  /**
-   * Returns a brisk route instance for a given URL pattern
-   */
-  on(pattern) {
-    const briskRoute = new BriskRoute(this.#app, this.#middleware, {
-      pattern,
-      globalMatchers: this.#globalMatchers
-    });
-    this.#pushToRoutes(briskRoute);
-    return briskRoute;
-  }
-  /**
-   * Define matcher for a given param. The global params are applied
-   * on all the routes (unless overridden at the route level).
-   */
-  where(param, matcher) {
-    if (typeof matcher === "string") {
-      this.#globalMatchers[param] = { match: new RegExp(matcher) };
-    } else if (is3.regExp(matcher)) {
-      this.#globalMatchers[param] = { match: matcher };
-    } else {
-      this.#globalMatchers[param] = matcher;
-    }
-    return this;
-  }
-  /**
-   * Commit routes to the store. The router is freezed after the
-   * commit method is called.
-   */
-  commit() {
-    const routeNamesByDomain = /* @__PURE__ */ new Map();
-    toRoutesJSON(this.routes).forEach((route) => {
-      if (!routeNamesByDomain.has(route.domain)) {
-        routeNamesByDomain.set(route.domain, /* @__PURE__ */ new Set());
-      }
-      const routeNames = routeNamesByDomain.get(route.domain);
-      if (route.name && routeNames.has(route.name)) {
-        throw new RuntimeException6(
-          `Route with duplicate name found. A route with name "${route.name}" already exists`
-        );
-      }
-      if (route.name) {
-        routeNames.add(route.name);
-      }
-      this.register(route);
-      this.#store.add(route);
-    });
-    routeNamesByDomain.clear();
-    this.usingDomains = this.#store.usingDomains;
-    this.routes = [];
-    this.#globalMatchers = {};
-    this.#middleware = [];
-  }
-  /**
-   * Find route for a given URL, method and optionally domain
-   */
-  match(url, method, hostname) {
-    const matchingDomain = this.#store.matchDomain(hostname);
-    return matchingDomain.length ? this.#store.match(url, method, {
-      tokens: matchingDomain,
-      hostname
-    }) : this.#store.match(url, method);
-  }
-  /**
-   * Make URL to a pre-registered route
-   */
-  makeUrl(routeIdentifier, params, options) {
-    const normalizedOptions = Object.assign({}, options);
-    const builder = normalizedOptions.domain ? this.builderForDomain(normalizedOptions.domain) : this.builder();
-    builder.params(params);
-    builder.qs(normalizedOptions.qs);
-    normalizedOptions.prefixUrl && builder.prefixUrl(normalizedOptions.prefixUrl);
-    normalizedOptions.disableRouteLookup && builder.disableRouteLookup();
-    return builder.make(routeIdentifier);
-  }
-  /**
-   * Makes a signed URL to a pre-registered route.
-   */
-  makeSignedUrl(routeIdentifier, params, options) {
-    const normalizedOptions = Object.assign({}, options);
-    const builder = normalizedOptions.domain ? this.builderForDomain(normalizedOptions.domain) : this.builder();
-    builder.params(params);
-    builder.qs(normalizedOptions.qs);
-    normalizedOptions.prefixUrl && builder.prefixUrl(normalizedOptions.prefixUrl);
-    normalizedOptions.disableRouteLookup && builder.disableRouteLookup();
-    return builder.makeSigned(routeIdentifier, normalizedOptions);
-  }
-};
-
-// src/http_context/main.ts
-import { inspect } from "node:util";
-import Macroable8 from "@poppinss/macroable";
-import { RuntimeException as RuntimeException7 } from "@poppinss/utils";
-
-// src/http_context/local_storage.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var asyncLocalStorage = {
-  /**
-   * Check if the async local storage for the HTTP
-   * context is enabled or not
-   */
-  isEnabled: false,
-  /**
-   * HTTP context storage instance for the current scope
-   */
-  storage: null,
-  /**
-   * Create the storage instance. This method must be called only
-   * once.
-   */
-  create() {
-    this.isEnabled = true;
-    this.storage = new AsyncLocalStorage();
-    return this.storage;
-  },
-  /**
-   * Destroy the create storage instance
-   */
-  destroy() {
-    this.isEnabled = false;
-    this.storage = null;
-  }
-};
-
-// src/http_context/main.ts
-var HttpContext = class extends Macroable8 {
-  constructor(request, response, logger, containerResolver) {
-    super();
-    this.request = request;
-    this.response = response;
-    this.logger = logger;
-    this.containerResolver = containerResolver;
-    this.request.ctx = this;
-    this.response.ctx = this;
-  }
-  /**
-   * Find if async localstorage is enabled for HTTP requests
-   * or not
-   */
-  static get usingAsyncLocalStorage() {
-    return asyncLocalStorage.isEnabled;
-  }
-  /**
-   * Get access to the HTTP context. Available only when
-   * "usingAsyncLocalStorage" is true
-   */
-  static get() {
-    if (!this.usingAsyncLocalStorage || !asyncLocalStorage.storage) {
-      return null;
-    }
-    return asyncLocalStorage.storage.getStore() || null;
-  }
-  /**
-   * Get the HttpContext instance or raise an exception if not
-   * available
-   */
-  static getOrFail() {
-    if (!this.usingAsyncLocalStorage || !asyncLocalStorage.storage) {
-      throw new RuntimeException7(
-        'HTTP context is not available. Enable "useAsyncLocalStorage" inside "config/app.ts" file'
-      );
-    }
-    const store = this.get();
-    if (!store) {
-      throw new RuntimeException7("Http context is not available outside of an HTTP request");
-    }
-    return store;
-  }
-  /**
-   * Run a method that doesn't have access to HTTP context from
-   * the async local storage.
-   */
-  static runOutsideContext(callback, ...args) {
-    if (!asyncLocalStorage.storage) {
-      return callback(...args);
-    }
-    return asyncLocalStorage.storage.exit(callback, ...args);
-  }
-  /**
-   * Reference to the current route. Not available inside
-   * server middleware
-   */
-  route;
-  /**
-   * A unique key for the current route
-   */
-  routeKey;
-  /**
-   * Route params
-   */
-  params = {};
-  /**
-   * Route subdomains
-   */
-  subdomains = {};
-  /**
-   * A helper to see top level properties on the context object
-   */
-  /* c8 ignore next 3 */
-  inspect() {
-    return inspect(this, false, 1, true);
-  }
-};
-
-// src/server/main.ts
-import onFinished2 from "on-finished";
-import Middleware2 from "@poppinss/middleware";
-import { moduleCaller as moduleCaller2, moduleImporter as moduleImporter4 } from "@adonisjs/fold";
-
-// src/qs.ts
-import { parse as parse3, stringify } from "qs";
-var Qs = class {
-  #config;
-  constructor(config) {
-    this.#config = config;
-  }
-  parse(value) {
-    return parse3(value, this.#config.parse);
-  }
-  stringify(value) {
-    return stringify(value, this.#config.stringify);
-  }
-};
-
-// src/server/factories/final_handler.ts
-function finalHandler(router, resolver, ctx, errorResponder) {
-  return function() {
-    const url = ctx.request.url();
-    const method = ctx.request.method();
-    const hostname = router.usingDomains ? ctx.request.hostname() : void 0;
-    const route = router.match(url, method, hostname);
-    if (route) {
-      ctx.params = route.params;
-      ctx.subdomains = route.subdomains;
-      ctx.route = route.route;
-      ctx.routeKey = route.routeKey;
-      return route.route.execute(route.route, resolver, ctx, errorResponder);
-    }
-    return Promise.reject(new E_ROUTE_NOT_FOUND([method, url]));
-  };
-}
-
-// src/server/factories/write_response.ts
-function writeResponse(ctx) {
-  return function() {
-    try {
-      ctx.response.finish();
-    } catch (error) {
-      ctx.logger.fatal({ err: error }, "Response serialization failed");
-      ctx.response.internalServerError(error.message);
-      ctx.response.finish();
-    }
-  };
-}
-
-// src/server/factories/middleware_handler.ts
-function middlewareHandler(resolver, ctx) {
-  return function(fn, next) {
-    return fn.handle(resolver, ctx, next);
-  };
-}
-
-// src/server/main.ts
-var Server = class {
-  /**
-   * The default error handler to use
-   */
-  #defaultErrorHandler = {
-    report() {
-    },
-    handle(error, ctx) {
-      ctx.response.status(error.status || 500).send(error.message || "Internal server error");
-    }
-  };
-  /**
-   * Logger instance, a child logger is added
-   * to the context to have request specific
-   * logging capabilities.
-   */
-  #logger;
-  /**
-   * Registered error handler (if any)
-   */
-  #errorHandler;
-  /**
-   * Resolved error handler is an instance of the lazily imported error
-   * handler class.
-   */
-  #resolvedErrorHandler = this.#defaultErrorHandler;
-  /**
-   * Emitter is required to notify when a request finishes
-   */
-  #emitter;
-  /**
-   * The application instance to be shared with the router
-   */
-  #app;
-  /**
-   * The encryption instance to be shared with the router
-   */
-  #encryption;
-  /**
-   * Server config
-   */
-  #config;
-  /**
-   * Query string parser used by the server
-   */
-  #qsParser;
-  /**
-   * Server middleware stack runs on every incoming HTTP request
-   */
-  #serverMiddlewareStack;
-  /**
-   * Reference to the router used by the server
-   */
-  #router;
-  /**
-   * Reference to the underlying Node HTTP server in use
-   */
-  #nodeHttpServer;
-  /**
-   * Middleware store to be shared with the routes
-   */
-  #middleware = [];
-  /**
-   * The request error response is attached to the middleware
-   * pipeline to intercept errors and invoke the user
-   * registered error handler.
-   *
-   * We share this with the route middleware pipeline as well,
-   * so that it does not throw any exceptions
-   */
-  #requestErrorResponder = (error, ctx) => {
-    this.#resolvedErrorHandler.report(error, ctx);
-    return this.#resolvedErrorHandler.handle(error, ctx);
-  };
-  /**
-   * Know if async local storage is enabled or not.
-   */
-  get usingAsyncLocalStorage() {
-    return asyncLocalStorage.isEnabled;
-  }
-  constructor(app, encryption, emitter, logger, config) {
-    this.#app = app;
-    this.#emitter = emitter;
-    this.#config = config;
-    this.#logger = logger;
-    this.#encryption = encryption;
-    this.#qsParser = new Qs(this.#config.qs);
-    this.#router = new Router(this.#app, this.#encryption, this.#qsParser);
-    this.#createAsyncLocalStore();
-    debug_default("server config: %O", this.#config);
-  }
-  /**
-   * Create async local storage store when enabled
-   */
-  #createAsyncLocalStore() {
-    if (this.#config.useAsyncLocalStorage) {
-      debug_default("creating ALS store for HTTP context");
-      asyncLocalStorage.create();
-    } else {
-      asyncLocalStorage.destroy();
-    }
-  }
-  /**
-   * Creates an instance of the server middleware stack
-   */
-  #createServerMiddlewareStack() {
-    this.#serverMiddlewareStack = new Middleware2();
-    this.#middleware.forEach((middleware) => this.#serverMiddlewareStack.add(middleware));
-    this.#serverMiddlewareStack.freeze();
-    this.#middleware = [];
-  }
-  /**
-   * Handles the HTTP request
-   */
-  #handleRequest(ctx, resolver) {
-    return this.#serverMiddlewareStack.runner().errorHandler((error) => this.#requestErrorResponder(error, ctx)).finalHandler(finalHandler(this.#router, resolver, ctx, this.#requestErrorResponder)).run(middlewareHandler(resolver, ctx)).catch((error) => {
-      ctx.logger.fatal({ err: error }, "Exception raised by error handler");
-      return this.#defaultErrorHandler.handle(error, ctx);
-    }).finally(writeResponse(ctx));
-  }
-  /**
-   * Creates a pipeline of middleware.
-   */
-  pipeline(middleware) {
-    const middlewareStack = new Middleware2();
-    middleware.forEach((one) => {
-      middlewareStack.add(moduleCaller2(one, "handle").toHandleMethod());
-    });
-    middlewareStack.freeze();
-    const stackRunner = middlewareStack.runner();
-    return {
-      finalHandler(handler) {
-        stackRunner.finalHandler(handler);
-        return this;
-      },
-      errorHandler(handler) {
-        stackRunner.errorHandler(handler);
-        return this;
-      },
-      run(ctx) {
-        return stackRunner.run((handler, next) => {
-          return handler.handle(ctx.containerResolver, ctx, next);
-        });
-      }
-    };
-  }
-  /**
-   * Define an array of middleware to use on all the incoming HTTP request.
-   * Calling this method multiple times pushes to the existing list
-   * of middleware
-   */
-  use(middleware) {
-    middleware.forEach(
-      (one) => this.#middleware.push(moduleImporter4(one, "handle").toHandleMethod())
-    );
-    return this;
-  }
-  /**
-   * Register a custom error handler for HTTP requests.
-   * All errors will be reported to this method
-   */
-  errorHandler(handler) {
-    this.#errorHandler = handler;
-    return this;
-  }
-  /**
-   * Boot the server. Calling this method performs the following actions.
-   *
-   * - Register routes with the store.
-   * - Resolve and construct the error handler.
-   */
-  async boot() {
-    debug_default("booting HTTP server");
-    this.#createServerMiddlewareStack();
-    this.#router.commit();
-    if (this.#errorHandler) {
-      if (debug_default.enabled) {
-        debug_default('using custom error handler "%s"', this.#errorHandler);
-      }
-      const moduleExports = await this.#errorHandler();
-      this.#resolvedErrorHandler = await this.#app.container.make(moduleExports.default);
-    }
-  }
-  /**
-   * Set the HTTP server instance used to listen for requests.
-   */
-  setNodeServer(server) {
-    this.#nodeHttpServer = server;
-  }
-  /**
-   * Returns reference to the underlying HTTP server
-   * in use
-   */
-  getNodeServer() {
-    return this.#nodeHttpServer;
-  }
-  /**
-   * Returns reference to the router instance used
-   * by the server.
-   */
-  getRouter() {
-    return this.#router;
-  }
-  /**
-   * Creates an instance of the [[Request]] class
-   */
-  createRequest(req, res) {
-    return new Request(req, res, this.#encryption, this.#config, this.#qsParser);
-  }
-  /**
-   * Creates an instance of the [[Response]] class
-   */
-  createResponse(req, res) {
-    return new Response(req, res, this.#encryption, this.#config, this.#router, this.#qsParser);
-  }
-  /**
-   * Creates an instance of the [[HttpContext]] class
-   */
-  createHttpContext(request, response, resolver) {
-    return new HttpContext(
-      request,
-      response,
-      this.#logger.child({ request_id: request.id() }),
-      resolver
-    );
-  }
-  /**
-   * Handle request
-   */
-  handle(req, res) {
-    const hasRequestListener = this.#emitter.hasListeners("http:request_finished");
-    const startTime = hasRequestListener ? process.hrtime() : null;
-    const resolver = this.#app.container.createResolver();
-    const ctx = this.createHttpContext(
-      this.createRequest(req, res),
-      this.createResponse(req, res),
-      resolver
-    );
-    if (startTime) {
-      onFinished2(res, () => {
-        this.#emitter.emit("http:request_finished", {
-          ctx,
-          duration: process.hrtime(startTime)
-        });
-      });
-    }
-    if (this.usingAsyncLocalStorage) {
-      return asyncLocalStorage.storage.run(ctx, () => this.#handleRequest(ctx, resolver));
-    }
-    return this.#handleRequest(ctx, resolver);
-  }
-};
-
-// src/define_config.ts
-import proxyAddr from "proxy-addr";
-import string3 from "@poppinss/utils/string";
-function defineConfig(config) {
-  const { trustProxy: trustProxy2, ...rest } = config;
-  const normalizedConfig = {
-    allowMethodSpoofing: false,
-    trustProxy: proxyAddr.compile("loopback"),
-    subdomainOffset: 2,
-    generateRequestId: false,
-    useAsyncLocalStorage: false,
-    etag: false,
-    jsonpCallbackName: "callback",
-    cookie: {
-      maxAge: "2h",
-      path: "/",
-      httpOnly: true,
-      secure: false,
-      sameSite: false
-    },
-    qs: {
-      parse: {
-        depth: 5,
-        parameterLimit: 1e3,
-        allowSparse: false,
-        arrayLimit: 20,
-        comma: true
-      },
-      stringify: {
-        encode: true,
-        encodeValuesOnly: false,
-        arrayFormat: "indices",
-        skipNulls: false
-      }
-    },
-    ...rest
-  };
-  if (normalizedConfig.cookie.maxAge) {
-    normalizedConfig.cookie.maxAge = string3.seconds.parse(normalizedConfig.cookie.maxAge);
-  }
-  if (typeof trustProxy2 === "boolean") {
-    const tpValue = trustProxy2;
-    normalizedConfig.trustProxy = (_, __) => tpValue;
-  } else if (typeof trustProxy2 === "string") {
-    const tpValue = trustProxy2;
-    normalizedConfig.trustProxy = proxyAddr.compile(tpValue);
-  }
-  return normalizedConfig;
-}
-
-export {
-  Route,
-  BriskRoute,
-  RouteResource,
-  RouteGroup,
-  parseRange,
-  CookieClient,
-  Request,
-  Redirect,
-  E_ROUTE_NOT_FOUND,
-  E_CANNOT_LOOKUP_ROUTE,
-  E_HTTP_EXCEPTION,
-  E_HTTP_REQUEST_ABORTED,
-  exceptions_exports,
-  Response,
-  Qs,
-  Router,
-  HttpContext,
-  Server,
-  defineConfig
-};