@luxonis/visualizer-protobuf 2.15.0 → 2.16.1

package/dist/{FoxgloveServer-DiLI7KZU.js → FoxgloveServer-tJZcJH5-.js}

@@ -1498,11 +1498,9 @@ Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
   );
 };
 
-// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
-// versions:
-//   protoc-gen-ts_proto  v1.181.1
-//   protoc               v4.25.1
-// source: common.proto
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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/
 
 let CameraModel = /*#__PURE__*/function (CameraModel) {
   CameraModel[CameraModel["PERSPECTIVE"] = 0] = "PERSPECTIVE";
@@ -2196,11 +2194,9 @@ function isSet$6(value) {
   return value !== null && value !== undefined;
 }
 
-// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
-// versions:
-//   protoc-gen-ts_proto  v1.181.1
-//   protoc               v4.25.1
-// source: ImageAnnotations.proto
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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 protobufPackage$5 = "dai.proto.image_annotations";
 let PointsAnnotationType = /*#__PURE__*/function (PointsAnnotationType) {
@@ -2810,11 +2806,9 @@ function isSet$5(value) {
 }
 const protobufName$5 = "ImageAnnotations";
 
-// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
-// versions:
-//   protoc-gen-ts_proto  v1.181.1
-//   protoc               v4.25.1
-// source: ImgFrame.proto
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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 protobufPackage$4 = "dai.proto.img_frame";
 let Type = /*#__PURE__*/function (Type) {
@@ -3444,11 +3438,9 @@ function isSet$4(value) {
 }
 const protobufName$4 = "ImgFrame";
 
-// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
-// versions:
-//   protoc-gen-ts_proto  v1.181.1
-//   protoc               v4.25.1
-// source: EncodedFrame.proto
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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 protobufPackage$3 = "dai.proto.encoded_frame";
 let Profile = /*#__PURE__*/function (Profile) {
@@ -3851,11 +3843,9 @@ function isSet$3(value) {
 }
 const protobufName$3 = "EncodedFrame";
 
-// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
-// versions:
-//   protoc-gen-ts_proto  v1.181.1
-//   protoc               v4.25.1
-// source: ImgDetections.proto
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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 protobufPackage$2 = "dai.proto.img_detections";
 function createBaseImgDetections() {
@@ -4119,11 +4109,9 @@ function isSet$2(value) {
 }
 const protobufName$2 = "ImgDetections";
 
-// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
-// versions:
-//   protoc-gen-ts_proto  v1.181.1
-//   protoc               v4.25.1
-// source: PointCloudData.proto
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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 protobufPackage$1 = "dai.proto.point_cloud_data";
 function createBasePointCloudData() {
@@ -4431,11 +4419,9 @@ function isSet$1(value) {
 }
 const protobufName$1 = "PointCloudData";
 
-// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
-// versions:
-//   protoc-gen-ts_proto  v1.181.1
-//   protoc               v4.25.1
-// source: SpatialImgDetections.proto
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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 protobufPackage = "dai.proto.spatial_img_detections";
 let SpatialLocationCalculatorAlgorithm = /*#__PURE__*/function (SpatialLocationCalculatorAlgorithm) {

package/dist/comlink-D0blLC4P.js

@@ -0,0 +1,344 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const proxyMarker = Symbol("Comlink.proxy");
+const createEndpoint = Symbol("Comlink.endpoint");
+const releaseProxy = Symbol("Comlink.releaseProxy");
+const finalizer = Symbol("Comlink.finalizer");
+const throwMarker = Symbol("Comlink.thrown");
+const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
+/**
+ * Internal transfer handle to handle objects marked to proxy.
+ */
+const proxyTransferHandler = {
+    canHandle: (val) => isObject(val) && val[proxyMarker],
+    serialize(obj) {
+        const { port1, port2 } = new MessageChannel();
+        expose(obj, port1);
+        return [port2, [port2]];
+    },
+    deserialize(port) {
+        port.start();
+        return wrap(port);
+    },
+};
+/**
+ * Internal transfer handler to handle thrown exceptions.
+ */
+const throwTransferHandler = {
+    canHandle: (value) => isObject(value) && throwMarker in value,
+    serialize({ value }) {
+        let serialized;
+        if (value instanceof Error) {
+            serialized = {
+                isError: true,
+                value: {
+                    message: value.message,
+                    name: value.name,
+                    stack: value.stack,
+                },
+            };
+        }
+        else {
+            serialized = { isError: false, value };
+        }
+        return [serialized, []];
+    },
+    deserialize(serialized) {
+        if (serialized.isError) {
+            throw Object.assign(new Error(serialized.value.message), serialized.value);
+        }
+        throw serialized.value;
+    },
+};
+/**
+ * Allows customizing the serialization of certain values.
+ */
+const transferHandlers = new Map([
+    ["proxy", proxyTransferHandler],
+    ["throw", throwTransferHandler],
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+    for (const allowedOrigin of allowedOrigins) {
+        if (origin === allowedOrigin || allowedOrigin === "*") {
+            return true;
+        }
+        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+            return true;
+        }
+    }
+    return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+    ep.addEventListener("message", function callback(ev) {
+        if (!ev || !ev.data) {
+            return;
+        }
+        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+            return;
+        }
+        const { id, type, path } = Object.assign({ path: [] }, ev.data);
+        const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+        let returnValue;
+        try {
+            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
+            const rawValue = path.reduce((obj, prop) => obj[prop], obj);
+            switch (type) {
+                case "GET" /* MessageType.GET */:
+                    {
+                        returnValue = rawValue;
+                    }
+                    break;
+                case "SET" /* MessageType.SET */:
+                    {
+                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+                        returnValue = true;
+                    }
+                    break;
+                case "APPLY" /* MessageType.APPLY */:
+                    {
+                        returnValue = rawValue.apply(parent, argumentList);
+                    }
+                    break;
+                case "CONSTRUCT" /* MessageType.CONSTRUCT */:
+                    {
+                        const value = new rawValue(...argumentList);
+                        returnValue = proxy(value);
+                    }
+                    break;
+                case "ENDPOINT" /* MessageType.ENDPOINT */:
+                    {
+                        const { port1, port2 } = new MessageChannel();
+                        expose(obj, port2);
+                        returnValue = transfer(port1, [port1]);
+                    }
+                    break;
+                case "RELEASE" /* MessageType.RELEASE */:
+                    {
+                        returnValue = undefined;
+                    }
+                    break;
+                default:
+                    return;
+            }
+        }
+        catch (value) {
+            returnValue = { value, [throwMarker]: 0 };
+        }
+        Promise.resolve(returnValue)
+            .catch((value) => {
+            return { value, [throwMarker]: 0 };
+        })
+            .then((returnValue) => {
+            const [wireValue, transferables] = toWireValue(returnValue);
+            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+            if (type === "RELEASE" /* MessageType.RELEASE */) {
+                // detach and deactive after sending release response above.
+                ep.removeEventListener("message", callback);
+                closeEndPoint(ep);
+                if (finalizer in obj && typeof obj[finalizer] === "function") {
+                    obj[finalizer]();
+                }
+            }
+        })
+            .catch((error) => {
+            // Send Serialization Error To Caller
+            const [wireValue, transferables] = toWireValue({
+                value: new TypeError("Unserializable return value"),
+                [throwMarker]: 0,
+            });
+            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+        });
+    });
+    if (ep.start) {
+        ep.start();
+    }
+}
+function isMessagePort(endpoint) {
+    return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+    if (isMessagePort(endpoint))
+        endpoint.close();
+}
+function wrap(ep, target) {
+    const pendingListeners = new Map();
+    ep.addEventListener("message", function handleMessage(ev) {
+        const { data } = ev;
+        if (!data || !data.id) {
+            return;
+        }
+        const resolver = pendingListeners.get(data.id);
+        if (!resolver) {
+            return;
+        }
+        try {
+            resolver(data);
+        }
+        finally {
+            pendingListeners.delete(data.id);
+        }
+    });
+    return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+    if (isReleased) {
+        throw new Error("Proxy has been released and is not useable");
+    }
+}
+function releaseEndpoint(ep) {
+    return requestResponseMessage(ep, new Map(), {
+        type: "RELEASE" /* MessageType.RELEASE */,
+    }).then(() => {
+        closeEndPoint(ep);
+    });
+}
+const proxyCounter = new WeakMap();
+const proxyFinalizers = "FinalizationRegistry" in globalThis &&
+    new FinalizationRegistry((ep) => {
+        const newCount = (proxyCounter.get(ep) || 0) - 1;
+        proxyCounter.set(ep, newCount);
+        if (newCount === 0) {
+            releaseEndpoint(ep);
+        }
+    });
+function registerProxy(proxy, ep) {
+    const newCount = (proxyCounter.get(ep) || 0) + 1;
+    proxyCounter.set(ep, newCount);
+    if (proxyFinalizers) {
+        proxyFinalizers.register(proxy, ep, proxy);
+    }
+}
+function unregisterProxy(proxy) {
+    if (proxyFinalizers) {
+        proxyFinalizers.unregister(proxy);
+    }
+}
+function createProxy(ep, pendingListeners, path = [], target = function () { }) {
+    let isProxyReleased = false;
+    const proxy = new Proxy(target, {
+        get(_target, prop) {
+            throwIfProxyReleased(isProxyReleased);
+            if (prop === releaseProxy) {
+                return () => {
+                    unregisterProxy(proxy);
+                    releaseEndpoint(ep);
+                    pendingListeners.clear();
+                    isProxyReleased = true;
+                };
+            }
+            if (prop === "then") {
+                if (path.length === 0) {
+                    return { then: () => proxy };
+                }
+                const r = requestResponseMessage(ep, pendingListeners, {
+                    type: "GET" /* MessageType.GET */,
+                    path: path.map((p) => p.toString()),
+                }).then(fromWireValue);
+                return r.then.bind(r);
+            }
+            return createProxy(ep, pendingListeners, [...path, prop]);
+        },
+        set(_target, prop, rawValue) {
+            throwIfProxyReleased(isProxyReleased);
+            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
+            // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
+            const [value, transferables] = toWireValue(rawValue);
+            return requestResponseMessage(ep, pendingListeners, {
+                type: "SET" /* MessageType.SET */,
+                path: [...path, prop].map((p) => p.toString()),
+                value,
+            }, transferables).then(fromWireValue);
+        },
+        apply(_target, _thisArg, rawArgumentList) {
+            throwIfProxyReleased(isProxyReleased);
+            const last = path[path.length - 1];
+            if (last === createEndpoint) {
+                return requestResponseMessage(ep, pendingListeners, {
+                    type: "ENDPOINT" /* MessageType.ENDPOINT */,
+                }).then(fromWireValue);
+            }
+            // We just pretend that `bind()` didn’t happen.
+            if (last === "bind") {
+                return createProxy(ep, pendingListeners, path.slice(0, -1));
+            }
+            const [argumentList, transferables] = processArguments(rawArgumentList);
+            return requestResponseMessage(ep, pendingListeners, {
+                type: "APPLY" /* MessageType.APPLY */,
+                path: path.map((p) => p.toString()),
+                argumentList,
+            }, transferables).then(fromWireValue);
+        },
+        construct(_target, rawArgumentList) {
+            throwIfProxyReleased(isProxyReleased);
+            const [argumentList, transferables] = processArguments(rawArgumentList);
+            return requestResponseMessage(ep, pendingListeners, {
+                type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
+                path: path.map((p) => p.toString()),
+                argumentList,
+            }, transferables).then(fromWireValue);
+        },
+    });
+    registerProxy(proxy, ep);
+    return proxy;
+}
+function myFlat(arr) {
+    return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+    const processed = argumentList.map(toWireValue);
+    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+const transferCache = new WeakMap();
+function transfer(obj, transfers) {
+    transferCache.set(obj, transfers);
+    return obj;
+}
+function proxy(obj) {
+    return Object.assign(obj, { [proxyMarker]: true });
+}
+function toWireValue(value) {
+    for (const [name, handler] of transferHandlers) {
+        if (handler.canHandle(value)) {
+            const [serializedValue, transferables] = handler.serialize(value);
+            return [
+                {
+                    type: "HANDLER" /* WireValueType.HANDLER */,
+                    name,
+                    value: serializedValue,
+                },
+                transferables,
+            ];
+        }
+    }
+    return [
+        {
+            type: "RAW" /* WireValueType.RAW */,
+            value,
+        },
+        transferCache.get(value) || [],
+    ];
+}
+function fromWireValue(value) {
+    switch (value.type) {
+        case "HANDLER" /* WireValueType.HANDLER */:
+            return transferHandlers.get(value.name).deserialize(value.value);
+        case "RAW" /* WireValueType.RAW */:
+            return value.value;
+    }
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+    return new Promise((resolve) => {
+        const id = Math.trunc(Math.random() * Number.MAX_SAFE_INTEGER).toString();
+        pendingListeners.set(id, resolve);
+        if (ep.start) {
+            ep.start();
+        }
+        ep.postMessage(Object.assign({ id }, msg), transfers);
+    });
+}
+
+export { expose as e, wrap as w };

package/dist/{communicator-CkB-oBVq.js → communicator-D9LSiWws.js}

@@ -1,4 +1,4 @@
-import { p as protobufsBySchema } from './FoxgloveServer-DiLI7KZU.js';
+import { p as protobufsBySchema } from './FoxgloveServer-tJZcJH5-.js';
 
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v2.0. If a copy of the MPL was not distributed with this

package/dist/{foxglove-protocol-RZlF5fna.js → foxglove-protocol-RBwoTi12.js}

@@ -1,4 +1,4 @@
-import { C as ClientBinaryOpcode, B as BinaryOpcode } from './FoxgloveServer-DiLI7KZU.js';
+import { C as ClientBinaryOpcode, B as BinaryOpcode } from './FoxgloveServer-tJZcJH5-.js';
 
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v2.0. If a copy of the MPL was not distributed with this

package/dist/i420ToRgbaToPoitcloud.worker-CQFm7P7B.js

@@ -0,0 +1,48 @@
+import { e as expose } from './comlink-D0blLC4P.js';
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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/
+function i420ToRgbaToPointcloud(i420Data, i420Width, i420Height, depthWidth, depthHeight, data) {
+  const frameSize = i420Width * i420Height;
+  const uOffset = frameSize;
+  const vOffset = frameSize + frameSize / 4;
+  const pointCount = data.byteLength / 16;
+  const buffer = new ArrayBuffer(data.byteLength);
+  const view = new DataView(buffer);
+  const dataView = new DataView(data.buffer);
+  for (let i = 0; i < pointCount; i++) {
+    const depthX = i % depthWidth;
+    const depthY = Math.floor(i / depthWidth);
+    const i420X = Math.round(depthX * (i420Width / depthWidth));
+    const i420Y = Math.round(depthY * (i420Height / depthHeight));
+    if (i420X >= i420Width || i420Y >= i420Height) {
+      continue;
+    }
+    const index = i420Y * i420Width + i420X;
+    const uvIndex = Math.floor(i420Y / 2) * (i420Width / 2) + Math.floor(i420X / 2);
+    const Y = i420Data[index] ?? 0;
+    const U = (i420Data[uOffset + uvIndex] ?? 128) - 128;
+    const V = (i420Data[vOffset + uvIndex] ?? 128) - 128;
+    let R = Y + 1.402 * V;
+    let G = Y - 0.344136 * U - 0.714136 * V;
+    let B = Y + 1.772 * U;
+    R = Math.min(255, Math.max(0, R));
+    G = Math.min(255, Math.max(0, G));
+    B = Math.min(255, Math.max(0, B));
+    const offset = i * 16;
+    view.setFloat32(offset, dataView.getFloat32(offset, true), true); // x
+    view.setFloat32(offset + 4, dataView.getFloat32(offset + 4, true), true); // y
+    view.setFloat32(offset + 8, dataView.getFloat32(offset + 8, true), true); // z
+    view.setUint8(offset + 12, R); // Red
+    view.setUint8(offset + 13, G); // Green
+    view.setUint8(offset + 14, B); // Blue
+    view.setUint8(offset + 15, 255); // Alpha (fully opaque)
+  }
+  return new Uint8Array(buffer);
+}
+
+// Expose the function using Comlink
+expose({
+  i420ToRgbaToPointcloud
+});

package/dist/{index-BwXQcktX.js → index-B2r7A42O.js}

@@ -1,13 +1,14 @@
-import { au as ExternalTokenizer, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport } from './index-XshD358Z.js';
-import './FoxgloveServer-DiLI7KZU.js';
+import { au as ExternalTokenizer, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport } from './index-DZlfOfTk.js';
+import './FoxgloveServer-tJZcJH5-.js';
 import 'protobufjs/minimal';
 import 'ms';
+import './comlink-D0blLC4P.js';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
-import './foxglove-protocol-RZlF5fna.js';
+import './foxglove-protocol-RBwoTi12.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-CU7EP-1Z.js → index-BBF7QY1k.js}

@@ -1,13 +1,14 @@
-import { aq as styleTags, ar as tags, aN as javascriptLanguage, as as LRLanguage, at as LanguageSupport, av as LRParser, aK as html, aL as parseMixed, au as ExternalTokenizer } from './index-XshD358Z.js';
-import './FoxgloveServer-DiLI7KZU.js';
+import { aq as styleTags, ar as tags, aN as javascriptLanguage, as as LRLanguage, at as LanguageSupport, av as LRParser, aK as html, aL as parseMixed, au as ExternalTokenizer } from './index-DZlfOfTk.js';
+import './FoxgloveServer-tJZcJH5-.js';
 import 'protobufjs/minimal';
 import 'ms';
+import './comlink-D0blLC4P.js';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
-import './foxglove-protocol-RZlF5fna.js';
+import './foxglove-protocol-RBwoTi12.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-DWzj93US.js → index-BRBbEfLt.js}

@@ -1,13 +1,14 @@
-import { aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, az as flatIndent, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport } from './index-XshD358Z.js';
-import './FoxgloveServer-DiLI7KZU.js';
+import { aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, az as flatIndent, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport } from './index-DZlfOfTk.js';
+import './FoxgloveServer-tJZcJH5-.js';
 import 'protobufjs/minimal';
 import 'ms';
+import './comlink-D0blLC4P.js';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
-import './foxglove-protocol-RZlF5fna.js';
+import './foxglove-protocol-RBwoTi12.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-XYuXuR6J.js → index-Bj3e-oMi.js}

@@ -1,13 +1,14 @@
-import { an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aq as styleTags, ar as tags, as as LRLanguage, at as LanguageSupport, au as ExternalTokenizer, av as LRParser, aw as ifNotIn, ax as completeFromList, ay as syntaxTree } from './index-XshD358Z.js';
-import './FoxgloveServer-DiLI7KZU.js';
+import { an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aq as styleTags, ar as tags, as as LRLanguage, at as LanguageSupport, au as ExternalTokenizer, av as LRParser, aw as ifNotIn, ax as completeFromList, ay as syntaxTree } from './index-DZlfOfTk.js';
+import './FoxgloveServer-tJZcJH5-.js';
 import 'protobufjs/minimal';
 import 'ms';
+import './comlink-D0blLC4P.js';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
-import './foxglove-protocol-RZlF5fna.js';
+import './foxglove-protocol-RBwoTi12.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-BHvk_lXs.js → index-BjoXQ__u.js}

@@ -1,13 +1,14 @@
-import { aC as ContextTracker, au as ExternalTokenizer, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport, aL as parseMixed } from './index-XshD358Z.js';
-import './FoxgloveServer-DiLI7KZU.js';
+import { aC as ContextTracker, au as ExternalTokenizer, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport, aL as parseMixed } from './index-DZlfOfTk.js';
+import './FoxgloveServer-tJZcJH5-.js';
 import 'protobufjs/minimal';
 import 'ms';
+import './comlink-D0blLC4P.js';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
-import './foxglove-protocol-RZlF5fna.js';
+import './foxglove-protocol-RBwoTi12.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-CvOH_4Vb.js → index-BlnWOxsk.js}

@@ -1,13 +1,14 @@
-import { aq as styleTags, ar as tags, as as LRLanguage, at as LanguageSupport, av as LRParser, aD as LocalTokenGroup, aK as html, aL as parseMixed, aN as javascriptLanguage } from './index-XshD358Z.js';
-import './FoxgloveServer-DiLI7KZU.js';
+import { aq as styleTags, ar as tags, as as LRLanguage, at as LanguageSupport, av as LRParser, aD as LocalTokenGroup, aK as html, aL as parseMixed, aN as javascriptLanguage } from './index-DZlfOfTk.js';
+import './FoxgloveServer-tJZcJH5-.js';
 import 'protobufjs/minimal';
 import 'ms';
+import './comlink-D0blLC4P.js';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
-import './foxglove-protocol-RZlF5fna.js';
+import './foxglove-protocol-RBwoTi12.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-B5Y2BwAY.js → index-BvVi0uRg.js}

@@ -1,13 +1,14 @@
-import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, ap as foldNodeProp, aB as foldInside, an as indentNodeProp, ao as continuedIndent, aH as defineCSSCompletionSource, at as LanguageSupport } from './index-XshD358Z.js';
-import './FoxgloveServer-DiLI7KZU.js';
+import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, ap as foldNodeProp, aB as foldInside, an as indentNodeProp, ao as continuedIndent, aH as defineCSSCompletionSource, at as LanguageSupport } from './index-DZlfOfTk.js';
+import './FoxgloveServer-tJZcJH5-.js';
 import 'protobufjs/minimal';
 import 'ms';
+import './comlink-D0blLC4P.js';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
-import './foxglove-protocol-RZlF5fna.js';
+import './foxglove-protocol-RBwoTi12.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-B_XiOSDG.js → index-BvllHttZ.js}

@@ -1,13 +1,14 @@
-import { as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, aq as styleTags, ar as tags, at as LanguageSupport, av as LRParser } from './index-XshD358Z.js';
-import './FoxgloveServer-DiLI7KZU.js';
+import { as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, aq as styleTags, ar as tags, at as LanguageSupport, av as LRParser } from './index-DZlfOfTk.js';
+import './FoxgloveServer-tJZcJH5-.js';
 import 'protobufjs/minimal';
 import 'ms';
+import './comlink-D0blLC4P.js';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
-import './foxglove-protocol-RZlF5fna.js';
+import './foxglove-protocol-RBwoTi12.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';