@decartai/sdk 0.0.68 → 0.1.1

package/dist/utils/env.js

@@ -4,6 +4,5 @@ const readEnv = (env) => {
 	if (typeof globalThisAny.process !== "undefined") return globalThisAny.process.env?.[env]?.trim();
 	if (typeof globalThisAny.Deno !== "undefined") return globalThisAny.Deno.env?.get?.(env)?.trim();
 };
-
 //#endregion
-export { readEnv };
+export { readEnv };

package/dist/utils/errors.d.ts

@@ -17,6 +17,9 @@ declare const ERROR_CODES: {
   readonly QUEUE_RESULT_ERROR: "QUEUE_RESULT_ERROR";
   readonly JOB_NOT_COMPLETED: "JOB_NOT_COMPLETED";
   readonly TOKEN_CREATE_ERROR: "TOKEN_CREATE_ERROR";
+  readonly FILES_UPLOAD_ERROR: "FILES_UPLOAD_ERROR";
+  readonly FILES_GET_ERROR: "FILES_GET_ERROR";
+  readonly FILES_DELETE_ERROR: "FILES_DELETE_ERROR";
   readonly WEBRTC_WEBSOCKET_ERROR: "WEBRTC_WEBSOCKET_ERROR";
   readonly WEBRTC_ICE_ERROR: "WEBRTC_ICE_ERROR";
   readonly WEBRTC_TIMEOUT_ERROR: "WEBRTC_TIMEOUT_ERROR";

package/dist/utils/errors.js

@@ -11,6 +11,9 @@ const ERROR_CODES = {
 	QUEUE_RESULT_ERROR: "QUEUE_RESULT_ERROR",
 	JOB_NOT_COMPLETED: "JOB_NOT_COMPLETED",
 	TOKEN_CREATE_ERROR: "TOKEN_CREATE_ERROR",
+	FILES_UPLOAD_ERROR: "FILES_UPLOAD_ERROR",
+	FILES_GET_ERROR: "FILES_GET_ERROR",
+	FILES_DELETE_ERROR: "FILES_DELETE_ERROR",
 	WEBRTC_WEBSOCKET_ERROR: "WEBRTC_WEBSOCKET_ERROR",
 	WEBRTC_ICE_ERROR: "WEBRTC_ICE_ERROR",
 	WEBRTC_TIMEOUT_ERROR: "WEBRTC_TIMEOUT_ERROR",
@@ -79,6 +82,5 @@ function createQueueStatusError(message, status) {
 function createQueueResultError(message, status) {
 	return createSDKError(ERROR_CODES.QUEUE_RESULT_ERROR, message, { status });
 }
-
 //#endregion
-export { ERROR_CODES, classifyWebrtcError, createInvalidApiKeyError, createInvalidBaseUrlError, createInvalidInputError, createModelNotFoundError, createQueueResultError, createQueueStatusError, createQueueSubmitError, createSDKError };
+export { ERROR_CODES, classifyWebrtcError, createInvalidApiKeyError, createInvalidBaseUrlError, createInvalidInputError, createModelNotFoundError, createQueueResultError, createQueueStatusError, createQueueSubmitError, createSDKError };

package/dist/utils/logger.js

@@ -32,6 +32,5 @@ function createConsoleLogger(minLevel = "warn") {
 		error: (msg, data) => log("error", msg, data)
 	};
 }
-
 //#endregion
-export { createConsoleLogger, noopLogger };
+export { createConsoleLogger, noopLogger };

package/dist/utils/media.js

@@ -0,0 +1,43 @@
+//#region src/utils/media.ts
+async function blobToBase64(blob) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onloadend = () => {
+			const result = reader.result;
+			if (typeof result !== "string") {
+				reject(/* @__PURE__ */ new Error("FileReader did not return a string"));
+				return;
+			}
+			const base64 = result.split(",")[1];
+			if (!base64) {
+				reject(/* @__PURE__ */ new Error("Invalid data URL format"));
+				return;
+			}
+			resolve(base64);
+		};
+		reader.onerror = reject;
+		reader.readAsDataURL(blob);
+	});
+}
+async function imageToBase64(image) {
+	if (typeof image === "string") {
+		let url = null;
+		try {
+			url = new URL(image);
+		} catch {}
+		if (url?.protocol === "data:") {
+			const [, base64] = image.split(",", 2);
+			if (!base64) throw new Error("Invalid data URL image");
+			return base64;
+		}
+		if (url?.protocol === "http:" || url?.protocol === "https:") {
+			const response = await fetch(image);
+			if (!response.ok) throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
+			return blobToBase64(await response.blob());
+		}
+		return image;
+	}
+	return blobToBase64(image);
+}
+//#endregion
+export { imageToBase64 };

package/dist/utils/platform.js

@@ -0,0 +1,13 @@
+//#region src/utils/platform.ts
+function isDesktopSafari() {
+	const g = globalThis;
+	const ua = g?.navigator?.userAgent ?? "";
+	const platform = g?.navigator?.platform ?? "";
+	const maxTouchPoints = g?.navigator?.maxTouchPoints ?? 0;
+	if (!/^((?!chrome|chromium|crios|fxios|edg|firefox|opr|opera|android).)*safari/i.test(ua)) return false;
+	if (/iPad|iPhone|iPod/.test(ua)) return false;
+	if (platform === "MacIntel" && maxTouchPoints > 1) return false;
+	return true;
+}
+//#endregion
+export { isDesktopSafari };

package/dist/utils/user-agent.js

@@ -1,5 +1,4 @@
 import { VERSION } from "../version.js";
-
 //#region src/utils/user-agent.ts
 function getRuntimeEnvironment(globalThisAny = globalThis) {
 	if (globalThisAny.window) return "runtime/browser";
@@ -27,6 +26,5 @@ function buildUserAgent(integration, globalThisAny = globalThis) {
 		getRuntimeEnvironment(globalThisAny)
 	].join(" ");
 }
-
 //#endregion
-export { buildUserAgent };
+export { buildUserAgent };

package/dist/version.js

@@ -5,6 +5,5 @@
 * Falls back to '0.0.0-dev' in development.
 */
 const VERSION = typeof __PACKAGE_VERSION__ !== "undefined" ? __PACKAGE_VERSION__ : "0.0.0-dev";
-
 //#endregion
-export { VERSION };
+export { VERSION };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decartai/sdk",
-  "version": "0.0.68",
+  "version": "0.1.1",
   "description": "Decart's JavaScript SDK",
   "type": "module",
   "license": "MIT",
@@ -43,6 +43,7 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
+    "livekit-client": "^2.0.0",
     "mitt": "^3.0.1",
     "p-retry": "^6.2.1",
     "zod": "^4.0.17"

package/dist/realtime/webrtc-connection.js

@@ -1,500 +0,0 @@
-import { buildUserAgent } from "../utils/user-agent.js";
-import mitt from "mitt";
-
-//#region src/realtime/webrtc-connection.ts
-const ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
-const SETUP_TIMEOUT_MS = 3e4;
-var WebRTCConnection = class {
-	pc = null;
-	ws = null;
-	localStream = null;
-	connectionReject = null;
-	logger;
-	observability;
-	state = "disconnected";
-	websocketMessagesEmitter = mitt();
-	constructor(callbacks) {
-		this.callbacks = callbacks;
-		this.logger = callbacks.logger ?? {
-			debug() {},
-			info() {},
-			warn() {},
-			error() {}
-		};
-		this.observability = callbacks.observability;
-	}
-	getPeerConnection() {
-		return this.pc;
-	}
-	async connect(url, localStream, timeout, integration) {
-		const deadline = Date.now() + timeout;
-		this.localStream = localStream;
-		const userAgent = encodeURIComponent(buildUserAgent(integration));
-		const wsUrl = `${url}${url.includes("?") ? "&" : "?"}user_agent=${userAgent}`;
-		let rejectConnect;
-		const connectAbort = new Promise((_, reject) => {
-			rejectConnect = reject;
-		});
-		connectAbort.catch(() => {});
-		this.connectionReject = (error) => rejectConnect(error);
-		const totalStart = performance.now();
-		try {
-			const wsStart = performance.now();
-			await Promise.race([new Promise((resolve, reject) => {
-				const timer = setTimeout(() => reject(/* @__PURE__ */ new Error("WebSocket timeout")), timeout);
-				this.ws = new WebSocket(wsUrl);
-				this.ws.onopen = () => {
-					clearTimeout(timer);
-					this.observability.diagnostic("phaseTiming", {
-						phase: "websocket",
-						durationMs: performance.now() - wsStart,
-						success: true
-					});
-					resolve();
-				};
-				this.ws.onmessage = (e) => {
-					try {
-						this.handleSignalingMessage(JSON.parse(e.data));
-					} catch (err) {
-						this.logger.error("Signaling message parse error", { error: String(err) });
-					}
-				};
-				this.ws.onerror = () => {
-					clearTimeout(timer);
-					const error = /* @__PURE__ */ new Error("WebSocket error");
-					this.observability.diagnostic("phaseTiming", {
-						phase: "websocket",
-						durationMs: performance.now() - wsStart,
-						success: false,
-						error: error.message
-					});
-					reject(error);
-					rejectConnect(error);
-				};
-				this.ws.onclose = () => {
-					this.setState("disconnected");
-					clearTimeout(timer);
-					reject(/* @__PURE__ */ new Error("WebSocket closed before connection was established"));
-					rejectConnect(/* @__PURE__ */ new Error("WebSocket closed"));
-				};
-			}), connectAbort]);
-			if (this.callbacks.initialImage) {
-				const imageStart = performance.now();
-				await Promise.race([this.setImageBase64(this.callbacks.initialImage, {
-					prompt: this.callbacks.initialPrompt?.text,
-					enhance: this.callbacks.initialPrompt?.enhance
-				}), connectAbort]);
-				this.observability.diagnostic("phaseTiming", {
-					phase: "avatar-image",
-					durationMs: performance.now() - imageStart,
-					success: true
-				});
-			} else if (this.callbacks.initialPrompt) {
-				const promptStart = performance.now();
-				await Promise.race([this.sendInitialPrompt(this.callbacks.initialPrompt), connectAbort]);
-				this.observability.diagnostic("phaseTiming", {
-					phase: "initial-prompt",
-					durationMs: performance.now() - promptStart,
-					success: true
-				});
-			} else if (localStream) {
-				const nullStart = performance.now();
-				await Promise.race([this.setImageBase64(null, { prompt: null }), connectAbort]);
-				this.observability.diagnostic("phaseTiming", {
-					phase: "initial-prompt",
-					durationMs: performance.now() - nullStart,
-					success: true
-				});
-			}
-			const handshakeStart = performance.now();
-			await this.setupNewPeerConnection();
-			await Promise.race([new Promise((resolve, reject) => {
-				const checkConnection = setInterval(() => {
-					if (this.state === "connected" || this.state === "generating") {
-						clearInterval(checkConnection);
-						this.observability.diagnostic("phaseTiming", {
-							phase: "webrtc-handshake",
-							durationMs: performance.now() - handshakeStart,
-							success: true
-						});
-						resolve();
-					} else if (this.state === "disconnected") {
-						clearInterval(checkConnection);
-						this.observability.diagnostic("phaseTiming", {
-							phase: "webrtc-handshake",
-							durationMs: performance.now() - handshakeStart,
-							success: false,
-							error: "Connection lost during handshake"
-						});
-						reject(/* @__PURE__ */ new Error("Connection lost during WebRTC handshake"));
-					} else if (Date.now() >= deadline) {
-						clearInterval(checkConnection);
-						this.observability.diagnostic("phaseTiming", {
-							phase: "webrtc-handshake",
-							durationMs: performance.now() - handshakeStart,
-							success: false,
-							error: "Timeout"
-						});
-						reject(/* @__PURE__ */ new Error("Connection timeout"));
-					}
-				}, 100);
-				connectAbort.catch(() => clearInterval(checkConnection));
-			}), connectAbort]);
-			this.observability.diagnostic("phaseTiming", {
-				phase: "total",
-				durationMs: performance.now() - totalStart,
-				success: true
-			});
-		} finally {
-			this.connectionReject = null;
-		}
-	}
-	async handleSignalingMessage(msg) {
-		try {
-			if (msg.type === "error") {
-				const error = new Error(msg.error);
-				error.source = "server";
-				this.callbacks.onError?.(error);
-				if (this.connectionReject) {
-					this.connectionReject(error);
-					this.connectionReject = null;
-				}
-				return;
-			}
-			if (msg.type === "set_image_ack") {
-				this.websocketMessagesEmitter.emit("setImageAck", msg);
-				return;
-			}
-			if (msg.type === "prompt_ack") {
-				this.websocketMessagesEmitter.emit("promptAck", msg);
-				return;
-			}
-			if (msg.type === "generation_started") {
-				this.setState("generating");
-				return;
-			}
-			if (msg.type === "generation_tick") {
-				this.websocketMessagesEmitter.emit("generationTick", msg);
-				return;
-			}
-			if (msg.type === "generation_ended") return;
-			if (msg.type === "session_id") {
-				this.websocketMessagesEmitter.emit("sessionId", msg);
-				return;
-			}
-			if (!this.pc) return;
-			switch (msg.type) {
-				case "ready": {
-					await this.applyCodecPreference("video/VP8");
-					const offer = await this.pc.createOffer();
-					this.modifyVP8Bitrate(offer);
-					await this.callbacks.customizeOffer?.(offer);
-					await this.pc.setLocalDescription(offer);
-					this.send({
-						type: "offer",
-						sdp: offer.sdp || ""
-					});
-					break;
-				}
-				case "offer": {
-					await this.pc.setRemoteDescription({
-						type: "offer",
-						sdp: msg.sdp
-					});
-					const answer = await this.pc.createAnswer();
-					await this.pc.setLocalDescription(answer);
-					this.send({
-						type: "answer",
-						sdp: answer.sdp || ""
-					});
-					break;
-				}
-				case "answer":
-					await this.pc.setRemoteDescription({
-						type: "answer",
-						sdp: msg.sdp
-					});
-					break;
-				case "ice-candidate":
-					if (msg.candidate) {
-						await this.pc.addIceCandidate(msg.candidate);
-						this.observability.diagnostic("iceCandidate", {
-							source: "remote",
-							candidateType: msg.candidate.candidate?.match(/typ (\w+)/)?.[1] ?? "unknown",
-							protocol: msg.candidate.candidate?.match(/udp|tcp/i)?.[0]?.toLowerCase() ?? "unknown"
-						});
-					}
-					break;
-			}
-		} catch (error) {
-			this.logger.error("Signaling handler error", { error: String(error) });
-			this.callbacks.onError?.(error);
-			this.connectionReject?.(error);
-		}
-	}
-	send(message) {
-		if (this.ws?.readyState === WebSocket.OPEN) {
-			this.ws.send(JSON.stringify(message));
-			return true;
-		}
-		this.logger.warn("Message dropped: WebSocket is not open");
-		return false;
-	}
-	async setImageBase64(imageBase64, options) {
-		return new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				this.websocketMessagesEmitter.off("setImageAck", listener);
-				reject(/* @__PURE__ */ new Error("Image send timed out"));
-			}, options?.timeout ?? SETUP_TIMEOUT_MS);
-			const listener = (msg) => {
-				clearTimeout(timeoutId);
-				this.websocketMessagesEmitter.off("setImageAck", listener);
-				if (msg.success) resolve();
-				else reject(new Error(msg.error ?? "Failed to send image"));
-			};
-			this.websocketMessagesEmitter.on("setImageAck", listener);
-			const message = {
-				type: "set_image",
-				image_data: imageBase64
-			};
-			if (options?.prompt !== void 0) message.prompt = options.prompt;
-			if (options?.enhance !== void 0) message.enhance_prompt = options.enhance;
-			if (!this.send(message)) {
-				clearTimeout(timeoutId);
-				this.websocketMessagesEmitter.off("setImageAck", listener);
-				reject(/* @__PURE__ */ new Error("WebSocket is not open"));
-			}
-		});
-	}
-	/**
-	* Send the initial prompt to the server before WebRTC handshake.
-	*/
-	async sendInitialPrompt(prompt) {
-		return new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				this.websocketMessagesEmitter.off("promptAck", listener);
-				reject(/* @__PURE__ */ new Error("Prompt send timed out"));
-			}, SETUP_TIMEOUT_MS);
-			const listener = (msg) => {
-				if (msg.prompt === prompt.text) {
-					clearTimeout(timeoutId);
-					this.websocketMessagesEmitter.off("promptAck", listener);
-					if (msg.success) resolve();
-					else reject(new Error(msg.error ?? "Failed to send prompt"));
-				}
-			};
-			this.websocketMessagesEmitter.on("promptAck", listener);
-			if (!this.send({
-				type: "prompt",
-				prompt: prompt.text,
-				enhance_prompt: prompt.enhance ?? true
-			})) {
-				clearTimeout(timeoutId);
-				this.websocketMessagesEmitter.off("promptAck", listener);
-				reject(/* @__PURE__ */ new Error("WebSocket is not open"));
-			}
-		});
-	}
-	setState(state) {
-		if (this.state !== state) {
-			this.state = state;
-			this.callbacks.onStateChange?.(state);
-		}
-	}
-	async setupNewPeerConnection() {
-		if (this.pc) {
-			this.pc.getSenders().forEach((sender) => {
-				if (sender.track && this.pc) this.pc.removeTrack(sender);
-			});
-			this.pc.close();
-		}
-		this.pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
-		this.setState("connecting");
-		if (this.localStream) this.localStream.getTracks().forEach((track) => {
-			if (this.pc && this.localStream) this.pc.addTrack(track, this.localStream);
-		});
-		else {
-			this.pc.addTransceiver("video", { direction: "recvonly" });
-			this.pc.addTransceiver("audio", { direction: "recvonly" });
-		}
-		let fallbackStream = null;
-		this.pc.ontrack = (e) => {
-			if (e.streams?.[0]) this.callbacks.onRemoteStream?.(e.streams[0]);
-			else {
-				if (!fallbackStream) fallbackStream = new MediaStream();
-				fallbackStream.addTrack(e.track);
-				this.callbacks.onRemoteStream?.(fallbackStream);
-			}
-		};
-		this.pc.onicecandidate = (e) => {
-			this.send({
-				type: "ice-candidate",
-				candidate: e.candidate
-			});
-			if (e.candidate) this.observability.diagnostic("iceCandidate", {
-				source: "local",
-				candidateType: e.candidate.type ?? "unknown",
-				protocol: e.candidate.protocol ?? "unknown",
-				address: e.candidate.address ?? void 0,
-				port: e.candidate.port ?? void 0
-			});
-		};
-		let prevPcState = "new";
-		this.pc.onconnectionstatechange = () => {
-			if (!this.pc) return;
-			const s = this.pc.connectionState;
-			this.observability.diagnostic("peerConnectionStateChange", {
-				state: s,
-				previousState: prevPcState,
-				timestampMs: performance.now()
-			});
-			prevPcState = s;
-			if (s === "connected") this.emitSelectedCandidatePair();
-			const nextState = s === "connected" ? "connected" : ["connecting", "new"].includes(s) ? "connecting" : "disconnected";
-			if (this.state === "generating" && nextState !== "disconnected") return;
-			this.setState(nextState);
-		};
-		let prevIceState = "new";
-		this.pc.oniceconnectionstatechange = () => {
-			if (!this.pc) return;
-			const newIceState = this.pc.iceConnectionState;
-			this.observability.diagnostic("iceStateChange", {
-				state: newIceState,
-				previousState: prevIceState,
-				timestampMs: performance.now()
-			});
-			prevIceState = newIceState;
-			if (newIceState === "failed") {
-				this.setState("disconnected");
-				this.callbacks.onError?.(/* @__PURE__ */ new Error("ICE connection failed"));
-			}
-		};
-		let prevSignalingState = "stable";
-		this.pc.onsignalingstatechange = () => {
-			if (!this.pc) return;
-			const newState = this.pc.signalingState;
-			this.observability.diagnostic("signalingStateChange", {
-				state: newState,
-				previousState: prevSignalingState,
-				timestampMs: performance.now()
-			});
-			prevSignalingState = newState;
-		};
-		this.handleSignalingMessage({ type: "ready" });
-	}
-	async emitSelectedCandidatePair() {
-		if (!this.pc) return;
-		try {
-			const stats = await this.pc.getStats();
-			let found = false;
-			stats.forEach((report) => {
-				if (found) return;
-				if (report.type === "candidate-pair" && report.state === "succeeded") {
-					found = true;
-					let localCandidate;
-					let remoteCandidate;
-					stats.forEach((r) => {
-						if (r.id === report.localCandidateId) localCandidate = r;
-						if (r.id === report.remoteCandidateId) remoteCandidate = r;
-					});
-					if (localCandidate && remoteCandidate) this.observability.diagnostic("selectedCandidatePair", {
-						local: {
-							candidateType: String(localCandidate.candidateType ?? "unknown"),
-							protocol: String(localCandidate.protocol ?? "unknown"),
-							address: localCandidate.address,
-							port: localCandidate.port
-						},
-						remote: {
-							candidateType: String(remoteCandidate.candidateType ?? "unknown"),
-							protocol: String(remoteCandidate.protocol ?? "unknown"),
-							address: remoteCandidate.address,
-							port: remoteCandidate.port
-						}
-					});
-				}
-			});
-		} catch {}
-	}
-	cleanup() {
-		this.pc?.close();
-		this.pc = null;
-		this.ws?.close();
-		this.ws = null;
-		this.localStream = null;
-		this.setState("disconnected");
-	}
-	applyCodecPreference(preferredCodecName) {
-		if (!this.pc) return;
-		if (typeof RTCRtpSender === "undefined" || typeof RTCRtpSender.getCapabilities !== "function") {
-			this.logger.debug("RTCRtpSender capabilities not available in this environment");
-			return;
-		}
-		const videoTransceiver = this.pc.getTransceivers().find((r) => r.sender.track?.kind === "video" || r.receiver.track?.kind === "video");
-		if (!videoTransceiver) {
-			this.logger.warn("Video transceiver not found for codec preference");
-			return;
-		}
-		const capabilities = RTCRtpSender.getCapabilities("video");
-		if (!capabilities) {
-			this.logger.warn("Video sender capabilities unavailable");
-			return;
-		}
-		const preferredCodecs = [];
-		const otherCodecs = [];
-		capabilities.codecs.forEach((codec) => {
-			if (codec.mimeType.toLowerCase() === preferredCodecName.toLowerCase()) preferredCodecs.push(codec);
-			else otherCodecs.push(codec);
-		});
-		const orderedCodecs = [...preferredCodecs, ...otherCodecs];
-		if (orderedCodecs.length === 0) {
-			this.logger.debug("No video codecs found for preference setting");
-			return;
-		}
-		try {
-			videoTransceiver.setCodecPreferences(orderedCodecs);
-		} catch {
-			this.logger.debug("setCodecPreferences not supported, skipping");
-		}
-	}
-	modifyVP8Bitrate(offer) {
-		if (!offer.sdp) return;
-		const minBitrateInKbps = this.callbacks.vp8MinBitrate;
-		const startBitrateInKbps = this.callbacks.vp8StartBitrate;
-		if (minBitrateInKbps === void 0 || startBitrateInKbps === void 0) return;
-		if (minBitrateInKbps === 0 && startBitrateInKbps === 0) return;
-		const bitrateParams = `x-google-min-bitrate=${minBitrateInKbps};x-google-start-bitrate=${startBitrateInKbps}`;
-		const sdpLines = offer.sdp.split("\r\n");
-		const modifiedLines = [];
-		for (let i = 0; i < sdpLines.length; i++) {
-			if (sdpLines[i].includes("VP8/90000")) {
-				const match = sdpLines[i].match(/a=rtpmap:(\d+) VP8/);
-				if (match) {
-					const payloadType = match[1];
-					let fmtpIndex = -1;
-					let insertAfterIndex = i;
-					for (let j = i + 1; j < sdpLines.length && sdpLines[j].startsWith("a="); j++) {
-						if (sdpLines[j].startsWith(`a=fmtp:${payloadType}`)) {
-							fmtpIndex = j;
-							break;
-						}
-						if (sdpLines[j].startsWith(`a=rtcp-fb:${payloadType}`)) insertAfterIndex = j;
-						if (sdpLines[j].startsWith("a=rtpmap:")) break;
-					}
-					if (fmtpIndex !== -1) {
-						if (!sdpLines[fmtpIndex].includes("x-google-min-bitrate")) sdpLines[fmtpIndex] += `;${bitrateParams}`;
-					} else {
-						for (let k = i; k <= insertAfterIndex; k++) modifiedLines.push(sdpLines[k]);
-						modifiedLines.push(`a=fmtp:${payloadType} ${bitrateParams}`);
-						i = insertAfterIndex;
-						continue;
-					}
-				}
-			}
-			modifiedLines.push(sdpLines[i]);
-		}
-		offer.sdp = modifiedLines.join("\r\n");
-	}
-};
-
-//#endregion
-export { WebRTCConnection };