open-nest 0.0.0-stage → 0.0.2

package/dist/fetch-Bmr9TEe3.mjs

@@ -0,0 +1,958 @@
+import { BadRequestException, HttpException, Injectable, PayloadTooLargeException, RequestMethod, StreamableFile, VERSION_NEUTRAL, VersioningType, mixin } from "@nestjs/common";
+import { AbstractHttpAdapter, NestFactory } from "@nestjs/core";
+import { Readable } from "node:stream";
+//#region src/lib/events.ts
+var Emitter = class {
+	listeners = /* @__PURE__ */ new Map();
+	on(event, fn) {
+		let set = this.listeners.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(event, set);
+		}
+		set.add(fn);
+		return this;
+	}
+	once(event, fn) {
+		const wrapped = (...args) => {
+			this.removeListener(event, fn);
+			fn(...args);
+		};
+		wrapped.original = fn;
+		return this.on(event, wrapped);
+	}
+	removeListener(event, fn) {
+		const set = this.listeners.get(event);
+		if (!set) return this;
+		for (const listener of set) if (listener === fn || listener.original === fn) set.delete(listener);
+		return this;
+	}
+	emit(event, ...args) {
+		const set = this.listeners.get(event);
+		if (!set) return;
+		for (const fn of Array.from(set)) fn(...args);
+	}
+};
+//#endregion
+//#region src/lib/request.ts
+var FetchSocket = class extends Emitter {
+	destroyed = false;
+	readable = true;
+	writable = true;
+	setKeepAlive() {}
+	setNoDelay() {}
+	setTimeout() {}
+	close() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.emit("close");
+	}
+};
+function createRequest(input, socket) {
+	const url = new URL(input.url);
+	const headers = {};
+	input.headers.forEach((value, key) => {
+		const prev = headers[key];
+		if (prev == null) headers[key] = value;
+		else if (Array.isArray(prev)) prev.push(value);
+		else headers[key] = [prev, value];
+	});
+	const query = {};
+	for (const key of new Set(url.searchParams.keys())) {
+		const all = url.searchParams.getAll(key);
+		const first = all[0];
+		if (first == null) continue;
+		query[key] = all.length > 1 ? all : first;
+	}
+	const forwarded = input.headers.get("x-forwarded-for")?.split(",")[0]?.trim();
+	const host = input.headers.get("host") ?? url.hostname;
+	return {
+		raw: input,
+		method: input.method.toUpperCase(),
+		url: url.pathname + url.search,
+		originalUrl: url.pathname + url.search,
+		path: url.pathname,
+		headers,
+		query,
+		params: {},
+		body: void 0,
+		ip: forwarded ?? "",
+		hostname: host.split(":")[0] ?? "",
+		socket
+	};
+}
+//#endregion
+//#region src/lib/response.ts
+var FetchResponse = class extends Emitter {
+	statusCode = 200;
+	headersSent = false;
+	writableEnded = false;
+	destroyed = false;
+	writable = true;
+	socket;
+	headers = new Headers();
+	controller;
+	wrote = false;
+	streamClosed = false;
+	drainWaiters = [];
+	resolveReady;
+	readyPromise;
+	stream = new ReadableStream({
+		start: (controller) => {
+			this.controller = controller;
+		},
+		pull: () => {
+			const waiters = this.drainWaiters.splice(0);
+			for (const resume of waiters) resume();
+			this.emit("drain");
+		},
+		cancel: () => {
+			this.destroy();
+		}
+	});
+	constructor(socket) {
+		super();
+		this.socket = socket;
+		this.readyPromise = new Promise((resolve) => {
+			this.resolveReady = resolve;
+		});
+	}
+	ready() {
+		return this.readyPromise;
+	}
+	setHeader(name, value) {
+		this.headers.set(name, value);
+	}
+	appendHeader(name, value) {
+		this.headers.append(name, value);
+	}
+	getHeader(name) {
+		return this.headers.get(name);
+	}
+	removeHeader(name) {
+		this.headers.delete(name);
+	}
+	getHeaders() {
+		return Object.fromEntries(this.headers.entries());
+	}
+	status(code) {
+		this.statusCode = code;
+		return this;
+	}
+	writeHead(status, headers) {
+		this.statusCode = status;
+		if (headers) for (const [name, value] of Object.entries(headers)) if (Array.isArray(value)) for (const item of value) this.headers.append(name, String(item));
+		else this.headers.set(name, String(value));
+		this.commit();
+	}
+	flushHeaders() {
+		this.commit();
+	}
+	write(chunk, encoding, cb) {
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (this.writableEnded) {
+			cb?.();
+			return false;
+		}
+		if (!this.headersSent) this.writeHead(this.statusCode);
+		const bytes = chunk instanceof Uint8Array ? chunk : new TextEncoder().encode(typeof chunk === "string" ? chunk : String(chunk));
+		this.controller.enqueue(bytes);
+		this.wrote = true;
+		if (!(this.stream.locked && (this.controller.desiredSize ?? 0) <= 0)) {
+			cb?.();
+			return true;
+		}
+		if (cb) this.drainWaiters.push(() => cb?.());
+		return false;
+	}
+	end(chunk, encoding, cb) {
+		if (typeof chunk === "function") {
+			cb = chunk;
+			chunk = void 0;
+		} else if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = void 0;
+		}
+		if (this.writableEnded) {
+			cb?.();
+			return;
+		}
+		if (chunk != null) this.write(chunk, encoding);
+		this.writableEnded = true;
+		this.writable = false;
+		if (!this.headersSent) this.commit();
+		else if (this.wrote) this.closeStream();
+		this.emit("finish");
+		this.emit("close");
+		cb?.();
+	}
+	closeStream() {
+		if (this.streamClosed) return;
+		this.streamClosed = true;
+		try {
+			this.controller.close();
+		} catch {}
+	}
+	send(body) {
+		this.end(body);
+	}
+	json(body) {
+		if (!this.headers.has("content-type")) this.setHeader("content-type", "application/json; charset=utf-8");
+		this.end(JSON.stringify(body));
+	}
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.writable = false;
+		this.socket.close();
+		if (!this.headersSent) {
+			this.headersSent = true;
+			this.writableEnded = true;
+			this.closeStream();
+			this.resolveReady(new Response(null, { status: 499 }));
+		}
+		this.emit("close");
+	}
+	commit() {
+		if (this.headersSent) return;
+		this.headersSent = true;
+		const empty = this.writableEnded && !this.wrote;
+		if (empty) this.closeStream();
+		this.resolveReady(new Response(empty ? null : this.stream, {
+			status: this.statusCode,
+			headers: this.headers
+		}));
+	}
+};
+//#endregion
+//#region src/lib/express.ts
+var ExpressRequest = class extends Readable {
+	raw;
+	method;
+	originalUrl;
+	headers;
+	query;
+	params;
+	body;
+	_body;
+	rawBody;
+	ip;
+	hostname;
+	socket;
+	file;
+	files;
+	urlValue;
+	started = false;
+	resumeRead;
+	constructor(input, socket) {
+		super();
+		const base = createRequest(input, socket);
+		this.raw = base.raw;
+		this.method = base.method;
+		this.originalUrl = base.originalUrl;
+		this.headers = base.headers;
+		this.query = base.query;
+		this.params = base.params;
+		this.body = base.body;
+		this.ip = base.ip;
+		this.hostname = base.hostname;
+		this.socket = base.socket;
+		this.urlValue = base.url;
+		if (input.body && this.headers["content-length"] == null && this.headers["transfer-encoding"] == null) this.headers["transfer-encoding"] = "chunked";
+		this.on("end", () => {
+			this._body = true;
+		});
+	}
+	get finished() {
+		return this._body === true;
+	}
+	get url() {
+		return this.urlValue;
+	}
+	set url(value) {
+		this.urlValue = value;
+	}
+	get path() {
+		const query = this.urlValue.indexOf("?");
+		return (query === -1 ? this.urlValue : this.urlValue.slice(0, query)) || "/";
+	}
+	get(name) {
+		const value = this.headers[name.toLowerCase()];
+		if (Array.isArray(value)) return value[0];
+		return value;
+	}
+	header(name) {
+		return this.get(name);
+	}
+	_read() {
+		if (!this.started) {
+			this.started = true;
+			this.drain();
+			return;
+		}
+		this.resumeRead?.();
+		this.resumeRead = void 0;
+	}
+	async drain() {
+		const body = this.raw.body;
+		if (!body) {
+			this.push(null);
+			return;
+		}
+		const reader = body.getReader();
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				const chunk = Buffer.from(value);
+				if (!this.push(chunk)) await new Promise((resolve) => {
+					this.resumeRead = resolve;
+				});
+			}
+			this.push(null);
+		} catch (error) {
+			this.destroy(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+};
+var ExpressResponse = class extends FetchResponse {
+	req;
+	constructor(socket, req) {
+		super(socket);
+		this.req = req;
+	}
+	send(body) {
+		if (body == null || body === "") {
+			this.end();
+			return;
+		}
+		if (typeof body === "string") {
+			if (!this.getHeader("content-type")) this.setHeader("content-type", "text/html; charset=utf-8");
+			this.end(body);
+			return;
+		}
+		if (body instanceof Uint8Array) {
+			if (!this.getHeader("content-type")) this.setHeader("content-type", "application/octet-stream");
+			this.end(body);
+			return;
+		}
+		this.json(body);
+	}
+	set(field, value) {
+		if (typeof field === "string") {
+			this.writeHeader(field, value ?? "");
+			return this;
+		}
+		for (const [name, item] of Object.entries(field)) this.writeHeader(name, item);
+		return this;
+	}
+	redirect(statusOrUrl, url) {
+		const status = typeof statusOrUrl === "number" ? statusOrUrl : 302;
+		const location = typeof statusOrUrl === "string" ? statusOrUrl : url ?? "/";
+		this.status(status);
+		this.setHeader("location", location);
+		this.end();
+	}
+	writeHeader(name, value) {
+		if (Array.isArray(value)) {
+			for (const item of value) this.appendHeader(name, String(item));
+			return;
+		}
+		this.setHeader(name, String(value));
+	}
+};
+function errorStatus(err) {
+	if (!err || typeof err !== "object") return void 0;
+	const record = err;
+	if (typeof record.status === "number") return record.status;
+	if (typeof record.statusCode === "number") return record.statusCode;
+}
+function asHttpException(err) {
+	if (err instanceof HttpException) return err;
+	const status = errorStatus(err);
+	if (status == null) return err;
+	const message = err && typeof err === "object" && "message" in err && typeof err.message === "string" ? err.message : "Error";
+	return new HttpException(message, status);
+}
+function mountedUrl(url, mount) {
+	const query = url.indexOf("?");
+	const pathname = query === -1 ? url : url.slice(0, query);
+	const search = query === -1 ? "" : url.slice(query);
+	let rest = pathname.slice(mount.length);
+	if (!rest) rest = "/";
+	else if (!rest.startsWith("/")) rest = `/${rest}`;
+	return rest + search;
+}
+//#endregion
+//#region src/lib/router.ts
+const TOKEN = /:([A-Za-z_][A-Za-z0-9_]*)(\?)?|\{\*([A-Za-z_][A-Za-z0-9_]*)\}|\*([A-Za-z_][A-Za-z0-9_]*)/g;
+function normalizeMount(path) {
+	let source = path.endsWith("$") ? path.slice(0, -1) : path;
+	if (!source.startsWith("/")) source = `/${source}`;
+	if (source.length > 1 && source.endsWith("/")) source = source.slice(0, -1);
+	return source;
+}
+function escapeLiteral(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compile(path, kind) {
+	const exact = kind === "exact" || path.endsWith("$");
+	let source = path.endsWith("$") ? path.slice(0, -1) : path;
+	if (!source.startsWith("/")) source = `/${source}`;
+	if (/[()+]/.test(source) || /(?:^|\/)\*(?![A-Za-z_{])/.test(source)) throw new TypeError(`Unsupported route path "${path}". Use :param, :param?, {*name}, or *name.`);
+	let pattern = "^";
+	let cursor = 0;
+	for (const token of source.matchAll(TOKEN)) {
+		const index = token.index ?? 0;
+		pattern += escapeLiteral(source.slice(cursor, index));
+		const braceSplat = token[3];
+		const starSplat = token[4];
+		const name = token[1] ?? braceSplat ?? starSplat ?? "path";
+		const optional = token[2] === "?";
+		if (braceSplat != null || optional) {
+			if (pattern.endsWith("/")) pattern = pattern.slice(0, -1);
+			pattern += braceSplat != null ? `(?:/(?<${name}>.*))?` : `(?:/(?<${name}>[^/]+))?`;
+		} else if (starSplat != null) pattern += `(?<${name}>.*)`;
+		else pattern += `(?<${name}>[^/]+)`;
+		cursor = index + token[0].length;
+	}
+	pattern += escapeLiteral(source.slice(cursor));
+	if (source === "/") pattern = exact ? "^/?$" : "^/.*$";
+	else pattern += exact ? "/?$" : "(?:/.*)?$";
+	const re = new RegExp(pattern);
+	return (pathname) => {
+		const found = re.exec(pathname);
+		if (!found) return null;
+		const params = {};
+		for (const [key, value] of Object.entries(found.groups ?? {})) if (value != null) params[key] = value;
+		return params;
+	};
+}
+var Router = class {
+	layers = [];
+	use(pathOrHandler, handler) {
+		if (Array.isArray(pathOrHandler)) {
+			for (const path of pathOrHandler) this.add(null, path, handler, "prefix");
+			return;
+		}
+		this.add(null, pathOrHandler, handler, "prefix");
+	}
+	get(path, handler) {
+		this.add("GET", path, handler, "exact");
+	}
+	post(path, handler) {
+		this.add("POST", path, handler, "exact");
+	}
+	head(path, handler) {
+		this.add("HEAD", path, handler, "exact");
+	}
+	delete(path, handler) {
+		this.add("DELETE", path, handler, "exact");
+	}
+	put(path, handler) {
+		this.add("PUT", path, handler, "exact");
+	}
+	patch(path, handler) {
+		this.add("PATCH", path, handler, "exact");
+	}
+	options(path, handler) {
+		this.add("OPTIONS", path, handler, "exact");
+	}
+	all(path, handler) {
+		this.add(null, path, handler, "exact");
+	}
+	propfind(path, handler) {
+		this.add("PROPFIND", path, handler, "exact");
+	}
+	proppatch(path, handler) {
+		this.add("PROPPATCH", path, handler, "exact");
+	}
+	mkcol(path, handler) {
+		this.add("MKCOL", path, handler, "exact");
+	}
+	copy(path, handler) {
+		this.add("COPY", path, handler, "exact");
+	}
+	move(path, handler) {
+		this.add("MOVE", path, handler, "exact");
+	}
+	lock(path, handler) {
+		this.add("LOCK", path, handler, "exact");
+	}
+	unlock(path, handler) {
+		this.add("UNLOCK", path, handler, "exact");
+	}
+	search(path, handler) {
+		this.add("SEARCH", path, handler, "exact");
+	}
+	query(path, handler) {
+		this.add("QUERY", path, handler, "exact");
+	}
+	add(method, path, handler, kind) {
+		const fn = typeof path === "function" ? path : handler;
+		const route = typeof path === "function" ? "/" : path;
+		if (!fn) return;
+		const mount = kind === "prefix" ? normalizeMount(route) : null;
+		this.layers.push({
+			method,
+			mount,
+			match: compile(route, kind),
+			handler: fn,
+			error: fn.length >= 4
+		});
+	}
+	handle(req, res) {
+		const dispatch = (index, err) => {
+			const layer = this.layers[index];
+			if (!layer) {
+				if (!res.headersSent) {
+					const status = err ? errorStatus(err) ?? 500 : 404;
+					const message = err && typeof err === "object" && "message" in err && typeof err.message === "string" ? err.message : err ? "Internal server error" : "Not Found";
+					res.status(status).json({
+						statusCode: status,
+						message
+					});
+				}
+				return;
+			}
+			if (err) {
+				if (!layer.error) return dispatch(index + 1, err);
+				Promise.resolve().then(() => layer.handler(err, req, res, (nextErr) => dispatch(index + 1, nextErr))).catch((nextErr) => dispatch(index + 1, nextErr));
+				return;
+			}
+			if (layer.error) return dispatch(index + 1);
+			if (layer.method && layer.method !== req.method) return dispatch(index + 1);
+			const params = layer.match(req.path);
+			if (!params) return dispatch(index + 1);
+			req.params = params;
+			const previous = req.url;
+			if (layer.mount && layer.mount !== "/") req.url = mountedUrl(previous, layer.mount);
+			const restore = () => {
+				req.url = previous;
+			};
+			Promise.resolve().then(() => layer.handler(req, res, (nextErr) => {
+				restore();
+				dispatch(index + 1, nextErr);
+			})).catch((nextErr) => {
+				restore();
+				dispatch(index + 1, nextErr);
+			});
+		};
+		dispatch(0);
+	}
+};
+//#endregion
+//#region src/lib/version.ts
+function headerValue(headers, name) {
+	const value = headers[name.toLowerCase()];
+	if (Array.isArray(value)) return value[0];
+	return value;
+}
+function matches(version, found) {
+	if (found == null) return Array.isArray(version) && version.includes(VERSION_NEUTRAL);
+	if (Array.isArray(version)) return version.includes(found);
+	return version === found;
+}
+function matchesCustom(version, extracted) {
+	const values = Array.isArray(extracted) ? extracted : [extracted];
+	if (values.length === 0) return Array.isArray(version) && version.includes(VERSION_NEUTRAL);
+	if (Array.isArray(version)) return values.some((value) => version.includes(value));
+	return typeof version === "string" && values.includes(version);
+}
+function mediaTypeVersion(accept, key) {
+	for (const range of accept?.split(",") ?? []) for (const parameter of range.split(";").slice(1)) {
+		const trimmed = parameter.trim();
+		if (trimmed.startsWith(key)) return trimmed.slice(key.length);
+	}
+}
+function applyVersionFilter(handler, version, options) {
+	if (version === VERSION_NEUTRAL || options.type === VersioningType.URI) return (req, res, next) => handler(req, res, next);
+	return (req, res, next) => {
+		if (options.type === VersioningType.HEADER) {
+			if (matches(version, headerValue(req.headers, options.header))) return handler(req, res, next);
+			return next();
+		}
+		if (options.type === VersioningType.MEDIA_TYPE) {
+			if (matches(version, mediaTypeVersion(headerValue(req.headers, "accept"), options.key))) return handler(req, res, next);
+			return next();
+		}
+		if (options.type === VersioningType.CUSTOM) {
+			if (matchesCustom(version, options.extractor(req))) return handler(req, res, next);
+			return next();
+		}
+		throw new Error("Unsupported versioning options");
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/lib/multipart/index.ts
+async function readForm(req, limits) {
+	if (!(req.raw.headers.get("content-type") ?? "").toLowerCase().includes("multipart/form-data")) throw new BadRequestException("Expected multipart/form-data");
+	const form = await req.raw.formData();
+	const body = {};
+	const files = [];
+	let fields = 0;
+	for (const [fieldname, value] of form.entries()) {
+		if (typeof value === "string") {
+			fields += 1;
+			if (limits?.fields != null && fields > limits.fields) throw new PayloadTooLargeException();
+			const prev = body[fieldname];
+			if (prev == null) body[fieldname] = value;
+			else if (Array.isArray(prev)) prev.push(value);
+			else body[fieldname] = [prev, value];
+			continue;
+		}
+		if (limits?.files != null && files.length >= limits.files) throw new PayloadTooLargeException();
+		const buffer = new Uint8Array(await value.arrayBuffer());
+		if (limits?.fileSize != null && buffer.byteLength > limits.fileSize) throw new PayloadTooLargeException();
+		files.push({
+			fieldname,
+			originalname: value.name,
+			encoding: "7bit",
+			mimetype: value.type,
+			buffer,
+			size: buffer.byteLength
+		});
+	}
+	req.body = body;
+	return files;
+}
+function FileInterceptor(field, options) {
+	let MixinInterceptor = class MixinInterceptor {
+		async intercept(context, next) {
+			const req = context.switchToHttp().getRequest();
+			const file = (await readForm(req, options?.limits)).find((item) => item.fieldname === field);
+			if (file) req.file = file;
+			return next.handle();
+		}
+	};
+	MixinInterceptor = __decorate([Injectable()], MixinInterceptor);
+	return mixin(MixinInterceptor);
+}
+function FilesInterceptor(field, maxCount, options) {
+	let MixinInterceptor = class MixinInterceptor {
+		async intercept(context, next) {
+			const req = context.switchToHttp().getRequest();
+			const matched = (await readForm(req, options?.limits)).filter((item) => item.fieldname === field);
+			if (maxCount != null && matched.length > maxCount) throw new PayloadTooLargeException();
+			req.files = matched;
+			return next.handle();
+		}
+	};
+	MixinInterceptor = __decorate([Injectable()], MixinInterceptor);
+	return mixin(MixinInterceptor);
+}
+function AnyFilesInterceptor(options) {
+	let MixinInterceptor = class MixinInterceptor {
+		async intercept(context, next) {
+			const req = context.switchToHttp().getRequest();
+			req.files = await readForm(req, options?.limits);
+			return next.handle();
+		}
+	};
+	MixinInterceptor = __decorate([Injectable()], MixinInterceptor);
+	return mixin(MixinInterceptor);
+}
+//#endregion
+//#region src/fetch/index.ts
+const BODY_LIMIT = 1048576;
+var FetchAdapter = class extends AbstractHttpAdapter {
+	bodyLimit = BODY_LIMIT;
+	rawBody = false;
+	shuttingDown = false;
+	parsersReady = false;
+	constructor() {
+		super(new Router());
+	}
+	get router() {
+		return this.getInstance();
+	}
+	handle(input) {
+		if (this.shuttingDown) return Promise.resolve(new Response("Service Unavailable", {
+			status: 503,
+			headers: { connection: "close" }
+		}));
+		const socket = new FetchSocket();
+		const req = new ExpressRequest(input, socket);
+		const res = new ExpressResponse(socket, req);
+		const onAbort = () => {
+			socket.close();
+			queueMicrotask(() => {
+				if (!res.headersSent) res.end();
+			});
+		};
+		if (input.signal.aborted) onAbort();
+		else input.signal.addEventListener("abort", onAbort, { once: true });
+		this.router.handle(req, res);
+		return res.ready();
+	}
+	listen() {
+		throw new Error("FetchAdapter does not listen. Pass createFetcher() to the runtime fetch handler.");
+	}
+	initHttpServer(options) {
+		this.rawBody = options.rawBody === true;
+		if (options.return503OnClosing) this.router.use((req, res, next) => {
+			if (!this.shuttingDown) return next();
+			res.status(503).send("Service Unavailable");
+		});
+	}
+	beforeClose() {
+		this.shuttingDown = true;
+	}
+	close() {}
+	useStaticAssets(_root, _options) {
+		return this;
+	}
+	setViewEngine() {
+		return this;
+	}
+	getRequestHostname(request) {
+		return request.hostname;
+	}
+	getRequestMethod(request) {
+		return request.method;
+	}
+	getRequestUrl(request) {
+		return request.originalUrl;
+	}
+	status(response, statusCode) {
+		return response.status(statusCode);
+	}
+	reply(response, body, statusCode) {
+		if (statusCode != null) response.status(statusCode);
+		if (body == null) {
+			response.end();
+			return;
+		}
+		if (body instanceof StreamableFile) {
+			const headers = body.getHeaders();
+			if (!response.getHeader("content-type")) response.setHeader("content-type", headers.type);
+			if (headers.disposition && !response.getHeader("content-disposition")) {
+				const disposition = Array.isArray(headers.disposition) ? headers.disposition.join("; ") : headers.disposition;
+				response.setHeader("content-disposition", disposition);
+			}
+			if (headers.length != null && !response.getHeader("content-length")) response.setHeader("content-length", String(headers.length));
+			const stream = body.getStream();
+			stream.once("error", (err) => {
+				if (!response.headersSent) body.errorHandler(err, response);
+				else body.errorLogger(err);
+			});
+			response.once("close", () => {
+				if (!stream.readableEnded) stream.destroy();
+			});
+			stream.pipe(response);
+			return;
+		}
+		if (typeof body === "object") {
+			response.json(body);
+			return;
+		}
+		const text = typeof body === "string" ? body : typeof body === "number" || typeof body === "boolean" || typeof body === "bigint" ? String(body) : "";
+		response.send(text);
+	}
+	end(response, message) {
+		response.end(message);
+	}
+	render() {
+		throw new Error("FetchAdapter has no view engine.");
+	}
+	redirect(response, statusCode, url) {
+		response.status(statusCode);
+		response.setHeader("location", url);
+		response.end();
+	}
+	isHeadersSent(response) {
+		return response.headersSent;
+	}
+	getHeader(response, name) {
+		return response.getHeader(name);
+	}
+	setHeader(response, name, value) {
+		response.setHeader(name, value);
+	}
+	appendHeader(response, name, value) {
+		response.appendHeader(name, value);
+	}
+	setErrorHandler(handler) {
+		this.router.use(function(err, req, res, next) {
+			return handler(asHttpException(err), req, res, next);
+		});
+	}
+	setNotFoundHandler(handler) {
+		this.router.use((req, res, next) => handler(req, res, next));
+	}
+	getType() {
+		return "fetch";
+	}
+	isRouteOrderSensitive() {
+		return true;
+	}
+	applyVersionFilter(handler, version, versioningOptions) {
+		return applyVersionFilter(handler, version, versioningOptions);
+	}
+	createMiddlewareFactory(method) {
+		return (path, callback) => {
+			const exact = path.endsWith("$");
+			const verb = method === RequestMethod.ALL ? null : RequestMethod[method];
+			this.router.add(verb, exact ? path.slice(0, -1) : path, callback, exact ? "exact" : "prefix");
+		};
+	}
+	registerParserMiddleware() {
+		if (this.parsersReady) return;
+		this.parsersReady = true;
+		this.router.use(async (req, res, next) => {
+			if (req._body || req.method === "GET" || req.method === "HEAD" || !req.raw.body) return next();
+			const type = req.raw.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() ?? "";
+			if (type.startsWith("multipart/")) return next();
+			const json = type === "application/json" || type.endsWith("+json");
+			const urlencoded = type === "application/x-www-form-urlencoded";
+			if (!json && !urlencoded) {
+				req.body = req.raw.body;
+				return next();
+			}
+			if (!(req instanceof ExpressRequest)) return next();
+			let bytes;
+			try {
+				bytes = await readLimited(req, this.bodyLimit);
+			} catch (error) {
+				return next(error);
+			}
+			if (this.rawBody) req.rawBody = bytes;
+			const text = new TextDecoder().decode(bytes);
+			if (urlencoded) {
+				const params = new URLSearchParams(text);
+				const body = {};
+				for (const key of new Set(params.keys())) {
+					const all = params.getAll(key);
+					const first = all[0];
+					if (first == null) continue;
+					body[key] = all.length > 1 ? all : first;
+				}
+				req.body = body;
+				req._body = true;
+				return next();
+			}
+			try {
+				req.body = text ? JSON.parse(text) : {};
+			} catch {
+				return next(new BadRequestException("Invalid JSON"));
+			}
+			req._body = true;
+			next();
+		});
+	}
+	enableCors(options) {
+		this.router.use((req, res, next) => {
+			const allowed = allowedOrigin(headerString(req.headers.origin), options?.origin, options?.credentials === true);
+			if (allowed) {
+				res.setHeader("access-control-allow-origin", allowed);
+				if (options?.credentials) res.setHeader("access-control-allow-credentials", "true");
+				if (allowed !== "*") res.appendHeader("vary", "Origin");
+			}
+			const methods = options?.methods ?? "GET,HEAD,PUT,PATCH,POST,DELETE";
+			const requestHeaders = headerString(req.headers["access-control-request-headers"]);
+			const allowHeaders = options?.allowedHeaders ?? requestHeaders ?? "";
+			res.setHeader("access-control-allow-methods", Array.isArray(methods) ? methods.join(",") : methods);
+			if (allowHeaders) res.setHeader("access-control-allow-headers", Array.isArray(allowHeaders) ? allowHeaders.join(",") : allowHeaders);
+			if (options?.exposedHeaders) {
+				const exposed = options.exposedHeaders;
+				res.setHeader("access-control-expose-headers", Array.isArray(exposed) ? exposed.join(",") : exposed);
+			}
+			if (options?.maxAge != null) res.setHeader("access-control-max-age", String(options.maxAge));
+			if (req.method === "OPTIONS" && req.headers["access-control-request-method"]) {
+				res.status(204).end();
+				return;
+			}
+			next();
+		});
+	}
+	setBodyLimit(limit) {
+		this.bodyLimit = limit;
+	}
+};
+function headerString(value) {
+	return Array.isArray(value) ? value[0] : value;
+}
+function allowedOrigin(origin, rule, credentials) {
+	const fallback = credentials ? origin : "*";
+	if (rule == null || rule === true || rule === "*") return fallback;
+	if (rule === false || !origin) return void 0;
+	if (rule instanceof RegExp) return rule.test(origin) ? origin : void 0;
+	if (typeof rule === "string") return rule === origin ? origin : void 0;
+	if (Array.isArray(rule)) return rule.some((item) => item instanceof RegExp ? item.test(origin) : item === origin) ? origin : void 0;
+	return rule(origin) ? origin : void 0;
+}
+function readLimited(req, limit) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let total = 0;
+		let settled = false;
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			req.destroy();
+			reject(error);
+		};
+		req.on("data", (chunk) => {
+			total += chunk.byteLength;
+			if (total > limit) {
+				fail(new PayloadTooLargeException());
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			if (settled) return;
+			settled = true;
+			const bytes = new Uint8Array(total);
+			let offset = 0;
+			for (const chunk of chunks) {
+				bytes.set(chunk, offset);
+				offset += chunk.byteLength;
+			}
+			resolve(bytes);
+		});
+		req.on("error", (error) => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		});
+		req.resume();
+	});
+}
+function createFetcher({ module, configure, opts, bodyLimit }, adapter = new FetchAdapter()) {
+	if (bodyLimit != null) adapter.setBodyLimit(bodyLimit);
+	let pending;
+	const instance = () => {
+		if (pending) return pending;
+		pending = (async () => {
+			const app = await NestFactory.create(module, adapter, opts);
+			await configure?.(app);
+			await app.init();
+			return app;
+		})();
+		return pending;
+	};
+	const handler = (async (request) => {
+		await instance();
+		return adapter.handle(request);
+	});
+	handler.app = instance;
+	handler.close = async () => {
+		if (pending) await (await pending).close();
+		pending = void 0;
+	};
+	return handler;
+}
+//#endregion
+export { FilesInterceptor as a, FileInterceptor as i, createFetcher as n, AnyFilesInterceptor as r, FetchAdapter as t };