@ikonai/sdk 1.10.0 → 1.11.2

package/log-type-DewKVFaU.js

@@ -0,0 +1,832 @@
+var e = 20971520, t = {
+	None: 0,
+	SendBackToSender: 1,
+	Delayable: 2,
+	SendToUser: 4,
+	Compressed: 8,
+	Unreliable: 16
+};
+function n(e) {
+	return e;
+}
+function r(e) {
+	if (e.length < 8) throw Error("Protocol message too short");
+	return (e[4] | e[5] << 8 | e[6] << 16 | e[7] << 24) >>> 0;
+}
+function i(e) {
+	return r(e) & 4294901760;
+}
+function a(e) {
+	let t = V(e), n = new DataView(t.buffer, t.byteOffset, t.byteLength);
+	if (t.length < 27) throw Error("Protocol payload too short");
+	let r = n.getUint32(0, !0), i = n.getUint32(4, !0), a = n.getUint32(8, !0), o = n.getUint32(12, !0), s = n.getUint32(16, !0), c = n.getUint32(20, !0), l = n.getUint8(24), u = n.getUint8(25), d = n.getUint8(26);
+	if (r > t.length) throw Error(`Protocol message declares ${r} bytes but carries ${t.length}`);
+	if (27 + c * 4 > t.length) throw Error("Protocol header exceeds payload length");
+	let f = [], p = 27;
+	for (let e = 0; e < c; e++) f.push(n.getUint32(p, !0)), p += 4;
+	return {
+		length: r,
+		opcode: i,
+		senderId: a,
+		trackId: o,
+		sequenceId: s,
+		targetIds: f,
+		payloadVersion: l,
+		payloadType: u,
+		flags: d
+	};
+}
+function o(e, t, n) {
+	let r = V(e), i = a(r);
+	if (t !== void 0 && i.opcode !== t) throw Error(`Unexpected opcode ${i.opcode}`);
+	if (i.payloadType !== 8) throw Error(`Unexpected payload type ${i.payloadType}`);
+	let o = 27 + i.targetIds.length * 4;
+	return r.subarray(o, i.length);
+}
+async function s(e, n, r) {
+	let i = V(e), o = a(i);
+	if (n !== void 0 && o.opcode !== n) throw Error(`Unexpected opcode ${o.opcode}`);
+	if (o.payloadType !== 8) throw Error(`Unexpected payload type ${o.payloadType}`);
+	let s = 27 + o.targetIds.length * 4, c = i.subarray(s, o.length);
+	return (o.flags & t.Compressed) !== 0 && (c = await l(c)), c;
+}
+function c(e, t, r, i, a) {
+	let o = a?.trackId ?? 0, s = a?.sequenceId ?? 0, c = a?.flags ?? 0, l = a?.targetIds ?? [], u = a?.payloadType ?? 8, d = 27 + l.length * 4, f = d + t.length, p = new Uint8Array(f), m = new DataView(p.buffer);
+	m.setUint32(0, f, !0), m.setUint32(4, e >>> 0, !0), m.setUint32(8, i >>> 0, !0), m.setUint32(12, o >>> 0, !0), m.setUint32(16, s >>> 0, !0), m.setUint32(20, l.length >>> 0, !0), m.setUint8(24, r & 255), m.setUint8(25, u & 255), m.setUint8(26, c & 255);
+	let h = 27;
+	for (let e = 0; e < l.length; e++) m.setUint32(h, l[e] >>> 0, !0), h += 4;
+	return p.set(t, d), n(p);
+}
+async function l(t) {
+	if (typeof DecompressionStream > "u") throw Error("DecompressionStream not supported");
+	let n = new DecompressionStream("gzip"), r = n.writable.getWriter(), i = new Uint8Array(t);
+	r.write(i).then(() => r.close()).catch(() => void 0);
+	let a = n.readable.getReader(), o = [], s = 0;
+	for (;;) {
+		let { done: t, value: n } = await a.read();
+		if (t) break;
+		if (o.push(n), s += n.length, s > 20971520) throw await a.cancel().catch(() => void 0), Error(`Decompressed payload exceeds the maximum of ${e} bytes`);
+	}
+	let c = new Uint8Array(s), l = 0;
+	for (let e = 0; e < o.length; e++) c.set(o[e], l), l += o[e].length;
+	return c;
+}
+var u = /* @__PURE__ */ function(e) {
+	return e[e.Null = 1] = "Null", e[e.Bool = 2] = "Bool", e[e.Int32 = 3] = "Int32", e[e.Int64 = 4] = "Int64", e[e.UInt32 = 5] = "UInt32", e[e.UInt64 = 6] = "UInt64", e[e.Float32 = 7] = "Float32", e[e.Float64 = 8] = "Float64", e[e.Array = 9] = "Array", e[e.Dict = 10] = "Dict", e[e.Object = 11] = "Object", e[e.String = 12] = "String", e[e.Binary = 13] = "Binary", e[e.Guid = 14] = "Guid", e;
+}({}), d = 161, f = 162, p = new TextEncoder(), m = new TextDecoder("utf-8", { fatal: !0 }), h = class e {
+	buffer = new D();
+	cached;
+	constructor(e = 1) {
+		this.buffer.writeByte(d), this.buffer.writeVarUInt(e >>> 0);
+	}
+	writeInt32Field(e, t) {
+		this.writeFixedField(e, 3, () => this.buffer.writeInt32(t | 0));
+	}
+	writeUInt32Field(e, t) {
+		this.writeFixedField(e, 5, () => this.buffer.writeUInt32(t >>> 0));
+	}
+	writeInt64Field(e, t) {
+		this.writeFixedField(e, 4, () => this.buffer.writeBigInt64(t));
+	}
+	writeUInt64Field(e, t) {
+		this.writeFixedField(e, 6, () => this.buffer.writeBigUInt64(t));
+	}
+	writeFloat32Field(e, t) {
+		this.writeFixedField(e, 7, () => this.buffer.writeFloat32(t));
+	}
+	writeFloat64Field(e, t) {
+		this.writeFixedField(e, 8, () => this.buffer.writeFloat64(t));
+	}
+	writeBoolField(e, t) {
+		this.writeFixedField(e, 2, () => this.buffer.writeByte(+!!t));
+	}
+	writeGuidField(e, t) {
+		let n = t instanceof E ? t.asBytes() : t;
+		if (n.length !== 16) throw Error("Guid payload must be 16 bytes");
+		this.writeFixedField(e, 14, () => this.buffer.writeBytes(n));
+	}
+	writeStringField(e, t) {
+		let n = p.encode(t ?? "");
+		this.writeVariableField(e, 12, n);
+	}
+	writeBinaryField(e, t) {
+		this.writeVariableField(e, 13, t);
+	}
+	writeObjectField(t, n, r) {
+		let i = new e(n);
+		r(i);
+		let a = i.finish();
+		this.writeVariableField(t, 11, a);
+	}
+	writeArrayField(e, t, n) {
+		let r = new g(t);
+		n(r);
+		let i = r.finish();
+		this.writeVariableField(e, 9, i);
+	}
+	writeDictionaryField(e, t, n, r) {
+		let i = new _(t, n);
+		r(i);
+		let a = i.finish();
+		this.writeVariableField(e, 10, a);
+	}
+	finish() {
+		return this.cached ||= (this.buffer.writeByte(f), this.buffer.toUint8Array()), this.cached;
+	}
+	writeFixedField(e, t, n) {
+		this.writeFieldHeader(e, t, 0), n();
+	}
+	writeVariableField(e, t, n) {
+		this.writeFieldHeader(e, t, n.length), this.buffer.writeBytes(n);
+	}
+	writeFieldHeader(e, t, n) {
+		this.buffer.writeUInt32(e >>> 0), this.buffer.writeByte(A(t)), j(t) && this.buffer.writeVarUInt(n >>> 0);
+	}
+}, g = class e {
+	elementType;
+	payload = new D();
+	count = 0;
+	constructor(e) {
+		this.elementType = e;
+	}
+	writeInt32(e) {
+		this.ensureElementType(3), this.count++, this.payload.writeInt32(e | 0);
+	}
+	writeUInt32(e) {
+		this.ensureElementType(5), this.count++, this.payload.writeUInt32(e >>> 0);
+	}
+	writeInt64(e) {
+		this.ensureElementType(4), this.count++, this.payload.writeBigInt64(e);
+	}
+	writeUInt64(e) {
+		this.ensureElementType(6), this.count++, this.payload.writeBigUInt64(e);
+	}
+	writeFloat32(e) {
+		this.ensureElementType(7), this.count++, this.payload.writeFloat32(e);
+	}
+	writeFloat64(e) {
+		this.ensureElementType(8), this.count++, this.payload.writeFloat64(e);
+	}
+	writeBool(e) {
+		this.ensureElementType(2), this.count++, this.payload.writeByte(+!!e);
+	}
+	writeGuid(e) {
+		this.ensureElementType(14), this.count++;
+		let t = e instanceof E ? e.asBytes() : e;
+		if (t.length !== 16) throw Error("Guid payload must be 16 bytes");
+		this.payload.writeBytes(t);
+	}
+	writeString(e) {
+		this.ensureElementType(12), this.count++;
+		let t = p.encode(e ?? "");
+		this.payload.writeVarUInt(t.length), this.payload.writeBytes(t);
+	}
+	writeBinary(e) {
+		this.ensureElementType(13), this.count++, this.payload.writeVarUInt(e.length), this.payload.writeBytes(e);
+	}
+	writeObject(e, t) {
+		this.ensureElementType(11), this.count++;
+		let n = new h(e);
+		t(n);
+		let r = n.finish();
+		this.payload.writeVarUInt(r.length), this.payload.writeBytes(r);
+	}
+	writeArray(t, n) {
+		this.ensureElementType(9), this.count++;
+		let r = new e(t);
+		n(r);
+		let i = r.finish();
+		this.payload.writeBytes(i);
+	}
+	writeDictionary(e, t, n) {
+		this.ensureElementType(10), this.count++;
+		let r = new _(e, t);
+		n(r);
+		let i = r.finish();
+		this.payload.writeBytes(i);
+	}
+	finish() {
+		let e = new D();
+		return e.writeByte(A(this.elementType)), e.writeVarUInt(this.count), e.writeBytes(this.payload.toUint8Array()), e.toUint8Array();
+	}
+	ensureElementType(e) {
+		if (this.elementType !== e) throw Error(`Array element type is ${u[this.elementType]}, expected ${u[e]}`);
+	}
+}, _ = class {
+	keyType;
+	valueType;
+	payload = new D();
+	count = 0;
+	entryOpen = !1;
+	constructor(e, t) {
+		this.keyType = e, this.valueType = t, N(e);
+	}
+	beginEntry() {
+		if (this.entryOpen) throw Error("Previous dictionary entry not completed");
+		return this.count++, this.entryOpen = !0, new v(this.keyType, this.valueType, this.payload, () => {
+			this.entryOpen = !1;
+		});
+	}
+	finish() {
+		if (this.entryOpen) throw Error("Dictionary entry not completed");
+		let e = new D();
+		return e.writeByte(A(this.keyType)), e.writeByte(A(this.valueType)), e.writeVarUInt(this.count), e.writeBytes(this.payload.toUint8Array()), e.toUint8Array();
+	}
+}, v = class {
+	keyType;
+	valueType;
+	payload;
+	onComplete;
+	keyWritten = !1;
+	valueWritten = !1;
+	completed = !1;
+	constructor(e, t, n, r) {
+		this.keyType = e, this.valueType = t, this.payload = n, this.onComplete = r;
+	}
+	writeKeyInt32(e) {
+		this.ensureKeyType(3), this.payload.writeInt32(e | 0), this.keyWritten = !0;
+	}
+	writeKeyUInt32(e) {
+		this.ensureKeyType(5), this.payload.writeUInt32(e >>> 0), this.keyWritten = !0;
+	}
+	writeKeyInt64(e) {
+		this.ensureKeyType(4), this.payload.writeBigInt64(e), this.keyWritten = !0;
+	}
+	writeKeyUInt64(e) {
+		this.ensureKeyType(6), this.payload.writeBigUInt64(e), this.keyWritten = !0;
+	}
+	writeKeyFloat32(e) {
+		this.ensureKeyType(7), this.payload.writeFloat32(e), this.keyWritten = !0;
+	}
+	writeKeyFloat64(e) {
+		this.ensureKeyType(8), this.payload.writeFloat64(e), this.keyWritten = !0;
+	}
+	writeKeyBool(e) {
+		this.ensureKeyType(2), this.payload.writeByte(+!!e), this.keyWritten = !0;
+	}
+	writeKeyGuid(e) {
+		this.ensureKeyType(14);
+		let t = e instanceof E ? e.asBytes() : e;
+		if (t.length !== 16) throw Error("Guid payload must be 16 bytes");
+		this.payload.writeBytes(t), this.keyWritten = !0;
+	}
+	writeKeyString(e) {
+		this.ensureKeyType(12);
+		let t = p.encode(e ?? "");
+		this.payload.writeVarUInt(t.length), this.payload.writeBytes(t), this.keyWritten = !0;
+	}
+	writeKeyBinary(e) {
+		this.ensureKeyType(13), this.payload.writeVarUInt(e.length), this.payload.writeBytes(e), this.keyWritten = !0;
+	}
+	writeValueInt32(e) {
+		this.ensureValueType(3), this.payload.writeInt32(e | 0), this.valueWritten = !0;
+	}
+	writeValueUInt32(e) {
+		this.ensureValueType(5), this.payload.writeUInt32(e >>> 0), this.valueWritten = !0;
+	}
+	writeValueInt64(e) {
+		this.ensureValueType(4), this.payload.writeBigInt64(e), this.valueWritten = !0;
+	}
+	writeValueUInt64(e) {
+		this.ensureValueType(6), this.payload.writeBigUInt64(e), this.valueWritten = !0;
+	}
+	writeValueFloat32(e) {
+		this.ensureValueType(7), this.payload.writeFloat32(e), this.valueWritten = !0;
+	}
+	writeValueFloat64(e) {
+		this.ensureValueType(8), this.payload.writeFloat64(e), this.valueWritten = !0;
+	}
+	writeValueBool(e) {
+		this.ensureValueType(2), this.payload.writeByte(+!!e), this.valueWritten = !0;
+	}
+	writeValueGuid(e) {
+		this.ensureValueType(14);
+		let t = e instanceof E ? e.asBytes() : e;
+		if (t.length !== 16) throw Error("Guid payload must be 16 bytes");
+		this.payload.writeBytes(t), this.valueWritten = !0;
+	}
+	writeNullValue() {
+		this.ensureValueType(1), this.valueWritten = !0;
+	}
+	writeValueBinary(e) {
+		this.ensureValueType(13), this.payload.writeVarUInt(e.length), this.payload.writeBytes(e), this.valueWritten = !0;
+	}
+	writeValueString(e) {
+		this.ensureValueType(12);
+		let t = p.encode(e ?? "");
+		this.payload.writeVarUInt(t.length), this.payload.writeBytes(t), this.valueWritten = !0;
+	}
+	writeValueObject(e, t) {
+		this.ensureValueType(11);
+		let n = new h(e);
+		t(n);
+		let r = n.finish();
+		this.payload.writeVarUInt(r.length), this.payload.writeBytes(r), this.valueWritten = !0;
+	}
+	writeValueArray(e, t) {
+		this.ensureValueType(9);
+		let n = new g(e);
+		t(n);
+		let r = n.finish();
+		this.payload.writeBytes(r), this.valueWritten = !0;
+	}
+	writeValueDictionary(e, t, n) {
+		this.ensureValueType(10);
+		let r = new _(e, t);
+		n(r);
+		let i = r.finish();
+		this.payload.writeBytes(i), this.valueWritten = !0;
+	}
+	complete() {
+		if (!this.completed) {
+			if (!this.keyWritten || !this.valueWritten) throw Error("Dictionary entry must write both key and value");
+			this.completed = !0, this.onComplete();
+		}
+	}
+	ensureKeyType(e) {
+		if (this.keyType !== e) throw Error(`Dictionary key type is ${u[this.keyType]}, expected ${u[e]}`);
+	}
+	ensureValueType(e) {
+		if (this.valueType !== e) throw Error(`Dictionary value type is ${u[this.valueType]}, expected ${u[e]}`);
+	}
+}, y = class e {
+	buffer;
+	version;
+	offset;
+	end;
+	constructor(e, t, n) {
+		this.buffer = e, this.version = t, this.offset = n, this.end = e.length - 1;
+	}
+	static create(t) {
+		let n = V(t);
+		if (n.length < 2) throw Error("Teleport payload too short");
+		if (n[0] !== d || n[n.length - 1] !== f) throw Error("Teleport object missing markers");
+		let r = { offset: 1 }, i = O(n, r, "InvalidLength");
+		return new e(n, i, r.offset);
+	}
+	next() {
+		if (this.offset >= this.end) return null;
+		if (this.offset + 5 > this.buffer.length) throw Error("Teleport object truncated");
+		let e = F(this.buffer, this.offset);
+		this.offset += 4;
+		let t = this.buffer[this.offset++], n = t >> 4 & 15;
+		if (t & 15) throw Error("Teleport field flags must be zero");
+		let r = M(n), i;
+		if (r >= 0) P(this.buffer, this.offset, r), i = this.buffer.subarray(this.offset, this.offset + r), this.offset += r;
+		else {
+			let e = { offset: this.offset }, t = O(this.buffer, e, "InvalidLength");
+			P(this.buffer, e.offset, t), i = this.buffer.subarray(e.offset, e.offset + t), this.offset = e.offset + t;
+		}
+		return new x(e, n, i);
+	}
+}, b = class {
+	type;
+	payload;
+	constructor(e, t) {
+		this.type = e, this.payload = t;
+	}
+	asInt32() {
+		return this.ensureType(3), new DataView(this.payload.buffer, this.payload.byteOffset, 4).getInt32(0, !0);
+	}
+	asUInt32() {
+		return this.ensureType(5), new DataView(this.payload.buffer, this.payload.byteOffset, 4).getUint32(0, !0);
+	}
+	asInt64() {
+		return this.ensureType(4), new DataView(this.payload.buffer, this.payload.byteOffset, 8).getBigInt64(0, !0);
+	}
+	asUInt64() {
+		return this.ensureType(6), new DataView(this.payload.buffer, this.payload.byteOffset, 8).getBigUint64(0, !0);
+	}
+	asFloat32() {
+		return this.ensureType(7), new DataView(this.payload.buffer, this.payload.byteOffset, 4).getFloat32(0, !0);
+	}
+	asFloat64() {
+		return this.ensureType(8), new DataView(this.payload.buffer, this.payload.byteOffset, 8).getFloat64(0, !0);
+	}
+	asBool() {
+		return this.ensureType(2), this.payload.length > 0 && this.payload[0] !== 0;
+	}
+	asBinary() {
+		return this.ensureType(13), this.payload;
+	}
+	asUtf8() {
+		return this.ensureType(12), this.payload;
+	}
+	asString() {
+		return this.ensureType(12), m.decode(this.payload);
+	}
+	asGuid() {
+		return this.ensureType(14), E.fromBytes(this.payload);
+	}
+	asObject() {
+		return this.ensureType(11), y.create(this.payload);
+	}
+	asArray() {
+		return this.ensureType(9), S.create(this.payload);
+	}
+	asDictionary() {
+		return this.ensureType(10), w.create(this.payload);
+	}
+	ensureType(e) {
+		if (this.type !== e) throw Error(`Teleport value has type ${u[this.type]}, expected ${u[e]}`);
+	}
+}, x = class extends b {
+	fieldId;
+	constructor(e, t, n) {
+		super(t, n), this.fieldId = e;
+	}
+	get isNull() {
+		return this.type === 1;
+	}
+}, S = class e {
+	payload;
+	elementType;
+	count;
+	offset;
+	index = 0;
+	constructor(e) {
+		if (this.payload = e, e.length === 0) throw Error("Array payload too short");
+		let t = e[0];
+		if (this.elementType = t >> 4 & 15, t & 15) throw Error("Array flags must be zero");
+		let n = { offset: 1 };
+		this.count = O(e, n, "ArrayMalformed"), this.offset = n.offset;
+	}
+	static create(t) {
+		return new e(V(t));
+	}
+	next() {
+		if (this.index >= this.count) {
+			if (this.offset !== this.payload.length) throw Error("Array payload contains trailing data");
+			return null;
+		}
+		let e = this.readValue();
+		return this.index++, e;
+	}
+	readValue() {
+		switch (this.elementType) {
+			case 3:
+			case 5:
+			case 7:
+			case 8:
+			case 2:
+			case 4:
+			case 6:
+			case 14: {
+				let e = M(this.elementType);
+				P(this.payload, this.offset, e);
+				let t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new C(this.elementType, t);
+			}
+			case 12:
+			case 13: {
+				let e = { offset: this.offset }, t = O(this.payload, e, "ArrayMalformed");
+				P(this.payload, e.offset, t);
+				let n = this.payload.subarray(e.offset, e.offset + t);
+				return this.offset = e.offset + t, new C(this.elementType, n);
+			}
+			case 11: {
+				let e = { offset: this.offset }, t = O(this.payload, e, "ArrayMalformed");
+				P(this.payload, e.offset, t);
+				let n = this.payload.subarray(e.offset, e.offset + t);
+				return this.offset = e.offset + t, new C(11, n);
+			}
+			case 9: {
+				let e = L(this.payload, this.offset, 0), t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new C(9, t);
+			}
+			case 10: {
+				let e = R(this.payload, this.offset, 0), t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new C(10, t);
+			}
+			default: throw Error(`Unsupported array element type ${u[this.elementType]}`);
+		}
+	}
+}, C = class extends b {
+	constructor(e, t) {
+		super(e, t);
+	}
+}, w = class e {
+	payload;
+	keyType;
+	valueType;
+	count;
+	offset;
+	index = 0;
+	constructor(e) {
+		if (this.payload = e, e.length < 2) throw Error("Dictionary payload too short");
+		if (this.keyType = e[0] >> 4 & 15, this.valueType = e[1] >> 4 & 15, e[0] & 15 || e[1] & 15) throw Error("Dictionary key/value flags must be zero");
+		N(this.keyType);
+		let t = { offset: 2 };
+		this.count = O(e, t, "DictMalformed"), this.offset = t.offset;
+	}
+	static create(t) {
+		return new e(V(t));
+	}
+	next() {
+		if (this.index >= this.count) {
+			if (this.offset !== this.payload.length) throw Error("Dictionary payload contains trailing data");
+			return null;
+		}
+		let e = this.readKey(), t = this.readValue();
+		return this.index++, new T(e, t);
+	}
+	readKey() {
+		let e = M(this.keyType);
+		if (e >= 0) {
+			P(this.payload, this.offset, e);
+			let t = this.payload.subarray(this.offset, this.offset + e);
+			return this.offset += e, new b(this.keyType, t);
+		}
+		if (this.keyType === 12 || this.keyType === 13) {
+			let e = { offset: this.offset }, t = O(this.payload, e, "DictMalformed");
+			P(this.payload, e.offset, t);
+			let n = this.payload.subarray(e.offset, e.offset + t);
+			return this.offset = e.offset + t, new b(this.keyType, n);
+		}
+		throw Error("Unsupported dictionary key type");
+	}
+	readValue() {
+		switch (this.valueType) {
+			case 12:
+			case 13: {
+				let e = { offset: this.offset }, t = O(this.payload, e, "DictMalformed");
+				P(this.payload, e.offset, t);
+				let n = this.payload.subarray(e.offset, e.offset + t);
+				return this.offset = e.offset + t, new b(this.valueType, n);
+			}
+			case 11: {
+				let e = { offset: this.offset }, t = O(this.payload, e, "DictMalformed");
+				P(this.payload, e.offset, t);
+				let n = this.payload.subarray(e.offset, e.offset + t);
+				return this.offset = e.offset + t, new b(11, n);
+			}
+			case 9: {
+				let e = L(this.payload, this.offset, 0), t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new b(9, t);
+			}
+			case 10: {
+				let e = R(this.payload, this.offset, 0), t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new b(10, t);
+			}
+			case 3:
+			case 5:
+			case 7:
+			case 8:
+			case 2:
+			case 4:
+			case 6:
+			case 14:
+			case 1: {
+				let e = M(this.valueType);
+				P(this.payload, this.offset, e);
+				let t = this.payload.subarray(this.offset, this.offset + e);
+				return this.offset += e, new b(this.valueType, t);
+			}
+			default: throw Error(`Unsupported dictionary value type ${u[this.valueType]}`);
+		}
+	}
+}, T = class {
+	key;
+	value;
+	constructor(e, t) {
+		this.key = e, this.value = t;
+	}
+}, E = class e {
+	bytes;
+	constructor(e) {
+		this.bytes = e;
+	}
+	static fromString(t) {
+		if (!t) throw Error("Guid string is empty");
+		let n = t.replace(/-/g, "");
+		if (n.length !== 32) throw Error("Guid string must be 32 hex characters");
+		let r = /* @__PURE__ */ new Uint8Array(16), i = e.parseHexSlice(n, 0, 8), a = e.parseHexSlice(n, 8, 4), o = e.parseHexSlice(n, 12, 4);
+		e.writeUInt32LE(r, 0, i), e.writeUInt16LE(r, 4, a), e.writeUInt16LE(r, 6, o);
+		for (let t = 0; t < 8; t++) r[8 + t] = e.parseHexSlice(n, 16 + t * 2, 2);
+		return new e(r);
+	}
+	static fromBytes(t) {
+		if (t.length !== 16) throw Error("Guid byte array must be 16 bytes");
+		return new e(Uint8Array.from(t));
+	}
+	static createZero() {
+		return new e(/* @__PURE__ */ new Uint8Array(16));
+	}
+	static createRandom() {
+		let t = /* @__PURE__ */ new Uint8Array(16), n = globalThis.crypto;
+		if (n?.getRandomValues) n.getRandomValues(t);
+		else for (let e = 0; e < t.length; e++) t[e] = Math.floor(Math.random() * 256);
+		return t[6] = t[6] & 15 | 64, t[8] = t[8] & 63 | 128, new e(t);
+	}
+	toString() {
+		let t = this.bytes;
+		return [
+			e.toHex(e.readUInt32LE(t, 0), 8),
+			e.toHex(e.readUInt16LE(t, 4), 4),
+			e.toHex(e.readUInt16LE(t, 6), 4),
+			B(t.subarray(8, 10)),
+			B(t.subarray(10, 16))
+		].join("-");
+	}
+	asBytes() {
+		return this.bytes.slice();
+	}
+	static parseHexSlice(e, t, n) {
+		let r = e.substr(t, n), i = Number.parseInt(r, 16);
+		if (Number.isNaN(i)) throw Error("Guid string contains invalid characters");
+		return i >>> 0;
+	}
+	static writeUInt32LE(e, t, n) {
+		let r = n >>> 0;
+		e[t] = r & 255, e[t + 1] = r >>> 8 & 255, e[t + 2] = r >>> 16 & 255, e[t + 3] = r >>> 24 & 255;
+	}
+	static writeUInt16LE(e, t, n) {
+		let r = n & 65535;
+		e[t] = r & 255, e[t + 1] = r >>> 8 & 255;
+	}
+	static readUInt32LE(e, t) {
+		return (e[t] | e[t + 1] << 8 | e[t + 2] << 16 | e[t + 3] << 24) >>> 0;
+	}
+	static readUInt16LE(e, t) {
+		return (e[t] | e[t + 1] << 8) & 65535;
+	}
+	static toHex(e, t) {
+		return (e >>> 0).toString(16).padStart(t, "0");
+	}
+}, D = class e {
+	static INITIAL_CAPACITY = 256;
+	buffer;
+	dataView;
+	length = 0;
+	constructor() {
+		this.buffer = new Uint8Array(e.INITIAL_CAPACITY), this.dataView = new DataView(this.buffer.buffer);
+	}
+	ensureCapacity(e) {
+		let t = this.length + e;
+		if (t <= this.buffer.length) return;
+		let n = this.buffer.length;
+		for (; n < t;) n *= 2;
+		let r = new Uint8Array(n);
+		r.set(this.buffer.subarray(0, this.length)), this.buffer = r, this.dataView = new DataView(this.buffer.buffer);
+	}
+	writeByte(e) {
+		this.ensureCapacity(1), this.buffer[this.length++] = e & 255;
+	}
+	writeBytes(e) {
+		this.ensureCapacity(e.length), this.buffer.set(e, this.length), this.length += e.length;
+	}
+	writeUInt32(e) {
+		this.ensureCapacity(4), this.dataView.setUint32(this.length, e >>> 0, !0), this.length += 4;
+	}
+	writeInt32(e) {
+		this.ensureCapacity(4), this.dataView.setInt32(this.length, e | 0, !0), this.length += 4;
+	}
+	writeFloat32(e) {
+		this.ensureCapacity(4), this.dataView.setFloat32(this.length, e, !0), this.length += 4;
+	}
+	writeFloat64(e) {
+		this.ensureCapacity(8), this.dataView.setFloat64(this.length, e, !0), this.length += 8;
+	}
+	writeBigInt64(e) {
+		this.ensureCapacity(8), this.dataView.setBigInt64(this.length, e, !0), this.length += 8;
+	}
+	writeBigUInt64(e) {
+		this.ensureCapacity(8), this.dataView.setBigUint64(this.length, e, !0), this.length += 8;
+	}
+	writeVarUInt(e) {
+		let t = e >>> 0;
+		for (; t >= 128;) this.ensureCapacity(1), this.buffer[this.length++] = t & 127 | 128, t >>>= 7;
+		this.ensureCapacity(1), this.buffer[this.length++] = t & 127;
+	}
+	toUint8Array() {
+		return this.buffer.slice(0, this.length);
+	}
+};
+function O(e, t, n) {
+	if (t.offset >= e.length) throw Error(n);
+	let r = 0, i = 0, a = 0;
+	for (; t.offset < e.length;) {
+		let n = e[t.offset++];
+		if (a++, i === 28 && n & 112) throw Error("Teleport VarUInt exceeds 32-bit range");
+		if (r |= (n & 127) << i, !(n & 128)) {
+			let e = r >>> 0;
+			if (a !== k(e)) throw Error("Teleport VarUInt is not canonical");
+			return e;
+		}
+		if (i += 7, i >= 35) throw Error("Teleport VarUInt exceeds 32-bit range");
+	}
+	throw Error(n);
+}
+function k(e) {
+	return e < 128 ? 1 : e < 16384 ? 2 : e < 2097152 ? 3 : e < 268435456 ? 4 : 5;
+}
+function A(e, t = 0) {
+	if (t & 240) throw Error("Teleport flags must fit into 4 bits");
+	return (e & 15) << 4 | t & 15;
+}
+function j(e) {
+	return e === 12 || e === 13 || e === 9 || e === 11 || e === 10;
+}
+function M(e) {
+	switch (e) {
+		case 3:
+		case 5:
+		case 7: return 4;
+		case 4:
+		case 6:
+		case 8: return 8;
+		case 14: return 16;
+		case 2: return 1;
+		case 1: return 0;
+		default: return -1;
+	}
+}
+function N(e) {
+	if (e === 9 || e === 11 || e === 10 || e === 1) throw Error("Dictionary keys must be primitive Teleport types");
+}
+function P(e, t, n) {
+	if (t < 0 || n < 0 || t + n > e.length) throw Error("Teleport payload exceeds bounds");
+}
+function F(e, t) {
+	return (e[t] | e[t + 1] << 8 | e[t + 2] << 16 | e[t + 3] << 24) >>> 0;
+}
+var I = 128;
+function L(e, t, n) {
+	if (n >= I) throw Error("Teleport nesting depth exceeded");
+	if (t >= e.length) throw Error("Array payload exceeds bounds");
+	let r = e[t], i = r >> 4 & 15;
+	if (r & 15) throw Error("Array flags must be zero");
+	let a = { offset: t + 1 }, o = O(e, a, "ArrayMalformed"), s = M(i);
+	if (s >= 0) {
+		let n = s * o;
+		return P(e, a.offset, n), a.offset + n - t;
+	}
+	let c = a.offset;
+	for (let t = 0; t < o; t++) c = z(i, e, c, "ArrayMalformed", n + 1);
+	return c - t;
+}
+function R(e, t, n) {
+	if (n >= I) throw Error("Teleport nesting depth exceeded");
+	if (t + 2 > e.length) throw Error("Dictionary payload too short");
+	let r = e[t] >> 4 & 15, i = e[t + 1] >> 4 & 15;
+	if (e[t] & 15 || e[t + 1] & 15) throw Error("Dictionary key/value flags must be zero");
+	N(r);
+	let a = { offset: t + 2 }, o = O(e, a, "DictMalformed"), s = a.offset;
+	for (let t = 0; t < o; t++) s = z(r, e, s, "DictMalformed", n + 1), s = z(i, e, s, "DictMalformed", n + 1);
+	return s - t;
+}
+function z(e, t, n, r, i) {
+	let a = M(e);
+	if (a >= 0) return P(t, n, a), n + a;
+	switch (e) {
+		case 12:
+		case 13: {
+			let e = { offset: n }, i = O(t, e, r);
+			return P(t, e.offset, i), e.offset + i;
+		}
+		case 11: {
+			let e = { offset: n }, i = O(t, e, r);
+			return P(t, e.offset, i), e.offset + i;
+		}
+		case 9: return n + L(t, n, i);
+		case 10: return n + R(t, n, i);
+		default: throw Error(`Unsupported Teleport type ${u[e]}`);
+	}
+}
+function B(e) {
+	return Array.from(e).map((e) => e.toString(16).padStart(2, "0")).join("");
+}
+function V(e) {
+	return e instanceof Uint8Array ? e : new Uint8Array(e);
+}
+//#endregion
+//#region ../../shared/protocol/src/enums/log-type.ts
+var H = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.Trace = 1] = "Trace", e[e.Debug = 2] = "Debug", e[e.Info = 4] = "Info", e[e.Warning = 8] = "Warning", e[e.Error = 16] = "Error", e[e.Critical = 32] = "Critical", e[e.Event = 64] = "Event", e[e.Usage = 128] = "Usage", e[e.Exception = 256] = "Exception", e;
+}({}), U = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.Playing = 1] = "Playing", e[e.Blocked = 2] = "Blocked", e[e.Hidden = 3] = "Hidden", e;
+}({}), W = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.Opus = 1] = "Opus", e[e.Mp3 = 2] = "Mp3", e[e.RawPcm16 = 3] = "RawPcm16", e;
+}({}), G = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.MobileWeb = 1] = "MobileWeb", e[e.MobileApp = 2] = "MobileApp", e[e.DesktopWeb = 3] = "DesktopWeb", e[e.DesktopApp = 4] = "DesktopApp", e;
+}({}), K = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.Backend = 2] = "Backend", e[e.Server = 4] = "Server", e[e.Plugin = 8] = "Plugin", e[e.Browser = 16] = "Browser", e[e.Native = 32] = "Native", e;
+}({}), q = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.WebSocket = 1] = "WebSocket", e[e.WebSocketProxy = 2] = "WebSocketProxy", e[e.WebTransport = 4] = "WebTransport", e[e.WebTransportProxy = 8] = "WebTransportProxy", e[e.Tcp = 16] = "Tcp", e[e.TcpProxy = 32] = "TcpProxy", e[e.Https = 64] = "Https", e[e.WebRTC = 128] = "WebRTC", e[e.TcpTls = 256] = "TcpTls", e[e.Udp = 512] = "Udp", e[e.UdpDtls = 1024] = "UdpDtls", e[e.HttpStream = 2048] = "HttpStream", e[e.HttpStreamProxy = 4096] = "HttpStreamProxy", e;
+}({}), J = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.SendBackToSender = 1] = "SendBackToSender", e[e.Delayable = 2] = "Delayable", e[e.SendToUser = 4] = "SendToUser", e[e.Compressed = 8] = "Compressed", e[e.Unreliable = 16] = "Unreliable", e;
+}({}), Y = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.MessagePack = 1] = "MessagePack", e[e.MemoryPack = 2] = "MemoryPack", e[e.Json = 4] = "Json", e[e.Teleport = 8] = "Teleport", e[e.All = 15] = "All", e;
+}({}), X = /* @__PURE__ */ function(e) {
+	return e[e.Css = 0] = "Css", e[e.Flutter = 1] = "Flutter", e;
+}({}), Z = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.Machine = 1] = "Machine", e[e.Human = 2] = "Human", e;
+}({}), Q = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.H264 = 1] = "H264", e[e.Vp8 = 2] = "Vp8", e[e.Vp9 = 3] = "Vp9", e[e.Av1 = 4] = "Av1", e;
+}({}), $ = /* @__PURE__ */ function(e) {
+	return e[e.Unknown = 0] = "Unknown", e[e.DotNet = 1] = "DotNet", e[e.TypeScript = 2] = "TypeScript", e[e.Cpp = 3] = "Cpp", e[e.Dart = 4] = "Dart", e[e.Rust = 5] = "Rust", e;
+}({}), ee = /* @__PURE__ */ function(e) {
+	return e[e.Local = 0] = "Local", e[e.Cloud = 1] = "Cloud", e;
+}({});
+//#endregion
+export { a as C, i as S, s as T, h as _, q as a, c as b, Y as c, X as d, Z as f, y as g, E as h, K as i, $ as l, e as m, U as n, H as o, Q as p, G as r, J as s, W as t, ee as u, u as v, o as w, r as x, n as y };