@eggjs/koa 3.1.0-beta.19 → 3.1.0-beta.20

package/dist/index.js

@@ -1,8 +1,1367 @@
-import { Context } from "./context.js";
-import { Request } from "./request.js";
-import { Response } from "./response.js";
-import { Application } from "./application.js";
+import util, { debuglog } from "node:util";
+import Emitter from "node:events";
+import Stream from "node:stream";
+import http from "node:http";
+import { getAsyncLocalStorage } from "gals";
+import { isGeneratorFunction } from "is-type-of";
+import onFinished from "on-finished";
+import statuses from "statuses";
+import compose from "koa-compose";
+import createError, { HttpError } from "http-errors";
+import Cookies from "cookies";
+import net from "node:net";
+import { format } from "node:url";
+import qs from "node:querystring";
+import accepts from "accepts";
+import contentType from "content-type";
+import parse from "parseurl";
+import typeis, { is } from "type-is";
+import fresh from "fresh";
+import assert from "node:assert";
+import { extname } from "node:path";
+import contentDisposition from "content-disposition";
+import { getType } from "cache-content-type";
+import escape from "escape-html";
+import destroy from "destroy";
+import vary from "vary";
+import encodeUrl from "encodeurl";
 
+//#region src/context.ts
+var Context = class {
+	app;
+	req;
+	res;
+	request;
+	response;
+	originalUrl;
+	respond;
+	#state = {};
+	constructor(app, req, res) {
+		this.app = app;
+		this.req = req;
+		this.res = res;
+		this.request = new app.RequestClass(app, this, req, res);
+		this.response = new app.ResponseClass(app, this, req, res);
+		this.request.response = this.response;
+		this.response.request = this.request;
+		this.originalUrl = req.url ?? "/";
+	}
+	/**
+	* util.inspect() implementation, which
+	* just returns the JSON output.
+	*/
+	inspect() {
+		return this.toJSON();
+	}
+	/**
+	* Custom inspection implementation for newer Node.js versions.
+	*/
+	[util.inspect.custom]() {
+		return this.inspect();
+	}
+	/**
+	* Return JSON representation.
+	*
+	* Here we explicitly invoke .toJSON() on each
+	* object, as iteration will otherwise fail due
+	* to the getters and cause utilities such as
+	* clone() to fail.
+	*/
+	toJSON() {
+		return {
+			request: this.request.toJSON(),
+			response: this.response.toJSON(),
+			app: this.app.toJSON(),
+			originalUrl: this.originalUrl,
+			req: "<original node req>",
+			res: "<original node res>",
+			socket: "<original node socket>"
+		};
+	}
+	assert(value, status, errorMessageOrProps, errorProps) {
+		if (value) return;
+		status = status ?? 500;
+		if (typeof errorMessageOrProps === "string") throw createError(status, errorMessageOrProps, errorProps ?? {});
+		throw createError(status, errorMessageOrProps ?? {});
+	}
+	throw(arg1, arg2, errorProps) {
+		const args = [];
+		if (typeof arg2 === "number") {
+			args.push(arg2);
+			args.push(arg1);
+		} else {
+			args.push(arg1);
+			if (arg2) args.push(arg2);
+		}
+		if (errorProps) args.push(errorProps);
+		throw createError(...args);
+	}
+	/**
+	* Default error handling.
+	* @private
+	*/
+	onerror(err) {
+		if (err === null || err === void 0) return;
+		if (!(err instanceof Error || Object.prototype.toString.call(err) === "[object Error]")) err = new Error(util.format("non-error thrown: %j", err));
+		let headerSent = false;
+		if (this.response.headerSent || !this.response.writable) {
+			headerSent = true;
+			err.headerSent = true;
+		}
+		this.app.emit("error", err, this);
+		if (headerSent) return;
+		const res = this.res;
+		for (const name of res.getHeaderNames()) res.removeHeader(name);
+		if (err.headers) this.response.set(err.headers);
+		this.response.type = "text";
+		let statusCode = err.status || err.statusCode;
+		if (err.code === "ENOENT") statusCode = 404;
+		if (typeof statusCode !== "number" || !statuses.message[statusCode]) statusCode = 500;
+		const statusMessage = statuses.message[statusCode];
+		const msg = err.expose ? err.message : statusMessage;
+		err.status = statusCode;
+		this.response.status = statusCode;
+		this.response.length = Buffer.byteLength(msg);
+		res.end(msg);
+	}
+	_cookies;
+	get cookies() {
+		if (!this._cookies) this._cookies = new Cookies(this.req, this.res, {
+			keys: this.app.keys,
+			secure: this.request.secure
+		});
+		return this._cookies;
+	}
+	set cookies(cookies) {
+		this._cookies = cookies;
+	}
+	get state() {
+		return this.#state;
+	}
+	acceptsLanguages(languages, ...others) {
+		return this.request.acceptsLanguages(languages, ...others);
+	}
+	acceptsEncodings(encodings, ...others) {
+		return this.request.acceptsEncodings(encodings, ...others);
+	}
+	acceptsCharsets(charsets, ...others) {
+		return this.request.acceptsCharsets(charsets, ...others);
+	}
+	accepts(args, ...others) {
+		return this.request.accepts(args, ...others);
+	}
+	get(field) {
+		return this.request.get(field);
+	}
+	is(type, ...types) {
+		return this.request.is(type, ...types);
+	}
+	get querystring() {
+		return this.request.querystring;
+	}
+	set querystring(str) {
+		this.request.querystring = str;
+	}
+	get idempotent() {
+		return this.request.idempotent;
+	}
+	get socket() {
+		return this.request.socket;
+	}
+	get search() {
+		return this.request.search;
+	}
+	set search(str) {
+		this.request.search = str;
+	}
+	get method() {
+		return this.request.method;
+	}
+	set method(method) {
+		this.request.method = method;
+	}
+	get query() {
+		return this.request.query;
+	}
+	set query(obj) {
+		this.request.query = obj;
+	}
+	get path() {
+		return this.request.path;
+	}
+	set path(path) {
+		this.request.path = path;
+	}
+	get url() {
+		return this.request.url;
+	}
+	set url(url) {
+		this.request.url = url;
+	}
+	get accept() {
+		return this.request.accept;
+	}
+	set accept(accept) {
+		this.request.accept = accept;
+	}
+	get origin() {
+		return this.request.origin;
+	}
+	get href() {
+		return this.request.href;
+	}
+	get subdomains() {
+		return this.request.subdomains;
+	}
+	get protocol() {
+		return this.request.protocol;
+	}
+	get host() {
+		return this.request.host;
+	}
+	get hostname() {
+		return this.request.hostname;
+	}
+	get URL() {
+		return this.request.URL;
+	}
+	get header() {
+		return this.request.header;
+	}
+	get headers() {
+		return this.request.headers;
+	}
+	get secure() {
+		return this.request.secure;
+	}
+	get stale() {
+		return this.request.stale;
+	}
+	get fresh() {
+		return this.request.fresh;
+	}
+	get ips() {
+		return this.request.ips;
+	}
+	get ip() {
+		return this.request.ip;
+	}
+	/**
+	* Response delegation.
+	*/
+	attachment(...args) {
+		return this.response.attachment(...args);
+	}
+	redirect(...args) {
+		return this.response.redirect(...args);
+	}
+	remove(...args) {
+		return this.response.remove(...args);
+	}
+	vary(...args) {
+		return this.response.vary(...args);
+	}
+	has(...args) {
+		return this.response.has(...args);
+	}
+	set(...args) {
+		return this.response.set(...args);
+	}
+	append(...args) {
+		return this.response.append(...args);
+	}
+	flushHeaders(...args) {
+		return this.response.flushHeaders(...args);
+	}
+	get status() {
+		return this.response.status;
+	}
+	set status(status) {
+		this.response.status = status;
+	}
+	get message() {
+		return this.response.message;
+	}
+	set message(msg) {
+		this.response.message = msg;
+	}
+	get body() {
+		return this.response.body;
+	}
+	set body(val) {
+		this.response.body = val;
+	}
+	get length() {
+		return this.response.length;
+	}
+	set length(n) {
+		this.response.length = n;
+	}
+	get type() {
+		return this.response.type;
+	}
+	set type(type) {
+		this.response.type = type;
+	}
+	get lastModified() {
+		return this.response.lastModified;
+	}
+	set lastModified(val) {
+		this.response.lastModified = val;
+	}
+	get etag() {
+		return this.response.etag;
+	}
+	set etag(val) {
+		this.response.etag = val;
+	}
+	get headerSent() {
+		return this.response.headerSent;
+	}
+	get writable() {
+		return this.response.writable;
+	}
+};
+
+//#endregion
+//#region src/request.ts
+var Request = class {
+	app;
+	req;
+	res;
+	ctx;
+	response;
+	originalUrl;
+	constructor(app, ctx, req, res) {
+		this.app = app;
+		this.req = req;
+		this.res = res;
+		this.ctx = ctx;
+		this.originalUrl = req.url ?? "/";
+	}
+	/**
+	* Return request header.
+	*/
+	get header() {
+		return this.req.headers;
+	}
+	/**
+	* Set request header.
+	*/
+	set header(val) {
+		this.req.headers = val;
+	}
+	/**
+	* Return request header, alias as request.header
+	*/
+	get headers() {
+		return this.req.headers;
+	}
+	/**
+	* Set request header, alias as request.header
+	*/
+	set headers(val) {
+		this.req.headers = val;
+	}
+	/**
+	* Get request URL.
+	*/
+	get url() {
+		return this.req.url ?? "/";
+	}
+	/**
+	* Set request URL.
+	*/
+	set url(val) {
+		this.req.url = val;
+	}
+	/**
+	* Get origin of URL.
+	*/
+	get origin() {
+		return `${this.protocol}://${this.host}`;
+	}
+	/**
+	* Get full request URL.
+	*/
+	get href() {
+		if (/^https?:\/\//i.test(this.originalUrl)) return this.originalUrl;
+		return this.origin + this.originalUrl;
+	}
+	/**
+	* Get request method.
+	*/
+	get method() {
+		return this.req.method ?? "GET";
+	}
+	/**
+	* Set request method.
+	*/
+	set method(val) {
+		this.req.method = val;
+	}
+	/**
+	* Get request pathname.
+	*/
+	get path() {
+		return parse(this.req)?.pathname ?? "";
+	}
+	/**
+	* Set pathname, retaining the query string when present.
+	*/
+	set path(pathname) {
+		const url = parse(this.req);
+		if (!url) return;
+		if (url.pathname === pathname) return;
+		url.pathname = pathname;
+		url.path = null;
+		this.url = format(url);
+	}
+	_parsedUrlQueryCache;
+	/**
+	* Get parsed query string.
+	*/
+	get query() {
+		const str = this.querystring;
+		if (!this._parsedUrlQueryCache) this._parsedUrlQueryCache = {};
+		let parsedUrlQuery = this._parsedUrlQueryCache[str];
+		if (!parsedUrlQuery) {
+			parsedUrlQuery = qs.parse(str);
+			this._parsedUrlQueryCache[str] = parsedUrlQuery;
+		}
+		return parsedUrlQuery;
+	}
+	/**
+	* Set query string as an object.
+	*/
+	set query(obj) {
+		this.querystring = qs.stringify(obj);
+	}
+	/**
+	* Get query string.
+	*/
+	get querystring() {
+		if (!this.req) return "";
+		return parse(this.req)?.query ?? "";
+	}
+	/**
+	* Set query string.
+	*/
+	set querystring(str) {
+		const url = parse(this.req);
+		if (!url) return;
+		if (url.search === `?${str}`) return;
+		url.search = str;
+		url.path = null;
+		this.url = format(url);
+	}
+	/**
+	* Get the search string. Same as the query string
+	* except it includes the leading ?.
+	*/
+	get search() {
+		const querystring = this.querystring;
+		if (!querystring) return "";
+		return `?${querystring}`;
+	}
+	/**
+	* Set the search string. Same as
+	* request.querystring= but included for ubiquity.
+	*/
+	set search(str) {
+		this.querystring = str;
+	}
+	/**
+	* Parse the "Host" header field host
+	* and support X-Forwarded-Host when a
+	* proxy is enabled.
+	* return `hostname:port` format
+	*/
+	get host() {
+		let host = this.app.proxy ? this.get("X-Forwarded-Host") : "";
+		if (host) host = splitCommaSeparatedValues(host, 1)[0];
+		if (!host) {
+			if (this.req.httpVersionMajor >= 2) host = this.get(":authority");
+			if (!host) host = this.get("Host");
+		}
+		return host;
+	}
+	/**
+	* Parse the "Host" header field hostname
+	* and support X-Forwarded-Host when a
+	* proxy is enabled.
+	*/
+	get hostname() {
+		const host = this.host;
+		if (!host) return "";
+		if (host[0] === "[") return this.URL.hostname || "";
+		return host.split(":", 1)[0];
+	}
+	_memoizedURL;
+	/**
+	* Get WHATWG parsed URL.
+	* Lazily memoized.
+	*/
+	get URL() {
+		if (!this._memoizedURL) {
+			const originalUrl = this.originalUrl || "";
+			try {
+				this._memoizedURL = new URL(`${this.origin}${originalUrl}`);
+			} catch {
+				this._memoizedURL = Object.create(null);
+			}
+		}
+		return this._memoizedURL;
+	}
+	/**
+	* Check if the request is fresh, aka
+	* Last-Modified and/or the ETag
+	* still match.
+	*/
+	get fresh() {
+		const method = this.method;
+		const status = this.response.status;
+		if (method !== "GET" && method !== "HEAD") return false;
+		if (status >= 200 && status < 300 || status === 304) return fresh(this.header, this.response.header);
+		return false;
+	}
+	/**
+	* Check if the request is stale, aka
+	* "Last-Modified" and / or the "ETag" for the
+	* resource has changed.
+	*/
+	get stale() {
+		return !this.fresh;
+	}
+	/**
+	* Check if the request is idempotent.
+	*/
+	get idempotent() {
+		return [
+			"GET",
+			"HEAD",
+			"PUT",
+			"DELETE",
+			"OPTIONS",
+			"TRACE"
+		].includes(this.method);
+	}
+	/**
+	* Return the request socket.
+	*/
+	get socket() {
+		return this.req.socket;
+	}
+	/**
+	* Get the charset when present or undefined.
+	*/
+	get charset() {
+		try {
+			const { parameters } = contentType.parse(this.req);
+			return parameters.charset || "";
+		} catch {
+			return "";
+		}
+	}
+	/**
+	* Return parsed Content-Length when present.
+	*/
+	get length() {
+		const len = this.get("Content-Length");
+		if (len === "") return;
+		return Number.parseInt(len);
+	}
+	/**
+	* Return the protocol string "http" or "https"
+	* when requested with TLS. When the proxy setting
+	* is enabled the "X-Forwarded-Proto" header
+	* field will be trusted. If you're running behind
+	* a reverse proxy that supplies https for you this
+	* may be enabled.
+	*/
+	get protocol() {
+		if (this.socket.encrypted) return "https";
+		if (!this.app.proxy) return "http";
+		let proto = this.get("X-Forwarded-Proto");
+		if (proto) proto = splitCommaSeparatedValues(proto, 1)[0];
+		return proto || "http";
+	}
+	/**
+	* Shorthand for:
+	*
+	*    this.protocol == 'https'
+	*/
+	get secure() {
+		return this.protocol === "https";
+	}
+	/**
+	* When `app.proxy` is `true`, parse
+	* the "X-Forwarded-For" ip address list.
+	*
+	* For example if the value was "client, proxy1, proxy2"
+	* you would receive the array `["client", "proxy1", "proxy2"]`
+	* where "proxy2" is the furthest down-stream.
+	*/
+	get ips() {
+		const proxy = this.app.proxy;
+		const val = this.get(this.app.proxyIpHeader);
+		let ips = proxy && val ? splitCommaSeparatedValues(val) : [];
+		if (this.app.maxIpsCount > 0) ips = ips.slice(-this.app.maxIpsCount);
+		return ips;
+	}
+	_ip;
+	/**
+	* Return request's remote address
+	* When `app.proxy` is `true`, parse
+	* the "X-Forwarded-For" ip address list and return the first one
+	*/
+	get ip() {
+		if (!this._ip) this._ip = this.ips[0] || this.socket.remoteAddress || "";
+		return this._ip;
+	}
+	set ip(ip) {
+		this._ip = ip;
+	}
+	/**
+	* Return subdomains as an array.
+	*
+	* Subdomains are the dot-separated parts of the host before the main domain
+	* of the app. By default, the domain of the app is assumed to be the last two
+	* parts of the host. This can be changed by setting `app.subdomainOffset`.
+	*
+	* For example, if the domain is "tobi.ferrets.example.com":
+	* If `app.subdomainOffset` is not set, this.subdomains is
+	* `["ferrets", "tobi"]`.
+	* If `app.subdomainOffset` is 3, this.subdomains is `["tobi"]`.
+	*/
+	get subdomains() {
+		const offset = this.app.subdomainOffset;
+		const hostname = this.hostname;
+		if (net.isIP(hostname)) return [];
+		return hostname.split(".").reverse().slice(offset);
+	}
+	_accept;
+	/**
+	* Get accept object.
+	* Lazily memoized.
+	*/
+	get accept() {
+		return this._accept || (this._accept = accepts(this.req));
+	}
+	/**
+	* Set accept object.
+	*/
+	set accept(obj) {
+		this._accept = obj;
+	}
+	accepts(args, ...others) {
+		return this.accept.types(args, ...others);
+	}
+	acceptsEncodings(encodings, ...others) {
+		if (!encodings) return this.accept.encodings();
+		if (Array.isArray(encodings)) encodings = [...encodings, ...others];
+		else encodings = [encodings, ...others];
+		return this.accept.encodings(...encodings);
+	}
+	acceptsCharsets(charsets, ...others) {
+		if (!charsets) return this.accept.charsets();
+		if (Array.isArray(charsets)) charsets = [...charsets, ...others];
+		else charsets = [charsets, ...others];
+		return this.accept.charsets(...charsets);
+	}
+	acceptsLanguages(languages, ...others) {
+		if (!languages) return this.accept.languages();
+		if (Array.isArray(languages)) languages = [...languages, ...others];
+		else languages = [languages, ...others];
+		return this.accept.languages(...languages);
+	}
+	/**
+	* Check if the incoming request contains the "Content-Type"
+	* header field and if it contains any of the given mime `type`s.
+	* If there is no request body, `null` is returned.
+	* If there is no content type, `false` is returned.
+	* Otherwise, it returns the first `type` that matches.
+	*
+	* Examples:
+	*
+	*     // With Content-Type: text/html; charset=utf-8
+	*     this.is('html'); // => 'html'
+	*     this.is('text/html'); // => 'text/html'
+	*     this.is('text/*', 'application/json'); // => 'text/html'
+	*
+	*     // When Content-Type is application/json
+	*     this.is('json', 'urlencoded'); // => 'json'
+	*     this.is('application/json'); // => 'application/json'
+	*     this.is('html', 'application/*'); // => 'application/json'
+	*
+	*     this.is('html'); // => false
+	*/
+	is(type, ...types) {
+		let testTypes = [];
+		if (type) testTypes = Array.isArray(type) ? type : [type];
+		return typeis(this.req, [...testTypes, ...types]);
+	}
+	/**
+	* Return the request mime type void of
+	* parameters such as "charset".
+	*/
+	get type() {
+		const type = this.get("Content-Type");
+		if (!type) return "";
+		return type.split(";")[0];
+	}
+	/**
+	* Return request header.
+	*
+	* The `Referrer` header field is special-cased,
+	* both `Referrer` and `Referer` are interchangeable.
+	*
+	* Examples:
+	*
+	*     this.get('Content-Type');
+	*     // => "text/plain"
+	*
+	*     this.get('content-type');
+	*     // => "text/plain"
+	*
+	*     this.get('Something');
+	*     // => ''
+	*/
+	get(field) {
+		const req = this.req;
+		switch (field = field.toLowerCase()) {
+			case "referer":
+			case "referrer": return req.headers.referrer || req.headers.referer || "";
+			default: return req.headers[field] || "";
+		}
+	}
+	/**
+	* Inspect implementation.
+	*/
+	inspect() {
+		if (!this.req) return;
+		return this.toJSON();
+	}
+	/**
+	* Custom inspection implementation for newer Node.js versions.
+	*/
+	[util.inspect.custom]() {
+		return this.inspect();
+	}
+	/**
+	* Return JSON representation.
+	*/
+	toJSON() {
+		return {
+			method: this.method,
+			url: this.url,
+			header: this.header
+		};
+	}
+};
+/**
+* Split a comma-separated value string into an array of values, with an optional limit.
+* All the values are trimmed of whitespace and filtered out empty values.
+*
+* @param {string} value - The comma-separated value string to split.
+* @param {number} [limit] - The maximum number of values to return.
+* @returns {string[]} An array of values from the comma-separated string.
+*/
+function splitCommaSeparatedValues(value, limit) {
+	return value.split(",", limit).map((v) => v.trim()).filter((v) => v.length > 0);
+}
+
+//#endregion
+//#region src/response.ts
+var Response = class {
+	app;
+	req;
+	res;
+	ctx;
+	request;
+	constructor(app, ctx, req, res) {
+		this.app = app;
+		this.req = req;
+		this.res = res;
+		this.ctx = ctx;
+	}
+	/**
+	* Return the request socket.
+	*/
+	get socket() {
+		return this.res.socket;
+	}
+	/**
+	* Return response header.
+	*/
+	get header() {
+		return this.res.getHeaders() || {};
+	}
+	/**
+	* Return response header, alias as response.header
+	*/
+	get headers() {
+		return this.header;
+	}
+	_explicitStatus;
+	/**
+	* Get response status code.
+	*/
+	get status() {
+		return this.res.statusCode;
+	}
+	/**
+	* Set response status code.
+	*/
+	set status(code) {
+		if (this.headerSent) return;
+		assert.ok(Number.isInteger(code), "status code must be a number");
+		assert.ok(code >= 100 && code <= 999, `invalid status code: ${code}`);
+		this._explicitStatus = true;
+		this.res.statusCode = code;
+		if (this.req.httpVersionMajor < 2 && statuses.message[code]) this.res.statusMessage = statuses.message[code];
+		if (this.body && statuses.empty[code]) this.body = null;
+	}
+	/**
+	* Get response status message
+	*/
+	get message() {
+		return this.res.statusMessage ?? statuses.message[this.status];
+	}
+	/**
+	* Set response status message
+	*/
+	set message(msg) {
+		this.res.statusMessage = msg;
+	}
+	_body;
+	_explicitNullBody;
+	/**
+	* Get response body.
+	*/
+	get body() {
+		return this._body;
+	}
+	/**
+	* Set response body.
+	*/
+	set body(val) {
+		const original = this._body;
+		this._body = val;
+		if (val === null || val === void 0) {
+			if (!statuses.empty[this.status]) this.status = 204;
+			if (val === null) this._explicitNullBody = true;
+			this.remove("Content-Type");
+			this.remove("Content-Length");
+			this.remove("Transfer-Encoding");
+			return;
+		}
+		if (!this._explicitStatus) this.status = 200;
+		const setType = !this.has("Content-Type");
+		if (typeof val === "string") {
+			if (setType) this.type = /^\s*?</.test(val) ? "html" : "text";
+			this.length = Buffer.byteLength(val);
+			return;
+		}
+		if (Buffer.isBuffer(val)) {
+			if (setType) this.type = "bin";
+			this.length = val.length;
+			return;
+		}
+		if (val instanceof Stream) {
+			onFinished(this.res, destroy.bind(null, val));
+			if (original != val) {
+				val.once("error", (err) => this.ctx.onerror(err));
+				if (original !== null && original !== void 0) this.remove("Content-Length");
+			}
+			if (setType) this.type = "bin";
+			return;
+		}
+		this.remove("Content-Length");
+		this.type = "json";
+	}
+	/**
+	* Set Content-Length field to `n`.
+	*/
+	set length(n) {
+		if (n === void 0) return;
+		if (!this.has("Transfer-Encoding")) this.set("Content-Length", n);
+	}
+	/**
+	* Return parsed response Content-Length when present.
+	*
+	* When Content-Length is not defined it will return `undefined`.
+	*/
+	get length() {
+		if (this.has("Content-Length")) return Number.parseInt(this.get("Content-Length")) || 0;
+		const body = this.body;
+		if (!body || body instanceof Stream) return;
+		if (typeof body === "string") return Buffer.byteLength(body);
+		if (Buffer.isBuffer(body)) return body.length;
+		return Buffer.byteLength(JSON.stringify(body));
+	}
+	/**
+	* Check if a header has been written to the socket.
+	*/
+	get headerSent() {
+		return this.res.headersSent;
+	}
+	/**
+	* Vary on `field`.
+	*/
+	vary(field) {
+		if (this.headerSent) return;
+		vary(this.res, field);
+	}
+	_getBackReferrer() {
+		const referrer = this.ctx.get("Referrer");
+		if (referrer) {
+			if (referrer.startsWith("/")) return referrer;
+			if (new URL(referrer, this.ctx.href).host === this.ctx.host) return referrer;
+		}
+	}
+	/**
+	* Perform a 302 redirect to `url`.
+	*
+	* The string "back" is special-cased
+	* to provide Referrer support, when Referrer
+	* is not present `alt` or "/" is used.
+	*
+	* Examples:
+	*
+	*    this.redirect('back');
+	*    this.redirect('back', '/index.html');
+	*    this.redirect('/login');
+	*    this.redirect('http://google.com'); // will format to 'http://google.com/'
+	*/
+	redirect(url, alt) {
+		if (url === "back") url = this._getBackReferrer() || alt || "/";
+		if (url.startsWith("https://") || url.startsWith("http://")) url = new URL(url).toString();
+		this.set("Location", encodeUrl(url));
+		if (!statuses.redirect[this.status]) this.status = 302;
+		if (this.ctx.accepts("html")) {
+			url = escape(url);
+			this.type = "text/html; charset=utf-8";
+			this.body = `Redirecting to ${url}.`;
+			return;
+		}
+		this.type = "text/plain; charset=utf-8";
+		this.body = `Redirecting to ${url}.`;
+	}
+	/**
+	* Set Content-Disposition header to "attachment" with optional `filename`.
+	*/
+	attachment(filename, options) {
+		if (filename) this.type = extname(filename);
+		this.set("Content-Disposition", contentDisposition(filename, options));
+	}
+	/**
+	* Set Content-Type response header with `type` through `mime.lookup()`
+	* when it does not contain a charset.
+	*
+	* Examples:
+	*
+	*     this.type = '.html';
+	*     this.type = 'html';
+	*     this.type = 'json';
+	*     this.type = 'application/json';
+	*     this.type = 'png';
+	*/
+	set type(type) {
+		if (!type) {
+			this.remove("Content-Type");
+			return;
+		}
+		const mimeType = getType(type);
+		if (mimeType) this.set("Content-Type", mimeType);
+	}
+	/**
+	* Return the response mime type void of
+	* parameters such as "charset".
+	*/
+	get type() {
+		const type = this.get("Content-Type");
+		if (!type) return "";
+		return type.split(";", 1)[0];
+	}
+	/**
+	* Check whether the response is one of the listed types.
+	* Pretty much the same as `this.request.is()`.
+	*
+	*     this.response.is('html')
+	*     this.response.is('html', 'json')
+	*/
+	is(type, ...types) {
+		let testTypes = [];
+		if (type) testTypes = Array.isArray(type) ? type : [type];
+		return is(this.type, [...testTypes, ...types]);
+	}
+	/**
+	* Set the Last-Modified date using a string or a Date.
+	*
+	*     this.response.lastModified = new Date();
+	*     this.response.lastModified = '2013-09-13';
+	*/
+	set lastModified(val) {
+		if (typeof val === "string") val = new Date(val);
+		if (val) this.set("Last-Modified", val.toUTCString());
+	}
+	/**
+	* Get the Last-Modified date in Date form, if it exists.
+	*/
+	get lastModified() {
+		const date = this.get("last-modified");
+		if (date) return new Date(date);
+	}
+	/**
+	* Set the ETag of a response.
+	* This will normalize the quotes if necessary.
+	*
+	*     this.response.etag = 'md5-hash-sum';
+	*     this.response.etag = '"md5-hash-sum"';
+	*     this.response.etag = 'W/"123456789"';
+	*/
+	set etag(val) {
+		if (!/^(W\/)?"/.test(val)) val = `"${val}"`;
+		this.set("ETag", val);
+	}
+	/**
+	* Get the ETag of a response.
+	*/
+	get etag() {
+		return this.get("ETag");
+	}
+	/**
+	* Return response header.
+	*
+	* Examples:
+	*
+	*     this.get('Content-Type');
+	*     // => "text/plain"
+	*
+	*     this.get('content-type');
+	*     // => "text/plain"
+	*/
+	get(field) {
+		return this.header[field.toLowerCase()] || "";
+	}
+	/**
+	* Returns true if the header identified by name is currently set in the outgoing headers.
+	* The header name matching is case-insensitive.
+	*
+	* Examples:
+	*
+	*     this.has('Content-Type');
+	*     // => true
+	*
+	*     this.get('content-type');
+	*     // => true
+	*/
+	has(field) {
+		return this.res.hasHeader(field);
+	}
+	/**
+	* Set header `field` to `val` or pass
+	* an object of header fields.
+	*
+	* Examples:
+	*
+	*    this.set('Foo', ['bar', 'baz']);
+	*    this.set('Accept', 'application/json');
+	*    this.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+	*/
+	set(field, val) {
+		if (this.headerSent) return;
+		if (typeof field === "string") {
+			let value = val;
+			if (Array.isArray(val)) value = val.map((v) => typeof v === "string" ? v : String(v));
+			else if (typeof val !== "string") value = String(val);
+			this.res.setHeader(field, value);
+		} else for (const key in field) this.set(key, field[key]);
+	}
+	/**
+	* Append additional header `field` with value `val`.
+	*
+	* Examples:
+	*
+	* ```
+	* this.append('Link', ['<http://localhost/>', '<http://localhost:3000/>']);
+	* this.append('Set-Cookie', 'foo=bar; Path=/; HttpOnly');
+	* this.append('Warning', '199 Miscellaneous warning');
+	*/
+	append(field, val) {
+		const prev = this.get(field);
+		let value = val;
+		if (prev) value = Array.isArray(prev) ? prev.concat(value) : [prev].concat(val);
+		return this.set(field, value);
+	}
+	/**
+	* Remove header `field`.
+	*/
+	remove(field) {
+		if (this.headerSent) return;
+		this.res.removeHeader(field);
+	}
+	/**
+	* Checks if the request is writable.
+	* Tests for the existence of the socket
+	* as node sometimes does not set it.
+	*/
+	get writable() {
+		if (this.res.writableEnded || this.res.finished) return false;
+		const socket = this.res.socket;
+		if (!socket) return true;
+		return socket.writable;
+	}
+	/**
+	* Inspect implementation.
+	*/
+	inspect() {
+		if (!this.res) return;
+		const o = this.toJSON();
+		Reflect.set(o, "body", this.body);
+		return o;
+	}
+	[util.inspect.custom]() {
+		return this.inspect();
+	}
+	/**
+	* Return JSON representation.
+	*/
+	toJSON() {
+		return {
+			status: this.status,
+			message: this.message,
+			header: this.header
+		};
+	}
+	/**
+	* Flush any set headers and begin the body
+	*/
+	flushHeaders() {
+		this.res.flushHeaders();
+	}
+};
+
+//#endregion
+//#region src/application.ts
+const debug = debuglog("egg/koa/application");
+/**
+* Expose `Application` class.
+* Inherits from `Emitter.prototype`.
+*/
+var Application = class extends Emitter {
+	/**
+	* Make HttpError available to consumers of the library so that consumers don't
+	* have a direct dependency upon `http-errors`
+	*/
+	static HttpError = HttpError;
+	_proxy;
+	_env;
+	subdomainOffset;
+	proxyIpHeader;
+	maxIpsCount;
+	_keys;
+	middleware;
+	ctxStorage;
+	silent;
+	ContextClass;
+	context;
+	RequestClass;
+	request;
+	ResponseClass;
+	response;
+	/**
+	* Initialize a new `Application`.
+	*
+	* @param {object} [options] Application options
+	* @param {string} [options.env] Environment, default is `development`
+	* @param {string[]} [options.keys] Signed cookie keys
+	* @param {boolean} [options.proxy] Trust proxy headers
+	* @param {number} [options.subdomainOffset] Subdomain offset
+	* @param {string} [options.proxyIpHeader] Proxy IP header, defaults to X-Forwarded-For
+	* @param {number} [options.maxIpsCount] Max IPs read from proxy IP header, default to 0 (means infinity)
+	*/
+	constructor(options) {
+		super();
+		options = options || {};
+		this._proxy = options.proxy || false;
+		this.subdomainOffset = options.subdomainOffset || 2;
+		this.proxyIpHeader = options.proxyIpHeader || "X-Forwarded-For";
+		this.maxIpsCount = options.maxIpsCount || 0;
+		this._env = options.env || process.env.NODE_ENV || "development";
+		if (options.keys) this._keys = options.keys;
+		this.middleware = [];
+		this.ctxStorage = getAsyncLocalStorage();
+		this.silent = false;
+		this.ContextClass = class ApplicationContext extends Context {};
+		this.context = this.ContextClass.prototype;
+		this.RequestClass = class ApplicationRequest extends Request {};
+		this.request = this.RequestClass.prototype;
+		this.ResponseClass = class ApplicationResponse extends Response {};
+		this.response = this.ResponseClass.prototype;
+	}
+	get keys() {
+		return this._keys;
+	}
+	set keys(value) {
+		this._keys = value;
+	}
+	get env() {
+		return this._env;
+	}
+	set env(value) {
+		this._env = value;
+	}
+	get proxy() {
+		return this._proxy;
+	}
+	set proxy(value) {
+		this._proxy = value;
+	}
+	/**
+	* Shorthand for:
+	*
+	*    http.createServer(app.callback()).listen(...)
+	*/
+	listen(...args) {
+		debug("listen with args: %o", args);
+		return http.createServer(this.callback()).listen(...args);
+	}
+	/**
+	* Return JSON representation.
+	* We only bother showing settings.
+	*/
+	toJSON() {
+		return {
+			subdomainOffset: this.subdomainOffset,
+			proxy: this.proxy,
+			env: this.env
+		};
+	}
+	/**
+	* Inspect implementation.
+	*/
+	inspect() {
+		return this.toJSON();
+	}
+	[util.inspect.custom]() {
+		return this.inspect();
+	}
+	/**
+	* Use the given middleware `fn`.
+	*/
+	use(fn) {
+		if (typeof fn !== "function") throw new TypeError("middleware must be a function!");
+		const name = fn._name || fn.name || "-";
+		if (isGeneratorFunction(fn)) throw new TypeError(`Support for generators was removed, middleware: ${name}. See the documentation for examples of how to convert old middleware https://github.com/koajs/koa/blob/master/docs/migration.md`);
+		debug("use %o #%d", name, this.middleware.length);
+		this.middleware.push(fn);
+		return this;
+	}
+	/**
+	* Return a request handler callback
+	* for node's native http server.
+	*/
+	callback() {
+		const fn = compose(this.middleware);
+		if (!this.listenerCount("error")) this.on("error", this.onerror.bind(this));
+		const handleRequest = (req, res) => {
+			const ctx = this.createContext(req, res);
+			return this.ctxStorage.run(ctx, async () => {
+				return await this.handleRequest(ctx, fn);
+			});
+		};
+		return handleRequest;
+	}
+	/**
+	* return current context from async local storage
+	*/
+	get currentContext() {
+		return this.ctxStorage.getStore();
+	}
+	/**
+	* Handle request in callback.
+	* @private
+	*/
+	async handleRequest(ctx, fnMiddleware) {
+		this.emit("request", ctx);
+		const res = ctx.res;
+		res.statusCode = 404;
+		const onerror = (err) => ctx.onerror(err);
+		onFinished(res, (err) => {
+			if (err) onerror(err);
+			this.emit("response", ctx);
+		});
+		try {
+			await fnMiddleware(ctx);
+			return this._respond(ctx);
+		} catch (err) {
+			return onerror(err);
+		}
+	}
+	/**
+	* Initialize a new context.
+	* @private
+	*/
+	createContext(req, res) {
+		return new this.ContextClass(this, req, res);
+	}
+	/**
+	* Default error handler.
+	* @private
+	*/
+	onerror(err) {
+		if (!(err instanceof Error || Object.prototype.toString.call(err) === "[object Error]")) throw new TypeError(util.format("non-error thrown: %j", err));
+		if (err.status === 404 || err.expose) return;
+		if (this.silent) return;
+		const msg = err.stack || err.toString();
+		console.error(`\n${msg.replaceAll(/^/gm, "  ")}\n`);
+	}
+	/**
+	* Response helper.
+	*/
+	_respond(ctx) {
+		if (ctx.respond === false) return;
+		if (!ctx.writable) return;
+		const res = ctx.res;
+		let body = ctx.body;
+		const code = ctx.status;
+		if (statuses.empty[code]) {
+			ctx.body = null;
+			return res.end();
+		}
+		if (ctx.method === "HEAD") {
+			if (!res.headersSent && !ctx.response.has("Content-Length")) {
+				const { length } = ctx.response;
+				if (Number.isInteger(length)) ctx.length = length;
+			}
+			return res.end();
+		}
+		if (body === null || body === void 0) {
+			if (ctx.response._explicitNullBody) {
+				ctx.response.remove("Content-Type");
+				ctx.response.remove("Transfer-Encoding");
+				return res.end();
+			}
+			if (ctx.req.httpVersionMajor >= 2) body = String(code);
+			else body = ctx.message || String(code);
+			if (!res.headersSent) {
+				ctx.type = "text";
+				ctx.length = Buffer.byteLength(body);
+			}
+			return res.end(body);
+		}
+		if (Buffer.isBuffer(body)) return res.end(body);
+		if (typeof body === "string") return res.end(body);
+		if (body instanceof Stream) return body.pipe(res);
+		body = JSON.stringify(body);
+		if (!res.headersSent) ctx.length = Buffer.byteLength(body);
+		res.end(body);
+	}
+};
+
+//#endregion
 //#region src/index.ts
 var src_default = Application;