@potok-web-framework/core 0.1.0 → 0.3.0

package/dist/server.mjs

@@ -0,0 +1,1192 @@
+import { l as createSignal } from "./utils-CAe_kbSH.mjs";
+import { t as fragment } from "./fragment-BahmURhz.mjs";
+import { t as PortalIn } from "./portal-CbcYOHLv.mjs";
+import { t as CLIENT_ENTRY_FILE_NAME } from "./constants-BOAOReQ3.mjs";
+import { t as htmlElement } from "./html-element-Cm0RtMkT.mjs";
+import path from "path";
+import { Readable, Writable } from "node:stream";
+import util from "node:util";
+import { Buffer } from "node:buffer";
+var ServerNode = class {
+	libNode;
+	parent = null;
+	children = [];
+	constructor(e) {
+		this.libNode = e;
+	}
+	addChild(e, t) {
+		if (t) {
+			let n = this.children.indexOf(t);
+			this.children.splice(n + 1, 0, e);
+		} else this.children.push(e);
+		e.parent = this;
+	}
+	remove() {
+		this.parent && this.parent.children.splice(this.parent.children.indexOf(this), 1);
+	}
+	stringify() {
+		if (this.libNode.type === "text") {
+			let e = this.libNode.context.parentBlock?.nearestParentElement?.props.tag;
+			return e && ["title", "script"].includes(e) ? String(this.libNode.props.text) : `<!-- -->${this.libNode.props.text}`;
+		} else if (this.libNode.type === "html-element") {
+			let e = `<${this.libNode.props.tag}`;
+			for (let [t, n] of Object.entries(Object.getOwnPropertyDescriptors(this.libNode.props))) {
+				if ([
+					"tag",
+					"children",
+					"ref"
+				].includes(t) || t.startsWith("on")) continue;
+				let r = n.get?.() ?? n.value;
+				if (r) {
+					if (t === "style") {
+						let t = "";
+						Object.entries(r).forEach(([e, n]) => {
+							t += `${e.replace(/([A-Z])/g, "-$1").toLowerCase()}:${n};`;
+						}), e += ` style="${t}"`;
+						continue;
+					}
+					if (t.startsWith("aria")) {
+						e += ` ${t.toLowerCase().replace("aria", "aria-")}="${r}"`;
+						continue;
+					}
+					if (t === "className") {
+						e += ` class="${r}"`;
+						continue;
+					}
+					e += ` ${t}="${r}"`;
+				}
+			}
+			return e += ">", this.children.forEach((t) => {
+				e += t.stringify();
+			}), e += `</${this.libNode.props.tag}>`, e;
+		}
+		throw Error("Not implemented");
+	}
+};
+async function renderToString(t) {
+	let n = createSignal({
+		portals: {},
+		listeners: {}
+	}), r = /* @__PURE__ */ new Map(), i, a = [];
+	if (t({
+		parentBlock: null,
+		index: 0,
+		portals: n.portals,
+		contexts: {},
+		listeners: n.listeners,
+		isServer: !0,
+		promises: a,
+		isHydrating: !1,
+		insertNode(e, t, n) {
+			e && !r.has(e) && r.set(e, new ServerNode(e)), r.has(t) || r.set(t, new ServerNode(t));
+			let a = r.get(t);
+			if (r.set(t, a), e === null) i = a;
+			else {
+				let t = n && r.has(n) ? r.get(n) : null;
+				r.get(e)?.addChild(a, t);
+			}
+		},
+		updateTextNode() {},
+		updateHtmlElementNodeProp() {},
+		removeNode(e) {
+			r.get(e)?.remove();
+		}
+	}), await Promise.all(a), !i) throw Error("Корневая нода не найдена");
+	return i.stringify();
+}
+var classRegExp = /^([A-Z][a-z0-9]*)+$/, kTypes = [
+	"string",
+	"function",
+	"number",
+	"object",
+	"Function",
+	"Object",
+	"boolean",
+	"bigint",
+	"symbol"
+];
+function determineSpecificType(e) {
+	if (e == null) return "" + e;
+	if (typeof e == "function" && e.name) return `function ${e.name}`;
+	if (typeof e == "object") return e.constructor?.name ? `an instance of ${e.constructor.name}` : `${util.inspect(e, { depth: -1 })}`;
+	let t = util.inspect(e, { colors: !1 });
+	return t.length > 28 && (t = `${t.slice(0, 25)}...`), `type ${typeof e} (${t})`;
+}
+var ERR_HTTP_BODY_NOT_ALLOWED = class extends Error {
+	constructor() {
+		super("Adding content for this request method or response status is not allowed.");
+	}
+}, ERR_HTTP_CONTENT_LENGTH_MISMATCH = class extends Error {
+	constructor(e, t) {
+		super(`Response body's content-length of ${e} byte(s) does not match the content-length of ${t} byte(s) set in header`);
+	}
+}, ERR_HTTP_HEADERS_SENT = class extends Error {
+	constructor(e) {
+		super(`Cannot ${e} headers after they are sent to the client`);
+	}
+}, ERR_INVALID_ARG_VALUE = class extends TypeError {
+	constructor(e, t, n = "is invalid") {
+		let r = util.inspect(t);
+		r.length > 128 && (r = `${r.slice(0, 128)}...`);
+		let i = e.includes(".") ? "property" : "argument";
+		super(`The ${i} '${e}' ${n}. Received ${r}`);
+	}
+}, ERR_INVALID_CHAR = class extends TypeError {
+	constructor(e, t) {
+		let n = `Invalid character in ${e}`;
+		t !== void 0 && (n += ` ["${t}"]`), super(n);
+	}
+}, ERR_HTTP_INVALID_HEADER_VALUE = class extends TypeError {
+	constructor(e, t) {
+		super(`Invalid value "${e}" for header "${t}"`);
+	}
+}, ERR_HTTP_INVALID_STATUS_CODE = class extends RangeError {
+	originalStatusCode;
+	constructor(e) {
+		super(`Invalid status code: ${e}`), this.originalStatusCode = e;
+	}
+}, ERR_HTTP_TRAILER_INVALID = class extends Error {
+	constructor() {
+		super("Trailers are invalid with this transfer encoding");
+	}
+}, ERR_INVALID_ARG_TYPE = class extends TypeError {
+	constructor(e, t, n) {
+		Array.isArray(t) || (t = [t]);
+		let r = "The ";
+		if (e.endsWith(" argument")) r += `${e} `;
+		else {
+			let t = e.includes(".") ? "property" : "argument";
+			r += `"${e}" ${t} `;
+		}
+		r += "must be ";
+		let i = [], a = [], o = [];
+		for (let e of t) kTypes.includes(e) ? i.push(e.toLowerCase()) : classRegExp.exec(e) === null ? o.push(e) : a.push(e);
+		if (a.length > 0) {
+			let e = i.indexOf("object");
+			e !== -1 && (i.splice(e, 1), a.push("Object"));
+		}
+		if (i.length > 0) {
+			if (i.length > 2) {
+				let e = i.pop();
+				r += `one of type ${i.join(", ")}, or ${e}`;
+			} else i.length === 2 ? r += `one of type ${i[0]} or ${i[1]}` : r += `of type ${i[0]}`;
+			(a.length > 0 || o.length > 0) && (r += " or ");
+		}
+		if (a.length > 0) {
+			if (a.length > 2) {
+				let e = a.pop();
+				r += `an instance of ${a.join(", ")}, or ${e}`;
+			} else r += `an instance of ${a[0]}`, a.length === 2 && (r += ` or ${a[1]}`);
+			o.length > 0 && (r += " or ");
+		}
+		if (o.length > 0) if (o.length > 2) {
+			let e = o.pop();
+			r += `one of ${o.join(", ")}, or ${e}`;
+		} else o.length === 2 ? r += `one of ${o[0]} or ${o[1]}` : (o[0].toLowerCase() !== o[0] && (r += "an "), r += `${o[0]}`);
+		r += `. Received ${determineSpecificType(n)}`, super(r);
+	}
+}, ERR_INVALID_HTTP_TOKEN = class extends TypeError {
+	constructor(e, t) {
+		super(`${e} must be a valid HTTP token ["${t}"]`);
+	}
+}, ERR_METHOD_NOT_IMPLEMENTED = class extends Error {
+	constructor(e) {
+		super(`The ${e} method is not implemented`);
+	}
+}, ERR_STREAM_ALREADY_FINISHED = class extends Error {
+	constructor(e) {
+		super(`Cannot call ${e} after a stream was finished`);
+	}
+}, ERR_STREAM_CANNOT_PIPE = class extends Error {
+	constructor() {
+		super("Cannot pipe, not readable");
+	}
+}, ERR_STREAM_DESTROYED = class extends Error {
+	constructor(e) {
+		super(`Cannot call ${e} after a stream was destroyed`);
+	}
+}, ERR_STREAM_NULL_VALUES = class extends TypeError {
+	constructor() {
+		super("May not write null values to stream");
+	}
+}, ERR_STREAM_WRITE_AFTER_END = class extends Error {
+	constructor() {
+		super("write after end");
+	}
+}, kHeaders = Symbol("kHeaders"), kHeadersDistinct = Symbol("kHeadersDistinct"), kHeadersCount = Symbol("kHeadersCount"), kTrailers = Symbol("kTrailers"), kTrailersDistinct = Symbol("kTrailersDistinct"), kTrailersCount = Symbol("kTrailersCount"), FetchIncomingMessage = class extends Readable {
+	get socket() {
+		return null;
+	}
+	set socket(e) {
+		throw new ERR_METHOD_NOT_IMPLEMENTED("socket");
+	}
+	httpVersionMajor;
+	httpVersionMinor;
+	httpVersion;
+	complete = !1;
+	[kHeaders] = null;
+	[kHeadersDistinct] = null;
+	[kHeadersCount] = 0;
+	rawHeaders = [];
+	[kTrailers] = null;
+	[kTrailersDistinct] = null;
+	[kTrailersCount] = 0;
+	rawTrailers = [];
+	joinDuplicateHeaders = !1;
+	aborted = !1;
+	upgrade = !1;
+	url = "";
+	method;
+	_consuming;
+	_dumped;
+	_stream = null;
+	constructor() {
+		super({}), this._readableState.readingMore = !0, this._consuming = !1, this._dumped = !1;
+	}
+	get connection() {
+		return null;
+	}
+	set connection(e) {
+		console.error("No support for IncomingMessage.connection");
+	}
+	get headers() {
+		if (!this[kHeaders]) {
+			this[kHeaders] = {};
+			let e = this.rawHeaders, t = this[kHeaders];
+			for (let n = 0; n < this[kHeadersCount]; n += 2) this._addHeaderLine(e[n], e[n + 1], t);
+		}
+		return this[kHeaders];
+	}
+	set headers(e) {
+		this[kHeaders] = e;
+	}
+	get headersDistinct() {
+		if (!this[kHeadersDistinct]) {
+			this[kHeadersDistinct] = {};
+			let e = this.rawHeaders, t = this[kHeadersDistinct];
+			for (let n = 0; n < this[kHeadersCount]; n += 2) this._addHeaderLineDistinct(e[n], e[n + 1], t);
+		}
+		return this[kHeadersDistinct];
+	}
+	set headersDistinct(e) {
+		this[kHeadersDistinct] = e;
+	}
+	get trailers() {
+		if (!this[kTrailers]) {
+			this[kTrailers] = {};
+			let e = this.rawTrailers, t = this[kTrailers];
+			for (let n = 0; n < this[kTrailersCount]; n += 2) this._addHeaderLine(e[n], e[n + 1], t);
+		}
+		return this[kTrailers];
+	}
+	set trailers(e) {
+		this[kTrailers] = e;
+	}
+	get trailersDistinct() {
+		if (!this[kTrailersDistinct]) {
+			this[kTrailersDistinct] = {};
+			let e = this.rawTrailers, t = this[kTrailersDistinct];
+			for (let n = 0; n < this[kTrailersCount]; n += 2) this._addHeaderLineDistinct(e[n], e[n + 1], t);
+		}
+		return this[kTrailersDistinct];
+	}
+	set trailersDistinct(e) {
+		this[kTrailersDistinct] = e;
+	}
+	setTimeout(e, t) {
+		return this;
+	}
+	async _read(e) {
+		if (this._consuming ||= (this._readableState.readingMore = !1, !0), this._stream == null) {
+			this.complete = !0, this.push(null);
+			return;
+		}
+		let t = this._stream.getReader();
+		try {
+			let e = await t.read();
+			e.done ? (this.complete = !0, this.push(null)) : this.push(e.value);
+		} catch (e) {
+			this.destroy(e);
+		} finally {
+			t.releaseLock();
+		}
+	}
+	_destroy(e, t) {
+		(!this.readableEnded || !this.complete) && (this.aborted = !0, this.emit("aborted")), setTimeout(onError$1, 0, this, e, t);
+	}
+	_addHeaderLines(e, t) {
+		if (e?.length) {
+			let n;
+			if (this.complete ? (this.rawTrailers = e, this[kTrailersCount] = t, n = this[kTrailers]) : (this.rawHeaders = e, this[kHeadersCount] = t, n = this[kHeaders]), n) for (let r = 0; r < t; r += 2) this._addHeaderLine(e[r], e[r + 1], n);
+		}
+	}
+	_addHeaderLine(e, t, n) {
+		e = matchKnownFields(e);
+		let r = e.charCodeAt(0);
+		r === 0 || r === 2 ? (e = e.slice(1), typeof n[e] == "string" ? n[e] += (r === 0 ? ", " : "; ") + t : n[e] = t) : r === 1 ? n["set-cookie"] === void 0 ? n["set-cookie"] = [t] : n["set-cookie"].push(t) : this.joinDuplicateHeaders ? n[e] === void 0 ? n[e] = t : n[e] += ", " + t : n[e] === void 0 && (n[e] = t);
+	}
+	_addHeaderLineDistinct(e, t, n) {
+		e = e.toLowerCase(), n[e] ? n[e].push(t) : n[e] = [t];
+	}
+	_dump() {
+		this._dumped || (this._dumped = !0, this.removeAllListeners("data"), this.resume());
+	}
+};
+function matchKnownFields(e, t = !1) {
+	switch (e.length) {
+		case 3:
+			if (e === "Age" || e === "age") return "age";
+			break;
+		case 4:
+			if (e === "Host" || e === "host") return "host";
+			if (e === "From" || e === "from") return "from";
+			if (e === "ETag" || e === "etag") return "etag";
+			if (e === "Date" || e === "date") return "\0date";
+			if (e === "Vary" || e === "vary") return "\0vary";
+			break;
+		case 6:
+			if (e === "Server" || e === "server") return "server";
+			if (e === "Cookie" || e === "cookie") return "cookie";
+			if (e === "Origin" || e === "origin") return "\0origin";
+			if (e === "Expect" || e === "expect") return "\0expect";
+			if (e === "Accept" || e === "accept") return "\0accept";
+			break;
+		case 7:
+			if (e === "Referer" || e === "referer") return "referer";
+			if (e === "Expires" || e === "expires") return "expires";
+			if (e === "Upgrade" || e === "upgrade") return "\0upgrade";
+			break;
+		case 8:
+			if (e === "Location" || e === "location") return "location";
+			if (e === "If-Match" || e === "if-match") return "\0if-match";
+			break;
+		case 10:
+			if (e === "User-Agent" || e === "user-agent") return "user-agent";
+			if (e === "Set-Cookie" || e === "set-cookie") return "
";
+			if (e === "Connection" || e === "connection") return "\0connection";
+			break;
+		case 11:
+			if (e === "Retry-After" || e === "retry-after") return "retry-after";
+			break;
+		case 12:
+			if (e === "Content-Type" || e === "content-type") return "content-type";
+			if (e === "Max-Forwards" || e === "max-forwards") return "max-forwards";
+			break;
+		case 13:
+			if (e === "Authorization" || e === "authorization") return "authorization";
+			if (e === "Last-Modified" || e === "last-modified") return "last-modified";
+			if (e === "Cache-Control" || e === "cache-control") return "\0cache-control";
+			if (e === "If-None-Match" || e === "if-none-match") return "\0if-none-match";
+			break;
+		case 14:
+			if (e === "Content-Length" || e === "content-length") return "content-length";
+			break;
+		case 15:
+			if (e === "Accept-Encoding" || e === "accept-encoding") return "\0accept-encoding";
+			if (e === "Accept-Language" || e === "accept-language") return "\0accept-language";
+			if (e === "X-Forwarded-For" || e === "x-forwarded-for") return "\0x-forwarded-for";
+			break;
+		case 16:
+			if (e === "Content-Encoding" || e === "content-encoding") return "\0content-encoding";
+			if (e === "X-Forwarded-Host" || e === "x-forwarded-host") return "\0x-forwarded-host";
+			break;
+		case 17:
+			if (e === "If-Modified-Since" || e === "if-modified-since") return "if-modified-since";
+			if (e === "Transfer-Encoding" || e === "transfer-encoding") return "\0transfer-encoding";
+			if (e === "X-Forwarded-Proto" || e === "x-forwarded-proto") return "\0x-forwarded-proto";
+			break;
+		case 19:
+			if (e === "Proxy-Authorization" || e === "proxy-authorization") return "proxy-authorization";
+			if (e === "If-Unmodified-Since" || e === "if-unmodified-since") return "if-unmodified-since";
+			break;
+	}
+	return t ? "\0" + e : matchKnownFields(e.toLowerCase(), !0);
+}
+function onError$1(e, t, n) {
+	e.listenerCount("error") === 0 ? n() : n(t);
+}
+function validateString(e, t) {
+	if (typeof e != "string") throw new ERR_INVALID_ARG_TYPE(t, "string", e);
+}
+var linkValueRegExp = /^(?:<[^>]*>)(?:\s*;\s*[^;"\s]+(?:=(")?[^;"\s]*\1)?)*$/;
+function validateLinkHeaderFormat(e, t) {
+	if (e === void 0 || !linkValueRegExp.exec(e)) throw new ERR_INVALID_ARG_VALUE(t, e, "must be an array or string of format \"</styles.css>; rel=preload; as=style\"");
+}
+function validateLinkHeaderValue(e) {
+	if (typeof e == "string") return validateLinkHeaderFormat(e, "hints"), e;
+	if (Array.isArray(e)) {
+		let t = e.length, n = "";
+		if (t === 0) return n;
+		for (let r = 0; r < t; r++) {
+			let i = e[r];
+			validateLinkHeaderFormat(i, "hints"), n += i, r !== t - 1 && (n += ", ");
+		}
+		return n;
+	}
+	throw new ERR_INVALID_ARG_VALUE("hints", e, "must be an array or string of format \"</styles.css>; rel=preload; as=style\"");
+}
+function isUint8Array(e) {
+	return e != null && e[Symbol.toStringTag] === "Uint8Array";
+}
+const kNeedDrain = Symbol("kNeedDrain"), kOutHeaders = Symbol("kOutHeaders");
+function utcDate() {
+	return (/* @__PURE__ */ new Date()).toUTCString();
+}
+function getDefaultHighWaterMark(e) {
+	return e ? 16 : 64 * 1024;
+}
+var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+function checkIsHttpToken(e) {
+	return tokenRegExp.test(e);
+}
+var headerCharRegex$1 = /[^\t\x20-\x7e\x80-\xff]/;
+function checkInvalidHeaderChar$1(e) {
+	return headerCharRegex$1.test(e);
+}
+const chunkExpression = /(?:^|\W)chunked(?:$|\W)/i;
+var kCorked = Symbol("corked"), kChunkedBuffer = Symbol("kChunkedBuffer"), kChunkedLength = Symbol("kChunkedLength"), kUniqueHeaders = Symbol("kUniqueHeaders"), kBytesWritten = Symbol("kBytesWritten"), kErrored = Symbol("errored"), kHighWaterMark = Symbol("kHighWaterMark"), kRejectNonStandardBodyWrites = Symbol("kRejectNonStandardBodyWrites"), nop = () => {}, RE_CONN_CLOSE = /(?:^|\W)close(?:$|\W)/i;
+function isCookieField(e) {
+	return e.length === 6 && e.toLowerCase() === "cookie";
+}
+function isContentDispositionField(e) {
+	return e.length === 19 && e.toLowerCase() === "content-disposition";
+}
+var WrittenDataBuffer = class {
+	[kCorked] = 0;
+	[kHighWaterMark] = getDefaultHighWaterMark();
+	entries = [];
+	onWrite;
+	constructor(e = {}) {
+		this.onWrite = e.onWrite;
+	}
+	write(e, t, n) {
+		return this.entries.push({
+			data: e,
+			length: e.length,
+			encoding: t,
+			callback: n,
+			written: !1
+		}), this._flush(), !0;
+	}
+	cork() {
+		this[kCorked]++;
+	}
+	uncork() {
+		this[kCorked]--, this._flush();
+	}
+	_flush() {
+		if (this[kCorked] <= 0) for (let [e, t] of this.entries.entries()) t.written || (t.written = !0, this.onWrite != null && this.onWrite(e, t), t.callback != null && t.callback.call(void 0));
+	}
+	get writableLength() {
+		return this.entries.reduce((e, t) => e + (t.written && t.length ? t.length : 0), 0);
+	}
+	get writableHighWaterMark() {
+		return this[kHighWaterMark];
+	}
+	get writableCorked() {
+		return this[kCorked];
+	}
+}, FetchOutgoingMessage = class extends Writable {
+	req;
+	outputData;
+	outputSize;
+	writtenHeaderBytes = 0;
+	_last;
+	chunkedEncoding;
+	shouldKeepAlive;
+	maxRequestsOnConnectionReached;
+	_defaultKeepAlive;
+	useChunkedEncodingByDefault;
+	sendDate;
+	_removedConnection;
+	_removedContLen;
+	_removedTE;
+	strictContentLength;
+	[kBytesWritten];
+	_contentLength;
+	_hasBody;
+	_trailer;
+	[kNeedDrain];
+	finished;
+	_headerSent;
+	[kCorked];
+	[kChunkedBuffer];
+	[kChunkedLength];
+	_closed;
+	_header;
+	[kOutHeaders];
+	_keepAliveTimeout;
+	_maxRequestsPerSocket;
+	_onPendingData;
+	[kUniqueHeaders];
+	[kErrored];
+	[kHighWaterMark];
+	[kRejectNonStandardBodyWrites];
+	_writtenDataBuffer = new WrittenDataBuffer({ onWrite: this._onDataWritten.bind(this) });
+	constructor(e, t) {
+		super(), this.req = e, this.outputData = [], this.outputSize = 0, this.destroyed = !1, this._last = !1, this.chunkedEncoding = !1, this.shouldKeepAlive = !0, this.maxRequestsOnConnectionReached = !1, this._defaultKeepAlive = !0, this.useChunkedEncodingByDefault = !0, this.sendDate = !1, this._removedConnection = !1, this._removedContLen = !1, this._removedTE = !1, this.strictContentLength = !1, this[kBytesWritten] = 0, this._contentLength = null, this._hasBody = !0, this._trailer = "", this[kNeedDrain] = !1, this.finished = !1, this._headerSent = !1, this[kCorked] = 0, this[kChunkedBuffer] = [], this[kChunkedLength] = 0, this._closed = !1, this._header = null, this[kOutHeaders] = null, this._keepAliveTimeout = 0, this._onPendingData = nop, this[kErrored] = null, this[kHighWaterMark] = t?.highWaterMark ?? getDefaultHighWaterMark(), this[kRejectNonStandardBodyWrites] = t?.rejectNonStandardBodyWrites ?? !1, this[kUniqueHeaders] = null;
+	}
+	_renderHeaders() {
+		if (this._header) throw new ERR_HTTP_HEADERS_SENT("render");
+		let e = this[kOutHeaders], t = {};
+		if (e !== null) {
+			let n = Object.keys(e);
+			for (let r = 0, i = n.length; r < i; r++) {
+				let i = n[r];
+				t[e[i][0]] = e[i][1];
+			}
+		}
+		return t;
+	}
+	cork() {
+		this[kCorked]++, this._writtenDataBuffer != null && this._writtenDataBuffer.cork();
+	}
+	uncork() {
+		if (this[kCorked]--, this._writtenDataBuffer != null && this._writtenDataBuffer.uncork(), this[kCorked] || this[kChunkedBuffer].length === 0) return;
+		let e = this[kChunkedBuffer];
+		for (let { data: t, encoding: n, callback: r } of e) this._send(t ?? "", n, r);
+		this[kChunkedBuffer].length = 0, this[kChunkedLength] = 0;
+	}
+	setTimeout(e, t) {
+		return this;
+	}
+	destroy(e) {
+		return this.destroyed ? this : (this.destroyed = !0, this[kErrored] = e, this);
+	}
+	_send(e, t, n, r) {
+		if (!this._headerSent) {
+			let n = this._header;
+			typeof e == "string" && (t === "utf8" || t === "latin1" || !t) ? e = n + e : (this.outputData.unshift({
+				data: n,
+				encoding: "latin1",
+				callback: void 0
+			}), this.outputSize += n.length, this._onPendingData(n.length)), this._headerSent = !0, this.writtenHeaderBytes = n.length;
+			let [r, ...i] = this._header.split("\r\n"), a = /^HTTP\/1\.1 (?<statusCode>\d+) (?<statusMessage>.*)$/.exec(r);
+			if (a == null) throw Error("Unexpected! Status line was " + r);
+			let { statusCode: o, statusMessage: s } = a.groups ?? {}, c = parseInt(o, 10), l = [];
+			for (let e of i) if (e !== "") {
+				let t = e.indexOf(": "), n = e.slice(0, t), r = e.slice(t + 2);
+				l.push([n, r]);
+			}
+			let u = {
+				statusCode: c,
+				statusMessage: s,
+				headers: l
+			};
+			this.emit("_headersSent", u);
+		}
+		return this._writeRaw(e, t, n, r);
+	}
+	_writeRaw(e, t, n, r) {
+		return typeof t == "function" && (n = t, t = null), this._writtenDataBuffer == null ? (this.outputData.push({
+			data: e,
+			encoding: t,
+			callback: n
+		}), this.outputSize += e.length, this._onPendingData(e.length), this.outputSize < this[kHighWaterMark]) : (this.outputData.length && this._flushOutput(this._writtenDataBuffer), this._writtenDataBuffer.write(e, t, n));
+	}
+	_onDataWritten(e, t) {
+		let n = {
+			index: e,
+			entry: t
+		};
+		this.emit("_dataWritten", n);
+	}
+	_storeHeader(e, t) {
+		let n = {
+			connection: !1,
+			contLen: !1,
+			te: !1,
+			date: !1,
+			expect: !1,
+			trailer: !1,
+			header: e
+		};
+		if (t) if (t === this[kOutHeaders]) for (let e in t) {
+			let r = t[e];
+			processHeader(this, n, r[0], r[1], !1);
+		}
+		else if (Array.isArray(t)) if (t.length && Array.isArray(t[0])) for (let e = 0; e < t.length; e++) {
+			let r = t[e];
+			processHeader(this, n, r[0], r[1], !0);
+		}
+		else {
+			if (t.length % 2 != 0) throw new ERR_INVALID_ARG_VALUE("headers", t);
+			for (let e = 0; e < t.length; e += 2) processHeader(this, n, t[e], t[e + 1], !0);
+		}
+		else for (let e in t) t.hasOwnProperty(e) && processHeader(this, n, e, t[e], !0);
+		let { header: r } = n;
+		if (this.sendDate && !n.date && (r += "Date: " + utcDate() + "\r\n"), this.chunkedEncoding && (this.statusCode === 204 || this.statusCode === 304) && (this.statusCode + "", this.chunkedEncoding = !1, this.shouldKeepAlive = !1), this._removedConnection) this._last = !this.shouldKeepAlive;
+		else if (!n.connection) {
+			let e = this.shouldKeepAlive && (n.contLen || this.useChunkedEncodingByDefault);
+			if (e && this.maxRequestsOnConnectionReached) r += "Connection: close\r\n";
+			else if (e) {
+				if (r += "Connection: keep-alive\r\n", this._keepAliveTimeout && this._defaultKeepAlive) {
+					let e = Math.floor(this._keepAliveTimeout / 1e3), t = "";
+					this._maxRequestsPerSocket && ~~this._maxRequestsPerSocket > 0 && (t = `, max=${this._maxRequestsPerSocket}`), r += `Keep-Alive: timeout=${e}${t}\r\n`;
+				}
+			} else this._last = !0, r += "Connection: close\r\n";
+		}
+		if (!n.contLen && !n.te && (this._hasBody ? this.useChunkedEncodingByDefault ? !n.trailer && !this._removedContLen && typeof this._contentLength == "number" ? r += "Content-Length: " + this._contentLength + "\r\n" : this._removedTE ? this._last = !0 : (r += "Transfer-Encoding: chunked\r\n", this.chunkedEncoding = !0) : this._last = !0 : this.chunkedEncoding = !1), this.chunkedEncoding !== !0 && n.trailer) throw new ERR_HTTP_TRAILER_INVALID();
+		this._header = r + "\r\n", this._headerSent = !1, n.expect && this._send("");
+	}
+	get _headers() {
+		return console.warn("DEP0066: OutgoingMessage.prototype._headers is deprecated"), this.getHeaders();
+	}
+	set _headers(e) {
+		if (console.warn("DEP0066: OutgoingMessage.prototype._headers is deprecated"), e == null) this[kOutHeaders] = null;
+		else if (typeof e == "object") {
+			let t = this[kOutHeaders] = Object.create(null), n = Object.keys(e);
+			for (let r = 0; r < n.length; ++r) {
+				let i = n[r];
+				t[i.toLowerCase()] = [i, e[i]];
+			}
+		}
+	}
+	get connection() {
+		return null;
+	}
+	set connection(e) {
+		console.error("No support for OutgoingMessage.connection");
+	}
+	get socket() {
+		return null;
+	}
+	set socket(e) {
+		console.error("No support for OutgoingMessage.socket");
+	}
+	get _headerNames() {
+		console.warn("DEP0066: OutgoingMessage.prototype._headerNames is deprecated");
+		let e = this[kOutHeaders];
+		if (e !== null) {
+			let t = Object.create(null), n = Object.keys(e);
+			for (let r = 0; r < n.length; ++r) {
+				let i = n[r];
+				t[i] = e[i][0];
+			}
+			return t;
+		}
+		return null;
+	}
+	set _headerNames(e) {
+		if (console.warn("DEP0066: OutgoingMessage.prototype._headerNames is deprecated"), typeof e == "object" && e) {
+			let t = this[kOutHeaders];
+			if (!t) return;
+			let n = Object.keys(e);
+			for (let r = 0; r < n.length; ++r) {
+				let i = t[n[r]];
+				i && (i[0] = e[n[r]]);
+			}
+		}
+	}
+	setHeader(e, t) {
+		if (this._header) throw new ERR_HTTP_HEADERS_SENT("set");
+		validateHeaderName(e), validateHeaderValue(e, t);
+		let n = this[kOutHeaders];
+		return n === null && (this[kOutHeaders] = n = { __proto__: null }), n[e.toLowerCase()] = [e, t], this;
+	}
+	setHeaders(e) {
+		if (this._header) throw new ERR_HTTP_HEADERS_SENT("set");
+		if (!e || Array.isArray(e) || typeof e.keys != "function" || typeof e.get != "function") throw new ERR_INVALID_ARG_TYPE("headers", ["Headers", "Map"], e);
+		let t = [];
+		for (let { 0: n, 1: r } of e) {
+			if (n === "set-cookie") {
+				Array.isArray(r) ? t.push(...r) : t.push(r);
+				continue;
+			}
+			this.setHeader(n, r);
+		}
+		return t.length && this.setHeader("set-cookie", t), this;
+	}
+	appendHeader(e, t) {
+		if (this._header) throw new ERR_HTTP_HEADERS_SENT("append");
+		validateHeaderName(e), validateHeaderValue(e, t);
+		let n = e.toLowerCase(), r = this[kOutHeaders];
+		if (r === null || !r[n]) return this.setHeader(e, t);
+		Array.isArray(r[n][1]) || (r[n][1] = [r[n][1]]);
+		let i = r[n][1];
+		if (Array.isArray(t)) for (let e = 0, n = t.length; e < n; e++) i.push(t[e]);
+		else i.push(t);
+		return this;
+	}
+	getHeader(e) {
+		validateString(e, "name");
+		let t = this[kOutHeaders];
+		if (t !== null) return t[e.toLowerCase()]?.[1];
+	}
+	getHeaderNames() {
+		return this[kOutHeaders] === null ? [] : Object.keys(this[kOutHeaders]);
+	}
+	getRawHeaderNames() {
+		let e = this[kOutHeaders];
+		if (e === null) return [];
+		let t = Object.values(e), n = Array(t.length);
+		for (let e = 0, r = t.length; e < r; e++) n[e] = t[e][0];
+		return n;
+	}
+	getHeaders() {
+		let e = this[kOutHeaders], t = { __proto__: null };
+		if (e) {
+			let n = Object.keys(e);
+			for (let r = 0; r < n.length; ++r) {
+				let i = n[r];
+				t[i] = e[i][1];
+			}
+		}
+		return t;
+	}
+	hasHeader(e) {
+		return validateString(e, "name"), this[kOutHeaders] !== null && !!this[kOutHeaders][e.toLowerCase()];
+	}
+	removeHeader(e) {
+		if (validateString(e, "name"), this._header) throw new ERR_HTTP_HEADERS_SENT("remove");
+		let t = e.toLowerCase();
+		switch (t) {
+			case "connection":
+				this._removedConnection = !0;
+				break;
+			case "content-length":
+				this._removedContLen = !0;
+				break;
+			case "transfer-encoding":
+				this._removedTE = !0;
+				break;
+			case "date":
+				this.sendDate = !1;
+				break;
+		}
+		this[kOutHeaders] !== null && delete this[kOutHeaders][t];
+	}
+	_implicitHeader() {
+		throw new ERR_METHOD_NOT_IMPLEMENTED("_implicitHeader()");
+	}
+	get headersSent() {
+		return !!this._header;
+	}
+	write(e, t, n) {
+		typeof t == "function" && (n = t, t = null);
+		let r = write_(this, e, t, n, !1);
+		return r || (this[kNeedDrain] = !0), r;
+	}
+	addTrailers(e) {
+		this._trailer = "";
+		let t = Array.isArray(e), n = t ? [...e.keys()] : Object.keys(e);
+		for (let r = 0, i = n.length; r < i; r++) {
+			let i, a;
+			if (t) {
+				let t = e, o = n[r];
+				i = t[o][0], a = t[o][1];
+			} else {
+				let t = e, o = n[r];
+				i = o, a = t[o];
+			}
+			if (validateHeaderName(i, "Trailer name"), Array.isArray(a) && a.length > 1 && (!this[kUniqueHeaders] || !this[kUniqueHeaders].has(i.toLowerCase()))) for (let e = 0, t = a.length; e < t; e++) {
+				if (checkInvalidHeaderChar$1(a[e])) throw `${i}${e}`, new ERR_INVALID_CHAR("trailer content", i);
+				this._trailer += i + ": " + a[e] + "\r\n";
+			}
+			else {
+				if (Array.isArray(a) && (a = a.join("; ")), checkInvalidHeaderChar$1(String(a))) throw `${i}`, new ERR_INVALID_CHAR("trailer content", i);
+				this._trailer += i + ": " + a + "\r\n";
+			}
+		}
+	}
+	end(e, t, n) {
+		if (typeof e == "function" ? (n = e, e = null, t = null) : typeof t == "function" && (n = t, t = null), e) {
+			if (this.finished) return onError(this, new ERR_STREAM_WRITE_AFTER_END(), typeof n == "function" ? n : nop), this;
+			this._writtenDataBuffer != null && this._writtenDataBuffer.cork(), write_(this, e, t, null, !0);
+		} else if (this.finished) return typeof n == "function" && (this.writableFinished ? n(new ERR_STREAM_ALREADY_FINISHED("end")) : this.on("finish", n)), this;
+		else this._header || (this._writtenDataBuffer != null && this._writtenDataBuffer.cork(), this._contentLength = 0, this._implicitHeader());
+		if (typeof n == "function" && this.once("finish", n), strictContentLength(this) && this[kBytesWritten] !== this._contentLength) throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten], this._contentLength);
+		let r = onFinish.bind(void 0, this);
+		return this._hasBody && this.chunkedEncoding || !this._headerSent || this.writableLength || e ? this._send("", "latin1", r) : setTimeout(r, 0), this._writtenDataBuffer != null && this._writtenDataBuffer.uncork(), this[kCorked] = 1, this.uncork(), this.finished = !0, this.outputData.length === 0 && this._writtenDataBuffer != null && this._finish(), this;
+	}
+	_finish() {
+		this.emit("prefinish");
+	}
+	_flush() {
+		if (this._writtenDataBuffer != null) {
+			let e = this._flushOutput(this._writtenDataBuffer);
+			this.finished ? this._finish() : e && this[kNeedDrain] && (this[kNeedDrain] = !1, this.emit("drain"));
+		}
+	}
+	_flushOutput(e) {
+		for (; this[kCorked];) this[kCorked]--, e.cork();
+		let t = this.outputData.length;
+		if (t <= 0) return;
+		let n = this.outputData;
+		e.cork();
+		let r;
+		for (let i = 0; i < t; i++) {
+			let { data: t, encoding: a, callback: o } = n[i];
+			n[i].data = null, r = e.write(t ?? "", a, o);
+		}
+		return e.uncork(), this.outputData = [], this._onPendingData(-this.outputSize), this.outputSize = 0, r;
+	}
+	flushHeaders() {
+		this._header || this._implicitHeader(), this._send("");
+	}
+	pipe(e) {
+		return this.emit("error", new ERR_STREAM_CANNOT_PIPE()), e;
+	}
+};
+function processHeader(e, t, n, r, i) {
+	if (i && validateHeaderName(n), isContentDispositionField(n) && e._contentLength) if (Array.isArray(r)) for (let e = 0; e < r.length; e++) r[e] = String(Buffer.from(String(r[e]), "latin1"));
+	else r = String(Buffer.from(String(r), "latin1"));
+	if (Array.isArray(r)) {
+		if ((r.length < 2 || !isCookieField(n)) && (!e[kUniqueHeaders] || !e[kUniqueHeaders].has(n.toLowerCase()))) {
+			for (let a = 0; a < r.length; a++) storeHeader(e, t, n, r[a], i);
+			return;
+		}
+		r = r.join("; ");
+	}
+	storeHeader(e, t, n, String(r), i);
+}
+function storeHeader(e, t, n, r, i) {
+	i && validateHeaderValue(n, r), t.header += n + ": " + r + "\r\n", matchHeader(e, t, n, r);
+}
+function validateHeaderName(e, t) {
+	if (typeof e != "string" || !e || !checkIsHttpToken(e)) throw new ERR_INVALID_HTTP_TOKEN(t || "Header name", e);
+}
+function validateHeaderValue(e, t) {
+	if (t === void 0) throw new ERR_HTTP_INVALID_HEADER_VALUE(String(t), e);
+	if (checkInvalidHeaderChar$1(String(t))) throw `${e}`, new ERR_INVALID_CHAR("header content", e);
+}
+function matchHeader(e, t, n, r) {
+	if (!(n.length < 4 || n.length > 17)) switch (n = n.toLowerCase(), n) {
+		case "connection":
+			t.connection = !0, e._removedConnection = !1, RE_CONN_CLOSE.exec(r) === null ? e.shouldKeepAlive = !0 : e._last = !0;
+			break;
+		case "transfer-encoding":
+			t.te = !0, e._removedTE = !1, chunkExpression.exec(r) !== null && (e.chunkedEncoding = !0);
+			break;
+		case "content-length":
+			t.contLen = !0, e._contentLength = +r, e._removedContLen = !1;
+			break;
+		case "date":
+		case "expect":
+		case "trailer":
+			t[n] = !0;
+			break;
+		case "keep-alive":
+			e._defaultKeepAlive = !1;
+			break;
+	}
+}
+function onError(e, t, n) {
+	e.destroyed || setTimeout(emitErrorNt, 0, e, t, n);
+}
+function emitErrorNt(e, t, n) {
+	n(t), typeof e.emit == "function" && !e.destroyed && e.emit("error", t);
+}
+function strictContentLength(e) {
+	return e.strictContentLength && e._contentLength != null && e._hasBody && !e._removedContLen && !e.chunkedEncoding && !e.hasHeader("transfer-encoding");
+}
+function write_(e, t, n, r, i) {
+	if (typeof r != "function" && (r = nop), t === null) throw new ERR_STREAM_NULL_VALUES();
+	if (typeof t != "string" && !isUint8Array(t)) throw new ERR_INVALID_ARG_TYPE("chunk", [
+		"string",
+		"Buffer",
+		"Uint8Array"
+	], t);
+	let a;
+	if (e.finished ? a = new ERR_STREAM_WRITE_AFTER_END() : e.destroyed && (a = new ERR_STREAM_DESTROYED("write")), a) return e.destroyed ? setTimeout(r, 0, a) : onError(e, a, r), !1;
+	let o;
+	if (e.strictContentLength) {
+		if (o ??= typeof t == "string" ? Buffer.byteLength(t, n ?? void 0) : t.byteLength, strictContentLength(e) && (i ? e[kBytesWritten] + o !== e._contentLength : e[kBytesWritten] + o > (e._contentLength ?? 0))) throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(o + e[kBytesWritten], e._contentLength);
+		e[kBytesWritten] += o;
+	}
+	if (e._header || (i && (o ??= typeof t == "string" ? Buffer.byteLength(t, n ?? void 0) : t.byteLength, e._contentLength = o), e._implicitHeader()), !e._hasBody) {
+		if (e[kRejectNonStandardBodyWrites]) throw new ERR_HTTP_BODY_NOT_ALLOWED();
+		return setTimeout(r, 0), !0;
+	}
+	!i && e._writtenDataBuffer != null && !e._writtenDataBuffer.writableCorked && (e._writtenDataBuffer.cork(), setTimeout(connectionCorkNT, 0, e._writtenDataBuffer));
+	let s;
+	return e.chunkedEncoding && t.length !== 0 ? (o ??= typeof t == "string" ? Buffer.byteLength(t, n ?? void 0) : t.byteLength, e[kCorked] && e._headerSent ? (e[kChunkedBuffer].push({
+		data: t,
+		encoding: n,
+		callback: r
+	}), e[kChunkedLength] += o, s = e[kChunkedLength] < e[kHighWaterMark]) : s = e._send(t, n, r, o)) : s = e._send(t, n, r, o), "" + s, s;
+}
+function connectionCorkNT(e) {
+	e.uncork();
+}
+function onFinish(e) {
+	e.emit("finish");
+}
+Object.defineProperties(FetchOutgoingMessage.prototype, {
+	errored: { get() {
+		return this[kErrored];
+	} },
+	closed: { get() {
+		return this._closed;
+	} },
+	writableFinished: { get() {
+		return this.finished && this.outputSize === 0 && (this._writtenDataBuffer == null || this._writtenDataBuffer.writableLength === 0);
+	} },
+	writableObjectMode: { get() {
+		return !1;
+	} },
+	writableLength: { get() {
+		return this.outputSize + this[kChunkedLength] + (this._writtenDataBuffer == null ? 0 : this._writtenDataBuffer.writableLength);
+	} },
+	writableHighWaterMark: { get() {
+		return this._writtenDataBuffer == null ? this[kHighWaterMark] : this._writtenDataBuffer.writableHighWaterMark;
+	} },
+	writableCorked: { get() {
+		return this[kCorked];
+	} },
+	writableEnded: { get() {
+		return this.finished;
+	} },
+	writableNeedDrain: { get() {
+		return !this.destroyed && !this.finished && this[kNeedDrain];
+	} }
+});
+var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+function checkInvalidHeaderChar(e) {
+	return headerCharRegex.test(e);
+}
+const STATUS_CODES = {
+	100: "Continue",
+	101: "Switching Protocols",
+	102: "Processing",
+	103: "Early Hints",
+	200: "OK",
+	201: "Created",
+	202: "Accepted",
+	203: "Non-Authoritative Information",
+	204: "No Content",
+	205: "Reset Content",
+	206: "Partial Content",
+	207: "Multi-Status",
+	208: "Already Reported",
+	226: "IM Used",
+	300: "Multiple Choices",
+	301: "Moved Permanently",
+	302: "Found",
+	303: "See Other",
+	304: "Not Modified",
+	305: "Use Proxy",
+	307: "Temporary Redirect",
+	308: "Permanent Redirect",
+	400: "Bad Request",
+	401: "Unauthorized",
+	402: "Payment Required",
+	403: "Forbidden",
+	404: "Not Found",
+	405: "Method Not Allowed",
+	406: "Not Acceptable",
+	407: "Proxy Authentication Required",
+	408: "Request Timeout",
+	409: "Conflict",
+	410: "Gone",
+	411: "Length Required",
+	412: "Precondition Failed",
+	413: "Payload Too Large",
+	414: "URI Too Long",
+	415: "Unsupported Media Type",
+	416: "Range Not Satisfiable",
+	417: "Expectation Failed",
+	418: "I'm a Teapot",
+	421: "Misdirected Request",
+	422: "Unprocessable Entity",
+	423: "Locked",
+	424: "Failed Dependency",
+	425: "Too Early",
+	426: "Upgrade Required",
+	428: "Precondition Required",
+	429: "Too Many Requests",
+	431: "Request Header Fields Too Large",
+	451: "Unavailable For Legal Reasons",
+	500: "Internal Server Error",
+	501: "Not Implemented",
+	502: "Bad Gateway",
+	503: "Service Unavailable",
+	504: "Gateway Timeout",
+	505: "HTTP Version Not Supported",
+	506: "Variant Also Negotiates",
+	507: "Insufficient Storage",
+	508: "Loop Detected",
+	509: "Bandwidth Limit Exceeded",
+	510: "Not Extended",
+	511: "Network Authentication Required"
+};
+var FetchServerResponse = class e extends FetchOutgoingMessage {
+	static encoder = new TextEncoder();
+	statusCode = 200;
+	statusMessage;
+	_sent100;
+	_expect_continue;
+	[kOutHeaders] = null;
+	constructor(e, t) {
+		super(e, t), e.method === "HEAD" && (this._hasBody = !1), this.sendDate = !0, this._sent100 = !1, this._expect_continue = !1, (e.httpVersionMajor < 1 || e.httpVersionMinor < 1) && (this.useChunkedEncodingByDefault = chunkExpression.exec(String(e.headers.te)) !== null, this.shouldKeepAlive = !1), this.fetchResponse = new Promise((e) => {
+			let t = !1;
+			this.on("finish", () => {
+				t = !0;
+			});
+			let n = [], r = (e) => {
+				t || (n[e.index] = this.dataFromDataWrittenEvent(e));
+			};
+			this.on("_dataWritten", r), this.on("_headersSent", (i) => {
+				this.off("_dataWritten", r);
+				let { statusCode: a, statusMessage: o, headers: s } = i;
+				e(this._toFetchResponse(a, o, s, n, t));
+			});
+		});
+	}
+	dataFromDataWrittenEvent(t) {
+		let { index: n, entry: r } = t, { data: i, encoding: a } = r;
+		if (n === 0) {
+			if (typeof i != "string") throw console.error("First chunk should be string, not sure what happened."), new ERR_INVALID_ARG_TYPE("packet.data", [
+				"string",
+				"Buffer",
+				"Uint8Array"
+			], i);
+			i = i.slice(this.writtenHeaderBytes);
+		}
+		return typeof i == "string" && (i = a === void 0 || a === "utf8" || a === "utf-8" ? e.encoder.encode(i) : Buffer.from(i, a ?? void 0)), i ?? Buffer.from([]);
+	}
+	_finish() {
+		super._finish();
+	}
+	assignSocket(e) {
+		throw new ERR_METHOD_NOT_IMPLEMENTED("assignSocket");
+	}
+	detachSocket(e) {
+		throw new ERR_METHOD_NOT_IMPLEMENTED("detachSocket");
+	}
+	writeContinue(e) {
+		this._writeRaw("HTTP/1.1 100 Continue\r\n\r\n", "ascii", e), this._sent100 = !0;
+	}
+	writeProcessing(e) {
+		this._writeRaw("HTTP/1.1 102 Processing\r\n\r\n", "ascii", e);
+	}
+	writeEarlyHints(e, t) {
+		let n = "HTTP/1.1 103 Early Hints\r\n";
+		if (e.link === null || e.link === void 0) return;
+		let r = validateLinkHeaderValue(e.link);
+		if (r.length !== 0) {
+			n += "Link: " + r + "\r\n";
+			for (let t of Object.keys(e)) t !== "link" && (n += t + ": " + e[t] + "\r\n");
+			n += "\r\n", this._writeRaw(n, "ascii", t);
+		}
+	}
+	_implicitHeader() {
+		this.writeHead(this.statusCode);
+	}
+	writeHead(e, t, n) {
+		if (this._header) throw new ERR_HTTP_HEADERS_SENT("write");
+		let r = e;
+		if (e |= 0, e < 100 || e > 999) throw new ERR_HTTP_INVALID_STATUS_CODE(r);
+		typeof t == "string" ? this.statusMessage = t : (this.statusMessage ||= STATUS_CODES[e] || "unknown", n ??= t), this.statusCode = e;
+		let i;
+		if (this[kOutHeaders]) {
+			let e;
+			if (Array.isArray(n)) {
+				if (n.length % 2 != 0) throw new ERR_INVALID_ARG_VALUE("headers", n);
+				for (let t = 0; t < n.length; t += 2) e = n[t + 0], this.removeHeader(String(e));
+				for (let t = 0; t < n.length; t += 2) e = n[t], e && this.appendHeader(String(e), n[t + 1]);
+			} else if (n) {
+				let t = Object.keys(n);
+				for (let r = 0; r < t.length; r++) e = t[r], e && this.setHeader(e, n[e]);
+			}
+			i = this[kOutHeaders];
+		} else i = n;
+		if (checkInvalidHeaderChar(this.statusMessage)) throw new ERR_INVALID_CHAR("statusMessage");
+		let a = `HTTP/1.1 ${e} ${this.statusMessage}\r\n`;
+		(e === 204 || e === 304 || e >= 100 && e <= 199) && (this._hasBody = !1), this._expect_continue && !this._sent100 && (this.shouldKeepAlive = !1);
+		let o = i;
+		return this._storeHeader(a, o ?? null), this;
+	}
+	writeHeader = this.writeHead;
+	fetchResponse;
+	_toFetchResponse(e, t, n, r, i) {
+		let a = new Headers();
+		for (let [e, t] of n) a.append(e, t);
+		let o = this, s = this._hasBody ? new ReadableStream({ start(e) {
+			for (let t of r) e.enqueue(t);
+			i ? e.close() : (o.on("finish", () => {
+				i = !0, e.close();
+			}), o.on("_dataWritten", (t) => {
+				if (i) return;
+				let n = o.dataFromDataWrittenEvent(t);
+				e.enqueue(n);
+			}));
+		} }) : null;
+		if (s != null && typeof FixedLengthStream < "u") {
+			let e = parseInt(a.get("content-length") ?? "", 10);
+			e >= 0 && (s = s.pipeThrough(new FixedLengthStream(e)));
+		}
+		return new Response(s, {
+			status: e,
+			statusText: t,
+			headers: a
+		});
+	}
+};
+function toReqRes(e, t) {
+	let { createIncomingMessage: n = () => new FetchIncomingMessage(), createServerResponse: r = (e) => new FetchServerResponse(e), ctx: i } = t ?? {}, a = n(i), o = r(a, i), s = new URL(e.url);
+	a.httpVersionMajor = 1, a.httpVersionMinor = 1, a.httpVersion = "1.1", a.url = s.pathname + s.search, a.upgrade = !1;
+	let c = [];
+	for (let [t, n] of e.headers) c.push(t), c.push(n);
+	return a._addHeaderLines(c, c.length), a.method = e.method, a._stream = e.body, {
+		req: a,
+		res: o
+	};
+}
+function toFetchResponse(e) {
+	if (!(e instanceof FetchServerResponse)) throw Error("toFetchResponse must be called on a ServerResponse generated by toReqRes");
+	return e.fetchResponse;
+}
+var serverStarted = !1, setApp = () => {};
+function bootstrapApp(e) {
+	let o = e.port ?? 3e3;
+	if (serverStarted) setApp(e.app);
+	else {
+		let s = e.app;
+		setApp = (e) => {
+			s = e;
+		}, Bun.serve({
+			async fetch(e) {
+				let o = new URL(e.url), c = decodeURIComponent(o.pathname);
+				if (process.env.NODE_ENV === "development") {
+					let t = __POTOK_DEV__?.vite;
+					if (t) {
+						let n = await new Promise((n) => {
+							let { req: r, res: i } = toReqRes(e), a = i.end.bind(i);
+							i.end = (...e) => {
+								let t = a(...e);
+								return n(toFetchResponse(t)), t;
+							}, t.middlewares(r, i, () => {
+								n(void 0);
+							});
+						});
+						if (n) return n;
+					}
+				}
+				if (/\.[a-z0-9]+$/i.test(c)) {
+					let e = Bun.file(path.join(process.cwd(), "dist", c));
+					if (await e.exists()) return new Response(e, { headers: { "Content-Type": e.type } });
+				}
+				let l = await renderToString(fragment({ children: [s(e), PortalIn({
+					name: "lib-scripts",
+					children: __POTOK_DEV__ ? fragment({ children: [htmlElement({
+						tag: "script",
+						type: "module",
+						src: "/@vite/client"
+					}), htmlElement({
+						tag: "script",
+						type: "module",
+						src: "/src/client.ts"
+					})] }) : htmlElement({
+						tag: "script",
+						type: "module",
+						src: `/${CLIENT_ENTRY_FILE_NAME}.js`
+					})
+				})] }));
+				return new Response(l, { headers: { "Content-Type": "text/html; charset=utf-8" } });
+			},
+			port: o
+		}), serverStarted = !0, console.log(`Приложение запущено на порте ${o}`);
+	}
+}
+export { bootstrapApp };