@luxonis/visualizer-protobuf 2.13.0 → 2.15.0

package/dist/WorkerImageDecoder.worker-DCoSYoLL.js

@@ -0,0 +1,31 @@
+import { d as decodeRawImage } from './decodeImage-NYPkamnK.js';
+import './i18next-C5Qe4-E1.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/
+
+self.onmessage = async event => {
+  try {
+    const {
+      image,
+      options
+    } = event.data;
+    const buffer = new Uint8ClampedArray(image.width * image.height * 4);
+
+    // Decode image into the provided buffer
+    await decodeRawImage(image, options, buffer);
+
+    // Clear image data for earlier Garbage Collection
+    image.data.fill(0);
+
+    // Transfer the buffer back
+    self.postMessage({
+      result: buffer
+    }, [buffer.buffer]);
+  } catch (error) {
+    self.postMessage({
+      error: error instanceof Error ? error.message : "Unknown error occurred"
+    });
+  }
+};

package/dist/{decodeImage-BBqnjJjE.js → decodeImage-NYPkamnK.js}

@@ -1,348 +1,5 @@
 import { B as tinycolor, Q as t, C as merge } from './i18next-C5Qe4-E1.js';
 
-/**
- * @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);
-    });
-}
-
 // 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/
@@ -41795,7 +41452,7 @@ const MIN_MAX_16_BIT = {
  * See also:
  * https://github.com/ros2/common_interfaces/blob/366eea24ffce6c87f8860cbcd27f4863f46ad822/sensor_msgs/include/sensor_msgs/image_encodings.hpp
  */
-function decodeRawImage(image, options, output) {
+async function decodeRawImage(image, options, output) {
   const {
     encoding,
     width,
@@ -41807,60 +41464,69 @@ function decodeRawImage(image, options, output) {
     planeStride
   } = image;
   const is_bigendian = "is_bigendian" in image ? image.is_bigendian : false;
-  const rawData = image.data;
   switch (encoding) {
     case "yuv422":
     case "uyvy":
-      decodeUYVY(rawData, width, height, step, output);
+      decodeUYVY(image.data, width, height, step, output);
       break;
     case "nv12":
-      decodeNV12(rawData, width, height, output, stride, planeStride);
+      decodeNV12(image.data, width, height, output, stride, planeStride);
       break;
     case "yuv422_yuy2":
     case "yuyv":
-      decodeYUYV(rawData, width, height, step, output);
+      decodeYUYV(image.data, width, height, step, output);
       break;
     case "rgb8":
-      decodeRGB8(rawData, width, height, step, output);
+      decodeRGB8(image.data, width, height, step, output);
       break;
     case "rgb8p":
-      decodeRGB8p(rawData, width, height, step, output);
+      decodeRGB8p(image.data, width, height, step, output);
       break;
     case "rgba8":
-      decodeRGBA8(rawData, width, height, step, output);
+      decodeRGBA8(image.data, width, height, step, output);
       break;
     case "bgra8":
-      decodeBGRA8(rawData, width, height, step, output);
+      decodeBGRA8(image.data, width, height, step, output);
       break;
     case "bgr8":
     case "bgr8p":
     case "8UC3":
-      decodeBGR8p(rawData, width, height, step, output);
+      decodeBGR8p(image.data, width, height, step, output);
       break;
     case "bgr8i":
-      decodeBGR8i(rawData, width, height, step, output);
+      decodeBGR8i(image.data, width, height, step, output);
       break;
     case "32FC1":
-      decodeFloat1c(rawData, width, height, step, is_bigendian, output);
+      decodeFloat1c(image.data, width, height, step, is_bigendian, output);
       break;
     case "I420":
-      decodeI420(rawData, width, height, step, output);
+      decodeI420(image.data, width, height, step, output);
       break;
+
+    //if (!navigator.gpu) {
+    //  console.warn('WebGPU not supported, falling back to CPU');
+    //   decodeI420(image.data as Uint8Array, width, height, step, output);
+    //   return;
+    //}
+    //
+    //const res = await decodeI420ToRGBA(image.data as Uint8Array, width, height);
+    //output.set(res);
+    //break;
     case "bayer_rggb8":
-      decodeBayerRGGB8(rawData, width, height, step, output);
+      decodeBayerRGGB8(image.data, width, height, step, output);
       break;
     case "bayer_bggr8":
-      decodeBayerBGGR8(rawData, width, height, step, output);
+      decodeBayerBGGR8(image.data, width, height, step, output);
       break;
     case "bayer_gbrg8":
-      decodeBayerGBRG8(rawData, width, height, step, output);
+      decodeBayerGBRG8(image.data, width, height, step, output);
       break;
     case "bayer_grbg8":
-      decodeBayerGRBG8(rawData, width, height, step, output);
+      decodeBayerGRBG8(image.data, width, height, step, output);
       break;
     case "mono8":
     case "8UC1":
-      decodeMono8(rawData, width, height, step, output);
+      decodeMono8(image.data, width, height, step, output);
       break;
     case "mono16":
     case "16UC1":
@@ -41880,7 +41546,7 @@ function decodeRawImage(image, options, output) {
           a: 0
         };
         const converter = getColorConverter(settings, min, max);
-        decodeMono16(rawData, width, height, step, is_bigendian, output, {
+        decodeMono16(image.data, width, height, step, is_bigendian, output, {
           minValue: options.minValue,
           maxValue: options.maxValue,
           colorConverter: value => {
@@ -41895,4 +41561,4 @@ function decodeRawImage(image, options, output) {
   }
 }
 
-export { DataTextureLoader as $, SRGBColorSpace as A, Box3 as B, Color as C, DoubleSide as D, LinearSRGBColorSpace as E, Float32BufferAttribute as F, rgbaToLinear as G, RedFormat as H, InstancedBufferGeometry as I, RGBAFormat as J, getColorConverter as K, Line3 as L, Matrix4 as M, NotEqualStencilFunc as N, Object3D as O, PointsMaterial as P, FloatType as Q, ReplaceStencilOp as R, Sphere as S, UnsignedByteType as T, UniformsLib as U, Vector3 as V, WireframeGeometry as W, NEEDS_MIN_MAX as X, InstancedMesh as Y, CylinderGeometry as Z, ConeGeometry as _, InstancedInterleavedBuffer as a, DynamicDrawUsage as a$, LinearMipmapLinearFilter as a0, Loader as a1, LoaderUtils as a2, FileLoader as a3, MeshBasicMaterial as a4, Scene as a5, TextureLoader as a6, AnimationClip as a7, VectorKeyframeTrack as a8, QuaternionKeyframeTrack as a9, Material as aA, PropertyBinding as aB, LineLoop as aC, Points as aD, InterpolateLinear as aE, ColorManagement as aF, NearestMipmapNearestFilter as aG, LinearMipmapNearestFilter as aH, NearestMipmapLinearFilter as aI, MirroredRepeatWrapping as aJ, InterpolateDiscrete as aK, Texture as aL, NumberKeyframeTrack as aM, Interpolant as aN, EdgesGeometry as aO, LoadingManager as aP, stringToRgb as aQ, getLuminance as aR, Euler as aS, vec3TupleApproxEquals as aT, wrap as aU, releaseProxy as aV, decodeCompressedImageToBitmap as aW, CanvasTexture as aX, Shape as aY, SRGBToLinear as aZ, ShapeGeometry as a_, MeshLambertMaterial as aa, MeshPhongMaterial as ab, FrontSide as ac, PerspectiveCamera as ad, OrthographicCamera as ae, AmbientLight as af, SpotLight as ag, PointLight as ah, DirectionalLight as ai, BufferGeometry as aj, Group as ak, Quaternion as al, Bone as am, LineBasicMaterial as an, SkinnedMesh as ao, Line as ap, LineSegments as aq, RepeatWrapping as ar, Skeleton as as, BufferAttribute as at, TrianglesDrawMode as au, TriangleFanDrawMode as av, TriangleStripDrawMode as aw, MeshPhysicalMaterial as ax, ImageBitmapLoader as ay, InterleavedBuffer as az, InterleavedBufferAttribute as b, ShaderChunk as b0, IMAGE_DEFAULT_COLOR_MODE_SETTINGS as b1, colorHasTransparency as b2, StaticDrawUsage as b3, RawShaderMaterial as b4, GLSL3 as b5, colorFieldComputedPrefix as b6, getRotationTo as b7, SphereGeometry as b8, rgbaGradient as b9, InstancedBufferAttribute as ba, BoxGeometry as bb, DARK_OUTLINE as bc, LIGHT_OUTLINE as bd, CircleGeometry as be, LineDashedMaterial as bf, GreaterDepth as bg, EventDispatcher as bh, Plane as bi, Raycaster as bj, WebGLRenderTarget as bk, Ray as bl, MOUSE as bm, TOUCH as bn, Spherical as bo, WebGLRenderer as bp, NoToneMapping as bq, VSMShadowMap as br, HemisphereLight as bs, Vector2 as c, decodeRawImage as d, expose as e, ShaderLib as f, UniformsUtils as g, ShaderMaterial as h, Vector4 as i, Mesh as j, MathUtils as k, MeshStandardMaterial as l, makeRgba as m, rgbaToCssString as n, colorModeSettingsFields as o, autoSelectColorSettings as p, PlaneGeometry as q, rgbToThreeColor as r, stringToRgba as s, transfer as t, DataTexture as u, UVMapping as v, ClampToEdgeWrapping as w, NearestFilter as x, LinearFilter as y, FS_SRGB_TO_LINEAR as z };
+export { Loader as $, rgbaToLinear as A, Box3 as B, Color as C, DoubleSide as D, RedFormat as E, Float32BufferAttribute as F, RGBAFormat as G, getColorConverter as H, InstancedBufferGeometry as I, FloatType as J, UnsignedByteType as K, Line3 as L, Matrix4 as M, NotEqualStencilFunc as N, Object3D as O, PointsMaterial as P, NEEDS_MIN_MAX as Q, ReplaceStencilOp as R, Sphere as S, InstancedMesh as T, UniformsLib as U, Vector3 as V, WireframeGeometry as W, CylinderGeometry as X, ConeGeometry as Y, DataTextureLoader as Z, LinearMipmapLinearFilter as _, InstancedInterleavedBuffer as a, StaticDrawUsage as a$, LoaderUtils as a0, FileLoader as a1, MeshBasicMaterial as a2, Scene as a3, TextureLoader as a4, AnimationClip as a5, VectorKeyframeTrack as a6, QuaternionKeyframeTrack as a7, MeshLambertMaterial as a8, MeshPhongMaterial as a9, LineLoop as aA, Points as aB, InterpolateLinear as aC, ColorManagement as aD, NearestMipmapNearestFilter as aE, LinearMipmapNearestFilter as aF, NearestMipmapLinearFilter as aG, MirroredRepeatWrapping as aH, InterpolateDiscrete as aI, Texture as aJ, NumberKeyframeTrack as aK, Interpolant as aL, EdgesGeometry as aM, LoadingManager as aN, stringToRgb as aO, getLuminance as aP, Euler as aQ, vec3TupleApproxEquals as aR, decodeCompressedImageToBitmap as aS, CanvasTexture as aT, Shape as aU, SRGBToLinear as aV, ShapeGeometry as aW, DynamicDrawUsage as aX, ShaderChunk as aY, IMAGE_DEFAULT_COLOR_MODE_SETTINGS as aZ, colorHasTransparency as a_, FrontSide as aa, PerspectiveCamera as ab, OrthographicCamera as ac, AmbientLight as ad, SpotLight as ae, PointLight as af, DirectionalLight as ag, BufferGeometry as ah, Group as ai, Quaternion as aj, Bone as ak, LineBasicMaterial as al, SkinnedMesh as am, Line as an, LineSegments as ao, RepeatWrapping as ap, Skeleton as aq, BufferAttribute as ar, TrianglesDrawMode as as, TriangleFanDrawMode as at, TriangleStripDrawMode as au, MeshPhysicalMaterial as av, ImageBitmapLoader as aw, InterleavedBuffer as ax, Material as ay, PropertyBinding as az, InterleavedBufferAttribute as b, RawShaderMaterial as b0, GLSL3 as b1, colorFieldComputedPrefix as b2, getRotationTo as b3, SphereGeometry as b4, rgbaGradient as b5, InstancedBufferAttribute as b6, BoxGeometry as b7, DARK_OUTLINE as b8, LIGHT_OUTLINE as b9, CircleGeometry as ba, LineDashedMaterial as bb, GreaterDepth as bc, EventDispatcher as bd, Plane as be, Raycaster as bf, WebGLRenderTarget as bg, Ray as bh, MOUSE as bi, TOUCH as bj, Spherical as bk, WebGLRenderer as bl, NoToneMapping as bm, VSMShadowMap as bn, HemisphereLight as bo, Vector2 as c, decodeRawImage as d, ShaderLib as e, UniformsUtils as f, ShaderMaterial as g, Vector4 as h, Mesh as i, MathUtils as j, MeshStandardMaterial as k, rgbaToCssString as l, makeRgba as m, colorModeSettingsFields as n, autoSelectColorSettings as o, PlaneGeometry as p, DataTexture as q, rgbToThreeColor as r, stringToRgba as s, UVMapping as t, ClampToEdgeWrapping as u, NearestFilter as v, LinearFilter as w, FS_SRGB_TO_LINEAR as x, SRGBColorSpace as y, LinearSRGBColorSpace as z };

package/dist/{index-fN8Tpgww.js → index-B3np51f5.js}

@@ -1,4 +1,4 @@
-import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, aD as LocalTokenGroup, aE as snippetCompletion, ay as syntaxTree, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, az as flatIndent, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport, aw as ifNotIn, ax as completeFromList, aF as IterMode, aG as NodeWeakMap } from './index-DFlpZwK1.js';
+import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, aD as LocalTokenGroup, aE as snippetCompletion, ay as syntaxTree, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, az as flatIndent, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport, aw as ifNotIn, ax as completeFromList, aF as IterMode, aG as NodeWeakMap } from './index-XshD358Z.js';
 import './FoxgloveServer-DiLI7KZU.js';
 import 'protobufjs/minimal';
 import 'ms';

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

@@ -1,4 +1,4 @@
-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-DFlpZwK1.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-XshD358Z.js';
 import './FoxgloveServer-DiLI7KZU.js';
 import 'protobufjs/minimal';
 import 'ms';

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

@@ -1,4 +1,4 @@
-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-DFlpZwK1.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-XshD358Z.js';
 import './FoxgloveServer-DiLI7KZU.js';
 import 'protobufjs/minimal';
 import 'ms';

package/dist/{index-BK0O58zw.js → index-BVlhWOws.js}

@@ -1,4 +1,4 @@
-import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, ay as syntaxTree, aw as ifNotIn, as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport, aF as IterMode, ax as completeFromList, aG as NodeWeakMap, aE as snippetCompletion } from './index-DFlpZwK1.js';
+import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, ay as syntaxTree, aw as ifNotIn, as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport, aF as IterMode, ax as completeFromList, aG as NodeWeakMap, aE as snippetCompletion } from './index-XshD358Z.js';
 import './FoxgloveServer-DiLI7KZU.js';
 import 'protobufjs/minimal';
 import 'ms';

package/dist/{index-4msm-wtA.js → index-B_XiOSDG.js}

@@ -1,4 +1,4 @@
-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-DFlpZwK1.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-XshD358Z.js';
 import './FoxgloveServer-DiLI7KZU.js';
 import 'protobufjs/minimal';
 import 'ms';

package/dist/{index-DSIL_c41.js → index-BlTiOUx8.js}

@@ -1,4 +1,4 @@
-import { aC as ContextTracker, au as ExternalTokenizer, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ap as foldNodeProp, aM as bracketMatchingHandle, at as LanguageSupport, aI as EditorView, ay as syntaxTree, aJ as EditorSelection } from './index-DFlpZwK1.js';
+import { aC as ContextTracker, au as ExternalTokenizer, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ap as foldNodeProp, aM as bracketMatchingHandle, at as LanguageSupport, aI as EditorView, ay as syntaxTree, aJ as EditorSelection } from './index-XshD358Z.js';
 import './FoxgloveServer-DiLI7KZU.js';
 import 'protobufjs/minimal';
 import 'ms';

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

@@ -1,4 +1,4 @@
-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-DFlpZwK1.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-XshD358Z.js';
 import './FoxgloveServer-DiLI7KZU.js';
 import 'protobufjs/minimal';
 import 'ms';

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

@@ -1,4 +1,4 @@
-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-DFlpZwK1.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-XshD358Z.js';
 import './FoxgloveServer-DiLI7KZU.js';
 import 'protobufjs/minimal';
 import 'ms';