webhoster 0.1.1 → 0.3.1

package/index.cjs

@@ -1,3190 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var stream = require('stream');
-var http = _interopDefault(require('http'));
-var https = _interopDefault(require('https'));
-var http2 = _interopDefault(require('http2'));
-var util = require('util');
-var zlib = require('zlib');
-var crypto = _interopDefault(require('crypto'));
-var path = require('path');
-
-/** @typedef {import('stream').Readable} Readable */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
-/** @typedef {import('http').IncomingHttpHeaders} IncomingHttpHeaders */
-
-/**
- * @typedef {Object} HttpRequestOptions
- * @prop {RequestMethod} method always uppercase
- * @prop {URL} url
- * @prop {!IncomingHttpHeaders} headers
- * @prop {Object<string,any>} [locals]
- * @prop {Readable} stream
- * @prop {import('net').Socket|import('tls').TLSSocket} [socket]
- * @prop {boolean} [canPing]
- * @prop {function():Promise<any>} [onPing]
- * @prop {boolean} [unsealed]
- */
-
-class HttpRequest {
-  #canPing = false;
-
-  /** @type {function():Promise<any>} */
-  #onPing = null;
-
-  /** @param {HttpRequestOptions} options */
-  constructor(options) {
-    /** @type {RequestMethod} */
-    this.method = (options.method.toUpperCase());
-    this.url = options.url;
-    /** @type {IncomingHttpHeaders} */
-    this.headers = options.headers;
-    this.stream = options.stream;
-    this.socket = options.socket;
-    this.#canPing = options.canPing ?? false;
-    this.#onPing = options.onPing;
-    this.locals = options.locals || {};
-    this.unsealed = options.unsealed ?? false;
-    if (!this.unsealed) {
-      Object.seal(this);
-    }
-  }
-
-  /**
-   * @param {Readable} stream
-   * @return {Readable} previousStream
-   */
-  replaceStream(stream) {
-    const previousStream = this.stream;
-    this.stream = stream;
-    return previousStream;
-  }
-
-  get canPing() {
-    return this.#canPing;
-  }
-
-  /**
-   * @return {Promise<any>}
-   */
-  ping() {
-    if (!this.#onPing) {
-      return Promise.reject(new Error('NOT_IMPLEMENTED'));
-    }
-    if (!this.#canPing) {
-      return Promise.reject(new Error('NOT_SUPPORTED'));
-    }
-    return this.#onPing();
-  }
-}
-
-/** @typedef {import('stream').Writable} Writable */
-
-/** @typedef {import('http').OutgoingHttpHeaders} OutgoingHttpHeaders */
-
-/**
- * @typedef {Object} HttpResponseOptions
- * @prop {OutgoingHttpHeaders} [headers]
- * @prop {function():boolean} [onHeadersSent]
- * @prop {function(boolean):void} [onSendHeaders]
- * @prop {number} [status]
- * @prop {Writable} stream
- * @prop {import('net').Socket|import('tls').TLSSocket} [socket]
- * @prop {boolean} [canPushPath]
- * @prop {function(string):Promise<any>} [onPushPath]
- * @prop {Object<string,any>} [locals]
- * @prop {boolean} [unsealed]
- */
-
-class HttpResponse {
-  /** @type {function():boolean} */
-  #onHeadersSent = null;
-
-  /** @type {function(boolean):void} */
-  #onSendHeaders = null;
-
-  /** @type {function(string):Promise<any>} */
-  #onPushPath = null;
-
-  /** @type {boolean} */
-  #headersSent = false;
-
-  /** @type {Array<string>} */
-  #pushedPaths = [];
-
-  #canPushPath = false;
-
-  /** @param {HttpResponseOptions} options */
-  constructor(options) {
-    /** @type {OutgoingHttpHeaders} */
-    this.headers = options.headers || {};
-    this.stream = options.stream;
-    this.socket = options.socket;
-    this.status = options.status;
-    this.#onPushPath = options.onPushPath;
-    this.#onHeadersSent = options.onHeadersSent;
-    this.#onSendHeaders = options.onSendHeaders;
-    this.#canPushPath = options.canPushPath ?? false;
-    this.locals = options.locals || {};
-    this.unsealed = options.unsealed ?? false;
-    if (!this.unsealed) {
-      Object.seal(this);
-    }
-  }
-
-  get headersSent() {
-    if (this.#onHeadersSent) {
-      return this.#onHeadersSent();
-    }
-    return this.#headersSent;
-  }
-
-  /**
-   * @param {Writable} stream
-   * @return {Writable} previousStream
-   */
-  replaceStream(stream) {
-    const previousStream = this.stream;
-    this.stream = stream;
-    return previousStream;
-  }
-
-  /**
-   * @param {boolean} [flush]
-   * @return {void}
-   */
-  sendHeaders(flush) {
-    if (this.headersSent) {
-      throw new Error('ALREADY_SENT');
-    }
-    if (!this.#onSendHeaders) {
-      throw new Error('NOT_IMPLEMENTED');
-    }
-    this.#onSendHeaders(flush);
-    this.#headersSent = true;
-  }
-
-  get pushedPaths() {
-    return this.#pushedPaths;
-  }
-
-  get canPushPath() {
-    return this.#canPushPath;
-  }
-
-  /**
-   * @param {string} [path]
-   * @return {Promise<any>}
-   */
-  pushPath(path) {
-    if (this.#pushedPaths.includes(path)) {
-      return Promise.reject(new Error('ALREADY_PUSHED'));
-    }
-    if (!this.#onPushPath) {
-      return Promise.reject(new Error('NOT_IMPLEMENTED'));
-    }
-    if (!this.#canPushPath) {
-      return Promise.reject(new Error('NOT_SUPPORTED'));
-    }
-    return this.#onPushPath(path);
-  }
-}
-
-/**
- * @template {any} T
- * @class AsyncObject<T>
- */
-class AsyncObject {
-  /** @param {T} [value] */
-  constructor(value) {
-    this.value = value;
-    this.ready = false;
-    this.busy = false;
-    /** @type {{resolve:function(T):void, reject:function(Error?):void}[]} */
-    this.pendingPromises = [];
-  }
-
-  hasValue() {
-    return this.ready;
-  }
-
-  isBusy() {
-    return this.busy;
-  }
-
-  /** @return {Promise<T>} */
-  get() {
-    if (!this.isBusy() && this.hasValue()) {
-      return Promise.resolve(this.value);
-    }
-    return new Promise((resolve, reject) => {
-      this.pendingPromises.push({ resolve, reject });
-    });
-  }
-
-  /**
-   * @param {T} [value]
-   * @return {Promise<T>}
-   */
-  set(value) {
-    this.value = value;
-    this.busy = false;
-    this.ready = true;
-    while (this.pendingPromises.length) {
-      this.pendingPromises.shift().resolve(value);
-    }
-    return Promise.resolve(value);
-  }
-
-  /**
-   * @param {Error} [error] Error passed to pending promises
-   * @return {void}
-   */
-  reset(error) {
-    this.value = undefined;
-    this.busy = false;
-    this.ready = false;
-    while (this.pendingPromises.length) {
-      this.pendingPromises.shift().reject(error);
-    }
-  }
-
-  /** @return {void} */
-  prepare() {
-    this.value = undefined;
-    this.busy = true;
-    this.ready = false;
-  }
-
-  /** @return {void} */
-  setBusy() {
-    this.busy = true;
-  }
-}
-
-// eslint-disable-next-line jsdoc/require-returns-check
-/**
- * @param {any} [args]
- * @return {any}
- */
-// eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
-function noop(...args) {}
-
-/** @typedef {import('../types').Middleware} Middleware */
-/** @typedef {import('../types').MiddlewareErrorHandler} MiddlewareErrorHandler */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-/** @typedef {import('../types').MiddlewareFunctionResultType} MiddlewareFunctionResultType */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
-/** @typedef {import('../types/index.js').HandlerState} HandlerState */
-
-/** @type {HttpHandler} */
-let defaultInstance = null;
-
-/**
- * @param {Middleware} middleware
- * @return {boolean}
- */
-function isErrorHandler(middleware) {
-  return !!middleware && typeof middleware === 'object' && 'onError' in middleware && middleware.onError != null;
-}
-
-/**
- * @typedef {Object} HttpHandlerOptions
- * @prop {Middleware[]} [preprocessors]
- * @prop {Set<Middleware>} [middleware]
- * @prop {MiddlewareErrorHandler[]} [errorHandlers]
- */
-class HttpHandler {
-  /** @param {HttpHandlerOptions} options */
-  constructor(options = {}) {
-    this.preprocessors = options.preprocessors || [];
-    this.middleware = options.middleware || new Set();
-    this.errorHandlers = options.errorHandlers || [];
-    this.handleRequest = this.handleRequest.bind(this);
-    this.handleHttp1Request = this.handleHttp1Request.bind(this);
-    this.handleHttp2Stream = this.handleHttp2Stream.bind(this);
-  }
-
-  /** @return {HttpHandler} */
-  static get defaultInstance() {
-    if (!defaultInstance) {
-      defaultInstance = new HttpHandler();
-    }
-    return defaultInstance;
-  }
-
-  /**
-   * @param {Object} params
-   * @param {HttpRequest} params.req
-   * @param {HttpResponse} params.res
-   * @return {Promise<HttpResponse>}
-   */
-  handleRequest({ req, res }) {
-    /** @type {HandlerState} */
-    const state = { treeIndex: [] };
-    let isInErrorState = false;
-    /** @type {any} */
-    let caughtError = null;
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const context = this;
-    /**
-     * @param {Middleware} middleware
-     * @return {Promise<MiddlewareFunctionResult>}
-     */
-    function handleMiddleware(middleware) {
-      const isMiddlewareAnErrorHandler = isErrorHandler(middleware);
-      if (isInErrorState) {
-        if (isMiddlewareAnErrorHandler) {
-          isInErrorState = false;
-          /** @type {MiddlewareFunctionResult} */
-          let returnValue;
-          try {
-            returnValue = /** @type {MiddlewareErrorHandler} */ (middleware)
-              .onError({
-                req, res, state, err: caughtError,
-              });
-          } catch (err) {
-            isInErrorState = true;
-            caughtError = err;
-            returnValue = 'continue';
-          }
-          return Promise.resolve().then(() => returnValue);
-        }
-        if (middleware !== context.errorHandlers) {
-        // Consume and advance
-          return Promise.resolve();
-        }
-      } else if (isMiddlewareAnErrorHandler) {
-      // Don't run error handler if not in error state.
-        return Promise.resolve();
-      }
-
-      if (typeof middleware === 'boolean') {
-        if (middleware === false) {
-          return Promise.resolve('break');
-        }
-        return Promise.resolve();
-      }
-
-      switch (middleware) {
-        case 'break':
-          return Promise.resolve('break');
-        case 'end':
-          return Promise.resolve('end');
-        case 'continue':
-          return Promise.resolve();
-      }
-
-      if (middleware === null || typeof middleware === 'string' || typeof middleware === 'undefined') {
-        return Promise.resolve();
-      }
-
-      if (middleware instanceof Map) {
-        return handleMiddleware(middleware.values());
-      }
-
-      if (Symbol.iterator in middleware) {
-        const iterator = (/** @type {Iterable<Middleware>} */ (middleware))[Symbol.iterator]();
-
-        /**
-         * @param {MiddlewareFunctionResult} [chainResult]
-         * @return {Promise<MiddlewareFunctionResult>}
-         */
-        const chainLoop = (chainResult) => {
-          if (chainResult === 'end') {
-            return Promise.resolve('end');
-          }
-          if (chainResult === false || chainResult === 'break') {
-            return Promise.resolve();
-          }
-          if (chainResult != null && chainResult !== true) {
-            return handleMiddleware(chainResult).then(chainLoop);
-          }
-          const chainIteration = iterator.next();
-          if (chainIteration.done) return Promise.resolve();
-          state.treeIndex[state.treeIndex.length - 1] += 1;
-          /** @type {Middleware} */
-          const innerMiddleware = chainIteration.value;
-          return handleMiddleware(innerMiddleware).then(chainLoop);
-        };
-
-        // Start looping
-        state.treeIndex.push(-1);
-        return chainLoop().then((result) => {
-          state.treeIndex.pop();
-          return result;
-        });
-      }
-
-      if (middleware && typeof middleware === 'object') {
-        if ('execute' in middleware) {
-          if (typeof middleware.execute === 'function') {
-            return handleMiddleware(middleware.execute.bind(middleware));
-          }
-          return handleMiddleware(middleware.execute);
-        }
-        return handleMiddleware(Object.values(middleware));
-      }
-
-      if (typeof middleware !== 'function') {
-        console.warn('Unknown middleware', middleware);
-        return Promise.resolve();
-      }
-      return Promise.resolve().then(() => middleware({ req, res, state })).catch((err) => {
-        isInErrorState = true;
-        caughtError = err;
-        return /** @type {'continue'} */ ('continue');
-      });
-    }
-
-    const allMiddleware = [
-      this.preprocessors,
-      this.middleware,
-      this.errorHandlers,
-    ];
-    return handleMiddleware(allMiddleware).then(() => {
-      if (isInErrorState) {
-        isInErrorState = false;
-        throw caughtError;
-      }
-      return res;
-    });
-  }
-
-  /**
-   * @param {import('http').IncomingMessage} incomingMessage
-   * @param {import('http').ServerResponse} serverResponse
-   * @return {Promise<HttpResponse>}
-   */
-  handleHttp1Request(incomingMessage, serverResponse) {
-    // @ts-ignore If TLSSocketLike
-    const protocol = incomingMessage.socket.encrypted ? 'https:' : 'http:';
-
-    let url;
-    try {
-      url = new URL(`${protocol}//${incomingMessage.headers.host}${incomingMessage.url}`);
-    } catch (error) {
-      serverResponse.writeHead(400);
-      serverResponse.end();
-      return Promise.reject(error);
-    }
-
-    const req = new HttpRequest({
-      headers: incomingMessage.headers,
-      method: /** @type {RequestMethod} */ (incomingMessage.method?.toUpperCase()),
-      stream: incomingMessage,
-      socket: incomingMessage.socket,
-      url,
-    });
-
-    const res = new HttpResponse({
-      stream: serverResponse,
-      socket: serverResponse.socket,
-      onHeadersSent() {
-        return serverResponse.headersSent;
-      },
-      onSendHeaders(flush) {
-        if (res.status == null) return Promise.reject(new Error('NO_STATUS'));
-        serverResponse.writeHead(res.status, this.headers);
-        if (flush) {
-          serverResponse.flushHeaders();
-        }
-        return Promise.resolve();
-      },
-    });
-
-    return this.handleRequest({ req, res }).then(() => {
-      if (!res.stream.writableEnded) {
-        console.warn('Response stream was not ended.');
-        res.stream.end();
-      }
-      return res;
-    });
-  }
-
-  /**
-   * @param {import('http2').ServerHttp2Stream} stream
-   * @param {import('http2').IncomingHttpHeaders} headers
-   * @param {Partial<import('./HttpResponse.js').HttpResponseOptions>} [responseOptions]
-   * @return {Promise<HttpResponse>}
-   */
-  handleHttp2Stream(stream$1, headers, responseOptions = {}) {
-    let url;
-    try {
-      url = new URL([
-        headers[':scheme'] ?? '',
-        '://',
-        headers[':authority'] ?? '',
-        headers[':path'] ?? '',
-      ].join(''));
-    } catch (error) {
-      stream$1.respond({ ':status': 400 }, { endStream: true });
-      return Promise.reject(error);
-    }
-
-    /** @type {Set<AsyncObject<any>>} */
-    const pendingPushSyncLocks = new Set();
-    const req = new HttpRequest({
-      headers,
-      url,
-      method: /** @type {RequestMethod} */ (headers[':method']),
-      stream: stream$1,
-      socket: stream$1.session.socket,
-      canPing: true,
-      onPing() {
-        return new Promise((resolve, reject) => {
-          stream$1.session.ping((err, duration) => {
-            if (err) {
-              reject(err);
-              return;
-            }
-            resolve(duration);
-          });
-        });
-      },
-    });
-
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const context = this;
-    const res = new HttpResponse({
-      stream: stream$1,
-      socket: stream$1.session.socket,
-      canPushPath: stream$1.pushAllowed,
-      onHeadersSent() {
-        return stream$1.headersSent;
-      },
-      onSendHeaders() {
-        if (this.headers[':status'] == null) {
-          if (res.status == null) {
-            throw new Error('NO_STATUS');
-          }
-          this.headers[':status'] = res.status;
-        }
-        stream$1.respond(this.headers);
-      },
-      onPushPath(path) {
-        const syncLock = new AsyncObject();
-        pendingPushSyncLocks.add(syncLock);
-        syncLock.prepare();
-        return new Promise((resolve, reject) => {
-          if (!stream$1.pushAllowed) {
-            reject(new Error('PUSH_NOT_ALLOWED'));
-            return;
-          }
-          const newHeaders = {
-            ':scheme': headers[':scheme'],
-            ':authority': headers[':authority'],
-            ':path': path,
-            ':method': 'GET',
-          };
-          [
-            'accept',
-            'accept-encoding',
-            'accept-language',
-            'user-agent',
-            'cache-control',
-          ].forEach((passedHeader) => {
-            if (passedHeader in headers) {
-            // @ts-ignore Coerce
-              newHeaders[passedHeader] = headers[passedHeader];
-            }
-          });
-          stream$1.pushStream(newHeaders, ((err, pushStream) => {
-            if (err) {
-              pendingPushSyncLocks.delete(syncLock);
-              syncLock.set(null);
-              reject(err);
-              return;
-            }
-            context.handleHttp2Stream(pushStream, newHeaders, { canPushPath: false })
-              .then(resolve).catch(reject).finally(() => {
-                pendingPushSyncLocks.delete(syncLock);
-                syncLock.set(null);
-              });
-          }));
-        });
-      },
-      ...responseOptions,
-    });
-
-    // Workaround for https://github.com/nodejs/node/issues/31309
-    const STREAM_WAIT_MS = 0;
-    /** @type {NodeJS.Timeout} */
-    let pingTimeout = null;
-    /** @return {void} */
-    function sendPing() {
-      if (stream$1.session) stream$1.session.ping(noop);
-    }
-    const autoPingStream = new stream.PassThrough({
-      read(...args) {
-        clearTimeout(pingTimeout);
-        pingTimeout = setTimeout(sendPing, STREAM_WAIT_MS);
-        // eslint-disable-next-line no-underscore-dangle
-        return stream.PassThrough.prototype._read.call(this, ...args);
-      },
-    });
-    stream$1.pipe(autoPingStream);
-    req.replaceStream(autoPingStream);
-
-    stream$1.on('error', (err) => {
-      console.error(err);
-      console.error(headers[':path']);
-    });
-    return this.handleRequest({ req, res })
-      .then(() => Promise.all([...pendingPushSyncLocks.values()]
-        .map((syncLock) => syncLock.get().catch(noop))))
-      .then(() => {
-        res.stream.end();
-      })
-      .then(() => res);
-  }
-}
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  HttpRequest: HttpRequest,
-  HttpResponse: HttpResponse,
-  HttpHandler: HttpHandler
-});
-
-const SERVER_ALREADY_CREATED = 'SERVER_ALREADY_CREATED';
-
-/** @typedef {import('tls').TlsOptions} TlsOptions */
-
-/**
- * @typedef {Object} HttpListenerOptions
- * @prop {HttpHandler} [httpHandler]
- * @prop {number} [insecurePort=8080]
- * @prop {string} [insecureHost] blank defaults to '::' or '0.0.0.0'
- * @prop {number} [securePort=8443]
- * @prop {string} [secureHost] blank defaults to '::' or '0.0.0.0'
- * @prop {boolean} [useHttp=true]
- * @prop {boolean} [useHttps=false]
- * @prop {boolean} [useHttp2=true]
- * @prop {TlsOptions} [tlsOptions]
- */
-
-/** @type {HttpListener} */
-let defaultInstance$1;
-
-class HttpListener {
-  /** @param {HttpListenerOptions} options */
-  constructor(options = {}) {
-    this.httpHandler = options.httpHandler ?? HttpHandler.defaultInstance;
-    this.insecurePort = options.insecurePort ?? 8080;
-    this.insecureHost = options.insecureHost;
-    this.securePort = options.securePort ?? 8443;
-    this.secureHost = options.secureHost;
-    this.useHttp = options.useHttp !== false;
-    this.useHttps = options.useHttps === true;
-    this.useHttp2 = options.useHttp2 !== false;
-    this.tlsOptions = options.tlsOptions ?? {};
-  }
-
-  /** @return {HttpListener} */
-  static get defaultInstance() {
-    if (!defaultInstance$1) {
-      defaultInstance$1 = new HttpListener();
-    }
-    return defaultInstance$1;
-  }
-
-  /**
-   * @param {http.ServerOptions} [options]
-   * @return {http.Server}
-   */
-  createHttpServer(options = {}) {
-    if (!this.httpServer) {
-      this.httpServer = http.createServer(options);
-    } else if (Object.keys(options).length) {
-      throw new Error(SERVER_ALREADY_CREATED);
-    }
-    return this.httpServer;
-  }
-
-  /**
-   * @param {https.ServerOptions} [options]
-   * @return {https.Server}
-   */
-  createHttpsServer(options = {}) {
-    if (!this.httpsServer) {
-      this.httpsServer = https.createServer({
-        ...this.tlsOptions,
-        ...options,
-      });
-    } else if (Object.keys(options).length) {
-      throw new Error(SERVER_ALREADY_CREATED);
-    }
-    return this.httpsServer;
-  }
-
-  /**
-   * @param {http2.ServerOptions} [options]
-   * @return {http2.Http2SecureServer}
-   */
-  createHttp2Server(options = {}) {
-    if (!this.http2Server) {
-      this.http2Server = http2.createSecureServer({
-        allowHTTP1: true,
-        ...this.tlsOptions,
-        ...options,
-      });
-    } else if (Object.keys(options).length) {
-      throw new Error(SERVER_ALREADY_CREATED);
-    }
-    return this.http2Server;
-  }
-
-  /** @return {Promise<http.Server>} */
-  startHttpServer() {
-    return new Promise((resolve, reject) => {
-      this.createHttpServer();
-      this.httpServer.listen({
-        port: this.insecurePort,
-        host: this.insecureHost,
-      }, () => {
-        this.httpServer.removeListener('error', reject);
-        this.httpServer.addListener('request', this.httpHandler.handleHttp1Request);
-        resolve(this.httpServer);
-      });
-      this.httpServer.addListener('error', reject);
-    });
-  }
-
-  /** @return {Promise<https.Server>} */
-  startHttpsServer() {
-    return new Promise((resolve, reject) => {
-      this.createHttpsServer();
-      this.httpsServer.listen({
-        port: this.securePort,
-        host: this.secureHost,
-      }, () => {
-        this.httpsServer.removeListener('error', reject);
-        this.httpsServer.addListener('request', this.httpHandler.handleHttp1Request);
-        resolve(this.httpsServer);
-      });
-      this.httpsServer.addListener('error', reject);
-    });
-  }
-
-  /** @return {Promise<http2.Http2SecureServer>} */
-  startHttp2Server() {
-    return new Promise((resolve, reject) => {
-      this.createHttp2Server();
-      this.http2Server.listen({
-        port: this.securePort,
-        host: this.secureHost,
-      }, () => {
-        this.http2Server.removeListener('error', reject);
-        this.http2Server.addListener('stream', this.httpHandler.handleHttp2Stream);
-        this.http2Server.addListener('request', (req, res) => {
-          if (req.httpVersionMajor >= 2) return;
-          // @ts-ignore Ignore typings
-          this.httpHandler.handleHttp1Request(req, res);
-        });
-        resolve(this.http2Server);
-      });
-      this.http2Server.addListener('error', reject);
-    });
-  }
-
-  /** @return {Promise<void>} */
-  stopHttpServer() {
-    return new Promise((resolve, reject) => {
-      if (!this.httpServer) {
-        resolve();
-        return;
-      }
-      this.httpServer.close((err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
-  }
-
-  /** @return {Promise<void>} */
-  stopHttpsServer() {
-    return new Promise((resolve, reject) => {
-      if (!this.httpsServer) {
-        resolve();
-        return;
-      }
-      this.httpsServer.close((err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
-  }
-
-  /** @return {Promise<void>} */
-  stopHttp2Server() {
-    return new Promise((resolve, reject) => {
-      if (!this.http2Server) {
-        resolve();
-        return;
-      }
-      this.http2Server.close((err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
-  }
-
-  /**
-   * @return {Promise<[http.Server, https.Server, http2.Http2SecureServer]>}
-   */
-  startAll() {
-    return Promise.all([
-      this.useHttp ? this.startHttpServer() : Promise.resolve(null),
-      this.useHttps ? this.startHttpsServer() : Promise.resolve(null),
-      this.useHttp2 ? this.startHttp2Server() : Promise.resolve(null),
-    ]);
-  }
-
-  /**
-   * @return {Promise<void>}
-   */
-  stopAll() {
-    return Promise.all([
-      this.useHttp ? this.stopHttpServer() : Promise.resolve(null),
-      this.useHttps ? this.stopHttpsServer() : Promise.resolve(null),
-      this.useHttp2 ? this.stopHttp2Server() : Promise.resolve(null),
-    ]).then(() => null);
-  }
-}
-
-class HeadersParser {
-  constructor(headers = {}) {
-    /** @type {Object<string,any>} */
-    this.headers = headers;
-  }
-
-  /** @return {string} */
-  get contentType() {
-    return this.headers['content-type'];
-  }
-
-  /**
-   * The `media-type` directive of `Content-Type`.
-   * The MIME type of the resource or the data.
-   * (Always lowercase)
-   * @return {string}
-   */
-  get mediaType() {
-    return this.contentType?.split(';')[0].trim().toLowerCase();
-  }
-
-  /**
-   * The `charset` direct of `Content-Type`.
-   * The character encoding standard.
-   * (Always lowercase)
-   * @return {string} */
-  get charset() {
-    let value = null;
-    // eslint-disable-next-line no-unused-expressions
-    this.contentType?.split(';').some((directive) => {
-      const parameters = directive.split('=');
-      if (parameters[0].trim().toLowerCase() !== 'charset') {
-        return false;
-      }
-      value = parameters[1]?.trim().toLowerCase();
-      const firstQuote = value.indexOf('"');
-      const lastQuote = value.lastIndexOf('"');
-      if (firstQuote !== -1 && lastQuote !== -1) {
-        value = value.substring(firstQuote + 1, lastQuote);
-      }
-      return true;
-    });
-    return value;
-  }
-
-  /** @return {string} */
-  get boundary() {
-    let value = null;
-    // eslint-disable-next-line no-unused-expressions
-    this.contentType?.split(';').some((directive) => {
-      const parameters = directive.split('=');
-      if (parameters[0].trim().toLowerCase() !== 'boundary') {
-        return false;
-      }
-      value = parameters[1]?.trim().toLowerCase();
-      const firstQuote = value.indexOf('"');
-      const lastQuote = value.lastIndexOf('"');
-      if (firstQuote !== -1 && lastQuote !== -1) {
-        value = value.substring(firstQuote + 1, lastQuote);
-      }
-      return true;
-    });
-    return value;
-  }
-
-
-  /** @return {number} */
-  get contentLength() {
-    return parseInt(this.headers['content-length'], 10) || null;
-  }
-}
-
-/** @typedef {import('../types').HttpRequest} HttpRequest */
-
-/**
- * @param {string} cookieString
- * @return {[string,string][]}
- */
-function getEntriesFromCookie(cookieString) {
-  return cookieString.split(';').map((pair) => {
-    const indexOfEquals = pair.indexOf('=');
-    let name;
-    let value;
-    if (indexOfEquals === -1) {
-      name = '';
-      value = pair.trim();
-    } else {
-      name = pair.substr(0, indexOfEquals).trim();
-      value = pair.substr(indexOfEquals + 1).trim();
-    }
-    const firstQuote = value.indexOf('"');
-    const lastQuote = value.lastIndexOf('"');
-    if (firstQuote !== -1 && lastQuote !== -1) {
-      value = value.substring(firstQuote + 1, lastQuote);
-    }
-    return [name, value];
-  });
-}
-
-class RequestHeaders extends HeadersParser {
-  /** @param {HttpRequest} req */
-  constructor(req) {
-    super(req.headers);
-  }
-
-  /** @type {Object<string,string[]>} */
-  #cookiesProxy = null;
-
-  get cookies() {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const instance = this;
-    return {
-      /**
-       * @param {string} name
-       * @return {string}
-       */
-      get(name) {
-        return instance.cookieEntries[name]?.[0];
-      },
-      /**
-       * @param {string} name
-       * @return {string[]}
-       */
-      all(name) {
-        return instance.cookieEntries[name] ?? [];
-      },
-    };
-  }
-
-  /** @return {Object<string,string[]>} */
-  get cookieEntries() {
-    if (!this.#cookiesProxy) {
-      // eslint-disable-next-line @typescript-eslint/no-this-alias
-      const instance = this;
-      /** @type {Map<string,string[]>} */
-      const arrayProxyMap = new Map();
-      this.#cookiesProxy = new Proxy({}, {
-        get(cookieTarget, cookieName) {
-          if (typeof cookieName !== 'string') return undefined;
-          if (arrayProxyMap.has(cookieName)) {
-            return arrayProxyMap.get(cookieName);
-          }
-          const cookieString = (instance.headers.cookie ?? '');
-          const split = cookieString.split(';');
-          const values = [];
-          for (let i = 0; i < split.length; i += 1) {
-            const [key, value] = split[i].split('=');
-            if (key.trim() === cookieName) values.push(value);
-          }
-          const arrayProxy = new Proxy(values, {
-            get: (arrayTarget, arrayProp, receiver) => {
-              if (typeof arrayProp !== 'string') {
-                return Reflect.get(arrayTarget, arrayProp, receiver);
-              }
-              if (arrayProp === 'length') {
-                return getEntriesFromCookie(instance.headers.cookie ?? '')
-                  .filter(([key]) => (key === cookieName)).length;
-              }
-              if (Number.isNaN(parseInt(arrayProp, 10))) {
-                return Reflect.get(arrayTarget, arrayProp, receiver);
-              }
-              const entries = getEntriesFromCookie(instance.headers.cookie ?? '');
-              let count = 0;
-              for (let i = 0; i < entries.length; i += 1) {
-                const entry = entries[i];
-                if (entry[0] === cookieName) {
-                  if (arrayProp === count.toString()) {
-                    return entry[1];
-                  }
-                  count += 1;
-                }
-              }
-              return Reflect.get(arrayTarget, arrayProp, receiver);
-            },
-            set: (arrayTarget, arrayProp, value, receiver) => {
-              Reflect.set(arrayTarget, arrayProp, value, receiver);
-              if (typeof arrayProp !== 'string') return true;
-              const result = getEntriesFromCookie(instance.headers.cookie ?? '').reduce((prev, curr) => {
-                if (!curr[0]) return prev;
-                if (curr[0] === cookieName) return prev;
-                return `${prev};${curr[0]}=${curr[1]}`;
-              }, arrayTarget.map((v) => `${cookieName}=${v}`).join(';'));
-              instance.headers.cookie = result;
-              return true;
-            },
-          });
-          arrayProxyMap.set(cookieName, arrayProxy);
-          return arrayProxy;
-        },
-        ownKeys() {
-          const cookieString = (instance.headers.cookie || '');
-          const split = cookieString.split(';');
-          /** @type {string[]} */
-          const keys = [];
-          for (let i = 0; i < split.length; i += 1) {
-            const [key] = split[i].split('=');
-            const trimmed = key?.trim();
-            if (trimmed && !keys.includes(trimmed)) {
-              keys.push(trimmed);
-            }
-          }
-          return keys;
-        },
-        has(target, p) {
-          return instance.headers.cookie?.split(';')
-            .some((/** @type string */ cookie) => cookie.split('=')[0]?.trim() === p) ?? false;
-        },
-        getOwnPropertyDescriptor() {
-          return {
-            enumerable: true,
-            configurable: true,
-          };
-        },
-      });
-    }
-    return this.#cookiesProxy;
-  }
-}
-
-/** @typedef {import('../types').HttpRequest} HttpRequest */
-
-/**
- * @typedef {Object} RequestReaderOptions
- * @prop {boolean} [cache=true]
- */
-
-const BUFFER_SIZE = 4096;
-const STREAM_WAIT_MS = 0;
-
-/** @type {WeakMap<HttpRequest, RequestReader>} */
-const cache = new WeakMap();
-
-class RequestReader {
-  /** @type {AsyncObject<Buffer>} */
-  #buffer = new AsyncObject(null);
-
-  /**
-   * @param {HttpRequest} request
-   * @param {RequestReaderOptions} [options]
-   */
-  constructor(request, options) {
-    const o = {
-      cache: true,
-      ...options,
-    };
-    if (o.cache !== false) {
-      if (cache.has(request)) {
-        return cache.get(request);
-      }
-      cache.set(request, this);
-    }
-    this.request = request;
-  }
-
-  /** @return {Promise<Buffer>} */
-  readBuffer() {
-    if (this.#buffer.isBusy() || this.#buffer.hasValue()) return this.#buffer.get();
-    this.#buffer.prepare();
-    const hp = new RequestHeaders(this.request);
-    let data = Buffer.alloc(Math.min(BUFFER_SIZE, hp.contentLength || BUFFER_SIZE));
-    let bytesWritten = 0;
-    /** @type {NodeJS.Timeout} */
-    let sendPingTimeout = null;
-    this.request.stream.on('readable', () => {
-      let chunk;
-      // eslint-disable-next-line no-cond-assign
-      while (chunk = this.request.stream.read(Math.min(BUFFER_SIZE, this.request.stream.readableLength))) {
-        /** @type {Buffer} */
-        let buffer;
-        if (typeof chunk === 'string') {
-          console.warn('Unexpected string type on chunk!', this.request.stream.readableEncoding);
-          buffer = Buffer.from(chunk, this.request.stream.readableEncoding);
-        } else {
-          buffer = chunk;
-        }
-        if ((buffer.length + bytesWritten) > data.length) {
-          let newLength = data.length * 2;
-          while (newLength < buffer.length + data.length) {
-            newLength *= 2;
-          }
-          const newBuffer = Buffer.alloc(newLength);
-          data.copy(newBuffer);
-          data = newBuffer;
-        }
-        bytesWritten += buffer.copy(data, bytesWritten);
-      }
-      clearTimeout(sendPingTimeout);
-      if (this.request.canPing) {
-        sendPingTimeout = setTimeout(() => {
-          this.request.ping().catch(noop);
-        }, STREAM_WAIT_MS);
-      }
-    });
-    this.request.stream.on('end', () => {
-      clearTimeout(sendPingTimeout);
-      if (data.length > bytesWritten) {
-        data = data.subarray(0, bytesWritten);
-      }
-      this.#buffer.set(data);
-    });
-    this.request.stream.on('error', (err) => {
-      this.#buffer.reset(err);
-    });
-    return this.#buffer.get();
-  }
-
-  /** @return {Promise<string>} */
-  readString() {
-    return this.readBuffer().then((buffer) => {
-      const reqHeaders = new RequestHeaders(this.request);
-      // TODO: Compare TextDecoder, Buffer.from(), and StringDecoder performance
-      const decoder = new util.TextDecoder(reqHeaders.charset || 'utf-8');
-      return decoder.decode(buffer);
-    });
-  }
-
-  /** @return {Promise<Object<string,any>>} */
-  readJSON() {
-    return this.readString().then(JSON.parse);
-  }
-
-  /**
-   * The application/x-www-form-urlencoded format is in many ways an aberrant monstrosity,
-   * the result of many years of implementation accidents and compromises leading to a set of
-   * requirements necessary for interoperability, but in no way representing good design practices.
-   * In particular, readers are cautioned to pay close attention to the twisted details
-   * involving repeated (and in some cases nested) conversions between character encodings and byte sequences.
-   * Unfortunately the format is in widespread use due to the prevalence of HTML forms. [HTML]
-   * @return {Promise<[string, string][]>}
-   */
-  readUrlEncoded() {
-    // https://url.spec.whatwg.org/#urlencoded-parsing
-    const reqHeaders = new RequestHeaders(this.request);
-    const decoder = new util.TextDecoder(reqHeaders.charset || 'utf-8');
-    return this.readBuffer().then((buffer) => {
-      const sequences = [];
-      let startIndex = 0;
-      for (let i = 0; i < buffer.length; i += 1) {
-        if (buffer[i] === 0x26) {
-          sequences.push(buffer.subarray(startIndex, i));
-          startIndex = i + 1;
-        }
-        if (i === buffer.length - 1) {
-          sequences.push(buffer.subarray(startIndex, i));
-        }
-      }
-      /** @type {[string, string][]} */
-      const output = [];
-      sequences.forEach((bytes) => {
-        if (!bytes.length) return;
-
-        // Find 0x3D and replace 0x2B in one loop for better performance
-        let indexOf0x3D = -1;
-        for (let i = 0; i < bytes.length; i += 1) {
-          switch (bytes[i]) {
-            case 0x3D:
-              if (indexOf0x3D === -1) {
-                indexOf0x3D = i;
-              }
-              break;
-            case 0x2B:
-              // Replace bytes on original stream for memory conservation
-              // eslint-disable-next-line no-param-reassign
-              bytes[i] = 0x20;
-              break;
-          }
-        }
-        let name;
-        let value;
-        if (indexOf0x3D === -1) {
-          name = bytes;
-          value = bytes.subarray(bytes.length, 0);
-        } else {
-          name = bytes.subarray(0, indexOf0x3D);
-          value = bytes.subarray(indexOf0x3D + 1);
-        }
-        const nameString = decodeURIComponent(decoder.decode(name));
-        const valueString = decodeURIComponent(decoder.decode(value));
-        output.push([nameString, valueString]);
-      });
-      return output;
-    });
-  }
-
-  /** @return {Promise<Map<string,string>>} */
-  readUrlEncodedAsMap() {
-    return this.readUrlEncoded().then((tupleArray) => new Map(tupleArray));
-  }
-
-  /** @return {Promise<Object<string,string>>} */
-  readUrlEncodedAsObject() {
-    return this.readUrlEncoded().then((tupleArray) => Object.fromEntries(tupleArray));
-  }
-
-  /**
-   * Returns `readJSON()`, `readUrlEncodedAsObject`, or `Promise<null>` based on Content-Type
-   * @return {Promise<Object<string, any>|null>}
-   */
-  readObject() {
-    const reqHeaders = new RequestHeaders(this.request);
-    const mediaType = reqHeaders.mediaType?.toLowerCase() ?? '';
-    switch (mediaType) {
-      case 'application/json':
-        return this.readJSON();
-      case 'application/x-www-form-urlencoded':
-        return this.readUrlEncodedAsObject();
-      default:
-        return Promise.resolve(null);
-    }
-  }
-
-  /**
-   * Returns `readJSON()`, `readUrlEncoded`, `readBuffer()`, or `readString()` based on Content-Type
-   * @return {Promise<Object<string,any>|string|Buffer>}
-   */
-  read() {
-    const reqHeaders = new RequestHeaders(this.request);
-    const mediaType = reqHeaders.mediaType?.toLowerCase() ?? '';
-    switch (mediaType) {
-      case 'application/json':
-        return this.readJSON();
-      case 'application/x-www-form-urlencoded':
-        return this.readUrlEncoded();
-      case 'application/octet-stream':
-      case '':
-        return this.readBuffer();
-      default:
-        if (mediaType.startsWith('text')) {
-          return this.readString();
-        }
-        return this.readBuffer();
-    }
-  }
-}
-
-/** @typedef {import('../types').CookieDetails} CookieDetails */
-
-/** @private */
-class CookieObject {
-  /** @param {CookieDetails|string} options */
-  constructor(options) {
-    if (typeof options === 'string') {
-      return CookieObject.parse(options);
-    }
-    this.name = options.name;
-    this.value = options.value;
-    this.expires = options.expires;
-    this.maxAge = options.maxAge;
-    this.domain = options.domain;
-    this.path = options.path;
-    this.secure = options.secure;
-    this.httpOnly = options.httpOnly;
-    this.sameSite = options.sameSite;
-  }
-
-  /**
-   * @param {string} cookieString
-   * @return {CookieObject}
-   */
-  static parse(cookieString) {
-    /** @type {Partial<CookieDetails>} */
-    const options = {};
-    cookieString.split(';').forEach((pair, index) => {
-      const indexOfEquals = pair.indexOf('=');
-      let key;
-      let value;
-      if (indexOfEquals === -1) {
-        key = '';
-        value = pair.trim();
-      } else {
-        key = pair.substr(0, indexOfEquals).trim();
-        value = pair.substr(indexOfEquals + 1).trim();
-      }
-      const firstQuote = value.indexOf('"');
-      const lastQuote = value.lastIndexOf('"');
-      if (firstQuote !== -1 && lastQuote !== -1) {
-        value = value.substring(firstQuote + 1, lastQuote);
-      }
-      if (index === 0) {
-        options.name = key;
-        if (value != null) {
-          options.value = value;
-        }
-        return;
-      }
-      switch (key.toLowerCase()) {
-        case 'expires':
-          options.expires = new Date(value);
-          return;
-        case 'max-age':
-          options.maxAge = parseInt(value, 10);
-          return;
-        case 'domain':
-          options.domain = value;
-          break;
-        case 'path':
-          options.path = value;
-          break;
-        case 'secure':
-          options.secure = true;
-          break;
-        case 'httponly':
-          options.httpOnly = true;
-          break;
-        case 'samesite':
-          // @ts-ignore No cast
-          options.sameSite = value;
-          break;
-      }
-    });
-    return new CookieObject(options);
-  }
-
-  toString() {
-    // eslint-disable-next-line prefer-template
-    return (`${this.name ?? ''}=${this.value ?? ''}`)
-      + (this.expires != null ? `; Expires=${this.expires.toUTCString()}` : '')
-      + (this.maxAge != null ? `; Max-Age=${this.maxAge}` : '')
-      + (this.domain != null ? `; Domain=${this.domain}` : '')
-      + (this.path != null ? `; Path=${this.path}` : '')
-      + (this.secure ? '; Secure' : '')
-      + (this.httpOnly ? '; HttpOnly' : '')
-      + (this.sameSite ? `; SameSite=${this.sameSite}` : '');
-  }
-
-  toJSON() {
-    return {
-      name: this.name,
-      value: this.value,
-      expires: this.expires,
-      maxAge: this.maxAge,
-      domain: this.domain,
-      path: this.path,
-      secure: this.secure || undefined,
-      httpOnly: this.httpOnly || undefined,
-      sameSite: this.sameSite,
-    };
-  }
-}
-
-/** @typedef {import('../types').HttpResponse} HttpResponse */
-/** @typedef {import('../types').CookieDetails} CookieDetails */
-
-/** @type {(keyof CookieDetails)[]} */
-const COOKIE_DETAIL_KEYS = [
-  'name',
-  'value',
-  'expires',
-  'maxAge',
-  'domain',
-  'path',
-  'secure',
-  'httpOnly',
-  'sameSite',
-];
-
-class ResponseHeaders extends HeadersParser {
-  /** @param {HttpResponse} res */
-  constructor(res) {
-    super(res.headers);
-  }
-
-  /** @type {CookieObject[]} */
-  #setCookiesProxy = null;
-
-  /** @type {ProxyHandler<CookieObject>} */
-  #cookieObjectProxyHandler = {
-    set: (cookieTarget, cookieProp, cookieValue, receiver) => {
-      Reflect.set(cookieTarget, cookieProp, cookieValue, receiver);
-      const index = this.cookieEntries.findIndex((entry) => entry.toString() === cookieTarget.toString());
-      if (index !== -1) {
-        // Force reflection
-        Reflect.set(this.cookieEntries, index, cookieTarget);
-      }
-      return true;
-    },
-  };
-
-  get contentType() {
-    return super.contentType;
-  }
-
-  /** @param {string} contentType */
-  set contentType(contentType) {
-    this.headers['content-type'] = contentType;
-  }
-
-  get mediaType() {
-    return super.mediaType;
-  }
-
-  /** @param {string} mediaType */
-  set mediaType(mediaType) {
-    const { charset, boundary } = this;
-    this.contentType = [
-      mediaType ?? '',
-      charset ? `charset=${charset}` : null,
-      boundary ? `boundary=${boundary}` : null,
-    ].filter((s) => s != null).join(';');
-  }
-
-  get charset() {
-    return super.charset;
-  }
-
-  /** @param {string} charset */
-  set charset(charset) {
-    const { mediaType, boundary } = this;
-    this.contentType = [
-      mediaType ?? '',
-      charset ? `charset=${charset}` : null,
-      boundary ? `boundary=${boundary}` : null,
-    ].filter((s) => s != null).join(';');
-  }
-
-  /** @return {BufferEncoding} */
-  get charsetAsBufferEncoding() {
-    const { charset } = this;
-    switch (charset) {
-      case 'iso-8859-1':
-      case 'ascii':
-      case 'binary':
-      case 'latin1':
-        return 'latin1';
-      case 'utf-16le':
-      case 'ucs-2':
-      case 'ucs2':
-      case 'utf16le':
-        return 'utf16le';
-      case 'utf-8':
-      case 'utf8':
-        return 'utf-8';
-      default:
-      case 'base64':
-      case 'hex':
-        return /** @type {BufferEncoding} */ (charset);
-    }
-  }
-
-  /** @param {BufferEncoding} bufferEncoding */
-  set charsetAsBufferEncoding(bufferEncoding) {
-    switch (bufferEncoding) {
-      case 'ascii':
-      case 'binary':
-      case 'latin1':
-        this.charset = 'iso-8859-1';
-        break;
-      case 'ucs-2':
-      case 'ucs2':
-      case 'utf16le':
-        this.charset = 'utf-16le';
-        break;
-      case 'utf-8':
-      case 'utf8':
-        this.charset = 'utf-8';
-        break;
-      default:
-      case 'base64':
-      case 'hex':
-        this.charset = bufferEncoding;
-    }
-  }
-
-  get boundary() {
-    return super.boundary;
-  }
-
-  /** @param {string} boundary */
-  set boundary(boundary) {
-    const { mediaType, charset } = this;
-    this.contentType = [
-      mediaType ?? '',
-      charset ? `charset=${charset}` : null,
-      boundary ? `boundary=${boundary}` : null,
-    ].filter((s) => s != null).join(';');
-  }
-
-  get contentLength() {
-    return super.contentLength;
-  }
-
-  /** @param {number} value */
-  set contentLength(value) {
-    this.headers['content-length'] = value;
-  }
-
-  get cookies() {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const instance = this;
-    return {
-      /**
-       * @param {string|CookieDetails|CookieObject} nameOrDetails
-       * @return {boolean}
-       */
-      has(nameOrDetails) {
-        return !!this.getAll(nameOrDetails)[0];
-      },
-      /**
-       * @param {string|CookieDetails} partial
-       * @return {CookieObject}
-       */
-      get(partial) {
-        return this.getAll(partial)[0];
-      },
-      /**
-       * @param {string|CookieDetails} [partial]
-       * @return {CookieObject[]}
-       */
-      getAll(partial) {
-        const details = typeof partial === 'string' ? new CookieObject({ name: partial }) : partial ?? {};
-        /** @type {CookieDetails} */
-        const searchDetails = { name: details.name };
-        if (details.path) {
-          searchDetails.path = details.path;
-        }
-        return this.findAll(searchDetails);
-      },
-      /**
-       * @param {CookieDetails} details
-       * @return {CookieObject}
-       */
-      find(details) {
-        return this.findAll(details)[0];
-      },
-      /**
-       * @param {CookieDetails} [details]
-       * @return {CookieObject[]}
-       */
-      findAll(details = {}) {
-        return instance.cookieEntries
-          .filter((cookieObject) => COOKIE_DETAIL_KEYS.every((key) => {
-            if ((key in details) === false) {
-              return true;
-            }
-            switch (key) {
-              case 'expires':
-                return details.expires?.getTime() === cookieObject.expires?.getTime();
-              case 'path':
-                return (details.path ?? '') === (cookieObject.path ?? '');
-              default:
-                return details[key] === cookieObject[key];
-            }
-          }))
-          .sort((a, b) => (b?.path?.length ?? 0 - a?.path?.length ?? 0));
-      },
-      /**
-       * @param {string|CookieDetails} cookie
-       * @return {CookieObject}
-       */
-      set(cookie) {
-        const details = typeof cookie === 'string' ? new CookieObject(cookie) : cookie ?? {};
-        let cookieObject = this.find({
-          path: '',
-          ...details,
-        });
-        if (!cookieObject) {
-          cookieObject = new Proxy(new CookieObject(details), instance.#cookieObjectProxyHandler);
-          instance.cookieEntries.push(cookieObject);
-        } else {
-          COOKIE_DETAIL_KEYS.forEach((key) => {
-            // @ts-ignore Coerce
-            cookieObject[key] = details[key];
-          });
-        }
-        return cookieObject;
-      },
-      /**
-       * @param {string|CookieDetails} partial
-       * @return {number} count
-       */
-      remove(partial) {
-        const items = this.getAll(partial);
-        const count = items.length;
-        items.forEach((item) => {
-          instance.cookieEntries.splice(instance.cookieEntries.indexOf(item), 1);
-        });
-        return count;
-      },
-      /**
-       * @param {string|CookieDetails} partial name or details
-       * @return {CookieObject}
-       */
-      expire(partial) {
-        const details = typeof partial === 'string' ? new CookieObject({ name: partial }) : partial ?? {};
-        let object = this.get(details);
-        if (!object) {
-          object = new Proxy(new CookieObject(details), instance.#cookieObjectProxyHandler);
-          instance.cookieEntries.push(object);
-        }
-        delete object.expires;
-        object.maxAge = 0;
-        object.value = '';
-        return object;
-      },
-      /**
-       * @param {string|CookieDetails} [partial]
-       * @return {CookieObject[]}
-       */
-      expireAll(partial) {
-        const items = this.getAll(partial);
-        items.forEach((item) => {
-          /* eslint-disable no-param-reassign */
-          item.expires = null;
-          item.maxAge = 0;
-          item.value = '';
-          /* eslint-enable no-param-reassign */
-        });
-        return items;
-      },
-    };
-  }
-
-  /** @return {Array<CookieObject>} */
-  get cookieEntries() {
-    if (!this.#setCookiesProxy) {
-      if (!this.headers['set-cookie']) {
-        this.headers['set-cookie'] = [];
-      }
-      // eslint-disable-next-line @typescript-eslint/no-this-alias
-      const instance = this;
-      /** @type {CookieObject[]} */
-      const values = instance.headers['set-cookie']
-        .map((/** @type {string} */ setCookie) => new Proxy(
-          new CookieObject(setCookie),
-          instance.#cookieObjectProxyHandler,
-        ));
-      this.#setCookiesProxy = new Proxy(values, {
-        get: (arrayTarget, arrayProp, receiver) => {
-          if (typeof arrayProp !== 'string') {
-            return Reflect.get(arrayTarget, arrayProp, receiver);
-          }
-          if (arrayProp === 'length') {
-            return instance.headers['set-cookie'].length;
-          }
-          if (Number.isNaN(parseInt(arrayProp, 10))) {
-            return Reflect.get(arrayTarget, arrayProp, receiver);
-          }
-          const entry = instance.headers['set-cookie'][arrayProp];
-          if (typeof entry === 'undefined') {
-            return entry;
-          }
-          if (arrayProp in arrayTarget === false) {
-            Reflect.set(
-              arrayTarget,
-              arrayProp,
-              new Proxy(new CookieObject(entry), instance.#cookieObjectProxyHandler),
-            );
-          }
-          return Reflect.get(arrayTarget, arrayProp, receiver);
-        },
-        set: (arrayTarget, arrayProp, value, receiver) => {
-          Reflect.set(arrayTarget, arrayProp, value, receiver);
-          if (typeof arrayProp !== 'string') return true;
-          if (arrayProp === 'length') {
-            Reflect.set(instance.headers['set-cookie'], arrayProp, value);
-          }
-          if (value instanceof CookieObject) {
-            instance.headers['set-cookie'][arrayProp] = value.toString();
-          }
-          return true;
-        },
-      });
-    }
-    return this.#setCookiesProxy;
-  }
-}
-
-var index$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  HttpListener: HttpListener,
-  HeadersParser: HeadersParser,
-  RequestHeaders: RequestHeaders,
-  RequestReader: RequestReader,
-  ResponseHeaders: ResponseHeaders
-});
-
-class CaseInsensitiveObject {
-  /** @param {Object} [object] */
-  constructor(object) {
-    if (object && object instanceof CaseInsensitiveObject) {
-      return object;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const instance = this;
-    const proxy = new Proxy(instance, CaseInsensitiveObject.defaultProxyHandler);
-    Object.entries(object).forEach(([key, value]) => {
-      // @ts-ignore Coerce
-      this[key] = value;
-    });
-    return proxy;
-  }
-}
-
-/** @type {ProxyHandler<Object>} */
-CaseInsensitiveObject.defaultProxyHandler = {
-  get(target, p, receiver) {
-    return Reflect.get(target, typeof p === 'string' ? p.toLowerCase() : p, receiver);
-  },
-  set(target, p, receiver) {
-    return Reflect.set(target, typeof p === 'string' ? p.toLowerCase() : p, receiver);
-  },
-  has(target, p) {
-    return Reflect.has(target, typeof p === 'string' ? p.toLowerCase() : p);
-  },
-  deleteProperty(target, p) {
-    return Reflect.deleteProperty(target, typeof p === 'string' ? p.toLowerCase() : p);
-  },
-};
-
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-/**
- * @typedef {Object} CaseInsensitiveHeadersMiddlewareOptions
- * @prop {boolean} [request=false] Mutate request headers to be case-insensitive
- * @prop {boolean} [response=false] Mutate response headers to be case-insensistive
- */
-
-/** @implements {IMiddleware} */
-class CaseInsensitiveHeadersMiddleware {
-  /** @param {CaseInsensitiveHeadersMiddlewareOptions} options */
-  constructor(options) {
-    this.request = options.request === true;
-    this.response = options.response === true;
-  }
-
-  /**
-   * @param {!MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
-    if (this.request) {
-    // @ts-ignore Coerce
-      req.headers = new CaseInsensitiveObject(req.headers || {});
-    }
-    if (this.response) {
-    // @ts-ignore Coerce
-      res.headers = new CaseInsensitiveObject(res.headers || {});
-    }
-    return 'continue';
-  }
-}
-
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-/**
- * @typedef ContentDecoderMiddlewareOptions
- * @prop {number} [chunkSize]
- * @prop {boolean} [respondNotAcceptable=false]
- */
-
-/**
- * Implements `Accept-Encoding`
- * https://tools.ietf.org/html/rfc7231#section-5.3.4
- * @implements {IMiddleware}
- */
-class ContentDecoderMiddleware {
-  /** @param {ContentDecoderMiddlewareOptions} [options] */
-  constructor(options = {}) {
-    this.chunkSize = options.chunkSize;
-    this.respondNotAcceptable = options.respondNotAcceptable === true;
-  }
-
-  /**
-   * @param {!MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
-    switch (req.method) {
-      case 'HEAD':
-      case 'GET':
-        return 'continue';
-    }
-
-    res.headers['accept-encoding'] = 'gzip, deflate, br';
-    const contentEncoding = (req.headers['content-encoding'] ?? '').trim().toLowerCase();
-
-    switch (contentEncoding) {
-      case '':
-      case 'identity':
-        return 'continue';
-      case 'gzip':
-      case 'br':
-      case 'deflate':
-        break;
-      default:
-        if (this.respondNotAcceptable) {
-          res.status = 406;
-          return 'end';
-        }
-        return 'continue';
-    }
-
-    const source = req.stream;
-    let initialized = false;
-    const { chunkSize } = this;
-    const newReadable = new stream.PassThrough({
-      read(...args) {
-        if (!initialized) {
-        /** @type {import("zlib").Gzip} */
-          let gzipStream;
-          switch (contentEncoding) {
-            case 'deflate':
-              gzipStream = zlib.createInflate({ chunkSize });
-              break;
-            case 'gzip':
-              gzipStream = zlib.createGunzip({ chunkSize });
-              break;
-            case 'br':
-              gzipStream = zlib.createBrotliDecompress({ chunkSize });
-              break;
-            default:
-              throw new Error('UNKNOWN_ENCODING');
-          }
-          source.pipe(gzipStream).pipe(this);
-          initialized = true;
-        }
-        if (source.isPaused()) source.resume();
-        // eslint-disable-next-line no-underscore-dangle
-        stream.Transform.prototype._read.call(this, ...args);
-      },
-    });
-    source.pause();
-    req.replaceStream(newReadable);
-    return 'continue';
-  }
-}
-
-/** @typedef {{q:number?} & {[key:string]:string}} ParsedQualityValues */
-
-/**
- * @param {string} input
- * @return {Map<string, ParsedQualityValues>}
- */
-function parseQualityValues(input) {
-  if (!input || !input.trim()) {
-    return new Map();
-  }
-  const tupleArray = input
-    .split(',')
-    .map((values) => {
-      const [value, ...specifiers] = values.split(';');
-      return /** @type {[string, ParsedQualityValues]} */ ([
-        value.trim(),
-        {
-          ...Object.assign({}, ...specifiers.map((pair) => {
-            const [specifier, sValue] = pair.split('=');
-            const trimmedSpec = specifier?.trim();
-            const trimmedSValue = sValue?.trim();
-            if (trimmedSpec === 'q') {
-              const parsedQ = parseFloat(trimmedSValue);
-              return { q: Number.isNaN(parsedQ) ? 1 : parsedQ };
-            }
-            return { [trimmedSpec]: trimmedSValue };
-          })),
-        },
-      ]);
-    }).sort((a, b) => (b?.[1]?.q ?? 1) - (a?.[1]?.q ?? 1));
-  return new Map(tupleArray);
-}
-
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-/** @typedef {'br'|'gzip'|'deflate'|'identity'|'*'} COMPATIBLE_ENCODING */
-
-const DEFAULT_MINIMUM_SIZE = 256;
-
-/**
- * @typedef ContentEncoderMiddlewareOptions
- * @prop {number} [chunkSize]
- * @prop {boolean} [respondNotAcceptable=false]
- * @prop {'br'|'gzip'|'deflate'|'identity'} [preferredEncoding='identity']
- * @prop {number} [minimumSize=DEFAULT_MINIMUM_SIZE]
- */
-
-/** @type {COMPATIBLE_ENCODING[]} */
-const COMPATIBLE_ENCODINGS = ['br', 'gzip', 'deflate', 'identity', '*'];
-
-/** @implements {IMiddleware} */
-class ContentEncoderMiddleware {
-  /** @param {ContentEncoderMiddlewareOptions} [options] */
-  constructor(options = {}) {
-    this.chunkSize = options.chunkSize;
-    this.respondNotAcceptable = options.respondNotAcceptable === true;
-    this.preferredEncoding = options.preferredEncoding ?? 'identity';
-    this.minimumSize = options.minimumSize ?? DEFAULT_MINIMUM_SIZE;
-  }
-
-  /**
-   * @param {import('../types/index.js').HttpRequest} req
-   * @throws {NotAcceptableException} Error with `NOT_ACCEPTIBLE` message
-   * @return {COMPATIBLE_ENCODING}
-   */
-  static chooseEncoding(req) {
-  /**
-   * A request without an Accept-Encoding header field implies that the
-   * user agent has no preferences regarding content-codings.  Although
-   * this allows the server to use any content-coding in a response, it
-   * does not imply that the user agent will be able to correctly process
-   * all encodings.
-   */
-    if ('accept-encoding' in req.headers === false) {
-      return '*';
-    }
-
-    /** @type {string} */
-    const acceptString = (req.headers['accept-encoding']);
-    const encodings = parseQualityValues(acceptString?.toLowerCase());
-    if (!encodings.size) {
-    /**
-     * An Accept-Encoding header field with a combined field-value that is
-     * empty implies that the user agent does not want any content-coding in
-     * response.
-     */
-      return 'identity';
-    }
-    let encoding = COMPATIBLE_ENCODINGS[0];
-    const allowWildcards = (encodings.get('*')?.q !== 0);
-    const encodingEntries = [...encodings.entries()];
-    // @ts-ignore Cannot cast to COMPATIBLE_ENCODINGS
-    encoding = (encodingEntries.find(([value, spec]) => spec.q !== 0 && COMPATIBLE_ENCODINGS.includes(value))?.[0]);
-    if (allowWildcards && (encoding === '*' || !encoding)) {
-    // Server preference
-    // Get first compatible encoding not specified
-      encoding = COMPATIBLE_ENCODINGS.find((value) => !encodings.has(value));
-    }
-    if (allowWildcards && !encoding) {
-    // Get highest q'd compatible encoding not q=0 or '*'
-    // @ts-ignore Cannot cast to COMPATIBLE_ENCODINGS
-      encoding = encodingEntries
-      // @ts-ignore Cannot cast to COMPATIBLE_ENCODINGS
-        .find(([value, spec]) => spec.q !== 0 && value !== '*' && COMPATIBLE_ENCODINGS.includes(value))?.[0];
-    }
-    if (!encoding) {
-      throw new Error('NOT_ACCEPTABLE');
-    }
-    return encoding;
-  }
-
-  /**
-   * Implements `Accept-Encoding`
-   * https://tools.ietf.org/html/rfc7231#section-5.3.4
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
-    if (req.method === 'HEAD') {
-    // Never needs content-encoding
-      return 'continue';
-    }
-
-    /** @type {COMPATIBLE_ENCODING} */
-    let parsedEncoding;
-    if (this.respondNotAcceptable) {
-    // Parse now to catch the error;
-      try {
-        parsedEncoding = ContentEncoderMiddleware.chooseEncoding(req);
-      } catch (error) {
-        if (error?.message === 'NOT_ACCEPTABLE') {
-          res.status = 406;
-          return 'end';
-        }
-        // Unknown error
-        throw error;
-      }
-    }
-
-    /** @return {string} */
-    const getContentEncoding = () => {
-      if (!parsedEncoding) {
-        try {
-          parsedEncoding = ContentEncoderMiddleware.chooseEncoding(req);
-        } catch (error) {
-          if (error?.message !== 'NOT_ACCEPTABLE') {
-            throw error;
-          }
-        }
-      }
-      if (!parsedEncoding || parsedEncoding === '*') {
-        parsedEncoding = this.preferredEncoding || 'identity';
-      }
-      res.headers['content-encoding'] = parsedEncoding;
-      return parsedEncoding;
-    };
-
-    let finalCalled = false;
-    let transformCount = 0;
-    let inputLength = 0;
-    const newStream = new stream.Transform({
-      transform(chunk, encoding, callback) {
-        transformCount += 1;
-        inputLength += chunk.length;
-        // Stall to see if more chunks are in transit
-        process.nextTick(() => {
-          this.push(chunk);
-        });
-        callback();
-      },
-      final(callback) {
-        finalCalled = true;
-        callback();
-      },
-    });
-    const destination = res.replaceStream(newStream);
-
-    /**
-     * @param {'br'|'gzip'|'deflate'} encoding
-     * @return {import("zlib").Gzip}
-     */
-    const buildGzipStream = (encoding) => {
-      /** @type {import("zlib").Gzip} */
-      let gzipStream;
-      switch (encoding) {
-        case 'deflate':
-          gzipStream = zlib.createDeflate({ chunkSize: this.chunkSize });
-          break;
-        case 'gzip':
-          gzipStream = zlib.createGzip({ chunkSize: this.chunkSize });
-          break;
-        case 'br':
-          gzipStream = zlib.createBrotliCompress({ chunkSize: this.chunkSize });
-          break;
-        default:
-          throw new Error('UNKNOWN_ENCODING');
-      }
-
-      /** @type {Buffer[]} */
-      const pendingChunks = [];
-
-      gzipStream.on('data', (chunk) => {
-        if (finalCalled) {
-          pendingChunks.push(chunk);
-        } else {
-          let previousChunk;
-          // eslint-disable-next-line no-cond-assign
-          while (previousChunk = pendingChunks.shift()) {
-            destination.write(previousChunk);
-          }
-          destination.write(chunk);
-        }
-      });
-      gzipStream.on('end', () => {
-        let chunk;
-        // eslint-disable-next-line no-cond-assign
-        while (chunk = pendingChunks.shift()) {
-          destination.write(chunk);
-        }
-        destination.end();
-      });
-
-      return gzipStream;
-    };
-
-    // Don't do any work until first chunk is received (if at all).
-    // This allows middleware to set `Content-Encoding` manually,
-    // prevents allocation memory for a gzip stream unnecessarily, and
-    // prevents polluting 204 responses.
-
-    const onEnd = () => destination.end();
-    newStream.once('data', (chunk) => {
-    // Will be handled by .pipe() or .end() call
-      newStream.off('end', onEnd);
-
-      /** @type {string} */
-      let encoding = (res.headers['content-encoding']);
-      if (encoding == null) {
-      // Only continue if unset. Blank is still considered set.
-      // This allows forced encoding (eg: use gzip regardless of size; always identity)
-        if (inputLength > (this.minimumSize ?? DEFAULT_MINIMUM_SIZE) || transformCount > 1) {
-        // If we're getting data in chunks, assume larger than minimum
-          encoding = getContentEncoding().toLowerCase?.();
-        } else {
-          encoding = 'identity';
-        }
-      }
-
-      let next;
-      switch (encoding) {
-        case 'br':
-        case 'gzip':
-        case 'deflate':
-          next = buildGzipStream(encoding);
-          break;
-        default:
-          next = destination;
-      }
-      next.write(chunk);
-      newStream.pipe(next);
-    });
-
-    // In case no data is passed
-    newStream.on('end', onEnd);
-
-    return 'continue';
-  }
-}
-
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-/**
- * @typedef {Object} ContentLengthMiddlewareOptions
- * @prop {boolean} [delayCycle=true]
- * Delays writing to stream by one I/O cycle.
- * If `.end()` is called on the same event loop as write, then the
- * content length can be still calculated despite receiving data in chunks.
- * Compared to no delay, chunks are held in memory for two event loops instead
- * of just one.
- * @prop {boolean} [overrideHeader=false]
- * Always replace `Content-Length` header
- */
-
-/** @implements {IMiddleware} */
-class ContentLengthMiddleware {
-  /** @param {ContentLengthMiddlewareOptions} [options] */
-  constructor(options = {}) {
-    this.delayCycle = options.delayCycle !== false;
-    this.overrideHeader = options.overrideHeader !== true;
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
-    if (req.method === 'HEAD') {
-      return 'continue';
-    }
-
-    let length = 0;
-    /** @type {Buffer[]} */
-    const pendingChunks = [];
-    let delayPending = false;
-    const { delayCycle, overrideHeader } = this;
-    const newWritable = new stream.Transform({
-      transform(chunk, encoding, callback) {
-        length += chunk.length;
-        if (delayCycle === false) {
-          callback(null, chunk);
-          return;
-        }
-
-        pendingChunks.push(chunk);
-        if (!delayPending) {
-          delayPending = true;
-          process.nextTick(() => setImmediate(() => {
-            delayPending = false;
-            pendingChunks.splice(0, pendingChunks.length)
-              .forEach((buffer) => this.push(buffer));
-          }));
-        }
-        callback();
-      },
-      flush(callback) {
-        if (!res.headersSent) {
-        /**
-         * Any response message which "MUST NOT" include a message-body
-         * (such as the 1xx, 204, and 304 responses and any response to a HEAD request)
-         * is always terminated by the first empty line after the header fields,
-         * regardless of the entity-header fields present in the message.
-         * https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.4
-         */
-          if ((res.status >= 100 && res.status < 200) || res.status === 204 || res.status === 304) {
-            if (overrideHeader) {
-              delete res.headers['content-length'];
-            }
-          } else if (overrideHeader === true || res.headers['content-length'] == null) {
-            res.headers['content-length'] = length;
-          }
-        }
-        pendingChunks.splice(0, pendingChunks.length)
-          .forEach((buffer) => this.push(buffer));
-        callback();
-      },
-    });
-
-    const destination = res.replaceStream(newWritable);
-    newWritable.pipe(destination);
-
-    return 'continue';
-  }
-}
-
-/** @typedef {import('stream').Readable} Readable */
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-/**
- * @typedef {Object} ContentReaderMiddlewareOptions
- * @prop {string} [defaultMediaType]
- * Assumed mediatype if not specified
- * @prop {boolean} [parseJSON=false]
- * Automatically parses JSON if `application/json` mediatype
- * @prop {'entries'|'object'|'string'|'none'} [formURLEncodedFormat='none']
- * Automatically converts to object if `application/x-www-form-urlencoded` mediatype
- * @prop {boolean} [buildString=false]
- * Automatically builds string into one `read()` response
- * @prop {boolean|string} [cache=false]
- * Caches content in req.local.content or req.local[cacheName]
- */
-
-/** @implements {IMiddleware} */
-class ContentReaderMiddleware {
-  /** @param {ContentReaderMiddlewareOptions} [options] */
-  constructor(options = {}) {
-    this.defaultMediaType = options.defaultMediaType;
-    this.parseJSON = options.parseJSON === true;
-    this.formURLEncodedFormat = options.formURLEncodedFormat || 'none';
-    this.buildString = options.buildString === true;
-    this.cache = options.cache;
-  }
-
-  /**
-   * @param {string} charset
-   * @return {BufferEncoding}
-   */
-  static charsetAsBufferEncoding(charset) {
-    switch (charset) {
-      case 'iso-8859-1':
-      case 'ascii':
-      case 'binary':
-      case 'latin1':
-        return 'latin1';
-      case 'utf-16le':
-      case 'ucs-2':
-      case 'ucs2':
-      case 'utf16le':
-        return 'utf16le';
-      default:
-      case 'utf-8':
-      case 'utf8':
-        return 'utf-8';
-      case 'base64':
-      case 'hex':
-        return /** @type {BufferEncoding} */ (charset);
-    }
-  }
-
-  /**
-   * The application/x-www-form-urlencoded format is in many ways an aberrant monstrosity,
-   * the result of many years of implementation accidents and compromises leading to a set of
-   * requirements necessary for interoperability, but in no way representing good design practices.
-   * In particular, readers are cautioned to pay close attention to the twisted details
-   * involving repeated (and in some cases nested) conversions between character encodings and byte sequences.
-   * Unfortunately the format is in widespread use due to the prevalence of HTML forms. [HTML]
-   * @param {Buffer} buffer
-   * @param {string} charset
-   * @return {[string, string][]} Tuple
-   */
-  static readUrlEncoded(buffer, charset) {
-  // https://url.spec.whatwg.org/#urlencoded-parsing
-    const bufferEncoding = ContentReaderMiddleware.charsetAsBufferEncoding(charset);
-
-    const sequences = [];
-    let startIndex = 0;
-    for (let i = 0; i < buffer.length; i += 1) {
-      if (buffer[i] === 0x26) {
-        sequences.push(buffer.subarray(startIndex, i));
-        startIndex = i + 1;
-      }
-      if (i === buffer.length - 1) {
-        sequences.push(buffer.subarray(startIndex, i + 1));
-        break;
-      }
-    }
-    /** @type {[string, string][]} */
-    const output = [];
-    sequences.forEach((bytes) => {
-      if (!bytes.length) return;
-
-      // Find 0x3D and replace 0x2B in one loop for better performance
-      let indexOf0x3D = -1;
-      for (let i = 0; i < bytes.length; i += 1) {
-        switch (bytes[i]) {
-          case 0x3D:
-            if (indexOf0x3D === -1) {
-              indexOf0x3D = i;
-            }
-            break;
-          case 0x2B:
-          // Replace bytes on original stream for memory conservation
-          // eslint-disable-next-line no-param-reassign
-            bytes[i] = 0x20;
-            break;
-        }
-      }
-      let name;
-      let value;
-      if (indexOf0x3D === -1) {
-        name = bytes;
-        value = bytes.subarray(bytes.length, 0);
-      } else {
-        name = bytes.subarray(0, indexOf0x3D);
-        value = bytes.subarray(indexOf0x3D + 1);
-      }
-      const nameString = decodeURIComponent(name.toString(bufferEncoding));
-      const valueString = decodeURIComponent(value.toString(bufferEncoding));
-      output.push([nameString, valueString]);
-    });
-    return output;
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req }) {
-    switch (req.method) {
-      case 'HEAD':
-      case 'GET':
-        return 'continue';
-    }
-
-    const contentType = (req.headers['content-type']);
-    /** @type {string} */
-    let mediaType;
-    /** @type {string} */
-    let charset;
-    if (contentType) {
-      contentType.split(';').forEach((directive) => {
-        const parameters = directive.split('=');
-        if (parameters.length === 1) {
-          mediaType = directive.trim().toLowerCase();
-          return;
-        }
-        if (parameters[0].trim().toLowerCase() !== 'charset') {
-          return;
-        }
-        charset = parameters[1]?.trim().toLowerCase();
-        const firstQuote = charset.indexOf('"');
-        const lastQuote = charset.lastIndexOf('"');
-        if (firstQuote !== -1 && lastQuote !== -1) {
-          charset = charset.substring(firstQuote + 1, lastQuote);
-        }
-      });
-    }
-
-    if (!mediaType) {
-      mediaType = this.defaultMediaType;
-    }
-    const isFormUrlEncoded = mediaType === 'application/x-www-form-urlencoded';
-    const isJSON = /application\/(.+\+)?json/i.test(mediaType);
-    if (!charset) {
-      if (!mediaType) {
-        return 'continue';
-      }
-      if (isFormUrlEncoded && (this.formURLEncodedFormat || 'none') === 'none') {
-        return 'continue';
-      }
-      if (!isFormUrlEncoded && !isJSON && !mediaType.startsWith('text/')) {
-        return 'continue';
-      }
-    }
-
-    const readAll = isJSON || isFormUrlEncoded;
-
-    let fullString = '';
-    /** @type {Buffer[]} */
-    const pendingChunks = [];
-    const source = req.stream;
-    const {
-      buildString, formURLEncodedFormat, cache, parseJSON,
-    } = this;
-    const newReadable = new stream.Transform({
-      objectMode: true,
-      read(...args) {
-        if (source.isPaused()) source.resume();
-        // eslint-disable-next-line no-underscore-dangle
-        stream.Transform.prototype._read.call(this, ...args);
-      },
-      transform(chunk, encoding, callback) {
-        if (typeof chunk === 'string') {
-          if (readAll || buildString) {
-            fullString += chunk;
-          } else {
-            this.push(chunk);
-          }
-        } else if (isFormUrlEncoded) {
-          pendingChunks.push(chunk);
-        } else {
-          this.push(chunk);
-        }
-        callback();
-      },
-      flush(callback) {
-        let result = null;
-        if (isFormUrlEncoded) {
-          const combinedBuffer = Buffer.concat(pendingChunks);
-          if (formURLEncodedFormat === 'object') {
-            result = Object.fromEntries(ContentReaderMiddleware.readUrlEncoded(combinedBuffer, charset));
-          } else if (formURLEncodedFormat === 'string') {
-            result = combinedBuffer.toString(ContentReaderMiddleware.charsetAsBufferEncoding(charset));
-          } else {
-            result = ContentReaderMiddleware.readUrlEncoded(combinedBuffer, charset);
-          }
-        } else if (isJSON && parseJSON) {
-          try {
-            result = JSON.parse(fullString);
-          } catch {
-            result = fullString;
-          }
-        } else if (fullString) {
-          result = fullString;
-        }
-        if (cache && result) {
-          const cacheName = cache === true ? 'content' : cache;
-          req.locals[cacheName] = result;
-        }
-        callback(null, result);
-      },
-    });
-    req.replaceStream(newReadable);
-    if (!isFormUrlEncoded) {
-    // Data read from source will be decoded as a string
-      const encoding = ContentReaderMiddleware.charsetAsBufferEncoding(charset);
-      const stringDecoder = new stream.PassThrough({ encoding });
-      newReadable.setDefaultEncoding(encoding);
-      source.pipe(stringDecoder).pipe(newReadable);
-    } else {
-      source.pipe(newReadable);
-    }
-    source.pause();
-
-    return 'continue';
-  }
-}
-
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-/**
- * @typedef {Object} ContentWriterMiddlewareOptions
- * @prop {string} [defaultCharset='utf-8']
- * @prop {boolean} [setCharset=false]
- * Automatically applies charset in `Content-Type`
- * @prop {boolean} [setJSON=false]
- * Automatically applies `application/json` mediatype in `Content-Type`
- * @prop {boolean|string} [cache=false]
- * Caches content in res.local.content or res.local[cacheName]
- */
-
-/** @implements {IMiddleware} */
-class ContentWriterMiddleware {
-  /** @param {ContentWriterMiddlewareOptions} [options] */
-  constructor(options = {}) {
-    this.defaultCharset = options.defaultCharset || 'utf-8';
-    this.setCharset = options.setCharset === true;
-    this.setJSON = options.setJSON === true;
-    this.cache = options.cache;
-  }
-
-  /**
-   * @param {string} charset
-   * @return {BufferEncoding}
-   */
-  static charsetAsBufferEncoding(charset) {
-    switch (charset) {
-      case 'iso-8859-1':
-      case 'ascii':
-      case 'binary':
-      case 'latin1':
-        return 'latin1';
-      case 'utf-16le':
-      case 'ucs-2':
-      case 'ucs2':
-      case 'utf16le':
-        return 'utf16le';
-      default:
-      case 'utf-8':
-      case 'utf8':
-        return 'utf-8';
-      case 'base64':
-      case 'hex':
-        return /** @type {BufferEncoding} */ (charset);
-    }
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
-    if (req.method === 'HEAD') {
-      return 'continue';
-    }
-
-    /** @type {string} */
-    let charset = null;
-    /** @type {BufferEncoding} */
-    let encoding = null;
-    let hasSetJSON = false;
-
-    /** @return {string} */
-    const parseCharset = () => {
-      if (charset) return charset;
-      /** @type {string} */
-      const contentType = (res.headers['content-type']);
-      if (contentType) {
-        contentType.split(';').some((directive) => {
-          const parameters = directive.split('=');
-          if (parameters[0].trim().toLowerCase() !== 'charset') {
-            return false;
-          }
-          charset = parameters[1]?.trim().toLowerCase();
-          const firstQuote = charset.indexOf('"');
-          const lastQuote = charset.lastIndexOf('"');
-          if (firstQuote !== -1 && lastQuote !== -1) {
-            charset = charset.substring(firstQuote + 1, lastQuote);
-          }
-          return true;
-        });
-      }
-      if (!charset) {
-        charset = this.defaultCharset || 'utf-8';
-        if (this.setCharset && !res.headersSent) {
-          res.headers['content-type'] = `${contentType || ''};charset=${charset}`;
-        }
-      }
-      return charset;
-    };
-
-    /** @return {void} */
-    const setJSONMediaType = () => {
-      if (hasSetJSON) return;
-      /** @type {string} */
-      const contentType = (res.headers['content-type']);
-      res.headers['content-type'] = (contentType || '')
-        .split(';')
-        .map((directive) => {
-          const isKeyPair = directive.includes('=');
-          if (isKeyPair) return directive;
-          return 'application/json';
-        })
-        .join(';');
-
-      hasSetJSON = true;
-    };
-
-    const newWritable = new stream.Transform({
-      writableObjectMode: true,
-      transform: (chunk, e, callback) => {
-        if (Buffer.isBuffer(chunk)) {
-          callback(null, chunk);
-          return;
-        }
-        const cacheName = this.cache && (this.cache === true ? 'content' : this.cache);
-        if (typeof chunk === 'string') {
-          if (!encoding) {
-            encoding = ContentWriterMiddleware.charsetAsBufferEncoding(parseCharset());
-          }
-          if (cacheName) {
-            if (typeof res.locals[cacheName] === 'string') {
-              res.locals[cacheName] += chunk;
-            } else {
-              res.locals[cacheName] = chunk;
-            }
-          }
-          const callbackData = Buffer.from(chunk, encoding);
-          callback(null, callbackData);
-          return;
-        }
-        if (cacheName) {
-          res.locals[cacheName] = chunk;
-        }
-        if (typeof chunk === 'object') {
-          if (!encoding) {
-            encoding = ContentWriterMiddleware.charsetAsBufferEncoding(parseCharset());
-          }
-          if (this.setJSON && !hasSetJSON && !res.headersSent) {
-            setJSONMediaType();
-          }
-          callback(null, Buffer.from(JSON.stringify(chunk), encoding));
-          return;
-        }
-
-        callback(null, chunk);
-      },
-    });
-    const destination = res.replaceStream(newWritable);
-    newWritable.pipe(destination);
-
-    return 'continue';
-  }
-}
-
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
-
-/**
- * @typedef CORSMiddlewareOptions
- * @prop {(string|RegExp)[]} [allowOrigin]
- * Indicates whether the response can be shared, via returning the literal
- * value of the `Origin` request header (which can be `null`) or `*` in a response.
- * @prop {boolean} [allowCredentials]
- * Indicates whether the response can be shared when request’s credentials mode is "include".
- * @prop {RequestMethod[]} [allowMethods]
- * Indicates which methods are supported by the response’s URL for the purposes of the CORS protocol.
- * @prop {string[]} [allowHeaders]
- * Indicates which headers are supported by the response’s URL for the purposes of the CORS protocol.
- * @prop {number} [maxAge]
- * Indicates the number of seconds (5 by default) the information provided by the
- * `Access-Control-Allow-Methods` and `Access-Control-Allow-Headers` headers can be cached.
- * @prop {string[]} [exposeHeaders]
- * Indicates which headers can be exposed as part of the response by listing their names.
- */
-
-/** @implements {IMiddleware} */
-class CORSMiddleware {
-  /** @param {CORSMiddlewareOptions} [options] */
-  constructor(options = {}) {
-    this.allowOrigin = options.allowOrigin;
-    this.allowCredentials = options.allowCredentials === true;
-    this.allowMethods = options.allowMethods;
-    this.allowHeaders = options.allowHeaders;
-    this.maxAge = options.maxAge ?? 5;
-    this.exposeHeaders = options.exposeHeaders;
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
-    if (('origin' in req.headers) === false) {
-    // not CORS
-      return 'continue';
-    }
-    if (!this.allowOrigin) {
-    // Unspecified default of '*'
-      res.headers['access-control-allow-origin'] = '*';
-    } else {
-      this.allowOrigin.some((origin) => {
-        if (origin === '*') {
-          res.headers['access-control-allow-origin'] = '*';
-          return true;
-        }
-        if (typeof origin === 'string') {
-          if (req.headers.origin?.toLowerCase() === origin.toLowerCase()) {
-            res.headers['access-control-allow-origin'] = req.headers.origin;
-            return true;
-          }
-          return false;
-        }
-        if (origin.test(req.headers.origin)) {
-          res.headers['access-control-allow-origin'] = req.headers.origin;
-          return true;
-        }
-        return false;
-      });
-    }
-    if (this.allowCredentials) {
-      res.headers['access-control-allow-credentials'] = 'true';
-    }
-    if (req.method === 'OPTIONS') {
-      if (this.allowMethods) {
-        res.headers['access-control-allow-methods'] = this.allowMethods.join(',');
-      } else {
-        res.headers['access-control-allow-methods'] = [
-          'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'CONNECT', 'TRACE', 'PATCH',
-        ].join(',');
-      }
-      if (this.allowHeaders) {
-        res.headers['access-control-allow-headers'] = this.allowHeaders.join(',');
-      } else {
-        res.headers['access-control-allow-headers'] = req.headers['access-control-request-headers'];
-      }
-      if (this.maxAge != null) {
-        res.headers['access-control-max-age'] = this.maxAge.toString(10);
-      }
-      // 200 instead of 204 for compatibility
-      res.status = 200;
-      res.stream.end('OK');
-      return 'end';
-    }
-
-    if (this.exposeHeaders) {
-      res.headers['access-control-expose-headers'] = this.exposeHeaders.join(',');
-    }
-    return 'continue';
-  }
-}
-
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-const DEFAULT_ALGORITHM = 'sha1';
-/** @type {crypto.HexBase64Latin1Encoding} */
-const DEFAULT_DIGEST = 'base64';
-
-/**
- * @typedef {Object} HashMiddlewareOptions
- * @prop {'md5'|'sha1'|'sha256'|'sha512'} [algorithm=DEFAULT_ALGORITHM]
- * @prop {crypto.HexBase64Latin1Encoding} [digest=DEFAULT_DIGEST]
- */
-
-/** @implements {IMiddleware} */
-class HashMiddleware {
-  /** @param {HashMiddlewareOptions} options */
-  constructor(options = {}) {
-    this.algorithm = options.algorithm || DEFAULT_ALGORITHM;
-    this.digest = options.digest || DEFAULT_DIGEST;
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ res }) {
-    const { algorithm, digest } = this;
-    let hasData = false;
-    let length = 0;
-    let abort = false;
-    const hashStream = crypto.createHash(algorithm);
-    const newWritable = new stream.Transform({
-      transform(chunk, encoding, callback) {
-        length += chunk.length;
-        hasData = true;
-        if (!abort && res.headersSent) {
-          abort = true;
-          hashStream.destroy();
-        }
-        if (abort) {
-          callback(null, chunk);
-          return;
-        }
-        // Manually pipe
-        const needsDrain = !hashStream.write(chunk);
-        if (needsDrain) {
-          hashStream.once('drain', () => {
-            callback(null, chunk);
-          });
-        } else {
-          callback(null, chunk);
-        }
-      },
-      flush(callback) {
-        if (!abort && hasData && res.status !== 206 && !res.headersSent) {
-          const hash = hashStream.digest(digest);
-          // https://tools.ietf.org/html/rfc7232#section-2.3
-          if (res.headers.etag == null) {
-            res.headers.etag = `${algorithm === 'md5' ? 'W/' : ''}"${length.toString(16)}-${hash}"`;
-          }
-          if (digest === 'base64') {
-            res.headers.digest = `${algorithm}=${hash}`;
-            if ((algorithm === 'md5')) {
-              res.headers['content-md5'] = hash;
-            }
-          }
-        }
-        callback();
-      },
-    });
-
-    const destination = res.replaceStream(newWritable);
-    newWritable.pipe(destination);
-    return 'continue';
-  }
-}
-
-/** @typedef {import('../lib').HttpRequest} HttpRequest */
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
-
-/** @typedef {RegExp|RequestMethod} MethodEntry */
-
-/**
- * @typedef {Object} MethodMiddlewareOptions
- * @prop {MethodEntry|MethodEntry[]} method
- */
-
-/** @implements {IMiddleware} */
-class MethodMiddleware {
-  /** @param {MethodMiddlewareOptions|MethodEntry|MethodEntry[]} options */
-  constructor(options) {
-    if (Array.isArray(options)) {
-      this.method = options;
-    } else if (typeof options === 'string' || options instanceof RegExp) {
-      this.method = [options];
-    } else {
-      this.method = Array.isArray(options.method) ? options.method : [options.method];
-    }
-  }
-
-  /** @type {Map<RequestMethod, MethodMiddleware>} */
-  static cache = new Map();
-
-  /**
-   * @param {RequestMethod} name
-   * @return {MethodMiddleware}
-   */
-  static byMethod(name) {
-    let m = MethodMiddleware.cache.get(name);
-    if (m) return m;
-    m = new MethodMiddleware(name);
-    MethodMiddleware.cache.set(name, m);
-    return m;
-  }
-
-  /**
-   * @param {RequestMethod} method
-   * @param {RegExp | string} input
-   * @return {boolean}
-   */
-  static test(method, input) {
-    if (typeof input === 'string') {
-      return method === input;
-    }
-    return input.test(method) === true;
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req }) {
-    for (let i = 0; i < this.method.length; i++) {
-      if (MethodMiddleware.test(req.method, this.method[i])) {
-        return 'continue';
-      }
-    }
-    return 'break';
-  }
-
-  static get CONNECT() { return MethodMiddleware.byMethod('CONNECT'); }
-
-  static get DELETE() { return MethodMiddleware.byMethod('DELETE'); }
-
-  static get GET() { return MethodMiddleware.byMethod('GET'); }
-
-  static get OPTIONS() { return MethodMiddleware.byMethod('OPTIONS'); }
-
-  static get HEAD() { return MethodMiddleware.byMethod('HEAD'); }
-
-  static get PATCH() { return MethodMiddleware.byMethod('PATCH'); }
-
-  static get POST() { return MethodMiddleware.byMethod('POST'); }
-
-  static get PUT() { return MethodMiddleware.byMethod('PUT'); }
-
-  static get TRACE() { return MethodMiddleware.byMethod('TRACE'); }
-}
-
-/** @typedef {import('../types').HttpRequest} HttpRequest */
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
-
-/** @typedef {RegExp|string} PathEntry */
-
-/**
- * @typedef {Object} PathHistoryEntry hello?
- * @prop {string} base
- * @prop {number[]} treeIndex
- */
-
-/**
- * @typedef {Object} PathState
- * @prop {PathHistoryEntry[]} history
- * @prop {string} currentPath
- */
-
-/**
- * @typedef {Object} PathMiddlewareOptions
- * @prop {PathEntry|PathEntry[]} [path]
- * @prop {string} [key='path']
- * @prop {boolean} [absolute=false]
- * Path is not relative to previous PathMiddleware. Defaults to `false`.
- * @prop {boolean} [subPath=false]
- * Path values are subpaths. Default to `false`;
- */
-
-/** @implements {IMiddleware} */
-class PathMiddleware {
-  /** @param {PathMiddlewareOptions|PathEntry|PathEntry[]} options */
-  constructor(options) {
-    if (Array.isArray(options)) {
-      this.path = options;
-      this.key = 'path';
-      this.absolute = false;
-      this.subPath = false;
-    } else if (typeof options === 'string' || options instanceof RegExp) {
-      this.path = [options];
-      this.key = 'path';
-      this.absolute = false;
-      this.subPath = false;
-    } else {
-      this.path = Array.isArray(options.path) ? options.path : [options.path];
-      this.key = options.key || 'path';
-      this.absolute = options.absolute === true;
-      this.subPath = options.subPath === true;
-    }
-  }
-
-  /**
-   * @param {PathEntry|PathEntry[]} entry
-   */
-  static SUBPATH(entry) {
-    const path = Array.isArray(entry) ? entry : [entry];
-    return new PathMiddleware({
-      path: path.map((p) => (typeof p === 'string' ? RegExp(`^(${p})/*.*$`) : p)),
-      subPath: true,
-    });
-  }
-
-  /**
-   * @param {string} path
-   * @param {RegExp | string} input
-   * @return {?string}
-   */
-  static test(path, input) {
-    if (typeof input === 'string') {
-      return (path === input ? input : null);
-    }
-    const result = input.exec(path);
-    if (!result) return null;
-    if (result.length === 1) {
-      return result[0];
-    }
-    return result[1] ?? result[0];
-  }
-
-  /**
-   * @param {HttpRequest} req
-   * @param {string} base new base subpath
-   * @param {number[]} treeIndex this node's treeIndex
-   * @param {string} currentPath
-   * @return {void}
-   */
-  writePathState(req, base, treeIndex, currentPath) {
-    /** @type {PathState} */
-    let state = req.locals[this.key];
-    if (!state) {
-      state = { history: [], currentPath };
-      req.locals[this.key] = state;
-    } else if (!state.history) {
-      state.history = [];
-    }
-    state.history.push({ base, treeIndex: [...treeIndex] });
-    state.currentPath = currentPath;
-  }
-
-  /**
-   * @param {HttpRequest} req
-   * @param {number[]} treeIndex this node's treeIndex
-   * @return {string} joined base path
-   */
-  readPathState(req, treeIndex) {
-    /** @type {PathState} */
-    const state = req.locals[this.key];
-    if (!state || !state.history || !state.history.length) {
-      return '/';
-    }
-    const paths = [];
-    let newLength = 0;
-    /* eslint-disable no-labels, no-restricted-syntax */
-    historyLoop: {
-      for (let i = 0; i < state.history.length; i++) {
-        const item = state.history[i];
-        if (item.treeIndex.length >= treeIndex.length) break;
-        for (let j = 0; j < item.treeIndex.length - 1; j++) {
-          if (item.treeIndex[j] !== treeIndex[j]) break historyLoop;
-        }
-        paths.push(item.base);
-        newLength++;
-      }
-    }
-    if (state.history.length !== newLength) {
-      state.history.length = newLength;
-    }
-    if (!paths.length) {
-      return '/';
-    }
-    return path.join(...paths);
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, state }) {
-    const currentPath = this.absolute ? '' : this.readPathState(req, state.treeIndex);
-    const comparison = this.absolute ? req.url.pathname : `/${path.relative(currentPath, req.url.pathname)}`;
-
-    for (let i = 0; i < this.path.length; i++) {
-      const path$1 = this.path[i];
-      const result = PathMiddleware.test(comparison, path$1);
-      if (result) {
-        if (this.subPath) {
-          this.writePathState(req, result, state.treeIndex, path.join(currentPath, result));
-        }
-        return 'continue';
-      }
-    }
-
-    return 'break';
-  }
-}
-
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-/**
- * @typedef {Object} SendHeadersMiddlewareOptions
- * @prop {boolean} [setStatus=false]
- * Automatically set `200` or `204` status if not set
- */
-
-/** @implements {IMiddleware} */
-class SendHeadersMiddleware {
-  /** @param {SendHeadersMiddlewareOptions} options */
-  constructor(options = {}) {
-    this.setStatus = options.setStatus === true;
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ res }) {
-    const newWritable = new stream.PassThrough();
-    const destination = res.replaceStream(newWritable);
-    newWritable.once('data', () => {
-      if (!res.headersSent) {
-        if (this.setStatus && res.status == null) {
-          res.status = 200;
-        }
-        res.sendHeaders(false);
-      }
-    });
-    newWritable.on('end', () => {
-      if (!res.headersSent) {
-        if (this.setStatus && res.status == null) {
-          res.status = 204;
-        }
-        res.sendHeaders(false);
-      }
-    });
-    newWritable.pipe(destination);
-    return 'continue';
-  }
-}
-
-var index$2 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  CaseInsensitiveHeadersMiddleware: CaseInsensitiveHeadersMiddleware,
-  ContentDecoderMiddleware: ContentDecoderMiddleware,
-  ContentEncoderMiddleware: ContentEncoderMiddleware,
-  ContentLengthMiddleware: ContentLengthMiddleware,
-  ContentReaderMiddleware: ContentReaderMiddleware,
-  ContentWriterMiddleware: ContentWriterMiddleware,
-  CorsMiddleware: CORSMiddleware,
-  HashMiddleware: HashMiddleware,
-  MethodMiddleware: MethodMiddleware,
-  PathMiddleware: PathMiddleware,
-  SendHeadersMiddleware: SendHeadersMiddleware
-});
-
-/* eslint-disable import/prefer-default-export */
-
-/** @typedef {import('../lib/HttpHandler').default} HttpHandler */
-/** @typedef {import('http2').Http2SecureServer} Http2SecureServer */
-
-/**
- * @param {HttpHandler} httpHandler
- * @param {RegExp} [socketioPath] /^\/socket.io\//i
- * @return {void}
- */
-function addHttp2Support(httpHandler, socketioPath = /^\/socket.io\//i) {
-  const fn = httpHandler.handleHttp2Stream;
-  /** @type {fn} */
-  const newFunction = (...args) => {
-    const headers = args[1];
-    if (headers?.[':path']?.match(socketioPath)) {
-      return Promise.resolve(null);
-    }
-    return fn.call(httpHandler, ...args);
-  };
-  // @ts-ignore
-  // eslint-disable-next-line no-param-reassign
-  httpHandler.handleHttp2Stream = newFunction;
-}
-
-var socketio = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  addHttp2Support: addHttp2Support
-});
-
-var index$3 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  socketio: socketio
-});
-
-exports.errata = index$3;
-exports.helpers = index$1;
-exports.lib = index;
-exports.middleware = index$2;