@luxonis/visualizer-protobuf 2.68.1 → 2.68.3

package/dist/{index-CiGEicGF.js → index-ATiX0ct8.js}

@@ -2,9 +2,9 @@ import { d as dist$1, e as estimateObjectSize, r as reportError, A as AppError,
 import { w as wrap$3, p as proxy } from './comlink-CsH1ih07.js';
 import { u as uint8ArrayToUint16Array } from './utils-Hzt3wxhG.js';
 import { p as protobufsBySchema, a as protobufSchemaNameToType, g as getDefaultExportFromCjs, c as commonjsGlobal } from './protobuf-BFCtaU7c.js';
-import { B as BinaryOpcode } from './FoxgloveServer-h5m-pXp3.js';
 import * as React$1 from 'react';
 import React__default, { useRef, useMemo, createContext, useContext, forwardRef, createElement, useState, Component, useCallback, useEffect, useLayoutEffect, useReducer, useImperativeHandle, Fragment as Fragment$1, Suspense } from 'react';
+import { B as BinaryOpcode } from './FoxgloveServer-h5m-pXp3.js';
 import { p as parseFoxgloveMessage } from './foxglove-protocol-BSYuI-q2.js';
 import { DndProvider } from 'react-dnd';
 import { HTML5Backend } from 'react-dnd-html5-backend';
@@ -1445,9 +1445,6 @@ class WebRtcDataChannel {
         return this.channel.label;
     }
     sendMessage(message) {
-        if (message instanceof DataView && this.withFragmentation) {
-            console.log('Sending Fragmented message:', message);
-        }
         if (this.channel.readyState === "open") {
             const chunks = message instanceof DataView && this.withFragmentation
                 ? makeChunks(message)
@@ -1576,237 +1573,6 @@ class WebRtcConnection {
     on = this.events.on.bind(this.events);
 }
 
-const ICE_SERVERS_API_ENDPOINT = "https://signal.cloud.luxonis.com/api/v1/turn-credentials";
-const DEFAULT_SIGNALING_SERVER_URL = "wss://signal.cloud.luxonis.com/session/";
-const DEFAULT_ICE_SERVERS = [
-    { urls: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"] },
-];
-class WebRtcClient {
-    config;
-    socket;
-    connection = null;
-    signalingConnectionRetries;
-    events = new EventEmitter();
-    iceCandidates = [];
-    candidateQueue = [];
-    constructor(config) {
-        this.config = config;
-        // If user doesn't provide iceServers and doesn't want to use Luxonis ice servers, use default ice servers
-        if (!config.useLuxonisIceServers && config.iceServers === undefined) {
-            this.config.iceServers = DEFAULT_ICE_SERVERS;
-        }
-        this.signalingConnectionRetries =
-            (config.signalingConnectionRetries ?? 3) || 0;
-        console.log("WebRtcClient Configuration:", this.config);
-        this.connectSignalingServer();
-    }
-    async useLuxonisIceServers() {
-        console.log("Using Luxonis ICE servers");
-        try {
-            const response = await fetch(ICE_SERVERS_API_ENDPOINT);
-            const data = (await response.json());
-            if (data.iceServers) {
-                if (this.config.iceServers === undefined) {
-                    this.config.iceServers = [data.iceServers];
-                }
-                else {
-                    this.config.iceServers.push(data.iceServers);
-                }
-            }
-            else {
-                console.error("DAI Connection Error: Retrieved ICE servers are invalid.", data);
-                if (this.config.iceServers === undefined ||
-                    this.config.iceServers.length === 0) {
-                    console.error("DAI Connection Error: Retrieved ICE servers are invalid and no ICE servers were provided by client, falling back to default.");
-                    this.config.iceServers = DEFAULT_ICE_SERVERS;
-                }
-            }
-        }
-        catch (error) {
-            console.error("DAI Connection Error: Cannot retrieve ICE servers.", error);
-            if (this.config.iceServers === undefined ||
-                this.config.iceServers.length === 0) {
-                console.error("DAI Connection Error: Retrieved ICE servers are invalid and no ICE servers were provided by client, falling back to default.");
-                this.config.iceServers = DEFAULT_ICE_SERVERS;
-            }
-        }
-    }
-    get signalingServerConnected() {
-        return this.socket.readyState === WebSocket.OPEN;
-    }
-    disconnect(reason) {
-        this.connection?.close();
-        this.sendMessage({
-            Disconnect: {
-                type: "normal",
-                reason,
-            },
-        });
-    }
-    connect() {
-        this.sendMessage({
-            ConnectSession: {
-                client_id: this.config.clientId,
-                application_identifier: this.config.applicationIdentifier,
-                auth_payload: this.config.authPayload,
-            },
-        });
-    }
-    connectSignalingServer() {
-        this.socket = new WebSocket(this.config.signalingServerUrl ?? DEFAULT_SIGNALING_SERVER_URL);
-        this.socket.onopen = () => {
-            console.log("Signaling: Connected to signaling server");
-            this.connect();
-        };
-        // this.socket.onclose = () => console.debug('[WebRTC] Disconnected from signaling server');
-        this.socket.onerror = (error) => {
-            this.events.emit("error", ["signaling_connection_error", error]);
-            if (!this.events.isEventHandled("error")) {
-                console.error("[WebRTC] Signaling connection error:", error);
-            }
-            setTimeout(() => {
-                if (this.signalingConnectionRetries) {
-                    this.signalingConnectionRetries -= 1;
-                    if (this.socket.readyState === WebSocket.CLOSED ||
-                        this.socket.readyState === WebSocket.CLOSING) {
-                        // console.debug('[WebRTC] Reconnecting to signaling server');
-                        this.connectSignalingServer();
-                    }
-                }
-            }, 3_000);
-        };
-        this.socket.onmessage = (event) => {
-            const message = JSON.parse(event.data);
-            this.handleSignalingMessage(message);
-        };
-    }
-    disconnectSignalingServer(reason) {
-        if (this.signalingServerConnected) {
-            this.sendMessage({
-                Disconnect: {
-                    type: "normal",
-                    reason,
-                },
-            });
-            this.socket.close();
-        }
-    }
-    handleSignalingMessage(message) {
-        if ("AcknowledgeSession" in message) {
-            console.log("Signaling: Received AcknowledgeSession message", message);
-            if (message.AcknowledgeSession.acknowledge) {
-                if (this.config.useLuxonisIceServers) {
-                    this.useLuxonisIceServers().then(() => this.createConnection());
-                }
-                else {
-                    this.createConnection();
-                }
-            }
-            else {
-                if (!this.events.isEventHandled("error")) {
-                    console.error("[WebRTC] Connection refused:", message.AcknowledgeSession.reason);
-                }
-                this.events.emit("error", [
-                    "signaling_rejected",
-                    message.AcknowledgeSession.reason,
-                ]);
-                this.dispose("Connection refused");
-            }
-        }
-        else if ("Candidate" in message) {
-            console.log("Signaling: Received Candidate message", message);
-            void this.handleCandidateMessage(message);
-        }
-        else if ("Disconnect" in message) {
-            console.log("Signaling: Received Disconnect message", message);
-            this.dispose("Targed disconnected");
-        }
-    }
-    async handleCandidateMessage({ Candidate: { type: kind, candidate }, }) {
-        if (!this.connection) {
-            console.log("Candidate message received before connection established, adding to queue", { Candidate: { type: kind, candidate } });
-            this.candidateQueue.push({ Candidate: { type: kind, candidate } });
-            return;
-        }
-        // console.debug('[WebRTC] Processing candidate message', kind);
-        switch (kind) {
-            case "answer":
-            case "offer": {
-                const data = `${candidate}`;
-                if (data === "null" || data === "") {
-                    console.error("[WebRTC] Offer refused: remote description cannot be null");
-                    this.reconnect("Error: received invalid candidate");
-                    return;
-                }
-                // console.debug('[WebRTC] Offer accepted. Setting remote description..');
-                await this.connection.setRemoteDescription(kind, candidate);
-                // console.debug('[WebRTC] Set remote description');
-                for (const iceCandidate of this.iceCandidates) {
-                    // console.debug('[WebRTC] Adding stored ICE candidate');
-                    void this.connection.addIceCandidate(JSON.parse(iceCandidate));
-                }
-                this.iceCandidates = [];
-                if (kind === "offer") {
-                    const answer = await this.connection.createDescription("answer");
-                    // console.debug('[WebRTC] Answer created (set local description)');
-                    this.sendMessage({
-                        Candidate: {
-                            type: "answer",
-                            candidate: answer.sdp ?? "",
-                        },
-                    });
-                }
-                return;
-            }
-            case "candidate": {
-                if (this.connection.peerConnection.remoteDescription === null) {
-                    // console.debug('[WebRTC] Storing ICE candidate (remote description is not set yet)');
-                    this.iceCandidates.push(candidate);
-                }
-                else {
-                    // console.debug('[WebRTC] Adding ICE candidate');
-                    return this.connection.addIceCandidate(JSON.parse(candidate));
-                }
-            }
-        }
-    }
-    reconnect(reason) {
-        // console.debug(`[WebRTC] Reconnecting: ${reason}`);
-        this.disconnect(reason);
-        this.connect();
-    }
-    sendMessage(message) {
-        // console.debug('[WebRTC] Sending message', message);
-        if (this.socket.readyState === WebSocket.OPEN) {
-            this.socket.send(JSON.stringify(message));
-        }
-    }
-    createConnection() {
-        this.connection = new WebRtcConnection({
-            iceServers: this.config.iceServers,
-            onCandidate: (candidate) => {
-                this.sendMessage({
-                    Candidate: {
-                        type: "candidate",
-                        candidate: JSON.stringify(candidate),
-                    },
-                });
-            },
-            onConnectionEstablished: () => this.disconnectSignalingServer("P2P connection established"),
-            withFragmentation: this.config.withFragmentation,
-        });
-        for (const candidate of this.candidateQueue) {
-            void this.handleCandidateMessage(candidate);
-        }
-        this.events.emit("connection_established", [this.connection]);
-    }
-    dispose(reason) {
-        this.disconnect(reason);
-        this.disconnectSignalingServer(reason);
-    }
-    on = this.events.on.bind(this.events);
-}
-
 var safeStableStringify = {exports: {}};
 
 (function (module, exports) {
@@ -5982,9 +5748,7 @@ function setYear(date, year) {
   return _date;
 }
 
-const SECOND = 1000;
-const MINUTE = 60 * SECOND;
-function formatDate$1(date, format$1) {
+function formatDate$2(date, format$1) {
     switch (format$1) {
         case 'iso':
             return date.toISOString();
@@ -10232,61 +9996,6 @@ z
     .string()
     .regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/, { message: 'Version must be in the format X.Y or X.Y.Z' });
 
-/**
- * Convert array of 16 byte values to UUID string format of the form:
- * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
- */
-var byteToHex$1 = [];
-for (var i$1 = 0; i$1 < 256; ++i$1) {
-  byteToHex$1.push((i$1 + 0x100).toString(16).slice(1));
-}
-function unsafeStringify$1(arr, offset = 0) {
-  // Note: Be careful editing this code!  It's been tuned for performance
-  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
-  //
-  // Note to future-self: No, you can't remove the `toLowerCase()` call.
-  // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351
-  return (byteToHex$1[arr[offset + 0]] + byteToHex$1[arr[offset + 1]] + byteToHex$1[arr[offset + 2]] + byteToHex$1[arr[offset + 3]] + '-' + byteToHex$1[arr[offset + 4]] + byteToHex$1[arr[offset + 5]] + '-' + byteToHex$1[arr[offset + 6]] + byteToHex$1[arr[offset + 7]] + '-' + byteToHex$1[arr[offset + 8]] + byteToHex$1[arr[offset + 9]] + '-' + byteToHex$1[arr[offset + 10]] + byteToHex$1[arr[offset + 11]] + byteToHex$1[arr[offset + 12]] + byteToHex$1[arr[offset + 13]] + byteToHex$1[arr[offset + 14]] + byteToHex$1[arr[offset + 15]]).toLowerCase();
-}
-
-// Unique ID creation requires a high quality random # generator. In the browser we therefore
-// require the crypto API and do not support built-in fallback to lower quality random number
-// generators (like Math.random()).
-
-var getRandomValues$1;
-var rnds8$1 = new Uint8Array(16);
-function rng$1() {
-  // lazy load so that environments that need to polyfill have a chance to do so
-  if (!getRandomValues$1) {
-    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
-    getRandomValues$1 = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
-    if (!getRandomValues$1) {
-      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
-    }
-  }
-  return getRandomValues$1(rnds8$1);
-}
-
-var randomUUID$1 = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-var native$1 = {
-  randomUUID: randomUUID$1
-};
-
-function v4$1(options, buf, offset) {
-  if (native$1.randomUUID && !buf && !options) {
-    return native$1.randomUUID();
-  }
-  options = options || {};
-  var rnds = options.random || (options.rng || rng$1)();
-
-  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-  rnds[6] = rnds[6] & 0x0f | 0x40;
-  rnds[8] = rnds[8] & 0x3f | 0x80;
-  return unsafeStringify$1(rnds);
-}
-
-const MB = 1024 ** 2;
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -14948,7 +14657,7 @@ function getFormatter$2(_a, type, getDateTimeFormat, options) {
     }
     return getDateTimeFormat(locale, filteredOptions);
 }
-function formatDate(config, getDateTimeFormat) {
+function formatDate$1(config, getDateTimeFormat) {
     var _a = [];
     for (var _i = 2; _i < arguments.length; _i++) {
         _a[_i - 2] = arguments[_i];
@@ -15244,7 +14953,7 @@ function createIntl$1(config, cache) {
         onError(new MissingDataError("Missing locale data for locale: \"".concat(locale, "\" in Intl.DateTimeFormat. Using default locale: \"").concat(defaultLocale, "\" as fallback. See https://formatjs.io/docs/react-intl#runtime-requirements for more details")));
     }
     verifyConfigMessages(resolvedConfig);
-    return __assign$6(__assign$6({}, resolvedConfig), { formatters: formatters, formatNumber: formatNumber$1.bind(null, resolvedConfig, formatters.getNumberFormat), formatNumberToParts: formatNumberToParts.bind(null, resolvedConfig, formatters.getNumberFormat), formatRelativeTime: formatRelativeTime.bind(null, resolvedConfig, formatters.getRelativeTimeFormat), formatDate: formatDate.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatDateToParts: formatDateToParts.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatTime: formatTime.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatDateTimeRange: formatDateTimeRange.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatTimeToParts: formatTimeToParts.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatPlural: formatPlural.bind(null, resolvedConfig, formatters.getPluralRules), 
+    return __assign$6(__assign$6({}, resolvedConfig), { formatters: formatters, formatNumber: formatNumber$1.bind(null, resolvedConfig, formatters.getNumberFormat), formatNumberToParts: formatNumberToParts.bind(null, resolvedConfig, formatters.getNumberFormat), formatRelativeTime: formatRelativeTime.bind(null, resolvedConfig, formatters.getRelativeTimeFormat), formatDate: formatDate$1.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatDateToParts: formatDateToParts.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatTime: formatTime.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatDateTimeRange: formatDateTimeRange.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatTimeToParts: formatTimeToParts.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatPlural: formatPlural.bind(null, resolvedConfig, formatters.getPluralRules), 
         // @ts-expect-error TODO: will get to this later
         formatMessage: formatMessage$1.bind(null, resolvedConfig, formatters), 
         // @ts-expect-error TODO: will get to this later
@@ -15937,15 +15646,15 @@ function isErrorLike(value) {
 	&& 'stack' in value;
 }
 
-const ANSI_BACKGROUND_OFFSET = 10;
+const ANSI_BACKGROUND_OFFSET$1 = 10;
 
-const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`;
+const wrapAnsi16$1 = (offset = 0) => code => `\u001B[${code + offset}m`;
 
-const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi256$1 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
 
-const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const wrapAnsi16m$1 = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
 
-const styles$1 = {
+const styles$3 = {
 	modifier: {
 		reset: [0, 0],
 		// 21 isn't widely supported and 22 does the same thing
@@ -16004,49 +15713,49 @@ const styles$1 = {
 	},
 };
 
-Object.keys(styles$1.modifier);
-const foregroundColorNames = Object.keys(styles$1.color);
-const backgroundColorNames = Object.keys(styles$1.bgColor);
-[...foregroundColorNames, ...backgroundColorNames];
+Object.keys(styles$3.modifier);
+const foregroundColorNames$1 = Object.keys(styles$3.color);
+const backgroundColorNames$1 = Object.keys(styles$3.bgColor);
+[...foregroundColorNames$1, ...backgroundColorNames$1];
 
-function assembleStyles() {
+function assembleStyles$1() {
 	const codes = new Map();
 
-	for (const [groupName, group] of Object.entries(styles$1)) {
+	for (const [groupName, group] of Object.entries(styles$3)) {
 		for (const [styleName, style] of Object.entries(group)) {
-			styles$1[styleName] = {
+			styles$3[styleName] = {
 				open: `\u001B[${style[0]}m`,
 				close: `\u001B[${style[1]}m`,
 			};
 
-			group[styleName] = styles$1[styleName];
+			group[styleName] = styles$3[styleName];
 
 			codes.set(style[0], style[1]);
 		}
 
-		Object.defineProperty(styles$1, groupName, {
+		Object.defineProperty(styles$3, groupName, {
 			value: group,
 			enumerable: false,
 		});
 	}
 
-	Object.defineProperty(styles$1, 'codes', {
+	Object.defineProperty(styles$3, 'codes', {
 		value: codes,
 		enumerable: false,
 	});
 
-	styles$1.color.close = '\u001B[39m';
-	styles$1.bgColor.close = '\u001B[49m';
+	styles$3.color.close = '\u001B[39m';
+	styles$3.bgColor.close = '\u001B[49m';
 
-	styles$1.color.ansi = wrapAnsi16();
-	styles$1.color.ansi256 = wrapAnsi256();
-	styles$1.color.ansi16m = wrapAnsi16m();
-	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	styles$3.color.ansi = wrapAnsi16$1();
+	styles$3.color.ansi256 = wrapAnsi256$1();
+	styles$3.color.ansi16m = wrapAnsi16m$1();
+	styles$3.bgColor.ansi = wrapAnsi16$1(ANSI_BACKGROUND_OFFSET$1);
+	styles$3.bgColor.ansi256 = wrapAnsi256$1(ANSI_BACKGROUND_OFFSET$1);
+	styles$3.bgColor.ansi16m = wrapAnsi16m$1(ANSI_BACKGROUND_OFFSET$1);
 
 	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
-	Object.defineProperties(styles$1, {
+	Object.defineProperties(styles$3, {
 		rgbToAnsi256: {
 			value(red, green, blue) {
 				// We use the extended greyscale palette here, with the exception of
@@ -16096,7 +15805,7 @@ function assembleStyles() {
 			enumerable: false,
 		},
 		hexToAnsi256: {
-			value: hex => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			value: hex => styles$3.rgbToAnsi256(...styles$3.hexToRgb(hex)),
 			enumerable: false,
 		},
 		ansi256ToAnsi: {
@@ -16145,23 +15854,23 @@ function assembleStyles() {
 			enumerable: false,
 		},
 		rgbToAnsi: {
-			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			value: (red, green, blue) => styles$3.ansi256ToAnsi(styles$3.rgbToAnsi256(red, green, blue)),
 			enumerable: false,
 		},
 		hexToAnsi: {
-			value: hex => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			value: hex => styles$3.ansi256ToAnsi(styles$3.hexToAnsi256(hex)),
 			enumerable: false,
 		},
 	});
 
-	return styles$1;
+	return styles$3;
 }
 
-const ansiStyles = assembleStyles();
+const ansiStyles$1 = assembleStyles$1();
 
 /* eslint-env browser */
 
-const level = (() => {
+const level$1 = (() => {
 	if (navigator.userAgentData) {
 		const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium');
 		if (brand && brand.version > 93) {
@@ -16176,20 +15885,20 @@ const level = (() => {
 	return 0;
 })();
 
-const colorSupport = level !== 0 && {
-	level,
+const colorSupport$1 = level$1 !== 0 && {
+	level: level$1,
 	hasBasic: true,
-	has256: level >= 2,
-	has16m: level >= 3,
+	has256: level$1 >= 2,
+	has16m: level$1 >= 3,
 };
 
-const supportsColor = {
-	stdout: colorSupport,
-	stderr: colorSupport,
+const supportsColor$1 = {
+	stdout: colorSupport$1,
+	stderr: colorSupport$1,
 };
 
 // TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.
-function stringReplaceAll(string, substring, replacer) {
+function stringReplaceAll$1(string, substring, replacer) {
 	let index = string.indexOf(substring);
 	if (index === -1) {
 		return string;
@@ -16208,7 +15917,7 @@ function stringReplaceAll(string, substring, replacer) {
 	return returnValue;
 }
 
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+function stringEncaseCRLFWithFirstIndex$1(string, prefix, postfix, index) {
 	let endIndex = 0;
 	let returnValue = '';
 	do {
@@ -16222,124 +15931,124 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
 	return returnValue;
 }
 
-const {stdout: stdoutColor, stderr: stderrColor} = supportsColor;
+const {stdout: stdoutColor$1, stderr: stderrColor$1} = supportsColor$1;
 
-const GENERATOR = Symbol('GENERATOR');
-const STYLER = Symbol('STYLER');
-const IS_EMPTY = Symbol('IS_EMPTY');
+const GENERATOR$1 = Symbol('GENERATOR');
+const STYLER$1 = Symbol('STYLER');
+const IS_EMPTY$1 = Symbol('IS_EMPTY');
 
 // `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = [
+const levelMapping$1 = [
 	'ansi',
 	'ansi',
 	'ansi256',
 	'ansi16m',
 ];
 
-const styles = Object.create(null);
+const styles$2 = Object.create(null);
 
-const applyOptions = (object, options = {}) => {
+const applyOptions$1 = (object, options = {}) => {
 	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
 		throw new Error('The `level` option should be an integer from 0 to 3');
 	}
 
 	// Detect level if not set manually
-	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	const colorLevel = stdoutColor$1 ? stdoutColor$1.level : 0;
 	object.level = options.level === undefined ? colorLevel : options.level;
 };
 
-const chalkFactory = options => {
+const chalkFactory$1 = options => {
 	const chalk = (...strings) => strings.join(' ');
-	applyOptions(chalk, options);
+	applyOptions$1(chalk, options);
 
-	Object.setPrototypeOf(chalk, createChalk.prototype);
+	Object.setPrototypeOf(chalk, createChalk$1.prototype);
 
 	return chalk;
 };
 
-function createChalk(options) {
-	return chalkFactory(options);
+function createChalk$1(options) {
+	return chalkFactory$1(options);
 }
 
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+Object.setPrototypeOf(createChalk$1.prototype, Function.prototype);
 
-for (const [styleName, style] of Object.entries(ansiStyles)) {
-	styles[styleName] = {
+for (const [styleName, style] of Object.entries(ansiStyles$1)) {
+	styles$2[styleName] = {
 		get() {
-			const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+			const builder = createBuilder$1(this, createStyler$1(style.open, style.close, this[STYLER$1]), this[IS_EMPTY$1]);
 			Object.defineProperty(this, styleName, {value: builder});
 			return builder;
 		},
 	};
 }
 
-styles.visible = {
+styles$2.visible = {
 	get() {
-		const builder = createBuilder(this, this[STYLER], true);
+		const builder = createBuilder$1(this, this[STYLER$1], true);
 		Object.defineProperty(this, 'visible', {value: builder});
 		return builder;
 	},
 };
 
-const getModelAnsi = (model, level, type, ...arguments_) => {
+const getModelAnsi$1 = (model, level, type, ...arguments_) => {
 	if (model === 'rgb') {
 		if (level === 'ansi16m') {
-			return ansiStyles[type].ansi16m(...arguments_);
+			return ansiStyles$1[type].ansi16m(...arguments_);
 		}
 
 		if (level === 'ansi256') {
-			return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+			return ansiStyles$1[type].ansi256(ansiStyles$1.rgbToAnsi256(...arguments_));
 		}
 
-		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+		return ansiStyles$1[type].ansi(ansiStyles$1.rgbToAnsi(...arguments_));
 	}
 
 	if (model === 'hex') {
-		return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));
+		return getModelAnsi$1('rgb', level, type, ...ansiStyles$1.hexToRgb(...arguments_));
 	}
 
-	return ansiStyles[type][model](...arguments_);
+	return ansiStyles$1[type][model](...arguments_);
 };
 
-const usedModels = ['rgb', 'hex', 'ansi256'];
+const usedModels$1 = ['rgb', 'hex', 'ansi256'];
 
-for (const model of usedModels) {
-	styles[model] = {
+for (const model of usedModels$1) {
+	styles$2[model] = {
 		get() {
 			const {level} = this;
 			return function (...arguments_) {
-				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]);
-				return createBuilder(this, styler, this[IS_EMPTY]);
+				const styler = createStyler$1(getModelAnsi$1(model, levelMapping$1[level], 'color', ...arguments_), ansiStyles$1.color.close, this[STYLER$1]);
+				return createBuilder$1(this, styler, this[IS_EMPTY$1]);
 			};
 		},
 	};
 
 	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
-	styles[bgModel] = {
+	styles$2[bgModel] = {
 		get() {
 			const {level} = this;
 			return function (...arguments_) {
-				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
-				return createBuilder(this, styler, this[IS_EMPTY]);
+				const styler = createStyler$1(getModelAnsi$1(model, levelMapping$1[level], 'bgColor', ...arguments_), ansiStyles$1.bgColor.close, this[STYLER$1]);
+				return createBuilder$1(this, styler, this[IS_EMPTY$1]);
 			};
 		},
 	};
 }
 
-const proto$1 = Object.defineProperties(() => {}, {
-	...styles,
+const proto$2 = Object.defineProperties(() => {}, {
+	...styles$2,
 	level: {
 		enumerable: true,
 		get() {
-			return this[GENERATOR].level;
+			return this[GENERATOR$1].level;
 		},
 		set(level) {
-			this[GENERATOR].level = level;
+			this[GENERATOR$1].level = level;
 		},
 	},
 });
 
-const createStyler = (open, close, parent) => {
+const createStyler$1 = (open, close, parent) => {
 	let openAll;
 	let closeAll;
 	if (parent === undefined) {
@@ -16359,28 +16068,28 @@ const createStyler = (open, close, parent) => {
 	};
 };
 
-const createBuilder = (self, _styler, _isEmpty) => {
+const createBuilder$1 = (self, _styler, _isEmpty) => {
 	// Single argument is hot path, implicit coercion is faster than anything
 	// eslint-disable-next-line no-implicit-coercion
-	const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+	const builder = (...arguments_) => applyStyle$1(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
 
 	// We alter the prototype because we must return a function, but there is
 	// no way to create a function with a different prototype
-	Object.setPrototypeOf(builder, proto$1);
+	Object.setPrototypeOf(builder, proto$2);
 
-	builder[GENERATOR] = self;
-	builder[STYLER] = _styler;
-	builder[IS_EMPTY] = _isEmpty;
+	builder[GENERATOR$1] = self;
+	builder[STYLER$1] = _styler;
+	builder[IS_EMPTY$1] = _isEmpty;
 
 	return builder;
 };
 
-const applyStyle = (self, string) => {
+const applyStyle$1 = (self, string) => {
 	if (self.level <= 0 || !string) {
-		return self[IS_EMPTY] ? '' : string;
+		return self[IS_EMPTY$1] ? '' : string;
 	}
 
-	let styler = self[STYLER];
+	let styler = self[STYLER$1];
 
 	if (styler === undefined) {
 		return string;
@@ -16392,7 +16101,7 @@ const applyStyle = (self, string) => {
 			// Replace any instances already present with a re-opening code
 			// otherwise only the part of the string until said closing code
 			// will be colored, and the rest will simply be 'plain'.
-			string = stringReplaceAll(string, styler.close, styler.open);
+			string = stringReplaceAll$1(string, styler.close, styler.open);
 
 			styler = styler.parent;
 		}
@@ -16403,19 +16112,19 @@ const applyStyle = (self, string) => {
 	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
 	const lfIndex = string.indexOf('\n');
 	if (lfIndex !== -1) {
-		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+		string = stringEncaseCRLFWithFirstIndex$1(string, closeAll, openAll, lfIndex);
 	}
 
 	return openAll + string + closeAll;
 };
 
-Object.defineProperties(createChalk.prototype, styles);
+Object.defineProperties(createChalk$1.prototype, styles$2);
 
-const chalk = createChalk();
-createChalk({level: stderrColor ? stderrColor.level : 0});
+const chalk$1 = createChalk$1();
+createChalk$1({level: stderrColor$1 ? stderrColor$1.level : 0});
 
 /* eslint-disable no-var */
-var LogLevel;
+var LogLevel$1;
 (function (LogLevel) {
     LogLevel[LogLevel["trace"] = 10] = "trace";
     LogLevel[LogLevel["debug"] = 20] = "debug";
@@ -16423,11 +16132,11 @@ var LogLevel;
     LogLevel[LogLevel["warn"] = 40] = "warn";
     LogLevel[LogLevel["error"] = 50] = "error";
     LogLevel[LogLevel["fatal"] = 60] = "fatal";
-})(LogLevel || (LogLevel = {}));
-function isLogFnParamsCtx(params) {
+})(LogLevel$1 || (LogLevel$1 = {}));
+function isLogFnParamsCtx$1(params) {
     return typeof params[0] !== 'string' && typeof params[1] !== 'undefined';
 }
-function parseLogFormat(value) {
+function parseLogFormat$1(value) {
     switch (value) {
         case 'pretty':
         case 'plain':
@@ -16437,7 +16146,7 @@ function parseLogFormat(value) {
             return 'json';
     }
 }
-function logLevelName(level) {
+function logLevelName$1(level) {
     switch (level) {
         case 10:
             return ' T ';
@@ -16454,24 +16163,24 @@ function logLevelName(level) {
     }
     return '?????';
 }
-function colorize(level) {
+function colorize$1(level) {
     switch (level) {
         case 10:
-            return { color: chalk.gray, bgcolor: chalk.bgGray.black };
+            return { color: chalk$1.gray, bgcolor: chalk$1.bgGray.black };
         case 20:
-            return { color: chalk.gray, bgcolor: chalk.bgGray.black };
+            return { color: chalk$1.gray, bgcolor: chalk$1.bgGray.black };
         case 30:
-            return { color: chalk.white, bgcolor: chalk.bgWhite.black };
+            return { color: chalk$1.white, bgcolor: chalk$1.bgWhite.black };
         case 40:
-            return { color: chalk.yellow, bgcolor: chalk.bgYellow.black };
+            return { color: chalk$1.yellow, bgcolor: chalk$1.bgYellow.black };
         case 50:
-            return { color: chalk.red, bgcolor: chalk.bgRed.black };
+            return { color: chalk$1.red, bgcolor: chalk$1.bgRed.black };
         case 60:
-            return { color: chalk.red, bgcolor: chalk.bgRed.black };
+            return { color: chalk$1.red, bgcolor: chalk$1.bgRed.black };
     }
-    return { color: chalk.gray, bgcolor: chalk.bgGray.black };
+    return { color: chalk$1.gray, bgcolor: chalk$1.bgGray.black };
 }
-function customStringify(data, useSpaces = true) {
+function customStringify$1(data, useSpaces = true) {
     return (stringify$3(data, (_key, value) => {
         if (typeof Buffer !== 'undefined' && value instanceof Buffer) {
             return value.toString('base64');
@@ -16479,13 +16188,13 @@ function customStringify(data, useSpaces = true) {
         return value;
     }, useSpaces ? 2 : undefined) ?? '');
 }
-function prettyMessage(message) {
+function prettyMessage$1(message) {
     const logLevel = message.level ?? 30;
-    const { color, bgcolor } = colorize(logLevel);
+    const { color, bgcolor } = colorize$1(logLevel);
     const component = message.component ? `/${message.component}` : '';
     const baseMsg = [
-        chalk.gray(formatDate$1(new Date(message.when), 'time-dayofyear')),
-        bgcolor(logLevelName(logLevel)),
+        chalk$1.gray(formatDate$2(new Date(message.when), 'time-dayofyear')),
+        bgcolor(logLevelName$1(logLevel)),
         color(`${message.logger.name}${component}`),
         color(':'),
         color(message.message),
@@ -16494,7 +16203,7 @@ function prettyMessage(message) {
         for (const [key, value] of Object.entries(message.context)) {
             if (value instanceof Error) {
                 try {
-                    baseMsg.push(`\n\n[key = ${key} contains Error]\n\n${customStringify(serializeError(value))}`);
+                    baseMsg.push(`\n\n[key = ${key} contains Error]\n\n${customStringify$1(serializeError(value))}`);
                 }
                 catch {
                     baseMsg.push(`\n\n[key = ${key} contains Error]\n\n${value.name}\n${value.message}`);
@@ -16502,31 +16211,31 @@ function prettyMessage(message) {
                 delete message.context[key];
             }
         }
-        baseMsg.push(chalk.gray(`\n${customStringify(message.context)}`));
+        baseMsg.push(chalk$1.gray(`\n${customStringify$1(message.context)}`));
     }
     return baseMsg.join(' ');
 }
-function buildSerializeMessage(config) {
+function buildSerializeMessage$1(config) {
     if (config.format === 'pretty' || config.runtime === 'development') {
-        chalk.level = typeof document !== 'undefined' ? 0 : 3;
-        return prettyMessage;
+        chalk$1.level = typeof document !== 'undefined' ? 0 : 3;
+        return prettyMessage$1;
     }
     else if (config.format === 'json') {
-        return (message) => customStringify({ ...message, when: formatDate$1(message.when, 'iso') }, false);
+        return (message) => customStringify$1({ ...message, when: formatDate$2(message.when, 'iso') }, false);
     }
     else if (config.format === 'plain') {
         return (message) => {
             const logLevel = message.context.logLevel ?? 30;
             const component = message.context.component ? `/${JSON.stringify(message.context.component)}` : '';
             const baseMsg = [
-                formatDate$1(message.when, 'time-dayofyear'),
-                logLevelName(logLevel),
+                formatDate$2(message.when, 'time-dayofyear'),
+                logLevelName$1(logLevel),
                 `${message.logger.name}${component}`,
                 ':',
                 message.message,
             ];
             if (Object.keys(message.context).length > 0) {
-                baseMsg.push(`\n${customStringify(message.context)}`);
+                baseMsg.push(`\n${customStringify$1(message.context)}`);
             }
             return baseMsg.join(' ');
         };
@@ -16535,7 +16244,7 @@ function buildSerializeMessage(config) {
         throw new Error(`invalid configuration provided ${JSON.stringify(config, undefined, 2)}`);
     }
 }
-const writeMessage = (msg) => {
+const writeMessage$1 = (msg) => {
     if (msg.level < msg.logger.config.level)
         return;
     const message = msg.logger.serializeMessage(msg);
@@ -16551,29 +16260,29 @@ const writeMessage = (msg) => {
         console.log(message);
     }
 };
-const buildLogger = (name, initialConfig) => {
+const buildLogger$1 = (name, initialConfig) => {
     const _config = { ...initialConfig };
-    let serializeMessage = buildSerializeMessage(_config);
+    let serializeMessage = buildSerializeMessage$1(_config);
     const configure = (config) => {
         Object.assign(_config, config);
         // logger.trace({ config: logger.config }, `reconfigured logger: ${name}`);
-        serializeMessage = buildSerializeMessage(_config);
+        serializeMessage = buildSerializeMessage$1(_config);
     };
     const buildBoundFns = (opts) => {
         const { component } = opts;
         return {
-            trace: log.bind({ level: LogLevel.trace, component }),
-            debug: log.bind({ level: LogLevel.debug, component }),
-            info: log.bind({ level: LogLevel.info, component }),
-            warn: log.bind({ level: LogLevel.warn, component }),
-            error: log.bind({ level: LogLevel.error, component }),
-            fatal: log.bind({ level: LogLevel.fatal, component }),
+            trace: log.bind({ level: LogLevel$1.trace, component }),
+            debug: log.bind({ level: LogLevel$1.debug, component }),
+            info: log.bind({ level: LogLevel$1.info, component }),
+            warn: log.bind({ level: LogLevel$1.warn, component }),
+            error: log.bind({ level: LogLevel$1.error, component }),
+            fatal: log.bind({ level: LogLevel$1.fatal, component }),
         };
     };
     function log(...params) {
-        const ctxIndex = isLogFnParamsCtx(params) ? 0 : -1;
+        const ctxIndex = isLogFnParamsCtx$1(params) ? 0 : -1;
         const message = params.slice(ctxIndex + 1).join(' ');
-        writeMessage({
+        writeMessage$1({
             logger,
             when: new Date(),
             level: this.level,
@@ -16629,17 +16338,17 @@ const buildLogger = (name, initialConfig) => {
     // logger.trace({ config: logger.config }, `built logger: ${name}`);
     return logger;
 };
-const LOG_LEVEL_ENV = globalThis.ENV?.LOG_LEVEL ?? 'info';
-const defaultLogger = buildLogger('default', {
-    level: (typeof LOG_LEVEL_ENV === 'string' ? parseInt(LOG_LEVEL_ENV) : LOG_LEVEL_ENV) ?? 10,
+const LOG_LEVEL_ENV$1 = globalThis.ENV?.LOG_LEVEL ?? 'info';
+const defaultLogger$1 = buildLogger$1('default', {
+    level: (typeof LOG_LEVEL_ENV$1 === 'string' ? parseInt(LOG_LEVEL_ENV$1) : LOG_LEVEL_ENV$1) ?? 10,
     rootComponent: globalThis.ENV?.LOG_ROOT_COMPONENT ?? 'logger',
-    format: parseLogFormat(globalThis.ENV?.LOG_FORMAT),
+    format: parseLogFormat$1(globalThis.ENV?.LOG_FORMAT),
     runtime: globalThis.ENV?.RUNTIME ?? 'development',
 });
-const log$5 = defaultLogger;
-globalThis.log = defaultLogger;
+const log$6 = defaultLogger$1;
+globalThis.log = defaultLogger$1;
 
-const customFormats = {
+const customFormats$1 = {
     number: {
         bytes: {
             style: 'decimal',
@@ -16666,18 +16375,18 @@ const customFormats = {
         },
     },
 };
-const onIntlError = (error) => {
+const onIntlError$1 = (error) => {
     if (typeof window !== 'undefined') {
-        log$5.fatal(error);
+        log$6.fatal(error);
     }
 };
-const cache$1 = createIntlCache();
+const cache$2 = createIntlCache();
 createIntl({
     locale: 'en-US',
     defaultLocale: 'en-US',
-    formats: customFormats,
-    onError: onIntlError,
-}, cache$1);
+    formats: customFormats$1,
+    onError: onIntlError$1,
+}, cache$2);
 
 const undefined$1 = void null;
 
@@ -19697,6 +19406,1080 @@ renderCanvas.bind(null, function (data, _, opts) {
   return SvgRenderer.render(data, opts)
 });
 
+const ICE_SERVERS_API_ENDPOINT = "https://signal.cloud.luxonis.com/api/v1/turn-credentials";
+const DEFAULT_SIGNALING_SERVER_URL = "wss://signal.cloud.luxonis.com/session/";
+const DEFAULT_ICE_SERVERS = [
+    { urls: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"] },
+];
+const MAX_ACK_ATTEMPTS = 3;
+const ACK_RETRY_INTERVAL = 5_000;
+class WebRtcClient {
+    config;
+    socket;
+    connection = null;
+    signalingConnectionRetries;
+    hasAck = false;
+    ackRetryCount = 0;
+    events = new EventEmitter();
+    iceCandidates = [];
+    candidateQueue = [];
+    constructor(config) {
+        this.config = config;
+        // If user doesn't provide iceServers and doesn't want to use Luxonis ice servers, use default ice servers
+        if (!config.useLuxonisIceServers && config.iceServers === undefined) {
+            this.config.iceServers = DEFAULT_ICE_SERVERS;
+        }
+        this.signalingConnectionRetries =
+            (config.signalingConnectionRetries ?? 3) || 0;
+        this.connectSignalingServer();
+    }
+    async useLuxonisIceServers() {
+        try {
+            const response = await fetch(ICE_SERVERS_API_ENDPOINT);
+            const data = (await response.json());
+            if (data.iceServers) {
+                if (this.config.iceServers === undefined) {
+                    this.config.iceServers = [data.iceServers];
+                }
+                else {
+                    this.config.iceServers.push(data.iceServers);
+                }
+            }
+            else {
+                console.error("DAI Connection Error: Retrieved ICE servers are invalid.", data);
+                if (this.config.iceServers === undefined ||
+                    this.config.iceServers.length === 0) {
+                    console.error("DAI Connection Error: Retrieved ICE servers are invalid and no ICE servers were provided by client, falling back to default.");
+                    this.config.iceServers = DEFAULT_ICE_SERVERS;
+                }
+            }
+        }
+        catch (error) {
+            console.error("DAI Connection Error: Cannot retrieve ICE servers.", error);
+            if (this.config.iceServers === undefined ||
+                this.config.iceServers.length === 0) {
+                console.error("DAI Connection Error: Retrieved ICE servers are invalid and no ICE servers were provided by client, falling back to default.");
+                this.config.iceServers = DEFAULT_ICE_SERVERS;
+            }
+        }
+    }
+    get signalingServerConnected() {
+        return this.socket.readyState === WebSocket.OPEN;
+    }
+    disconnect(reason) {
+        this.connection?.close();
+        this.sendMessage({
+            Disconnect: {
+                type: "normal",
+                reason,
+            },
+        });
+    }
+    connect() {
+        this.sendConnectSessionMessage();
+        const interval = setInterval(() => {
+            this.sendConnectSessionMessage(interval);
+        }, ACK_RETRY_INTERVAL);
+    }
+    sendConnectSessionMessage(interval) {
+        if (this.hasAck) {
+            log$6.debug("[Signaling] Session acknowledged. Stopping retry interval.");
+            clearInterval(interval);
+            return;
+        }
+        if (this.ackRetryCount >= MAX_ACK_ATTEMPTS) {
+            log$6.error("[Signaling] Ran out of session acknowledge attempts");
+            clearInterval(interval);
+            this.events.emit("error", ["signaling_connection_timeout", "Run out of attempts to connect to signaling server"]);
+            return;
+        }
+        log$6.debug(`[Signaling] Sending ConnectSession message to signaling server number ${this.ackRetryCount + 1}/${MAX_ACK_ATTEMPTS}`);
+        this.sendMessage({
+            ConnectSession: {
+                client_id: this.config.clientId,
+                application_identifier: this.config.applicationIdentifier,
+                auth_payload: this.config.authPayload,
+            },
+        });
+        this.ackRetryCount += 1;
+    }
+    connectSignalingServer() {
+        log$6.debug({ signalingServerUrl: this.config.signalingServerUrl ?? DEFAULT_SIGNALING_SERVER_URL }, '[Signaling] Opening connection to Signaling server');
+        this.socket = new WebSocket(this.config.signalingServerUrl ?? DEFAULT_SIGNALING_SERVER_URL);
+        this.socket.onopen = () => {
+            log$6.debug("[Signaling] Connected to signaling server");
+            this.connect();
+        };
+        this.socket.onclose = () => {
+            log$6.debug('[Signaling] Disconnected from signaling server');
+            this.events.emit("signaling_connection_closed", []);
+        };
+        this.socket.onerror = (error) => {
+            this.events.emit("error", ["signaling_connection_error", error]);
+            if (!this.events.isEventHandled("error")) {
+                log$6.error({ error }, "[Signaling] Signaling connection error:");
+            }
+            setTimeout(() => {
+                if (this.signalingConnectionRetries) {
+                    this.signalingConnectionRetries -= 1;
+                    if (this.socket.readyState === WebSocket.CLOSED ||
+                        this.socket.readyState === WebSocket.CLOSING) {
+                        // console.debug('[WebRTC] Reconnecting to signaling server');
+                        this.connectSignalingServer();
+                    }
+                }
+            }, 3_000);
+        };
+        this.socket.onmessage = (event) => {
+            const message = JSON.parse(event.data);
+            log$6.debug({ message }, "[Signaling] New Signaling message");
+            this.handleSignalingMessage(message);
+        };
+    }
+    disconnectSignalingServer(reason) {
+        if (this.signalingServerConnected) {
+            this.sendMessage({
+                Disconnect: {
+                    type: "normal",
+                    reason,
+                },
+            });
+            this.socket.close();
+        }
+    }
+    handleSignalingMessage(message) {
+        if ("AcknowledgeSession" in message) {
+            log$6.debug({ message }, "[Signaling] Received AcknowledgeSession message");
+            this.hasAck = true;
+            if (message.AcknowledgeSession.acknowledge) {
+                if (this.config.useLuxonisIceServers) {
+                    this.useLuxonisIceServers().then(() => this.createConnection());
+                }
+                else {
+                    this.createConnection();
+                }
+            }
+            else {
+                if (!this.events.isEventHandled("error")) {
+                    console.error("[Signaling] Connection refused:", message.AcknowledgeSession.reason);
+                }
+                this.events.emit("error", [
+                    "signaling_rejected",
+                    message.AcknowledgeSession.reason,
+                ]);
+                this.dispose("Connection refused");
+            }
+        }
+        else if ("Candidate" in message) {
+            log$6.debug({ message }, "[Signaling] Received Candidate message");
+            void this.handleCandidateMessage(message);
+        }
+        else if ("Disconnect" in message) {
+            console.log({ message }, "[Signaling]: Received Disconnect message");
+            this.dispose("Target disconnected");
+        }
+    }
+    async handleCandidateMessage({ Candidate: { type: kind, candidate }, }) {
+        if (!this.connection) {
+            console.log("Candidate message received before connection established, adding to queue", { Candidate: { type: kind, candidate } });
+            this.candidateQueue.push({ Candidate: { type: kind, candidate } });
+            return;
+        }
+        // console.debug('[WebRTC] Processing candidate message', kind);
+        switch (kind) {
+            case "answer":
+            case "offer": {
+                const data = `${candidate}`;
+                if (data === "null" || data === "") {
+                    console.error("[Signaling] Offer refused: remote description cannot be null");
+                    this.reconnect("Error: received invalid candidate");
+                    return;
+                }
+                // console.debug('[WebRTC] Offer accepted. Setting remote description..');
+                await this.connection.setRemoteDescription(kind, candidate);
+                // console.debug('[WebRTC] Set remote description');
+                for (const iceCandidate of this.iceCandidates) {
+                    // console.debug('[WebRTC] Adding stored ICE candidate');
+                    void this.connection.addIceCandidate(JSON.parse(iceCandidate));
+                }
+                this.iceCandidates = [];
+                if (kind === "offer") {
+                    const answer = await this.connection.createDescription("answer");
+                    // console.debug('[WebRTC] Answer created (set local description)');
+                    this.sendMessage({
+                        Candidate: {
+                            type: "answer",
+                            candidate: answer.sdp ?? "",
+                        },
+                    });
+                }
+                return;
+            }
+            case "candidate": {
+                if (this.connection.peerConnection.remoteDescription === null) {
+                    // console.debug('[WebRTC] Storing ICE candidate (remote description is not set yet)');
+                    this.iceCandidates.push(candidate);
+                }
+                else {
+                    // console.debug('[WebRTC] Adding ICE candidate');
+                    return this.connection.addIceCandidate(JSON.parse(candidate));
+                }
+            }
+        }
+    }
+    reconnect(reason) {
+        // console.debug(`[WebRTC] Reconnecting: ${reason}`);
+        this.disconnect(reason);
+        this.connect();
+    }
+    sendMessage(message) {
+        // console.debug('[WebRTC] Sending message', message);
+        if (this.socket.readyState === WebSocket.OPEN) {
+            this.socket.send(JSON.stringify(message));
+        }
+    }
+    createConnection() {
+        this.connection = new WebRtcConnection({
+            iceServers: this.config.iceServers,
+            onCandidate: (candidate) => {
+                this.sendMessage({
+                    Candidate: {
+                        type: "candidate",
+                        candidate: JSON.stringify(candidate),
+                    },
+                });
+            },
+            onConnectionEstablished: () => this.disconnectSignalingServer("P2P connection established"),
+            withFragmentation: this.config.withFragmentation,
+        });
+        for (const candidate of this.candidateQueue) {
+            void this.handleCandidateMessage(candidate);
+        }
+        this.connection.on('connection_closed', () => this.events.emit('connection_closed', []));
+        this.events.emit("connection_established", [this.connection]);
+    }
+    dispose(reason) {
+        this.disconnect(reason);
+        this.disconnectSignalingServer(reason);
+    }
+    on = this.events.on.bind(this.events);
+}
+
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+function formatDate(date, format$1) {
+    switch (format$1) {
+        case 'iso':
+            return date.toISOString();
+        case 'time-dayofyear':
+            return format(date, 'D HH:mm:ss', { useAdditionalDayOfYearTokens: true });
+        case 'full':
+            return format(date, 'yyyy/MM/dd, hh:mm a');
+    }
+}
+
+z.string().min(6);
+z
+    .string()
+    .regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/, { message: 'Version must be in the format X.Y or X.Y.Z' });
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+var byteToHex$1 = [];
+for (var i$1 = 0; i$1 < 256; ++i$1) {
+  byteToHex$1.push((i$1 + 0x100).toString(16).slice(1));
+}
+function unsafeStringify$1(arr, offset = 0) {
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  //
+  // Note to future-self: No, you can't remove the `toLowerCase()` call.
+  // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351
+  return (byteToHex$1[arr[offset + 0]] + byteToHex$1[arr[offset + 1]] + byteToHex$1[arr[offset + 2]] + byteToHex$1[arr[offset + 3]] + '-' + byteToHex$1[arr[offset + 4]] + byteToHex$1[arr[offset + 5]] + '-' + byteToHex$1[arr[offset + 6]] + byteToHex$1[arr[offset + 7]] + '-' + byteToHex$1[arr[offset + 8]] + byteToHex$1[arr[offset + 9]] + '-' + byteToHex$1[arr[offset + 10]] + byteToHex$1[arr[offset + 11]] + byteToHex$1[arr[offset + 12]] + byteToHex$1[arr[offset + 13]] + byteToHex$1[arr[offset + 14]] + byteToHex$1[arr[offset + 15]]).toLowerCase();
+}
+
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+
+var getRandomValues$1;
+var rnds8$1 = new Uint8Array(16);
+function rng$1() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues$1) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+    getRandomValues$1 = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+    if (!getRandomValues$1) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+  return getRandomValues$1(rnds8$1);
+}
+
+var randomUUID$1 = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native$1 = {
+  randomUUID: randomUUID$1
+};
+
+function v4$1(options, buf, offset) {
+  if (native$1.randomUUID && !buf && !options) {
+    return native$1.randomUUID();
+  }
+  options = options || {};
+  var rnds = options.random || (options.rng || rng$1)();
+
+  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80;
+  return unsafeStringify$1(rnds);
+}
+
+const MB = 1024 ** 2;
+
+const ANSI_BACKGROUND_OFFSET = 10;
+
+const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`;
+
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		// 21 isn't widely supported and 22 does the same thing
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29],
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+
+		// Bright color
+		blackBright: [90, 39],
+		gray: [90, 39], // Alias of `blackBright`
+		grey: [90, 39], // Alias of `blackBright`
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39],
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+
+		// Bright color
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49], // Alias of `bgBlackBright`
+		bgGrey: [100, 49], // Alias of `bgBlackBright`
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49],
+	},
+};
+
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+
+function assembleStyles() {
+	const codes = new Map();
+
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`,
+			};
+
+			group[styleName] = styles$1[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false,
+		});
+	}
+
+	Object.defineProperty(styles$1, 'codes', {
+		value: codes,
+		enumerable: false,
+	});
+
+	styles$1.color.close = '\u001B[39m';
+	styles$1.bgColor.close = '\u001B[49m';
+
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				// We use the extended greyscale palette here, with the exception of
+				// black and white. normal palette only has 4 greyscale shades.
+				if (red === green && green === blue) {
+					if (red < 8) {
+						return 16;
+					}
+
+					if (red > 248) {
+						return 231;
+					}
+
+					return Math.round(((red - 8) / 247) * 24) + 232;
+				}
+
+				return 16
+					+ (36 * Math.round(red / 255 * 5))
+					+ (6 * Math.round(green / 255 * 5))
+					+ Math.round(blue / 255 * 5);
+			},
+			enumerable: false,
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) {
+					return [0, 0, 0];
+				}
+
+				let [colorString] = matches;
+
+				if (colorString.length === 3) {
+					colorString = [...colorString].map(character => character + character).join('');
+				}
+
+				const integer = Number.parseInt(colorString, 16);
+
+				return [
+					/* eslint-disable no-bitwise */
+					(integer >> 16) & 0xFF,
+					(integer >> 8) & 0xFF,
+					integer & 0xFF,
+					/* eslint-enable no-bitwise */
+				];
+			},
+			enumerable: false,
+		},
+		hexToAnsi256: {
+			value: hex => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false,
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) {
+					return 30 + code;
+				}
+
+				if (code < 16) {
+					return 90 + (code - 8);
+				}
+
+				let red;
+				let green;
+				let blue;
+
+				if (code >= 232) {
+					red = (((code - 232) * 10) + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+
+					const remainder = code % 36;
+
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = (remainder % 6) / 5;
+				}
+
+				const value = Math.max(red, green, blue) * 2;
+
+				if (value === 0) {
+					return 30;
+				}
+
+				// eslint-disable-next-line no-bitwise
+				let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
+
+				if (value === 2) {
+					result += 60;
+				}
+
+				return result;
+			},
+			enumerable: false,
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false,
+		},
+		hexToAnsi: {
+			value: hex => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false,
+		},
+	});
+
+	return styles$1;
+}
+
+const ansiStyles = assembleStyles();
+
+/* eslint-env browser */
+
+const level = (() => {
+	if (navigator.userAgentData) {
+		const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium');
+		if (brand && brand.version > 93) {
+			return 3;
+		}
+	}
+
+	if (/\b(Chrome|Chromium)\//.test(navigator.userAgent)) {
+		return 1;
+	}
+
+	return 0;
+})();
+
+const colorSupport = level !== 0 && {
+	level,
+	hasBasic: true,
+	has256: level >= 2,
+	has16m: level >= 3,
+};
+
+const supportsColor = {
+	stdout: colorSupport,
+	stderr: colorSupport,
+};
+
+// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
+
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
+
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+
+const {stdout: stdoutColor, stderr: stderrColor} = supportsColor;
+
+const GENERATOR = Symbol('GENERATOR');
+const STYLER = Symbol('STYLER');
+const IS_EMPTY = Symbol('IS_EMPTY');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = [
+	'ansi',
+	'ansi',
+	'ansi256',
+	'ansi16m',
+];
+
+const styles = Object.create(null);
+
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+		throw new Error('The `level` option should be an integer from 0 to 3');
+	}
+
+	// Detect level if not set manually
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+const chalkFactory = options => {
+	const chalk = (...strings) => strings.join(' ');
+	applyOptions(chalk, options);
+
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+
+	return chalk;
+};
+
+function createChalk(options) {
+	return chalkFactory(options);
+}
+
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+	styles[styleName] = {
+		get() {
+			const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+			Object.defineProperty(this, styleName, {value: builder});
+			return builder;
+		},
+	};
+}
+
+styles.visible = {
+	get() {
+		const builder = createBuilder(this, this[STYLER], true);
+		Object.defineProperty(this, 'visible', {value: builder});
+		return builder;
+	},
+};
+
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === 'rgb') {
+		if (level === 'ansi16m') {
+			return ansiStyles[type].ansi16m(...arguments_);
+		}
+
+		if (level === 'ansi256') {
+			return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		}
+
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+
+	if (model === 'hex') {
+		return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));
+	}
+
+	return ansiStyles[type][model](...arguments_);
+};
+
+const usedModels = ['rgb', 'hex', 'ansi256'];
+
+for (const model of usedModels) {
+	styles[model] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		},
+	};
+
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		},
+	};
+}
+
+const proto$1 = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		},
+	},
+});
+
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === undefined) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent,
+	};
+};
+
+const createBuilder = (self, _styler, _isEmpty) => {
+	// Single argument is hot path, implicit coercion is faster than anything
+	// eslint-disable-next-line no-implicit-coercion
+	const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+
+	// We alter the prototype because we must return a function, but there is
+	// no way to create a function with a different prototype
+	Object.setPrototypeOf(builder, proto$1);
+
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+
+	return builder;
+};
+
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) {
+		return self[IS_EMPTY] ? '' : string;
+	}
+
+	let styler = self[STYLER];
+
+	if (styler === undefined) {
+		return string;
+	}
+
+	const {openAll, closeAll} = styler;
+	if (string.includes('\u001B')) {
+		while (styler !== undefined) {
+			// Replace any instances already present with a re-opening code
+			// otherwise only the part of the string until said closing code
+			// will be colored, and the rest will simply be 'plain'.
+			string = stringReplaceAll(string, styler.close, styler.open);
+
+			styler = styler.parent;
+		}
+	}
+
+	// We can move both next actions out of loop, because remaining actions in loop won't have
+	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+	const lfIndex = string.indexOf('\n');
+	if (lfIndex !== -1) {
+		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	}
+
+	return openAll + string + closeAll;
+};
+
+Object.defineProperties(createChalk.prototype, styles);
+
+const chalk = createChalk();
+createChalk({level: stderrColor ? stderrColor.level : 0});
+
+/* eslint-disable no-var */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["trace"] = 10] = "trace";
+    LogLevel[LogLevel["debug"] = 20] = "debug";
+    LogLevel[LogLevel["info"] = 30] = "info";
+    LogLevel[LogLevel["warn"] = 40] = "warn";
+    LogLevel[LogLevel["error"] = 50] = "error";
+    LogLevel[LogLevel["fatal"] = 60] = "fatal";
+})(LogLevel || (LogLevel = {}));
+function isLogFnParamsCtx(params) {
+    return typeof params[0] !== 'string' && typeof params[1] !== 'undefined';
+}
+function parseLogFormat(value) {
+    switch (value) {
+        case 'pretty':
+        case 'plain':
+        case 'json':
+            return value;
+        default:
+            return 'json';
+    }
+}
+function logLevelName(level) {
+    switch (level) {
+        case 10:
+            return ' T ';
+        case 20:
+            return ' D ';
+        case 30:
+            return ' I ';
+        case 40:
+            return ' W ';
+        case 50:
+            return ' E ';
+        case 60:
+            return ' F ';
+    }
+    return '?????';
+}
+function colorize(level) {
+    switch (level) {
+        case 10:
+            return { color: chalk.gray, bgcolor: chalk.bgGray.black };
+        case 20:
+            return { color: chalk.gray, bgcolor: chalk.bgGray.black };
+        case 30:
+            return { color: chalk.white, bgcolor: chalk.bgWhite.black };
+        case 40:
+            return { color: chalk.yellow, bgcolor: chalk.bgYellow.black };
+        case 50:
+            return { color: chalk.red, bgcolor: chalk.bgRed.black };
+        case 60:
+            return { color: chalk.red, bgcolor: chalk.bgRed.black };
+    }
+    return { color: chalk.gray, bgcolor: chalk.bgGray.black };
+}
+function customStringify(data, useSpaces = true) {
+    return (stringify$3(data, (_key, value) => {
+        if (typeof Buffer !== 'undefined' && value instanceof Buffer) {
+            return value.toString('base64');
+        }
+        return value;
+    }, useSpaces ? 2 : undefined) ?? '');
+}
+function prettyMessage(message) {
+    const logLevel = message.level ?? 30;
+    const { color, bgcolor } = colorize(logLevel);
+    const component = message.component ? `/${message.component}` : '';
+    const baseMsg = [
+        chalk.gray(formatDate(new Date(message.when), 'time-dayofyear')),
+        bgcolor(logLevelName(logLevel)),
+        color(`${message.logger.name}${component}`),
+        color(':'),
+        color(message.message),
+    ];
+    if (Object.keys(message.context).length > 0) {
+        for (const [key, value] of Object.entries(message.context)) {
+            if (value instanceof Error) {
+                try {
+                    baseMsg.push(`\n\n[key = ${key} contains Error]\n\n${customStringify(serializeError(value))}`);
+                }
+                catch {
+                    baseMsg.push(`\n\n[key = ${key} contains Error]\n\n${value.name}\n${value.message}`);
+                }
+                delete message.context[key];
+            }
+        }
+        baseMsg.push(chalk.gray(`\n${customStringify(message.context)}`));
+    }
+    return baseMsg.join(' ');
+}
+function buildSerializeMessage(config) {
+    if (config.format === 'pretty' || config.runtime === 'development') {
+        chalk.level = typeof document !== 'undefined' ? 0 : 3;
+        return prettyMessage;
+    }
+    else if (config.format === 'json') {
+        return (message) => customStringify({ ...message, when: formatDate(message.when, 'iso') }, false);
+    }
+    else if (config.format === 'plain') {
+        return (message) => {
+            const logLevel = message.context.logLevel ?? 30;
+            const component = message.context.component ? `/${JSON.stringify(message.context.component)}` : '';
+            const baseMsg = [
+                formatDate(message.when, 'time-dayofyear'),
+                logLevelName(logLevel),
+                `${message.logger.name}${component}`,
+                ':',
+                message.message,
+            ];
+            if (Object.keys(message.context).length > 0) {
+                baseMsg.push(`\n${customStringify(message.context)}`);
+            }
+            return baseMsg.join(' ');
+        };
+    }
+    else {
+        throw new Error(`invalid configuration provided ${JSON.stringify(config, undefined, 2)}`);
+    }
+}
+const writeMessage = (msg) => {
+    if (msg.level < msg.logger.config.level)
+        return;
+    const message = msg.logger.serializeMessage(msg);
+    if (typeof document !== 'undefined') {
+        // eslint-disable-next-line no-console
+        console.log(message);
+    }
+    else if (typeof process !== 'undefined') {
+        process.stdout.write(`${message}\n`);
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.log(message);
+    }
+};
+const buildLogger = (name, initialConfig) => {
+    const _config = { ...initialConfig };
+    let serializeMessage = buildSerializeMessage(_config);
+    const configure = (config) => {
+        Object.assign(_config, config);
+        // logger.trace({ config: logger.config }, `reconfigured logger: ${name}`);
+        serializeMessage = buildSerializeMessage(_config);
+    };
+    const buildBoundFns = (opts) => {
+        const { component } = opts;
+        return {
+            trace: log.bind({ level: LogLevel.trace, component }),
+            debug: log.bind({ level: LogLevel.debug, component }),
+            info: log.bind({ level: LogLevel.info, component }),
+            warn: log.bind({ level: LogLevel.warn, component }),
+            error: log.bind({ level: LogLevel.error, component }),
+            fatal: log.bind({ level: LogLevel.fatal, component }),
+        };
+    };
+    function log(...params) {
+        const ctxIndex = isLogFnParamsCtx(params) ? 0 : -1;
+        const message = params.slice(ctxIndex + 1).join(' ');
+        writeMessage({
+            logger,
+            when: new Date(),
+            level: this.level,
+            context: ctxIndex !== -1 ? params[ctxIndex] : {},
+            component: this.component,
+            message,
+        });
+    }
+    const child = (component) => {
+        const parent = logger;
+        return {
+            ...parent,
+            ...buildBoundFns({ component }),
+        };
+    };
+    const canLogLevel = (level) => {
+        return _config.level <= level;
+    };
+    const logger = {
+        get config() {
+            return _config;
+        },
+        get name() {
+            return _config.rootComponent;
+        },
+        serializeMessage: msg => {
+            if (_config.format !== 'pretty') {
+                const newContext = { ...msg.context };
+                for (const entry of Object.entries(msg.context)) {
+                    let value = msg.context[entry[0]];
+                    if (value instanceof Error) {
+                        try {
+                            value = serializeError(value, {
+                                maxDepth: 3,
+                            });
+                        }
+                        catch (e) {
+                            logger.warn({ error: e }, `serialize of error failed`);
+                            // serialize failed, keep original value
+                        }
+                    }
+                    newContext[entry[0]] = value;
+                }
+                Object.assign(msg, { context: newContext });
+            }
+            return serializeMessage(msg);
+        },
+        child,
+        configure,
+        canLogLevel,
+        ...buildBoundFns({ component: null }),
+    };
+    // logger.trace({ config: logger.config }, `built logger: ${name}`);
+    return logger;
+};
+const LOG_LEVEL_ENV = globalThis.ENV?.LOG_LEVEL ?? 'info';
+const defaultLogger = buildLogger('default', {
+    level: (typeof LOG_LEVEL_ENV === 'string' ? parseInt(LOG_LEVEL_ENV) : LOG_LEVEL_ENV) ?? 10,
+    rootComponent: globalThis.ENV?.LOG_ROOT_COMPONENT ?? 'logger',
+    format: parseLogFormat(globalThis.ENV?.LOG_FORMAT),
+    runtime: globalThis.ENV?.RUNTIME ?? 'development',
+});
+const log$5 = defaultLogger;
+globalThis.log = defaultLogger;
+
+const customFormats = {
+    number: {
+        bytes: {
+            style: 'decimal',
+            maximumFractionDigits: 1,
+        },
+        temperature: {
+            style: 'decimal',
+            maximumFractionDigits: 0,
+        },
+    },
+    date: {
+        log: {
+            dateStyle: undefined,
+            timeStyle: 'medium',
+            hourCycle: 'h24',
+        },
+        short: {
+            dateStyle: 'short',
+            timeStyle: 'short',
+        },
+        long: {
+            dateStyle: 'long',
+            timeStyle: 'long',
+        },
+    },
+};
+const onIntlError = (error) => {
+    if (typeof window !== 'undefined') {
+        log$5.fatal(error);
+    }
+};
+const cache$1 = createIntlCache();
+createIntl({
+    locale: 'en-US',
+    defaultLocale: 'en-US',
+    formats: customFormats,
+    onError: onIntlError,
+}, cache$1);
+
 /**
  * uuidv7: A JavaScript implementation of UUID version 7
  *
@@ -86854,7 +87637,7 @@ function legacy(parser) {
     return new LanguageSupport(StreamLanguage.define(parser));
 }
 function sql$1(dialectName) {
-    return import('./index-BR6d3Vau.js').then(m => m.sql({ dialect: m[dialectName] }));
+    return import('./index-CYacWfNm.js').then(m => m.sql({ dialect: m[dialectName] }));
 }
 /**
 An array of language descriptions for known language packages.
@@ -86865,7 +87648,7 @@ const languages = [
         name: "C",
         extensions: ["c", "h", "ino"],
         load() {
-            return import('./index-CYLvsgL5.js').then(m => m.cpp());
+            return import('./index-DStKU_m4.js').then(m => m.cpp());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -86873,7 +87656,7 @@ const languages = [
         alias: ["cpp"],
         extensions: ["cpp", "c++", "cc", "cxx", "hpp", "h++", "hh", "hxx"],
         load() {
-            return import('./index-CYLvsgL5.js').then(m => m.cpp());
+            return import('./index-DStKU_m4.js').then(m => m.cpp());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -86893,7 +87676,7 @@ const languages = [
         name: "Go",
         extensions: ["go"],
         load() {
-            return import('./index-BCdQdtW5.js').then(m => m.go());
+            return import('./index-Bj-jvewZ.js').then(m => m.go());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -86908,7 +87691,7 @@ const languages = [
         name: "Java",
         extensions: ["java"],
         load() {
-            return import('./index-infICipp.js').then(m => m.java());
+            return import('./index-tDpn89Zp.js').then(m => m.java());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -86924,7 +87707,7 @@ const languages = [
         alias: ["json5"],
         extensions: ["json", "map"],
         load() {
-            return import('./index-CjHYdviO.js').then(m => m.json());
+            return import('./index-DTFKRqLM.js').then(m => m.json());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -86938,14 +87721,14 @@ const languages = [
         name: "LESS",
         extensions: ["less"],
         load() {
-            return import('./index-DXpkVS7w.js').then(m => m.less());
+            return import('./index-Bc5U6u60.js').then(m => m.less());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
         name: "Liquid",
         extensions: ["liquid"],
         load() {
-            return import('./index-BRbo2R3_.js').then(m => m.liquid());
+            return import('./index-Chc7ZsWv.js').then(m => m.liquid());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -86971,7 +87754,7 @@ const languages = [
         name: "PHP",
         extensions: ["php", "php3", "php4", "php5", "php7", "phtml"],
         load() {
-            return import('./index-ZiR_XG5f.js').then(m => m.php());
+            return import('./index-Cn_10J2U.js').then(m => m.php());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -86988,28 +87771,28 @@ const languages = [
         extensions: ["BUILD", "bzl", "py", "pyw"],
         filename: /^(BUCK|BUILD)$/,
         load() {
-            return import('./index-DuW_6rXO.js').then(m => m.python());
+            return import('./index-D8RZhg5u.js').then(m => m.python());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
         name: "Rust",
         extensions: ["rs"],
         load() {
-            return import('./index-DZF3BDjA.js').then(m => m.rust());
+            return import('./index-Bh2lN3Qs.js').then(m => m.rust());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
         name: "Sass",
         extensions: ["sass"],
         load() {
-            return import('./index-CkdQyQ56.js').then(m => m.sass({ indented: true }));
+            return import('./index-Cjd3IRB4.js').then(m => m.sass({ indented: true }));
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
         name: "SCSS",
         extensions: ["scss"],
         load() {
-            return import('./index-CkdQyQ56.js').then(m => m.sass());
+            return import('./index-Cjd3IRB4.js').then(m => m.sass());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -87040,7 +87823,7 @@ const languages = [
         name: "WebAssembly",
         extensions: ["wat", "wast"],
         load() {
-            return import('./index-DWfIq18N.js').then(m => m.wast());
+            return import('./index-DrYQWq6e.js').then(m => m.wast());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -87048,7 +87831,7 @@ const languages = [
         alias: ["rss", "wsdl", "xsd"],
         extensions: ["xml", "xsl", "xsd", "svg"],
         load() {
-            return import('./index-CWqy3204.js').then(m => m.xml());
+            return import('./index-Dlz-HJJO.js').then(m => m.xml());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
@@ -87056,7 +87839,7 @@ const languages = [
         alias: ["yml"],
         extensions: ["yaml", "yml"],
         load() {
-            return import('./index-BguswDvx.js').then(m => m.yaml());
+            return import('./index-j51ECvjo.js').then(m => m.yaml());
         }
     }),
     // Legacy modes ported from CodeMirror 5
@@ -87852,13 +88635,13 @@ const languages = [
         name: "Vue",
         extensions: ["vue"],
         load() {
-            return import('./index-Cay2B7V3.js').then(m => m.vue());
+            return import('./index-VLOOSQNv.js').then(m => m.vue());
         }
     }),
     /*@__PURE__*/LanguageDescription.of({
         name: "Angular Template",
         load() {
-            return import('./index-6-56hcEh.js').then(m => m.angular());
+            return import('./index-CYP-uQw-.js').then(m => m.angular());
         }
     })
 ];
@@ -166582,7 +167365,7 @@ function createRenderDelaySampler() {
   };
 }
 
-const ImagePanelComponent = /*#__PURE__*/React__default.lazy(async () => await import('./index-B25oQun6.js'));
+const ImagePanelComponent = /*#__PURE__*/React__default.lazy(async () => await import('./index-BH7Qg3OW.js'));
 const ImagePanelBody = ({
   topic,
   frameRenderedEvent,
@@ -166677,7 +167460,7 @@ const DEFAULT_CAMERA_STATE = {
 // License, v2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/
 
-const ThreeDeeRenderComponent = /*#__PURE__*/React__default.lazy(async () => await import('./index-BOD1lNuW.js'));
+const ThreeDeeRenderComponent = /*#__PURE__*/React__default.lazy(async () => await import('./index-LozxNs8k.js'));
 const PointCloudPanelBody = ({
   topic,
   frameRenderedEvent,