@fkn/lib 0.9.23 → 0.9.25

package/dgram.js

@@ -1,2 +1,406 @@
-import { n as e, r as t, t as n } from "./dgram-DHQcHefn.js";
-export { n as Socket, e as createSocket, t as default };
+import { t as e } from "./rolldown-runtime-Dy4uBu1J.js";
+import { o as t } from "./api-DLvscoll.js";
+import { t as n } from "./busy-B189uX--.js";
+import { l as r, n as i, o as a, s as o } from "./utils-C-cAd4r4.js";
+import "./wire.js";
+import { Buffer as s } from "buffer";
+import { EventEmitter as c } from "events";
+import { Address4 as l, Address6 as u } from "ip-address";
+//#region src/webvpn/dgram.ts
+var d = /* @__PURE__ */ e({
+	Socket: () => f,
+	createSocket: () => v,
+	default: () => y
+}), f = class extends c {
+	_type;
+	_localAddress;
+	_remoteAddress;
+	_connectedLocally;
+	_connectGeneration = 0;
+	_destroyed = !1;
+	_busyRelease;
+	_webVPNUdpSocketPromise;
+	_dataPort;
+	_socketId;
+	_sendQueue = [];
+	_sendQueueBytes = 0;
+	_sendFlushScheduled = !1;
+	_peerTailCache = /* @__PURE__ */ new Map();
+	constructor(e) {
+		if (super(e), !e) throw Error("Missing options");
+		this._type = e.type, e.connection && this.__webvpn_udp_socket_init__(e.connection);
+	}
+	_lastRecvBufferSize = 0;
+	_lastSendBufferSize = 0;
+	_lastTtl = 64;
+	_lastMulticastTtl = 1;
+	_lastMulticastLoopback = !0;
+	_setUdpOption(e) {
+		if (!this._webVPNUdpSocketPromise) {
+			this.emit("error", /* @__PURE__ */ Error("Cannot set socket option before bind"));
+			return;
+		}
+		this._webVPNUdpSocketPromise.then(async (t) => {
+			if (t) try {
+				await t.setOption(e);
+			} catch (e) {
+				this.emit("error", e);
+			}
+		});
+	}
+	_dataPortAcks = !1;
+	_dataPortConsumedBytes = 0;
+	_dataPortAckedBytes = 0;
+	_ackDataPortBatch(e) {
+		if (!this._dataPortAcks || !this._dataPort || (this._dataPortConsumedBytes += e, this._dataPortAckedBytes !== 0 && this._dataPortConsumedBytes - this._dataPortAckedBytes < 524288)) return;
+		this._dataPortAckedBytes = this._dataPortConsumedBytes;
+		let t = {
+			type: i,
+			consumedBytes: this._dataPortConsumedBytes
+		};
+		this._dataPort.postMessage(t);
+	}
+	_onTransportClosed(e) {
+		this._destroyed || (this._destroyed = !0, this._busyRelease?.(), this._dataPort?.close(), this._dataPort = void 0, this.listenerCount("error") > 0 && this.emit("error", Error(e || "WebVPN session closed")), this.emit("close"));
+	}
+	_onDataPortBatch(e) {
+		let t = new DataView(e), n = !1, r, i = 0;
+		for (; i + 4 <= e.byteLength;) {
+			let a = t.getUint32(i);
+			i += 4;
+			let o = i + a;
+			if (o > e.byteLength) break;
+			let c = i + 4, l = t.getUint8(c);
+			c += 1;
+			let u, d, f;
+			if (l === 2) {
+				if (!this._remoteAddress) {
+					i = o;
+					continue;
+				}
+				u = this._remoteAddress.address, d = this._remoteAddress.family, f = this._remoteAddress.port;
+			} else {
+				let n = new Uint8Array(e, c, l === 0 ? 4 : 16);
+				l === 0 ? (d = "IPv4", u = `${n[0]}.${n[1]}.${n[2]}.${n[3]}`) : (d = "IPv6", u = g(n)), c += n.byteLength, f = t.getUint16(c), c += 2;
+			}
+			let p = t.getUint32(c);
+			c += 4;
+			try {
+				this.emit("message", s.from(e.slice(c, c + p)), {
+					address: u,
+					family: d,
+					port: f,
+					size: p
+				});
+			} catch (e) {
+				n || (n = !0, r = e);
+			}
+			i = o;
+		}
+		if (n) throw r;
+	}
+	_peerTail(e, t) {
+		if (e === void 0 || t === void 0) return p;
+		let n = `${e}|${t}`, r = this._peerTailCache.get(n);
+		if (r) return r;
+		let i = l.isValid(e) ? h(e) : _(e), a = new Uint8Array(1 + i.byteLength + 2);
+		return a[0] = i.byteLength === 4 ? 0 : 1, a.set(i, 1), new DataView(a.buffer).setUint16(1 + i.byteLength, t), this._peerTailCache.size >= 4096 && this._peerTailCache.clear(), this._peerTailCache.set(n, a), a;
+	}
+	_portSend(e, t, n) {
+		let r = this._peerTail(t, n), i = new Uint8Array(8 + r.byteLength + 4 + e.byteLength), a = new DataView(i.buffer);
+		a.setUint32(0, i.byteLength - 4), a.setUint32(4, this._socketId), i.set(r, 8), a.setUint32(8 + r.byteLength, e.byteLength), i.set(e, 12 + r.byteLength), this._sendQueue.push(i), this._sendQueueBytes += i.byteLength, !this._sendFlushScheduled && (this._sendFlushScheduled = !0, queueMicrotask(() => {
+			this._sendFlushScheduled = !1;
+			let e = this._sendQueue, t = this._sendQueueBytes;
+			if (this._sendQueue = [], this._sendQueueBytes = 0, !e.length || !this._dataPort) return;
+			let n = new Uint8Array(t), r = 0;
+			for (let t of e) n.set(t, r), r += t.byteLength;
+			this._dataPort.postMessage(n.buffer, [n.buffer]);
+		}));
+	}
+	addMembership(e, t) {
+		if (l.isValid(e)) {
+			let n = h(e), r = t && l.isValid(t) ? h(t) : new Uint8Array([
+				0,
+				0,
+				0,
+				0
+			]);
+			this._setUdpOption({
+				type: 5,
+				group: n,
+				interface: r
+			});
+		} else if (u.isValid(e)) {
+			let t = _(e);
+			this._setUdpOption({
+				type: 7,
+				group: t,
+				ifIndex: 0
+			});
+		} else this.emit("error", /* @__PURE__ */ Error(`Invalid multicast address: ${e}`));
+	}
+	address() {
+		if (!this._localAddress) throw Error("EBADF");
+		return this._localAddress;
+	}
+	bind(...e) {
+		let n = a(...e), r = this._type === "udp6" ? "::" : "0.0.0.0", i = this.__webvpn_udp_socket_init__(t("a udp socket").then((e) => e.cloud.webvpn.udpSocket({
+			type: this._type,
+			address: n.address ?? r,
+			port: n.port,
+			dataPort: !0
+		})));
+		return n.callback && i.then((e) => {
+			e && n.callback.call(this);
+		}), this;
+	}
+	__webvpn_udp_socket_init__(e, t) {
+		return t && (this._localAddress = {
+			address: t.localAddress,
+			family: t.localFamily,
+			port: t.localPort
+		}), this._busyRelease ??= n("udp socket"), this._webVPNUdpSocketPromise = e.then((e) => {
+			if (e.dataPort) this._socketId = e.socketId, this._dataPort = e.dataPort, this._dataPortAcks = e.dataPortAcks === !0, this._dataPort.onmessage = (e) => {
+				try {
+					this._onDataPortBatch(e.data);
+				} finally {
+					this._ackDataPortBatch(e.data.byteLength);
+				}
+			};
+			else {
+				let t = e.dataReadableStream.getReader();
+				(async () => {
+					for (;;) {
+						let { value: e, done: n } = await t.read();
+						if (n) return;
+						this.emit("message", s.from(e.data), {
+							address: e.address,
+							family: e.family,
+							port: e.port,
+							size: e.size
+						});
+					}
+				})().catch((e) => this._onTransportClosed(e instanceof Error ? e.message : void 0));
+			}
+			return e.closed?.then((e) => this._onTransportClosed(e?.reason)).catch(() => {}), this._localAddress = {
+				address: e.localAddress,
+				family: e.localFamily,
+				port: e.localPort
+			}, e;
+		}).catch((e) => {
+			this.emit("error", e);
+		}), this._webVPNUdpSocketPromise.then((e) => {
+			if (!e) {
+				this._busyRelease?.();
+				return;
+			}
+			this.emit("listening");
+		}), this._webVPNUdpSocketPromise;
+	}
+	close(e) {
+		if (!this._webVPNUdpSocketPromise) throw Error("Socket not bound");
+		return this._webVPNUdpSocketPromise.then(async (t) => {
+			if (!t) throw Error("Socket not bound");
+			let n = this._destroyed;
+			this._destroyed = !0, this._busyRelease?.(), this._dataPort?.close(), this._dataPort = void 0;
+			try {
+				await t.close();
+			} finally {
+				try {
+					e && e();
+				} finally {
+					n || this.emit("close");
+				}
+			}
+		}).catch(() => {}), this;
+	}
+	connect(...e) {
+		if (!this._webVPNUdpSocketPromise) throw Error("Socket not bound");
+		this._webVPNUdpSocketPromise.then(async (t) => {
+			if (!t) throw Error("Socket not bound");
+			let n = e[0], r = this._type === "udp6" ? "::1" : "127.0.0.1", i = typeof e[1] == "string" ? e[1] : r, a = typeof e.at(-1) == "function" ? e.at(-1) : void 0, o = await t.connect({
+				remotePort: n,
+				remoteAddress: i
+			});
+			this._connectedLocally = o?.local === !0, this._remoteAddress = o?.address ? {
+				address: o.address,
+				family: o.family,
+				port: o.port
+			} : {
+				address: i,
+				family: this._type === "udp6" ? "IPv6" : "IPv4",
+				port: n
+			}, this._connectGeneration += 1, a && a();
+		}).catch((e) => {
+			this.emit("error", e);
+		});
+	}
+	disconnect() {
+		if (!this._webVPNUdpSocketPromise) throw Error("Socket not bound");
+		if (!this._remoteAddress) throw Error("ERR_SOCKET_DGRAM_NOT_CONNECTED");
+		let e = this._remoteAddress, t = this._connectedLocally, n = this._connectGeneration;
+		this._remoteAddress = void 0, this._connectedLocally = void 0, this._webVPNUdpSocketPromise.then((e) => e?.disconnect?.()).catch((r) => {
+			this._connectGeneration === n && (this._remoteAddress = e, this._connectedLocally = t), this.emit("error", r);
+		});
+	}
+	dropMembership(e, t) {
+		if (l.isValid(e)) {
+			let n = h(e), r = t && l.isValid(t) ? h(t) : new Uint8Array([
+				0,
+				0,
+				0,
+				0
+			]);
+			this._setUdpOption({
+				type: 6,
+				group: n,
+				interface: r
+			});
+		} else if (u.isValid(e)) {
+			let t = _(e);
+			this._setUdpOption({
+				type: 8,
+				group: t,
+				ifIndex: 0
+			});
+		} else this.emit("error", /* @__PURE__ */ Error(`Invalid multicast address: ${e}`));
+	}
+	getRecvBufferSize() {
+		return this._lastRecvBufferSize;
+	}
+	getSendBufferSize() {
+		return this._lastSendBufferSize;
+	}
+	getSendQueueSize() {
+		return 0;
+	}
+	getSendQueueCount() {
+		return 0;
+	}
+	ref() {
+		return this;
+	}
+	remoteAddress() {
+		if (!this._remoteAddress) throw Error("ERR_SOCKET_DGRAM_NOT_CONNECTED");
+		return {
+			address: this._remoteAddress.address,
+			family: this._remoteAddress.family,
+			port: this._remoteAddress.port
+		};
+	}
+	send(...e) {
+		this._webVPNUdpSocketPromise || this.bind();
+		let t = o(...e), n = m(t.message), r = n;
+		if (t.hasRange) {
+			let { offset: e, length: i } = t;
+			if (!Number.isInteger(e) || e < 0 || e > n.byteLength) throw Object.assign(/* @__PURE__ */ RangeError("\"offset\" is outside of buffer bounds"), { code: "ERR_BUFFER_OUT_OF_BOUNDS" });
+			if (!Number.isInteger(i) || i < 0 || i > n.byteLength - e) throw Object.assign(/* @__PURE__ */ RangeError("\"length\" is outside of buffer bounds"), { code: "ERR_BUFFER_OUT_OF_BOUNDS" });
+			r = n.subarray(e, e + i);
+		}
+		let i = this._type === "udp6" ? "::1" : "127.0.0.1";
+		if (!this._webVPNUdpSocketPromise) throw Error("Socket not bound");
+		this._webVPNUdpSocketPromise.then((e) => {
+			if (!e) throw Error("Socket not bound");
+			let n = t.callback, a = t.address ?? i, o = this._remoteAddress !== void 0 && t.address === void 0;
+			if (this._dataPort && (o || l.isValid(a) || u.isValid(a))) {
+				this._portSend(r, o ? void 0 : a, o ? void 0 : t.port), n?.call(this, null, r.byteLength);
+				return;
+			}
+			e.send({
+				port: t.port,
+				address: a,
+				message: r.byteOffset === 0 && r.byteLength === r.buffer.byteLength ? r.buffer : r.buffer.slice(r.byteOffset, r.byteOffset + r.byteLength)
+			}).then(() => n?.call(this, null, r.byteLength), (e) => n ? n.call(this, e, 0) : this.emit("error", e));
+		});
+	}
+	setBroadcast(e) {
+		this._setUdpOption({
+			type: 0,
+			value: e
+		});
+	}
+	setMulticastInterface(e) {}
+	setMulticastLoopback(e) {
+		return this._setUdpOption({
+			type: 3,
+			value: e
+		}), this._setUdpOption({
+			type: 4,
+			value: e
+		}), this._lastMulticastLoopback = e, e;
+	}
+	setMulticastTTL(e) {
+		return this._setUdpOption({
+			type: 2,
+			value: e
+		}), this._lastMulticastTtl = e, e;
+	}
+	setRecvBufferSize(e) {
+		this._setUdpOption({
+			type: 10,
+			value: e
+		}), this._lastRecvBufferSize = e;
+	}
+	setSendBufferSize(e) {
+		this._setUdpOption({
+			type: 9,
+			value: e
+		}), this._lastSendBufferSize = e;
+	}
+	setTTL(e) {
+		return this._setUdpOption({
+			type: 1,
+			value: e
+		}), this._lastTtl = e, e;
+	}
+	unref() {
+		return this;
+	}
+	addSourceSpecificMembership(e, t, n) {}
+	dropSourceSpecificMembership(e, t, n) {}
+	async [Symbol.asyncDispose]() {
+		await new Promise((e) => {
+			this.close(e);
+		});
+	}
+}, p = new Uint8Array([2]), m = (e) => {
+	if (typeof e == "string") return r.encode(e);
+	if (e instanceof Uint8Array) return e;
+	if (ArrayBuffer.isView(e)) return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+	if (Array.isArray(e)) {
+		let t = e.map(m), n = new Uint8Array(t.reduce((e, t) => e + t.byteLength, 0)), r = 0;
+		for (let e of t) n.set(e, r), r += e.byteLength;
+		return n;
+	}
+	return new Uint8Array(e);
+}, h = (e) => {
+	let t = e.split(".").map((e) => parseInt(e, 10));
+	if (t.length !== 4 || t.some((e) => Number.isNaN(e) || e < 0 || e > 255)) throw Error(`Invalid IPv4 address: ${e}`);
+	return new Uint8Array(t);
+}, g = (e) => {
+	let t = [];
+	for (let n = 0; n < 16; n += 2) t.push(e[n] << 8 | e[n + 1]);
+	let n = -1, r = 1;
+	for (let e = 0; e < 8;) {
+		if (t[e] !== 0) {
+			e++;
+			continue;
+		}
+		let i = e;
+		for (; i < 8 && t[i] === 0;) i++;
+		i - e > r && (n = e, r = i - e), e = i;
+	}
+	return n === -1 ? t.map((e) => e.toString(16)).join(":") : `${t.slice(0, n).map((e) => e.toString(16)).join(":")}::${t.slice(n + r).map((e) => e.toString(16)).join(":")}`;
+}, _ = (e) => {
+	let t = new u(e).getBitsBase16(0, 128).match(/.{2}/g);
+	if (!t || t.length !== 16) throw Error(`Invalid IPv6 address: ${e}`);
+	return new Uint8Array(t.map((e) => parseInt(e, 16)));
+}, v = (e, t) => {
+	let n = new f(typeof e == "string" ? { type: e } : e);
+	return t && n.on("message", t), n;
+}, y = {
+	Socket: f,
+	createSocket: v
+};
+//#endregion
+export { f as Socket, v as createSocket, y as default, d as t };

package/dns.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime-BIInC43l.cjs"),t=require("./api-C-TpWHAU.cjs");var n=e.t({lookup:()=>r}),r=(e,n)=>t.t.then(t=>t.cloud.dns.lookup(e,n));exports.lookup=r,Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return n}});
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime-BIInC43l.cjs"),t=require("./api-BCJO3EWi.cjs");var n=e.t({lookup:()=>r}),r=(e,n)=>t.a.then(t=>t.cloud.dns.lookup(e,n));exports.lookup=r,Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return n}});

package/dns.d.ts

@@ -1,6 +1,4 @@
-import { t as AddressLookupResult } from "./lookup-BtwWaCZJ.js";
-
-//#region src/lib/dns.d.ts
+import { n as AddressLookupResult } from "./contract-D6ksmIm6.js";
 declare namespace dns_d_exports {
   export { AddressLookupResult, lookup };
 }

package/dns.js

@@ -1,6 +1,6 @@
 import { t as e } from "./rolldown-runtime-Dy4uBu1J.js";
-import { t } from "./api-Jq4OSTp1.js";
-//#region src/lib/dns.ts
+import { a as t } from "./api-DLvscoll.js";
+//#region src/dns.ts
 var n = /* @__PURE__ */ e({ lookup: () => r }), r = (e, n) => t.then((t) => t.cloud.dns.lookup(e, n));
 //#endregion
 export { r as lookup, n as t };