routup 5.0.0-beta.3 → 5.0.0-beta.4

package/dist/{index-DCtnUoGL.d.mts → index-doDmTYzg.d.mts}

@@ -5,51 +5,55 @@ import { Key, ParseOptions, PathToRegexpOptions } from "path-to-regexp";
 import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/constants.d.ts
-declare enum MethodName {
-  GET = "GET",
-  POST = "POST",
-  PUT = "PUT",
-  PATCH = "PATCH",
-  DELETE = "DELETE",
-  OPTIONS = "OPTIONS",
-  HEAD = "HEAD"
-}
-declare enum HeaderName {
-  ACCEPT = "accept",
-  ACCEPT_CHARSET = "accept-charset",
-  ACCEPT_ENCODING = "accept-encoding",
-  ACCEPT_LANGUAGE = "accept-language",
-  ACCEPT_RANGES = "accept-ranges",
-  ALLOW = "allow",
-  CACHE_CONTROL = "cache-control",
-  CONTENT_DISPOSITION = "content-disposition",
-  CONTENT_ENCODING = "content-encoding",
-  CONTENT_LENGTH = "content-length",
-  CONTENT_RANGE = "content-range",
-  CONTENT_TYPE = "content-type",
-  CONNECTION = "connection",
-  COOKIE = "cookie",
-  ETag = "etag",
-  HOST = "host",
-  IF_MODIFIED_SINCE = "if-modified-since",
-  IF_NONE_MATCH = "if-none-match",
-  LAST_MODIFIED = "last-modified",
-  LOCATION = "location",
-  RANGE = "range",
-  RATE_LIMIT_LIMIT = "ratelimit-limit",
-  RATE_LIMIT_REMAINING = "ratelimit-remaining",
-  RATE_LIMIT_RESET = "ratelimit-reset",
-  RETRY_AFTER = "retry-after",
-  SET_COOKIE = "set-cookie",
-  TRANSFER_ENCODING = "transfer-encoding",
-  X_ACCEL_BUFFERING = "x-accel-buffering",
-  X_FORWARDED_HOST = "x-forwarded-host",
-  X_FORWARDED_FOR = "x-forwarded-for",
-  X_FORWARDED_PROTO = "x-forwarded-proto"
-}
+declare const MethodName: {
+  readonly GET: "GET";
+  readonly POST: "POST";
+  readonly PUT: "PUT";
+  readonly PATCH: "PATCH";
+  readonly DELETE: "DELETE";
+  readonly OPTIONS: "OPTIONS";
+  readonly HEAD: "HEAD";
+};
+type MethodName = typeof MethodName[keyof typeof MethodName];
+declare const HeaderName: {
+  readonly ACCEPT: "accept";
+  readonly ACCEPT_CHARSET: "accept-charset";
+  readonly ACCEPT_ENCODING: "accept-encoding";
+  readonly ACCEPT_LANGUAGE: "accept-language";
+  readonly ACCEPT_RANGES: "accept-ranges";
+  readonly ALLOW: "allow";
+  readonly CACHE_CONTROL: "cache-control";
+  readonly CONTENT_DISPOSITION: "content-disposition";
+  readonly CONTENT_ENCODING: "content-encoding";
+  readonly CONTENT_LENGTH: "content-length";
+  readonly CONTENT_RANGE: "content-range";
+  readonly CONTENT_TYPE: "content-type";
+  readonly CONNECTION: "connection";
+  readonly COOKIE: "cookie";
+  readonly ETag: "etag";
+  readonly HOST: "host";
+  readonly IF_MODIFIED_SINCE: "if-modified-since";
+  readonly IF_NONE_MATCH: "if-none-match";
+  readonly LAST_MODIFIED: "last-modified";
+  readonly LOCATION: "location";
+  readonly RANGE: "range";
+  readonly RATE_LIMIT_LIMIT: "ratelimit-limit";
+  readonly RATE_LIMIT_REMAINING: "ratelimit-remaining";
+  readonly RATE_LIMIT_RESET: "ratelimit-reset";
+  readonly RETRY_AFTER: "retry-after";
+  readonly SET_COOKIE: "set-cookie";
+  readonly TRANSFER_ENCODING: "transfer-encoding";
+  readonly X_ACCEL_BUFFERING: "x-accel-buffering";
+  readonly X_FORWARDED_HOST: "x-forwarded-host";
+  readonly X_FORWARDED_FOR: "x-forwarded-for";
+  readonly X_FORWARDED_PROTO: "x-forwarded-proto";
+};
+type HeaderName = typeof HeaderName[keyof typeof HeaderName];
 //#endregion
 //#region src/error/module.d.ts
+declare const ErrorSymbol: unique symbol;
 declare class RoutupError extends HTTPError {
+  readonly '@instanceof': symbol;
   constructor(input?: HTTPErrorInput$1);
 }
 //#endregion
@@ -57,7 +61,6 @@ declare class RoutupError extends HTTPError {
 type RoutupResponse = {
   status: number;
   headers: Headers;
-  statusText?: string;
 };
 type RoutupRequest = ServerRequest;
 type NextFn = (error?: Error) => unknown | Promise<unknown>;
@@ -113,6 +116,14 @@ interface IRoutupEvent {
    * Contains merged options from the router path stack with defaults applied.
    */
   readonly routerOptions: RouterOptions;
+  /**
+   * Abort signal tied to the request lifecycle.
+   *
+   * When a `timeout` router option is set, this signal aborts after the
+   * specified duration. Handlers performing long I/O (fetch, streams, DB queries)
+   * can pass this signal to those operations for cooperative cancellation.
+   */
+  readonly signal: AbortSignal;
   /**
    * Call the next handler in the pipeline (onion model).
    *
@@ -133,6 +144,7 @@ type RoutupEventCreateContext = {
   searchParams: URLSearchParams;
   response: RoutupResponse;
   store: Record<string | symbol, unknown>;
+  signal: AbortSignal;
   routerOptions: () => RouterOptions;
   next: (event: IRoutupEvent, error?: Error) => Promise<Response | undefined>;
 };
@@ -146,6 +158,7 @@ declare class RoutupEvent implements IRoutupEvent {
   readonly searchParams: URLSearchParams;
   readonly response: RoutupResponse;
   readonly store: Record<string | symbol, unknown>;
+  readonly signal: AbortSignal;
   protected _context: RoutupEventCreateContext;
   protected _routerOptions?: RouterOptions;
   constructor(context: RoutupEventCreateContext);
@@ -154,14 +167,15 @@ declare class RoutupEvent implements IRoutupEvent {
 }
 //#endregion
 //#region src/hook/constants.d.ts
-declare enum HookName {
-  REQUEST = "request",
-  RESPONSE = "response",
-  ERROR = "error",
-  CHILD_MATCH = "childMatch",
-  CHILD_DISPATCH_BEFORE = "childDispatchBefore",
-  CHILD_DISPATCH_AFTER = "childDispatchAfter"
-}
+declare const HookName: {
+  readonly REQUEST: "request";
+  readonly RESPONSE: "response";
+  readonly ERROR: "error";
+  readonly CHILD_MATCH: "childMatch";
+  readonly CHILD_DISPATCH_BEFORE: "childDispatchBefore";
+  readonly CHILD_DISPATCH_AFTER: "childDispatchAfter";
+};
+type HookName = typeof HookName[keyof typeof HookName];
 //#endregion
 //#region src/dispatcher/types.d.ts
 interface IDispatcherEvent {
@@ -202,10 +216,18 @@ interface IDispatcherEvent {
    * Used internally by router options resolution.
    */
   routerPath: RouterPathNode[];
+  /**
+   * Abort signal for cooperative cancellation.
+   *
+   * When a `timeout` router option is set, this signal aborts after the
+   * specified duration. Handlers can pass it to fetch(), streams, or other
+   * AbortSignal-aware APIs.
+   */
+  signal: AbortSignal;
   /**
    * Collected allowed methods for the current path (used for OPTIONS / 405 responses).
    */
-  methodsAllowed: string[];
+  methodsAllowed: Set<string>;
   /**
    * Set the continuation function for this event.
    *
@@ -221,8 +243,12 @@ interface IDispatcherEvent {
    *
    * Creates a lightweight snapshot with shared references (store, response, headers)
    * and pre-resolved router options. This is the event passed to handler functions.
+   *
+   * @param signal - Optional AbortSignal override. When provided, the built event
+   *                 uses this signal instead of the dispatcher event's own signal.
+   *                 Used by per-handler timeout to provide a handler-scoped signal.
    */
-  build(): RoutupEvent;
+  build(signal?: AbortSignal): RoutupEvent;
 }
 interface IDispatcher {
   dispatch(event: IDispatcherEvent): Promise<Response | undefined>;
@@ -235,13 +261,17 @@ type HookListener = HookErrorListener | HookDefaultListener;
 type HookUnsubscribeFn = () => void;
 //#endregion
 //#region src/hook/module.d.ts
+type HookEntry = {
+  fn: HookListener;
+  priority: number;
+};
 declare class HookManager {
-  protected items: Record<string, HookListener[]>;
+  protected items: Record<string, HookEntry[]>;
   constructor();
-  addListener(name: `${HookName}`, fn: HookListener): HookUnsubscribeFn;
-  removeListener(name: `${HookName}`): void;
-  removeListener(name: `${HookName}`, fn: HookListener): void;
-  trigger(name: `${HookName}`, event: IDispatcherEvent): Promise<void>;
+  addListener(name: HookName, fn: HookListener, priority?: number): HookUnsubscribeFn;
+  removeListener(name: HookName): void;
+  removeListener(name: HookName, fn: HookListener): void;
+  trigger(name: HookName, event: IDispatcherEvent): Promise<void>;
   private triggerListener;
   private isErrorListenerHook;
 }
@@ -269,16 +299,25 @@ declare class PathMatcher {
 declare function isPath(input: unknown): input is Path;
 //#endregion
 //#region src/handler/constants.d.ts
-declare enum HandlerType {
-  CORE = "core",
-  ERROR = "error"
-}
+declare const HandlerType: {
+  readonly CORE: "core";
+  readonly ERROR: "error";
+};
+type HandlerType = typeof HandlerType[keyof typeof HandlerType];
 declare const HandlerSymbol: unique symbol;
 //#endregion
 //#region src/handler/types-base.d.ts
 type HandlerBaseOptions = {
   method?: Uppercase<MethodName> | Lowercase<MethodName>;
   path?: Path;
+  /**
+   * Per-handler timeout in milliseconds.
+   *
+   * Overrides the router's `handlerTimeout` default. Whether this value
+   * can extend or only narrow the default is controlled by the router's
+   * `handlerTimeoutOverridable` option.
+   */
+  timeout?: number;
   onError?: HookErrorListener;
   onBefore?: HookDefaultListener;
   onAfter?: HookDefaultListener;
@@ -287,7 +326,7 @@ type HandlerBaseOptions = {
 //#region src/handler/error/types.d.ts
 type ErrorHandler = (error: RoutupError, event: IRoutupEvent) => unknown | Promise<unknown>;
 type ErrorHandlerOptions = HandlerBaseOptions & {
-  type: `${HandlerType.ERROR}`;
+  type: typeof HandlerType.ERROR;
   fn: ErrorHandler;
 };
 //#endregion
@@ -326,15 +365,17 @@ declare class Handler implements IDispatcher {
   dispatch(event: IDispatcherEvent): Promise<Response | undefined>;
   matchPath(path: string): boolean;
   setPath(path?: Path): void;
-  matchMethod(method: `${MethodName}`): boolean;
-  setMethod(input?: `${MethodName}`): void;
+  matchMethod(method: MethodName): boolean;
+  setMethod(input?: MethodName): void;
+  protected executeWithTimeout(fn: () => unknown | Promise<unknown>, routerOptions: RouterOptions, controller?: AbortController): Promise<unknown>;
+  protected resolveTimeout(routerOptions: RouterOptions): number | undefined;
   protected mountHooks(): void;
 }
 //#endregion
 //#region src/handler/core/types.d.ts
 type CoreHandler = (event: IRoutupEvent) => unknown | Promise<unknown>;
 type CoreHandlerOptions = HandlerBaseOptions & {
-  type: `${HandlerType.CORE}`;
+  type: typeof HandlerType.CORE;
   fn: CoreHandler;
 };
 //#endregion
@@ -437,6 +478,35 @@ declare function isWebHandler(input: unknown): input is WebHandler;
 declare function isHandlerOptions(input: unknown): input is HandlerOptions;
 declare function isHandler(input: unknown): input is Handler;
 //#endregion
+//#region src/plugin/error/constants.d.ts
+declare const PluginErrorCode: {
+  readonly PLUGIN: "PLUGIN";
+  readonly NOT_INSTALLED: "PLUGIN_NOT_INSTALLED";
+  readonly INSTALL: "PLUGIN_INSTALL";
+};
+type PluginErrorCode = typeof PluginErrorCode[keyof typeof PluginErrorCode];
+//#endregion
+//#region src/plugin/error/module.d.ts
+declare class PluginError extends RoutupError {
+  constructor(input?: HTTPErrorInput);
+}
+//#endregion
+//#region src/plugin/error/is.d.ts
+declare function isPluginError(input: unknown): input is PluginError;
+//#endregion
+//#region src/plugin/error/sub/install.d.ts
+declare class PluginInstallError extends PluginError {
+  readonly pluginName: string;
+  constructor(pluginName: string, cause?: Error);
+}
+//#endregion
+//#region src/plugin/error/sub/not-installed.d.ts
+declare class PluginNotInstalledError extends PluginError {
+  readonly pluginName: string;
+  readonly helperName: string;
+  constructor(pluginName: string, helperName: string);
+}
+//#endregion
 //#region src/plugin/types.d.ts
 type PluginInstallFn = (router: IRouter) => any;
 type Plugin = {
@@ -485,19 +555,45 @@ type TrustProxyFn = (address: string, hop: number) => boolean;
 type TrustProxyInput = boolean | number | string | string[] | TrustProxyFn;
 //#endregion
 //#region src/router/constants.d.ts
-declare enum RouterPipelineStep {
-  START = 0,
-  LOOKUP = 1,
-  CHILD_BEFORE = 2,
-  CHILD_DISPATCH = 3,
-  CHILD_AFTER = 4,
-  FINISH = 5
-}
+declare const RouterPipelineStep: {
+  readonly START: 0;
+  readonly LOOKUP: 1;
+  readonly CHILD_BEFORE: 2;
+  readonly CHILD_DISPATCH: 3;
+  readonly CHILD_AFTER: 4;
+  readonly FINISH: 5;
+};
+type RouterPipelineStep = typeof RouterPipelineStep[keyof typeof RouterPipelineStep];
 //#endregion
 //#region src/router/types.d.ts
 type RouterOptions = {
   path?: Path;
   name?: string;
+  /**
+   * Global request timeout in milliseconds.
+   *
+   * Applies to the entire dispatch pipeline in `fetch()`. When exceeded,
+   * the request is aborted and a 408 response is returned. The AbortSignal
+   * on the event is also aborted for cooperative cancellation.
+   */
+  timeout?: number;
+  /**
+   * Default per-handler timeout in milliseconds.
+   *
+   * Applies individually to each handler's `fn()` execution. Handlers can
+   * override this value via their own `timeout` option — see
+   * `handlerTimeoutOverridable` to control whether overrides can extend
+   * or only narrow this default.
+   */
+  handlerTimeout?: number;
+  /**
+   * Whether handlers can extend the `handlerTimeout` default.
+   *
+   * When `false` (default), a handler's `timeout` is clamped to
+   * `Math.min(handlerTimeout, handler.timeout)`. When `true`, the
+   * handler's `timeout` fully replaces the router default.
+   */
+  handlerTimeoutOverridable?: boolean;
   subdomainOffset: number;
   proxyIpMax: number;
   etag: EtagFn;
@@ -569,14 +665,14 @@ interface IRouter extends IDispatcher {
   /**
    * Add a hook listener.
    */
-  on(name: `${HookName.REQUEST}` | `${HookName.RESPONSE}` | `${HookName.CHILD_DISPATCH_BEFORE}` | `${HookName.CHILD_DISPATCH_AFTER}`, fn: HookDefaultListener): HookUnsubscribeFn;
-  on(name: `${HookName.CHILD_MATCH}`, fn: HookDefaultListener): HookUnsubscribeFn;
-  on(name: `${HookName.ERROR}`, fn: HookErrorListener): HookUnsubscribeFn;
+  on(name: typeof HookName.REQUEST | typeof HookName.RESPONSE | typeof HookName.CHILD_DISPATCH_BEFORE | typeof HookName.CHILD_DISPATCH_AFTER, fn: HookDefaultListener): HookUnsubscribeFn;
+  on(name: typeof HookName.CHILD_MATCH, fn: HookDefaultListener): HookUnsubscribeFn;
+  on(name: typeof HookName.ERROR, fn: HookErrorListener): HookUnsubscribeFn;
   /**
    * Remove a specific or all hook listeners for the given hook name.
    */
-  off(name: `${HookName}`): this;
-  off(name: `${HookName}`, fn: HookListener): this;
+  off(name: HookName): this;
+  off(name: HookName, fn: HookListener): this;
 }
 //#endregion
 //#region src/dispatcher/module.d.ts
@@ -588,7 +684,7 @@ declare class DispatcherEvent implements IDispatcherEvent {
   /**
    * Collected allowed methods (for OPTIONS).
    */
-  methodsAllowed: string[];
+  methodsAllowed: Set<string>;
   mountPath: string;
   error?: RoutupError;
   routerPath: RouterPathNode[];
@@ -603,6 +699,8 @@ declare class DispatcherEvent implements IDispatcherEvent {
    * Continuation function for middleware onion model.
    */
   protected _next?: (event: IRoutupEvent, error?: Error) => Promise<Response | undefined>;
+  protected _signal?: AbortSignal;
+  protected _signalCleanup?: () => void;
   /**
    * Whether _next has already been called (guard against double-invocation).
    */
@@ -613,11 +711,13 @@ declare class DispatcherEvent implements IDispatcherEvent {
   protected _nextResult?: Promise<Response | undefined>;
   constructor(request: RoutupRequest);
   get response(): RoutupResponse;
+  get signal(): AbortSignal;
+  set signal(value: AbortSignal);
   get dispatched(): boolean;
   set dispatched(value: boolean);
   protected next(event: IRoutupEvent, error?: Error): Promise<Response | undefined>;
   setNext(fn?: NextFn): void;
-  build(): RoutupEvent;
+  build(signal?: AbortSignal): RoutupEvent;
   protected get store(): Record<string | symbol, unknown>;
   protected resolveOptions(): RouterOptions;
 }
@@ -696,16 +796,16 @@ declare class Router implements IRouter {
    * @param name
    * @param fn
    */
-  on(name: `${HookName.REQUEST}` | `${HookName.RESPONSE}` | `${HookName.CHILD_DISPATCH_BEFORE}` | `${HookName.CHILD_DISPATCH_AFTER}`, fn: HookDefaultListener): HookUnsubscribeFn;
-  on(name: `${HookName.CHILD_MATCH}`, fn: HookDefaultListener): HookUnsubscribeFn;
-  on(name: `${HookName.ERROR}`, fn: HookErrorListener): HookUnsubscribeFn;
+  on(name: typeof HookName.REQUEST | typeof HookName.RESPONSE | typeof HookName.CHILD_DISPATCH_BEFORE | typeof HookName.CHILD_DISPATCH_AFTER, fn: HookDefaultListener, priority?: number): HookUnsubscribeFn;
+  on(name: typeof HookName.CHILD_MATCH, fn: HookDefaultListener, priority?: number): HookUnsubscribeFn;
+  on(name: typeof HookName.ERROR, fn: HookErrorListener, priority?: number): HookUnsubscribeFn;
   /**
    * Remove single or all hook listeners.
    *
    * @param name
    */
-  off(name: `${HookName}`): this;
-  off(name: `${HookName}`, fn: HookListener): this;
+  off(name: HookName): this;
+  off(name: HookName, fn: HookListener): this;
 }
 //#endregion
 //#region src/error/create.d.ts
@@ -714,7 +814,7 @@ declare class Router implements IRouter {
  * - an existing RoutupError (returned as-is)
  * - an HTTPError (wrapped into a RoutupError preserving status)
  * - an Error (wrapped preserving message and cause)
- * - an options object (statusCode, statusMessage, etc.)
+ * - an options object (status, message, etc.)
  * - a message string
  *
  * @param input
@@ -763,7 +863,7 @@ type EventStreamOptions = {
   maxMessageSize?: number;
 };
 type EventStreamHandle = {
-  write(message: string | EventStreamMessage): void;
+  write(message: string | EventStreamMessage): boolean;
   end(): void;
   response: Response;
 };
@@ -826,23 +926,6 @@ declare function setResponseContentTypeByFileName(event: IRoutupEvent, fileName:
 //#region src/response/to-response.d.ts
 declare function toResponse(value: unknown, event: IRoutupEvent): Promise<Response | undefined>;
 //#endregion
-//#region src/request/helpers/body.d.ts
-/**
- * Read and parse the request body.
- *
- * - `application/x-www-form-urlencoded` → plain object (duplicate keys become arrays)
- * - `application/json` or other → attempts JSON parse, returns undefined on failure
- *
- * The result is cached on the event store — calling `readBody()` multiple
- * times returns the same parsed result.
- *
- * For binary or streaming access, use `event.request.arrayBuffer()`,
- * `event.request.blob()`, or `event.request.body` directly.
- *
- * @experimental
- */
-declare function readBody<T = unknown>(event: IRoutupEvent): Promise<T | undefined>;
-//#endregion
 //#region src/request/helpers/cache.d.ts
 declare function isRequestCacheable(event: IRoutupEvent, modifiedTime: string | Date): boolean;
 //#endregion
@@ -900,5 +983,5 @@ declare function getRequestProtocol(event: IRoutupEvent, options?: RequestProtoc
 //#region src/router/options.d.ts
 declare function normalizeRouterOptions(input: RouterOptionsInput): Partial<RouterOptions>;
 //#endregion
-export { isPlugin as $, sendCreated as A, IDispatcher as At, EventStreamListener as B, HeaderName as Bt, sendStream as C, HandlerSymbol as Ct, SendFileOptions as D, Path as Dt, SendFileContentOptions as E, PathMatcher as Et, appendResponseHeaderDirective as F, NextFn as Ft, createError as G, ResponseCacheHeadersOptions as H, serializeEventStreamMessage as I, RoutupRequest as It, IRouter as J, Router as K, EventStreamHandle as L, RoutupResponse as Lt, setResponseHeaderContentType as M, RoutupEvent as Mt, setResponseHeaderAttachment as N, RoutupEventCreateContext as Nt, SendFileStats as O, PathMatcherExecResult as Ot, appendResponseHeader as P, IRoutupEvent as Pt, RouterPipelineContext as Q, EventStreamOptions as R, HTTPErrorInput$1 as Rt, setResponseContentTypeByFileName as S, HandlerBaseOptions as St, sendFormat as T, isPath as Tt, setResponseCacheHeaders as U, EventStreamMessage as V, MethodName as Vt, isError as W, RouterOptionsInput as X, RouterOptions as Y, RouterPathNode as Z, getRequestAcceptableContentTypes as _, Handler as _t, RequestIpOptions as a, isWebHandler as at, readBody as b, ErrorHandler as bt, getRequestHostName as c, WebHandler as ct, getRequestAcceptableLanguages as d, fromNodeMiddleware as dt, Plugin as et, getRequestAcceptableEncoding as f, NodeHandler as ft, getRequestAcceptableContentType as g, CoreHandlerOptions as gt, getRequestAcceptableCharsets as h, CoreHandler as ht, useRequestNegotiator as i, isHandlerOptions as it, sendAccepted as j, IDispatcherEvent as jt, sendFile as k, PathMatcherOptions as kt, matchRequestContentType as l, WebHandlerProvider as lt, getRequestAcceptableCharset as m, defineCoreHandler as mt, RequestProtocolOptions as n, PluginInstallFn as nt, getRequestIP as o, isWebHandlerProvider as ot, getRequestAcceptableEncodings as p, NodeMiddleware as pt, DispatcherEvent as q, getRequestProtocol as r, isHandler as rt, RequestHostNameOptions as s, fromWebHandler as st, normalizeRouterOptions as t, PluginInstallContext as tt, getRequestAcceptableLanguage as u, fromNodeHandler as ut, getRequestHeader as v, HandlerOptions as vt, sendRedirect as w, HandlerType as wt, toResponse as x, ErrorHandlerOptions as xt, isRequestCacheable as y, defineErrorHandler as yt, createEventStream as z, RoutupError as zt };
-//# sourceMappingURL=index-DCtnUoGL.d.mts.map
+export { Plugin as $, sendAccepted as A, PathMatcher as At, EventStreamMessage as B, RoutupRequest as Bt, sendRedirect as C, defineErrorHandler as Ct, SendFileStats as D, HandlerSymbol as Dt, SendFileOptions as E, HandlerBaseOptions as Et, serializeEventStreamMessage as F, IDispatcherEvent as Ft, Router as G, HeaderName as Gt, setResponseCacheHeaders as H, ErrorSymbol as Ht, EventStreamHandle as I, RoutupEvent as It, RouterOptions as J, DispatcherEvent as K, MethodName as Kt, EventStreamOptions as L, RoutupEventCreateContext as Lt, setResponseHeaderAttachment as M, PathMatcherExecResult as Mt, appendResponseHeader as N, PathMatcherOptions as Nt, sendFile as O, HandlerType as Ot, appendResponseHeaderDirective as P, IDispatcher as Pt, isPlugin as Q, createEventStream as R, IRoutupEvent as Rt, sendStream as S, HandlerOptions as St, SendFileContentOptions as T, ErrorHandlerOptions as Tt, isError as U, HTTPErrorInput$1 as Ut, ResponseCacheHeadersOptions as V, RoutupResponse as Vt, createError as W, RoutupError as Wt, RouterPathNode as X, RouterOptionsInput as Y, RouterPipelineContext as Z, getRequestAcceptableContentTypes as _, NodeMiddleware as _t, RequestIpOptions as a, PluginError as at, toResponse as b, CoreHandlerOptions as bt, getRequestHostName as c, isHandlerOptions as ct, getRequestAcceptableLanguages as d, fromWebHandler as dt, PluginInstallContext as et, getRequestAcceptableEncoding as f, WebHandler as ft, getRequestAcceptableContentType as g, NodeHandler as gt, getRequestAcceptableCharsets as h, fromNodeMiddleware as ht, useRequestNegotiator as i, isPluginError as it, setResponseHeaderContentType as j, Path as jt, sendCreated as k, isPath as kt, matchRequestContentType as l, isWebHandler as lt, getRequestAcceptableCharset as m, fromNodeHandler as mt, RequestProtocolOptions as n, PluginNotInstalledError as nt, getRequestIP as o, PluginErrorCode as ot, getRequestAcceptableEncodings as p, WebHandlerProvider as pt, IRouter as q, getRequestProtocol as r, PluginInstallError as rt, RequestHostNameOptions as s, isHandler as st, normalizeRouterOptions as t, PluginInstallFn as tt, getRequestAcceptableLanguage as u, isWebHandlerProvider as ut, getRequestHeader as v, defineCoreHandler as vt, sendFormat as w, ErrorHandler as wt, setResponseContentTypeByFileName as x, Handler as xt, isRequestCacheable as y, CoreHandler as yt, EventStreamListener as z, NextFn as zt };
+//# sourceMappingURL=index-doDmTYzg.d.mts.map

package/dist/node.d.mts

@@ -1,4 +1,4 @@
-import { $ as isPlugin, A as sendCreated, At as IDispatcher, B as EventStreamListener, Bt as HeaderName, C as sendStream, Ct as HandlerSymbol, D as SendFileOptions, Dt as Path, E as SendFileContentOptions, Et as PathMatcher, F as appendResponseHeaderDirective, Ft as NextFn, G as createError, H as ResponseCacheHeadersOptions, I as serializeEventStreamMessage, It as RoutupRequest, J as IRouter, K as Router, L as EventStreamHandle, Lt as RoutupResponse, M as setResponseHeaderContentType, Mt as RoutupEvent, N as setResponseHeaderAttachment, Nt as RoutupEventCreateContext, O as SendFileStats, Ot as PathMatcherExecResult, P as appendResponseHeader, Pt as IRoutupEvent, Q as RouterPipelineContext, R as EventStreamOptions, Rt as HTTPErrorInput, S as setResponseContentTypeByFileName, St as HandlerBaseOptions, T as sendFormat, Tt as isPath, U as setResponseCacheHeaders, V as EventStreamMessage, Vt as MethodName, W as isError, X as RouterOptionsInput, Y as RouterOptions, Z as RouterPathNode, _ as getRequestAcceptableContentTypes, _t as Handler, a as RequestIpOptions, at as isWebHandler, b as readBody, bt as ErrorHandler, c as getRequestHostName, ct as WebHandler, d as getRequestAcceptableLanguages, dt as fromNodeMiddleware, et as Plugin, f as getRequestAcceptableEncoding, ft as NodeHandler, g as getRequestAcceptableContentType, gt as CoreHandlerOptions, h as getRequestAcceptableCharsets, ht as CoreHandler, i as useRequestNegotiator, it as isHandlerOptions, j as sendAccepted, jt as IDispatcherEvent, k as sendFile, kt as PathMatcherOptions, l as matchRequestContentType, lt as WebHandlerProvider, m as getRequestAcceptableCharset, mt as defineCoreHandler, n as RequestProtocolOptions, nt as PluginInstallFn, o as getRequestIP, ot as isWebHandlerProvider, p as getRequestAcceptableEncodings, pt as NodeMiddleware, q as DispatcherEvent, r as getRequestProtocol, rt as isHandler, s as RequestHostNameOptions, st as fromWebHandler, t as normalizeRouterOptions, tt as PluginInstallContext, u as getRequestAcceptableLanguage, ut as fromNodeHandler, v as getRequestHeader, vt as HandlerOptions, w as sendRedirect, wt as HandlerType, x as toResponse, xt as ErrorHandlerOptions, y as isRequestCacheable, yt as defineErrorHandler, z as createEventStream, zt as RoutupError } from "./index-DCtnUoGL.mjs";
+import { $ as Plugin, A as sendAccepted, At as PathMatcher, B as EventStreamMessage, Bt as RoutupRequest, C as sendRedirect, Ct as defineErrorHandler, D as SendFileStats, Dt as HandlerSymbol, E as SendFileOptions, Et as HandlerBaseOptions, F as serializeEventStreamMessage, Ft as IDispatcherEvent, G as Router, Gt as HeaderName, H as setResponseCacheHeaders, Ht as ErrorSymbol, I as EventStreamHandle, It as RoutupEvent, J as RouterOptions, K as DispatcherEvent, Kt as MethodName, L as EventStreamOptions, Lt as RoutupEventCreateContext, M as setResponseHeaderAttachment, Mt as PathMatcherExecResult, N as appendResponseHeader, Nt as PathMatcherOptions, O as sendFile, Ot as HandlerType, P as appendResponseHeaderDirective, Pt as IDispatcher, Q as isPlugin, R as createEventStream, Rt as IRoutupEvent, S as sendStream, St as HandlerOptions, T as SendFileContentOptions, Tt as ErrorHandlerOptions, U as isError, Ut as HTTPErrorInput, V as ResponseCacheHeadersOptions, Vt as RoutupResponse, W as createError, Wt as RoutupError, X as RouterPathNode, Y as RouterOptionsInput, Z as RouterPipelineContext, _ as getRequestAcceptableContentTypes, _t as NodeMiddleware, a as RequestIpOptions, at as PluginError, b as toResponse, bt as CoreHandlerOptions, c as getRequestHostName, ct as isHandlerOptions, d as getRequestAcceptableLanguages, dt as fromWebHandler, et as PluginInstallContext, f as getRequestAcceptableEncoding, ft as WebHandler, g as getRequestAcceptableContentType, gt as NodeHandler, h as getRequestAcceptableCharsets, ht as fromNodeMiddleware, i as useRequestNegotiator, it as isPluginError, j as setResponseHeaderContentType, jt as Path, k as sendCreated, kt as isPath, l as matchRequestContentType, lt as isWebHandler, m as getRequestAcceptableCharset, mt as fromNodeHandler, n as RequestProtocolOptions, nt as PluginNotInstalledError, o as getRequestIP, ot as PluginErrorCode, p as getRequestAcceptableEncodings, pt as WebHandlerProvider, q as IRouter, r as getRequestProtocol, rt as PluginInstallError, s as RequestHostNameOptions, st as isHandler, t as normalizeRouterOptions, tt as PluginInstallFn, u as getRequestAcceptableLanguage, ut as isWebHandlerProvider, v as getRequestHeader, vt as defineCoreHandler, w as sendFormat, wt as ErrorHandler, x as setResponseContentTypeByFileName, xt as Handler, y as isRequestCacheable, yt as CoreHandler, z as EventStreamListener, zt as NextFn } from "./index-doDmTYzg.mjs";
 import * as _$srvx_node0 from "srvx/node";
 import * as _$srvx from "srvx";
 import { Server, ServerOptions } from "srvx";
@@ -7,5 +7,5 @@ import { Server, ServerOptions } from "srvx";
 declare function serve(router: Router, options?: Omit<ServerOptions, 'fetch'>): Server;
 declare function toNodeHandler(router: Router): _$srvx.NodeHttpHandler & _$srvx_node0.AdapterMeta;
 //#endregion
-export { CoreHandler, CoreHandlerOptions, DispatcherEvent, ErrorHandler, ErrorHandlerOptions, EventStreamHandle, EventStreamListener, EventStreamMessage, EventStreamOptions, HTTPErrorInput, Handler, HandlerBaseOptions, HandlerOptions, HandlerSymbol, HandlerType, HeaderName, IDispatcher, IDispatcherEvent, IRouter, IRoutupEvent, MethodName, NextFn, NodeHandler, NodeMiddleware, Path, PathMatcher, PathMatcherExecResult, PathMatcherOptions, Plugin, PluginInstallContext, PluginInstallFn, RequestHostNameOptions, RequestIpOptions, RequestProtocolOptions, ResponseCacheHeadersOptions, Router, RouterOptions, RouterOptionsInput, RouterPathNode, RouterPipelineContext, RoutupError, RoutupEvent, RoutupEventCreateContext, RoutupRequest, RoutupResponse, SendFileContentOptions, SendFileOptions, SendFileStats, WebHandler, WebHandlerProvider, appendResponseHeader, appendResponseHeaderDirective, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchRequestContentType, normalizeRouterOptions, readBody, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, toNodeHandler, toResponse, useRequestNegotiator };
+export { CoreHandler, CoreHandlerOptions, DispatcherEvent, ErrorHandler, ErrorHandlerOptions, ErrorSymbol, EventStreamHandle, EventStreamListener, EventStreamMessage, EventStreamOptions, HTTPErrorInput, Handler, HandlerBaseOptions, HandlerOptions, HandlerSymbol, HandlerType, HeaderName, IDispatcher, IDispatcherEvent, IRouter, IRoutupEvent, MethodName, NextFn, NodeHandler, NodeMiddleware, Path, PathMatcher, PathMatcherExecResult, PathMatcherOptions, Plugin, PluginError, PluginErrorCode, PluginInstallContext, PluginInstallError, PluginInstallFn, PluginNotInstalledError, RequestHostNameOptions, RequestIpOptions, RequestProtocolOptions, ResponseCacheHeadersOptions, Router, RouterOptions, RouterOptionsInput, RouterPathNode, RouterPipelineContext, RoutupError, RoutupEvent, RoutupEventCreateContext, RoutupRequest, RoutupResponse, SendFileContentOptions, SendFileOptions, SendFileStats, WebHandler, WebHandlerProvider, appendResponseHeader, appendResponseHeaderDirective, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isPluginError, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchRequestContentType, normalizeRouterOptions, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, toNodeHandler, toResponse, useRequestNegotiator };
 //# sourceMappingURL=node.d.mts.map

package/dist/node.mjs

@@ -1,4 +1,4 @@
-import { $ as setResponseCacheHeaders, A as createError, B as getRequestHeader, C as defineErrorHandler, D as PathMatcher, E as isPath, F as sendRedirect, G as setResponseHeaderContentType, H as sendCreated, I as sendFormat, J as appendResponseHeader, K as setResponseHeaderAttachment, L as getRequestAcceptableContentType, M as DispatcherEvent, N as RoutupEvent, O as HandlerSymbol, P as sendStream, Q as RoutupError, R as getRequestAcceptableContentTypes, S as fromNodeMiddleware, T as Handler, U as sendAccepted, V as sendFile, W as toResponse, X as createEventStream, Y as appendResponseHeaderDirective, Z as serializeEventStreamMessage, _ as isHandlerOptions, a as getRequestIP, b as isWebHandlerProvider, c as getRequestAcceptableLanguage, d as getRequestAcceptableEncodings, et as HeaderName, f as getRequestAcceptableCharset, g as isHandler, h as readBody, i as getRequestProtocol, j as isError, k as HandlerType, l as getRequestAcceptableLanguages, m as isRequestCacheable, n as normalizeRouterOptions, o as getRequestHostName, p as getRequestAcceptableCharsets, q as setResponseContentTypeByFileName, r as isPlugin, s as matchRequestContentType, t as Router, tt as MethodName, u as getRequestAcceptableEncoding, v as fromWebHandler, w as defineCoreHandler, x as fromNodeHandler, y as isWebHandler, z as useRequestNegotiator } from "./src-Tr9cHQaV.mjs";
+import { $ as appendResponseHeaderDirective, A as isPath, B as getRequestAcceptableContentTypes, C as isWebHandler, D as defineErrorHandler, E as fromNodeMiddleware, F as RoutupEvent, G as sendAccepted, H as getRequestHeader, I as sendStream, J as isError, K as toResponse, L as sendRedirect, M as HandlerSymbol, N as HandlerType, O as defineCoreHandler, P as DispatcherEvent, Q as appendResponseHeader, R as sendFormat, S as fromWebHandler, T as fromNodeHandler, U as sendFile, V as useRequestNegotiator, W as sendCreated, X as setResponseHeaderAttachment, Y as setResponseHeaderContentType, Z as setResponseContentTypeByFileName, _ as getRequestAcceptableCharset, a as PluginInstallError, at as HeaderName, b as isHandler, c as PluginErrorCode, d as getRequestHostName, et as createEventStream, f as matchRequestContentType, g as getRequestAcceptableEncodings, h as getRequestAcceptableEncoding, i as PluginNotInstalledError, it as setResponseCacheHeaders, j as PathMatcher, k as Handler, l as getRequestProtocol, m as getRequestAcceptableLanguages, n as normalizeRouterOptions, nt as ErrorSymbol, o as PluginError, ot as MethodName, p as getRequestAcceptableLanguage, q as createError, r as isPlugin, rt as RoutupError, s as isPluginError, t as Router, tt as serializeEventStreamMessage, u as getRequestIP, v as getRequestAcceptableCharsets, w as isWebHandlerProvider, x as isHandlerOptions, y as isRequestCacheable, z as getRequestAcceptableContentType } from "./src-Ck8GklBr.mjs";
 import { serve as serve$1, toNodeHandler as toNodeHandler$1 } from "srvx/node";
 //#region src/_entries/node.ts
 function serve(router, options) {
@@ -11,6 +11,6 @@ function toNodeHandler(router) {
 	return toNodeHandler$1(router.fetch.bind(router));
 }
 //#endregion
-export { DispatcherEvent, Handler, HandlerSymbol, HandlerType, HeaderName, MethodName, PathMatcher, Router, RoutupError, RoutupEvent, appendResponseHeader, appendResponseHeaderDirective, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchRequestContentType, normalizeRouterOptions, readBody, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, toNodeHandler, toResponse, useRequestNegotiator };
+export { DispatcherEvent, ErrorSymbol, Handler, HandlerSymbol, HandlerType, HeaderName, MethodName, PathMatcher, PluginError, PluginErrorCode, PluginInstallError, PluginNotInstalledError, Router, RoutupError, RoutupEvent, appendResponseHeader, appendResponseHeaderDirective, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isPluginError, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchRequestContentType, normalizeRouterOptions, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, toNodeHandler, toResponse, useRequestNegotiator };
 
 //# sourceMappingURL=node.mjs.map

package/dist/service-worker.d.mts

@@ -1,4 +1,4 @@
-import { $ as isPlugin, A as sendCreated, At as IDispatcher, B as EventStreamListener, Bt as HeaderName, C as sendStream, Ct as HandlerSymbol, D as SendFileOptions, Dt as Path, E as SendFileContentOptions, Et as PathMatcher, F as appendResponseHeaderDirective, Ft as NextFn, G as createError, H as ResponseCacheHeadersOptions, I as serializeEventStreamMessage, It as RoutupRequest, J as IRouter, K as Router, L as EventStreamHandle, Lt as RoutupResponse, M as setResponseHeaderContentType, Mt as RoutupEvent, N as setResponseHeaderAttachment, Nt as RoutupEventCreateContext, O as SendFileStats, Ot as PathMatcherExecResult, P as appendResponseHeader, Pt as IRoutupEvent, Q as RouterPipelineContext, R as EventStreamOptions, Rt as HTTPErrorInput, S as setResponseContentTypeByFileName, St as HandlerBaseOptions, T as sendFormat, Tt as isPath, U as setResponseCacheHeaders, V as EventStreamMessage, Vt as MethodName, W as isError, X as RouterOptionsInput, Y as RouterOptions, Z as RouterPathNode, _ as getRequestAcceptableContentTypes, _t as Handler, a as RequestIpOptions, at as isWebHandler, b as readBody, bt as ErrorHandler, c as getRequestHostName, ct as WebHandler, d as getRequestAcceptableLanguages, dt as fromNodeMiddleware, et as Plugin, f as getRequestAcceptableEncoding, ft as NodeHandler, g as getRequestAcceptableContentType, gt as CoreHandlerOptions, h as getRequestAcceptableCharsets, ht as CoreHandler, i as useRequestNegotiator, it as isHandlerOptions, j as sendAccepted, jt as IDispatcherEvent, k as sendFile, kt as PathMatcherOptions, l as matchRequestContentType, lt as WebHandlerProvider, m as getRequestAcceptableCharset, mt as defineCoreHandler, n as RequestProtocolOptions, nt as PluginInstallFn, o as getRequestIP, ot as isWebHandlerProvider, p as getRequestAcceptableEncodings, pt as NodeMiddleware, q as DispatcherEvent, r as getRequestProtocol, rt as isHandler, s as RequestHostNameOptions, st as fromWebHandler, t as normalizeRouterOptions, tt as PluginInstallContext, u as getRequestAcceptableLanguage, ut as fromNodeHandler, v as getRequestHeader, vt as HandlerOptions, w as sendRedirect, wt as HandlerType, x as toResponse, xt as ErrorHandlerOptions, y as isRequestCacheable, yt as defineErrorHandler, z as createEventStream, zt as RoutupError } from "./index-DCtnUoGL.mjs";
+import { $ as Plugin, A as sendAccepted, At as PathMatcher, B as EventStreamMessage, Bt as RoutupRequest, C as sendRedirect, Ct as defineErrorHandler, D as SendFileStats, Dt as HandlerSymbol, E as SendFileOptions, Et as HandlerBaseOptions, F as serializeEventStreamMessage, Ft as IDispatcherEvent, G as Router, Gt as HeaderName, H as setResponseCacheHeaders, Ht as ErrorSymbol, I as EventStreamHandle, It as RoutupEvent, J as RouterOptions, K as DispatcherEvent, Kt as MethodName, L as EventStreamOptions, Lt as RoutupEventCreateContext, M as setResponseHeaderAttachment, Mt as PathMatcherExecResult, N as appendResponseHeader, Nt as PathMatcherOptions, O as sendFile, Ot as HandlerType, P as appendResponseHeaderDirective, Pt as IDispatcher, Q as isPlugin, R as createEventStream, Rt as IRoutupEvent, S as sendStream, St as HandlerOptions, T as SendFileContentOptions, Tt as ErrorHandlerOptions, U as isError, Ut as HTTPErrorInput, V as ResponseCacheHeadersOptions, Vt as RoutupResponse, W as createError, Wt as RoutupError, X as RouterPathNode, Y as RouterOptionsInput, Z as RouterPipelineContext, _ as getRequestAcceptableContentTypes, _t as NodeMiddleware, a as RequestIpOptions, at as PluginError, b as toResponse, bt as CoreHandlerOptions, c as getRequestHostName, ct as isHandlerOptions, d as getRequestAcceptableLanguages, dt as fromWebHandler, et as PluginInstallContext, f as getRequestAcceptableEncoding, ft as WebHandler, g as getRequestAcceptableContentType, gt as NodeHandler, h as getRequestAcceptableCharsets, ht as fromNodeMiddleware, i as useRequestNegotiator, it as isPluginError, j as setResponseHeaderContentType, jt as Path, k as sendCreated, kt as isPath, l as matchRequestContentType, lt as isWebHandler, m as getRequestAcceptableCharset, mt as fromNodeHandler, n as RequestProtocolOptions, nt as PluginNotInstalledError, o as getRequestIP, ot as PluginErrorCode, p as getRequestAcceptableEncodings, pt as WebHandlerProvider, q as IRouter, r as getRequestProtocol, rt as PluginInstallError, s as RequestHostNameOptions, st as isHandler, t as normalizeRouterOptions, tt as PluginInstallFn, u as getRequestAcceptableLanguage, ut as isWebHandlerProvider, v as getRequestHeader, vt as defineCoreHandler, w as sendFormat, wt as ErrorHandler, x as setResponseContentTypeByFileName, xt as Handler, y as isRequestCacheable, yt as CoreHandler, z as EventStreamListener, zt as NextFn } from "./index-doDmTYzg.mjs";
 import * as _$srvx from "srvx";
 import { ServerOptions } from "srvx";
 import * as _$srvx_service_worker0 from "srvx/service-worker";
@@ -6,5 +6,5 @@ import * as _$srvx_service_worker0 from "srvx/service-worker";
 //#region src/_entries/service-worker.d.ts
 declare function serve(router: Router, options?: Omit<ServerOptions, 'fetch'>): _$srvx.Server<_$srvx_service_worker0.ServiceWorkerHandler>;
 //#endregion
-export { CoreHandler, CoreHandlerOptions, DispatcherEvent, ErrorHandler, ErrorHandlerOptions, EventStreamHandle, EventStreamListener, EventStreamMessage, EventStreamOptions, HTTPErrorInput, Handler, HandlerBaseOptions, HandlerOptions, HandlerSymbol, HandlerType, HeaderName, IDispatcher, IDispatcherEvent, IRouter, IRoutupEvent, MethodName, NextFn, NodeHandler, NodeMiddleware, Path, PathMatcher, PathMatcherExecResult, PathMatcherOptions, Plugin, PluginInstallContext, PluginInstallFn, RequestHostNameOptions, RequestIpOptions, RequestProtocolOptions, ResponseCacheHeadersOptions, Router, RouterOptions, RouterOptionsInput, RouterPathNode, RouterPipelineContext, RoutupError, RoutupEvent, RoutupEventCreateContext, RoutupRequest, RoutupResponse, SendFileContentOptions, SendFileOptions, SendFileStats, WebHandler, WebHandlerProvider, appendResponseHeader, appendResponseHeaderDirective, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchRequestContentType, normalizeRouterOptions, readBody, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, toResponse, useRequestNegotiator };
+export { CoreHandler, CoreHandlerOptions, DispatcherEvent, ErrorHandler, ErrorHandlerOptions, ErrorSymbol, EventStreamHandle, EventStreamListener, EventStreamMessage, EventStreamOptions, HTTPErrorInput, Handler, HandlerBaseOptions, HandlerOptions, HandlerSymbol, HandlerType, HeaderName, IDispatcher, IDispatcherEvent, IRouter, IRoutupEvent, MethodName, NextFn, NodeHandler, NodeMiddleware, Path, PathMatcher, PathMatcherExecResult, PathMatcherOptions, Plugin, PluginError, PluginErrorCode, PluginInstallContext, PluginInstallError, PluginInstallFn, PluginNotInstalledError, RequestHostNameOptions, RequestIpOptions, RequestProtocolOptions, ResponseCacheHeadersOptions, Router, RouterOptions, RouterOptionsInput, RouterPathNode, RouterPipelineContext, RoutupError, RoutupEvent, RoutupEventCreateContext, RoutupRequest, RoutupResponse, SendFileContentOptions, SendFileOptions, SendFileStats, WebHandler, WebHandlerProvider, appendResponseHeader, appendResponseHeaderDirective, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isPluginError, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchRequestContentType, normalizeRouterOptions, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, toResponse, useRequestNegotiator };
 //# sourceMappingURL=service-worker.d.mts.map

package/dist/service-worker.mjs

@@ -1,4 +1,4 @@
-import { $ as setResponseCacheHeaders, A as createError, B as getRequestHeader, C as defineErrorHandler, D as PathMatcher, E as isPath, F as sendRedirect, G as setResponseHeaderContentType, H as sendCreated, I as sendFormat, J as appendResponseHeader, K as setResponseHeaderAttachment, L as getRequestAcceptableContentType, M as DispatcherEvent, N as RoutupEvent, O as HandlerSymbol, P as sendStream, Q as RoutupError, R as getRequestAcceptableContentTypes, S as fromNodeMiddleware, T as Handler, U as sendAccepted, V as sendFile, W as toResponse, X as createEventStream, Y as appendResponseHeaderDirective, Z as serializeEventStreamMessage, _ as isHandlerOptions, a as getRequestIP, b as isWebHandlerProvider, c as getRequestAcceptableLanguage, d as getRequestAcceptableEncodings, et as HeaderName, f as getRequestAcceptableCharset, g as isHandler, h as readBody, i as getRequestProtocol, j as isError, k as HandlerType, l as getRequestAcceptableLanguages, m as isRequestCacheable, n as normalizeRouterOptions, o as getRequestHostName, p as getRequestAcceptableCharsets, q as setResponseContentTypeByFileName, r as isPlugin, s as matchRequestContentType, t as Router, tt as MethodName, u as getRequestAcceptableEncoding, v as fromWebHandler, w as defineCoreHandler, x as fromNodeHandler, y as isWebHandler, z as useRequestNegotiator } from "./src-Tr9cHQaV.mjs";
+import { $ as appendResponseHeaderDirective, A as isPath, B as getRequestAcceptableContentTypes, C as isWebHandler, D as defineErrorHandler, E as fromNodeMiddleware, F as RoutupEvent, G as sendAccepted, H as getRequestHeader, I as sendStream, J as isError, K as toResponse, L as sendRedirect, M as HandlerSymbol, N as HandlerType, O as defineCoreHandler, P as DispatcherEvent, Q as appendResponseHeader, R as sendFormat, S as fromWebHandler, T as fromNodeHandler, U as sendFile, V as useRequestNegotiator, W as sendCreated, X as setResponseHeaderAttachment, Y as setResponseHeaderContentType, Z as setResponseContentTypeByFileName, _ as getRequestAcceptableCharset, a as PluginInstallError, at as HeaderName, b as isHandler, c as PluginErrorCode, d as getRequestHostName, et as createEventStream, f as matchRequestContentType, g as getRequestAcceptableEncodings, h as getRequestAcceptableEncoding, i as PluginNotInstalledError, it as setResponseCacheHeaders, j as PathMatcher, k as Handler, l as getRequestProtocol, m as getRequestAcceptableLanguages, n as normalizeRouterOptions, nt as ErrorSymbol, o as PluginError, ot as MethodName, p as getRequestAcceptableLanguage, q as createError, r as isPlugin, rt as RoutupError, s as isPluginError, t as Router, tt as serializeEventStreamMessage, u as getRequestIP, v as getRequestAcceptableCharsets, w as isWebHandlerProvider, x as isHandlerOptions, y as isRequestCacheable, z as getRequestAcceptableContentType } from "./src-Ck8GklBr.mjs";
 import { serve as serve$1 } from "srvx/service-worker";
 //#region src/_entries/service-worker.ts
 function serve(router, options) {
@@ -8,6 +8,6 @@ function serve(router, options) {
 	});
 }
 //#endregion
-export { DispatcherEvent, Handler, HandlerSymbol, HandlerType, HeaderName, MethodName, PathMatcher, Router, RoutupError, RoutupEvent, appendResponseHeader, appendResponseHeaderDirective, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchRequestContentType, normalizeRouterOptions, readBody, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, toResponse, useRequestNegotiator };
+export { DispatcherEvent, ErrorSymbol, Handler, HandlerSymbol, HandlerType, HeaderName, MethodName, PathMatcher, PluginError, PluginErrorCode, PluginInstallError, PluginNotInstalledError, Router, RoutupError, RoutupEvent, appendResponseHeader, appendResponseHeaderDirective, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isPluginError, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchRequestContentType, normalizeRouterOptions, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, toResponse, useRequestNegotiator };
 
 //# sourceMappingURL=service-worker.mjs.map