@fkn/lib 0.4.9 → 0.5.0

package/http.js

@@ -0,0 +1,541 @@
+import { n as e } from "./chunk-CPXzm0be.js";
+import "./api-ByfayMm1.js";
+import "./utils-CNydj3OT.js";
+import { n as t, t as n } from "./net-Bl6_W3bd.js";
+import { Buffer as r } from "buffer";
+import { Stream as i } from "stream";
+//#region src/lib/webvpn/http.ts
+var a = /* @__PURE__ */ e({
+	Agent: () => T,
+	ClientRequest: () => C,
+	HTTPParser: () => _,
+	IncomingMessage: () => y,
+	METHODS: () => s,
+	STATUS_CODES: () => c,
+	Server: () => w,
+	ServerResponse: () => x,
+	_default: () => A,
+	createServer: () => k,
+	default: () => A,
+	get: () => O,
+	globalAgent: () => E,
+	request: () => D
+}), o = new TextDecoder("latin1"), s = /* @__PURE__ */ "ACL.BIND.CHECKOUT.CONNECT.COPY.DELETE.GET.HEAD.LINK.LOCK.M-SEARCH.MERGE.MKACTIVITY.MKCALENDAR.MKCOL.MOVE.NOTIFY.OPTIONS.PATCH.POST.PROPFIND.PROPPATCH.PURGE.PUT.REBIND.REPORT.SEARCH.SOURCE.SUBSCRIBE.TRACE.UNBIND.UNLINK.UNLOCK.UNSUBSCRIBE".split("."), c = {
+	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"
+}, l = new Set([
+	"content-type",
+	"content-length",
+	"user-agent",
+	"referer",
+	"host",
+	"authorization",
+	"proxy-authorization",
+	"if-modified-since",
+	"if-unmodified-since",
+	"from",
+	"location",
+	"max-forwards",
+	"retry-after",
+	"etag",
+	"last-modified",
+	"server",
+	"age",
+	"expires"
+]), u = 13, d = 10, f = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/, p = (e, t) => (e.code = t, e), m = (e, t) => {
+	if (e.length === 0) return t;
+	if (t.length === 0) return e;
+	let n = new Uint8Array(e.length + t.length);
+	return n.set(e, 0), n.set(t, e.length), n;
+}, h = (e, t) => {
+	for (let n = t; n + 1 < e.length; n++) if (e[n] === u && e[n + 1] === d) return n;
+	return -1;
+}, g = (e) => {
+	for (let t = 0; t + 3 < e.length; t++) if (e[t] === u && e[t + 1] === d && e[t + 2] === u && e[t + 3] === d) return t;
+	return -1;
+}, _ = class {
+	buf = new Uint8Array();
+	state = "HEAD";
+	framing = "none";
+	bodyRemaining = 0;
+	chunkState = "size";
+	skipBody = !1;
+	constructor(e, t) {
+		this.mode = e, this.handlers = t;
+	}
+	execute(e) {
+		this.buf = m(this.buf, e);
+		let t = !0;
+		for (; t;) if (t = !1, this.state === "HEAD") {
+			let e = g(this.buf);
+			if (e === -1) return;
+			let n = this.buf.subarray(0, e);
+			this.buf = this.buf.subarray(e + 4);
+			let r = this.parseHead(n);
+			this.handlers.onHeaders(r), this.setupBody(r), this.framing === "none" ? (this.handlers.onComplete(), this.reset(), t = this.buf.length > 0) : (this.state = "BODY", t = !0);
+		} else this.consumeBody() && (this.handlers.onComplete(), this.reset(), t = this.buf.length > 0);
+	}
+	finish() {
+		this.state === "BODY" && this.framing === "eof" && (this.handlers.onComplete(), this.reset());
+	}
+	reset() {
+		this.state = "HEAD", this.framing = "none", this.bodyRemaining = 0, this.chunkState = "size", this.skipBody = !1;
+	}
+	parseHead(e) {
+		let t = o.decode(e).split("\r\n"), n = t.shift() ?? "", r = [];
+		for (let e of t) (e.startsWith(" ") || e.startsWith("	")) && r.length > 0 ? r[r.length - 1] += " " + e.trim() : r.push(e);
+		let i = [], a = {};
+		for (let e of r) {
+			if (!e) continue;
+			let t = e.indexOf(":");
+			if (t === -1) continue;
+			let n = e.slice(0, t).trim(), r = e.slice(t + 1).trim();
+			i.push(n, r), this.addHeader(a, n, r);
+		}
+		let s = {
+			httpVersionMajor: 1,
+			httpVersionMinor: 1,
+			httpVersion: "1.1",
+			headers: a,
+			rawHeaders: i
+		};
+		if (this.mode === "request") {
+			let [e, t, r] = n.split(" ");
+			s.method = (e ?? "GET").toUpperCase(), s.url = t ?? "/", this.applyVersion(s, r);
+		} else {
+			let e = n.indexOf(" "), t = n.slice(0, e), r = n.slice(e + 1), i = r.indexOf(" "), a = i === -1 ? r : r.slice(0, i);
+			s.statusCode = parseInt(a, 10) || 0, s.statusMessage = i === -1 ? "" : r.slice(i + 1), this.applyVersion(s, t);
+		}
+		return s;
+	}
+	applyVersion(e, t) {
+		let n = /HTTP\/(\d)\.(\d)/i.exec(t ?? "");
+		n && (e.httpVersionMajor = parseInt(n[1], 10), e.httpVersionMinor = parseInt(n[2], 10), e.httpVersion = `${e.httpVersionMajor}.${e.httpVersionMinor}`);
+	}
+	addHeader(e, t, n) {
+		let r = t.toLowerCase();
+		if (r === "set-cookie") {
+			let t = e["set-cookie"];
+			Array.isArray(t) ? t.push(n) : e["set-cookie"] = [n];
+			return;
+		}
+		let i = e[r];
+		i === void 0 ? e[r] = n : l.has(r) || (e[r] = `${i}, ${n}`);
+	}
+	setupBody(e) {
+		if (this.skipBody) {
+			this.framing = "none";
+			return;
+		}
+		let t = e.headers["transfer-encoding"];
+		if (typeof t == "string" && t.toLowerCase().includes("chunked")) {
+			this.framing = "chunked", this.chunkState = "size";
+			return;
+		}
+		let n = e.headers["content-length"];
+		if (typeof n == "string" && n !== "") {
+			let e = parseInt(n, 10);
+			e > 0 ? (this.framing = "length", this.bodyRemaining = e) : this.framing = "none";
+			return;
+		}
+		if (this.mode === "response") {
+			let t = e.statusCode ?? 0;
+			t >= 100 && t < 200 || t === 204 || t === 304 ? this.framing = "none" : this.framing = "eof";
+		} else this.framing = "none";
+	}
+	consumeBody() {
+		if (this.framing === "length") {
+			if (this.buf.length === 0) return !1;
+			let e = Math.min(this.bodyRemaining, this.buf.length);
+			return this.handlers.onBody(this.buf.subarray(0, e)), this.buf = this.buf.subarray(e), this.bodyRemaining -= e, this.bodyRemaining === 0;
+		}
+		return this.framing === "eof" ? (this.buf.length > 0 && (this.handlers.onBody(this.buf), this.buf = new Uint8Array()), !1) : this.framing === "chunked" ? this.consumeChunked() : !0;
+	}
+	consumeChunked() {
+		for (;;) if (this.chunkState === "size") {
+			let e = h(this.buf, 0);
+			if (e === -1) return !1;
+			let t = o.decode(this.buf.subarray(0, e)), n = parseInt(t.split(";")[0].trim(), 16);
+			if (this.buf = this.buf.subarray(e + 2), Number.isNaN(n)) return !0;
+			n === 0 ? this.chunkState = "trailer" : (this.bodyRemaining = n, this.chunkState = "data");
+		} else if (this.chunkState === "data") {
+			if (this.buf.length === 0) return !1;
+			let e = Math.min(this.bodyRemaining, this.buf.length);
+			this.handlers.onBody(this.buf.subarray(0, e)), this.buf = this.buf.subarray(e), this.bodyRemaining -= e, this.bodyRemaining === 0 && (this.chunkState = "dataCRLF");
+		} else if (this.chunkState === "dataCRLF") {
+			if (this.buf.length < 2) return !1;
+			this.buf = this.buf.subarray(2), this.chunkState = "size";
+		} else {
+			let e = h(this.buf, 0);
+			if (e === -1) return !1;
+			let t = e === 0;
+			if (this.buf = this.buf.subarray(e + 2), t) return !0;
+		}
+	}
+}, v = (e, t) => r.isBuffer(e) ? e : typeof e == "string" ? r.from(e, t ?? "utf8") : e instanceof Uint8Array ? r.from(e) : e instanceof ArrayBuffer ? r.from(new Uint8Array(e)) : r.from(String(e)), y = class extends i.Readable {
+	httpVersion = "1.1";
+	httpVersionMajor = 1;
+	httpVersionMinor = 1;
+	headers = {};
+	rawHeaders = [];
+	trailers = {};
+	rawTrailers = [];
+	method;
+	url;
+	statusCode;
+	statusMessage;
+	complete = !1;
+	socket;
+	constructor(e) {
+		super(), this.socket = e;
+	}
+	get connection() {
+		return this.socket;
+	}
+	_applyHead(e) {
+		this.httpVersion = e.httpVersion, this.httpVersionMajor = e.httpVersionMajor, this.httpVersionMinor = e.httpVersionMinor, this.headers = e.headers, this.rawHeaders = e.rawHeaders, this.method = e.method, this.url = e.url, this.statusCode = e.statusCode, this.statusMessage = e.statusMessage;
+	}
+	_read() {}
+	setTimeout(e, t) {
+		return this.socket.setTimeout(e, t), this;
+	}
+}, b = class extends i.Writable {
+	_headerStore = /* @__PURE__ */ new Map();
+	headersSent = !1;
+	chunkedEncoding = !1;
+	finished = !1;
+	_bodyWritten = !1;
+	setHeader(e, t) {
+		if (this.headersSent) throw p(/* @__PURE__ */ Error("Cannot set headers after they are sent to the client"), "ERR_HTTP_HEADERS_SENT");
+		if (typeof e != "string" || !f.test(e)) throw p(/* @__PURE__ */ TypeError(`Header name must be a valid HTTP token [${JSON.stringify(String(e))}]`), "ERR_INVALID_HTTP_TOKEN");
+		if (t === void 0) throw p(/* @__PURE__ */ TypeError(`Invalid value "undefined" for header "${e}"`), "ERR_HTTP_INVALID_HEADER_VALUE");
+		return this._headerStore.set(e.toLowerCase(), [e, Array.isArray(t) ? [...t] : t]), this;
+	}
+	getHeader(e) {
+		return this._headerStore.get(e.toLowerCase())?.[1];
+	}
+	getHeaderNames() {
+		return [...this._headerStore.values()].map(([e]) => e);
+	}
+	getHeaders() {
+		let e = {};
+		for (let [t, n] of this._headerStore.values()) e[t] = n;
+		return e;
+	}
+	hasHeader(e) {
+		return this._headerStore.has(e.toLowerCase());
+	}
+	removeHeader(e) {
+		if (this.headersSent) throw Error("Cannot remove headers after they are sent to the client");
+		this._headerStore.delete(e.toLowerCase());
+	}
+	_storeHeader(e) {
+		let t = this.hasHeader("content-length"), n = this.getHeader("transfer-encoding");
+		typeof n == "string" && n.toLowerCase().includes("chunked") ? this.chunkedEncoding = !0 : !t && this._shouldSendBody() && (this.chunkedEncoding = !0, this.setHeader("Transfer-Encoding", "chunked"));
+		let r = e + "\r\n";
+		for (let [e, t] of this._headerStore.values()) if (Array.isArray(t)) for (let n of t) r += `${e}: ${n}\r\n`;
+		else r += `${e}: ${t}\r\n`;
+		return r += "\r\n", r;
+	}
+	_writeToSocket(e, t) {
+		if (!this.socket) {
+			t(/* @__PURE__ */ Error("Socket is not available"));
+			return;
+		}
+		this.socket.write(e, t);
+	}
+	write(e, t, n) {
+		return this._bodyWritten = !0, super.write(e, t, n);
+	}
+	_write(e, t, n) {
+		let i = v(e), a = [];
+		if (this.headersSent ||= (this._implicitHeader(), a.push(r.from(this._headBlock, "latin1")), !0), this.chunkedEncoding ? i.length > 0 && (a.push(r.from(`${i.length.toString(16)}\r\n`, "latin1")), a.push(i), a.push(r.from("\r\n", "latin1"))) : a.push(i), a.length === 0) {
+			n();
+			return;
+		}
+		this._writeToSocket(r.concat(a), n);
+	}
+	_final(e) {
+		let t = [];
+		if (this.headersSent ||= (!this.chunkedEncoding && !this.hasHeader("content-length") && this.setHeader("Content-Length", 0), this._implicitHeader(), t.push(r.from(this._headBlock, "latin1")), !0), this.chunkedEncoding && t.push(r.from("0\r\n\r\n", "latin1")), this.finished = !0, t.length === 0) {
+			e();
+			return;
+		}
+		this._writeToSocket(r.concat(t), e);
+	}
+	end(e, t, n) {
+		if (e != null && typeof e != "function" && !this._bodyWritten && !this.headersSent && !this.chunkedEncoding && !this.hasHeader("content-length")) {
+			let n = typeof t == "string" ? t : void 0;
+			this.setHeader("Content-Length", v(e, n).length);
+		}
+		return super.end(e, t, n);
+	}
+	_headBlock;
+}, x = class extends b {
+	statusCode = 200;
+	statusMessage;
+	_writeHeadCalled = !1;
+	sendDate = !0;
+	req;
+	socket;
+	_keepAlive = !0;
+	constructor(e) {
+		super(), this.req = e, this.socket = e.socket;
+	}
+	_shouldSendBody() {
+		if (this.req.method === "HEAD") return !1;
+		let e = this.statusCode;
+		return !(e >= 100 && e < 200 || e === 204 || e === 304);
+	}
+	writeHead(e, t, n) {
+		if (this._writeHeadCalled || this.headersSent) throw p(/* @__PURE__ */ Error("Cannot render headers after they are sent to the client"), "ERR_HTTP_HEADERS_SENT");
+		this._writeHeadCalled = !0, this.statusCode = e;
+		let r = n;
+		if (typeof t == "string" ? this.statusMessage = t : t != null && (r = t), Array.isArray(r)) {
+			let e = Array.isArray(r[0]) ? r : Array.from({ length: Math.floor(r.length / 2) }, (e, t) => [r[t * 2], r[t * 2 + 1]]);
+			for (let [t, n] of e) n !== void 0 && this._appendHeader(t, n);
+		} else if (r) for (let [e, t] of Object.entries(r)) t !== void 0 && this.setHeader(e, t);
+		return this;
+	}
+	_appendHeader(e, t) {
+		let n = this.getHeader(e);
+		if (n === void 0) this.setHeader(e, t);
+		else {
+			let r = [...Array.isArray(n) ? n : [n], ...Array.isArray(t) ? t : [t]].map(String);
+			this.setHeader(e, r);
+		}
+	}
+	_implicitHeader() {
+		let e = this.statusMessage ?? c[this.statusCode] ?? "unknown";
+		this.sendDate && !this.hasHeader("date") && this.setHeader("Date", (/* @__PURE__ */ new Date()).toUTCString()), this.hasHeader("connection") || this.setHeader("Connection", this._keepAlive ? "keep-alive" : "close"), this._headBlock = this._storeHeader(`HTTP/1.1 ${this.statusCode} ${e}`);
+	}
+	writeContinue() {
+		this._writeToSocket(r.from("HTTP/1.1 100 Continue\r\n\r\n", "latin1"), () => {});
+	}
+	setTimeout(e, t) {
+		return this.socket?.setTimeout(e, t), this;
+	}
+}, S = (...e) => {
+	let t = {}, n = {}, r, i = [...e], a = i.shift();
+	if (typeof a == "string" || a instanceof URL) {
+		let e = typeof a == "string" ? new URL(a) : a;
+		t = {
+			protocol: e.protocol,
+			hostname: e.hostname,
+			host: e.hostname,
+			port: e.port,
+			path: `${e.pathname}${e.search}`,
+			auth: e.username ? `${e.username}:${e.password}` : void 0
+		};
+		let o = i.shift();
+		typeof o == "function" ? r = o : o && typeof o == "object" && (n = o, r = i.shift());
+	} else a && typeof a == "object" && (n = a, r = i.shift());
+	return {
+		options: {
+			...t,
+			...n
+		},
+		callback: r
+	};
+}, C = class extends b {
+	method;
+	path;
+	host;
+	protocol;
+	socket;
+	get connection() {
+		return this.socket;
+	}
+	res = null;
+	aborted = !1;
+	_aborted = !1;
+	constructor(e, n) {
+		super(), this.method = (e.method ?? "GET").toUpperCase(), this.path = e.path ?? "/", this.protocol = e.protocol ?? "http:";
+		let i = e.hostname ?? e.host ?? "localhost";
+		this.host = i;
+		let a = Number(e.port ?? (this.protocol === "https:" ? 443 : 80));
+		if (n && this.once("response", n), e.headers) for (let [t, n] of Object.entries(e.headers)) n !== void 0 && this.setHeader(t, n);
+		if (!this.hasHeader("host")) {
+			let e = this.protocol === "https:" && a === 443 || this.protocol !== "https:" && a === 80;
+			this.setHeader("Host", e ? i : `${i}:${a}`);
+		}
+		e.auth && !this.hasHeader("authorization") && this.setHeader("Authorization", `Basic ${r.from(e.auth).toString("base64")}`), this.socket = new t(), this.emit("socket", this.socket), this.socket.on("error", (e) => {
+			this._aborted || this.emit("error", e);
+		}), this._attachResponseParser(), this.socket.connect({
+			host: i,
+			port: a
+		}, () => {
+			this.emit("connect");
+		});
+	}
+	_shouldSendBody() {
+		return this.method !== "GET" && this.method !== "HEAD" && this.method !== "DELETE";
+	}
+	_implicitHeader() {
+		this._headBlock = this._storeHeader(`${this.method} ${this.path} HTTP/1.1`);
+	}
+	_attachResponseParser() {
+		let e = new y(this.socket), t = new _("response", {
+			onHeaders: (n) => {
+				e._applyHead(n), this.method === "HEAD" && (t.skipBody = !0), this.res = e, this.emit("response", e);
+			},
+			onBody: (t) => {
+				e.push(r.from(t));
+			},
+			onComplete: () => {
+				e.complete = !0, e.push(null);
+			}
+		});
+		this.socket.on("data", (e) => {
+			this._aborted || t.execute(e);
+		}), this.socket.on("end", () => {
+			t.finish();
+		}), this.socket.on("close", () => {
+			this.emit("close");
+		});
+	}
+	abort() {
+		this._aborted || (this._aborted = !0, this.aborted = !0, this.emit("abort"), this.socket.destroy());
+	}
+	destroy(e) {
+		return this._aborted ? this : (this._aborted = !0, this.socket.destroy(e), super.destroy(e), this);
+	}
+	end(e, t, n) {
+		return this._aborted ? this : super.end(e, t, n);
+	}
+	_writeToSocket(e, t) {
+		if (this._aborted) {
+			t();
+			return;
+		}
+		super._writeToSocket(e, t);
+	}
+	setTimeout(e, t) {
+		return this.socket.setTimeout(e, t), this;
+	}
+	setNoDelay(e) {
+		this.socket.setNoDelay(e);
+	}
+	setSocketKeepAlive(e, t) {
+		this.socket.setKeepAlive(e, t);
+	}
+}, w = new Proxy(class extends n {
+	constructor(e, t) {
+		let n = {}, r = t;
+		typeof e == "function" ? r = e : e && (n = e), super(n), r && this.on("request", r), this.on("connection", (e) => this._handleConnection(e));
+	}
+	_handleConnection(e) {
+		let t = null, n = new _("request", {
+			onHeaders: (r) => {
+				t = new y(e), t._applyHead(r), r.method === "HEAD" && (n.skipBody = !0);
+				let i = new x(t), a = String(r.headers.connection ?? "").toLowerCase();
+				i._keepAlive = r.httpVersionMinor >= 1 ? a !== "close" : a === "keep-alive", i.on("finish", () => {
+					i._keepAlive || e.end();
+				}), this.emit("request", t, i);
+			},
+			onBody: (e) => {
+				t?.push(r.from(e));
+			},
+			onComplete: () => {
+				t && (t.complete = !0, t.push(null)), t = null;
+			}
+		});
+		e.on("data", (e) => n.execute(e)), e.on("end", () => {
+			n.finish(), t && t.push(null);
+		}), e.on("error", (t) => this.emit("clientError", t, e));
+	}
+}, { apply: (e, t, n) => new e(...n) }), T = class {
+	maxSockets;
+	maxFreeSockets;
+	keepAlive;
+	options;
+	constructor(e = {}) {
+		this.options = e, this.keepAlive = !!e.keepAlive, this.maxSockets = e.maxSockets ?? Infinity, this.maxFreeSockets = e.maxFreeSockets ?? 256;
+	}
+	getName(e = {}) {
+		return `${e.host ?? "localhost"}:${e.port ?? ""}:${e.localAddress ?? ""}`;
+	}
+	destroy() {}
+}, E = new T(), D = (...e) => {
+	let { options: t, callback: n } = S(...e);
+	return new C(t, n);
+}, O = (...e) => {
+	let t = D(...e);
+	return t.end(), t;
+}, k = (e, t) => new w(e, t), A = {
+	METHODS: s,
+	STATUS_CODES: c,
+	Agent: T,
+	globalAgent: E,
+	Server: w,
+	ServerResponse: x,
+	IncomingMessage: y,
+	ClientRequest: C,
+	OutgoingMessage: b,
+	createServer: k,
+	request: D,
+	get: O
+};
+//#endregion
+export { T as Agent, C as ClientRequest, _ as HTTPParser, y as IncomingMessage, s as METHODS, c as STATUS_CODES, w as Server, x as ServerResponse, A as _default, A as default, k as createServer, O as get, E as globalAgent, D as request, a as t };