@ohif/app 3.10.0-beta.113 → 3.10.0-beta.115

package/dist/5258.bundle.f95ab2e02467a734bdb6.js

@@ -0,0 +1,4519 @@
+"use strict";
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[5258],{
+
+/***/ 81985:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   BaseVolumeViewport: () => (/* reexport safe */ _RenderingEngine_BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_8__.A),
+/* harmony export */   CONSTANTS: () => (/* reexport module object */ _constants__WEBPACK_IMPORTED_MODULE_1__),
+/* harmony export */   Enums: () => (/* reexport module object */ _enums__WEBPACK_IMPORTED_MODULE_0__),
+/* harmony export */   Settings: () => (/* reexport safe */ _Settings__WEBPACK_IMPORTED_MODULE_22__.A),
+/* harmony export */   StackViewport: () => (/* reexport safe */ _RenderingEngine_StackViewport__WEBPACK_IMPORTED_MODULE_9__.A),
+/* harmony export */   VideoViewport: () => (/* reexport safe */ _RenderingEngine_VideoViewport__WEBPACK_IMPORTED_MODULE_10__.A),
+/* harmony export */   VolumeViewport: () => (/* reexport safe */ _RenderingEngine_VolumeViewport__WEBPACK_IMPORTED_MODULE_6__.A),
+/* harmony export */   addImageSlicesToViewports: () => (/* reexport safe */ _RenderingEngine_helpers__WEBPACK_IMPORTED_MODULE_31__.ge),
+/* harmony export */   addVolumesToViewports: () => (/* reexport safe */ _RenderingEngine_helpers__WEBPACK_IMPORTED_MODULE_31__.x),
+/* harmony export */   cache: () => (/* reexport safe */ _cache_cache__WEBPACK_IMPORTED_MODULE_16__.Ay),
+/* harmony export */   convertMapperToNotSharedMapper: () => (/* reexport safe */ _RenderingEngine_helpers_createVolumeMapper__WEBPACK_IMPORTED_MODULE_4__.h),
+/* harmony export */   createVolumeActor: () => (/* reexport safe */ _RenderingEngine_helpers_createVolumeActor__WEBPACK_IMPORTED_MODULE_3__.A),
+/* harmony export */   eventTarget: () => (/* reexport safe */ _eventTarget__WEBPACK_IMPORTED_MODULE_13__.A),
+/* harmony export */   getEnabledElement: () => (/* reexport safe */ _getEnabledElement__WEBPACK_IMPORTED_MODULE_19__.Ay),
+/* harmony export */   getEnabledElementByIds: () => (/* reexport safe */ _getEnabledElement__WEBPACK_IMPORTED_MODULE_19__.b1),
+/* harmony export */   getEnabledElementByViewportId: () => (/* reexport safe */ _getEnabledElement__WEBPACK_IMPORTED_MODULE_19__.yj),
+/* harmony export */   getEnabledElements: () => (/* reexport safe */ _getEnabledElement__WEBPACK_IMPORTED_MODULE_19__.zb),
+/* harmony export */   getRenderingEngine: () => (/* reexport safe */ _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_14__.lD),
+/* harmony export */   getRenderingEngines: () => (/* reexport safe */ _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_14__.qO),
+/* harmony export */   getWebWorkerManager: () => (/* reexport safe */ _init__WEBPACK_IMPORTED_MODULE_21__.G_),
+/* harmony export */   imageLoadPoolManager: () => (/* reexport safe */ _requestPool_imageLoadPoolManager__WEBPACK_IMPORTED_MODULE_18__.A),
+/* harmony export */   imageLoader: () => (/* reexport module object */ _loaders_imageLoader__WEBPACK_IMPORTED_MODULE_24__),
+/* harmony export */   metaData: () => (/* reexport module object */ _metaData__WEBPACK_IMPORTED_MODULE_20__),
+/* harmony export */   triggerEvent: () => (/* reexport safe */ _utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_28__.A),
+/* harmony export */   utilities: () => (/* reexport module object */ _utilities__WEBPACK_IMPORTED_MODULE_27__),
+/* harmony export */   volumeLoader: () => (/* reexport module object */ _loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_23__)
+/* harmony export */ });
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31749);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(19325);
+/* harmony import */ var _RenderingEngine__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(56706);
+/* harmony import */ var _RenderingEngine_helpers_createVolumeActor__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(61640);
+/* harmony import */ var _RenderingEngine_helpers_createVolumeMapper__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(92099);
+/* harmony import */ var _RenderingEngine_helpers_getOrCreateCanvas__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(30135);
+/* harmony import */ var _RenderingEngine_VolumeViewport__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(94155);
+/* harmony import */ var _RenderingEngine_VolumeViewport3D__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(40893);
+/* harmony import */ var _RenderingEngine_BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(46347);
+/* harmony import */ var _RenderingEngine_StackViewport__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(58165);
+/* harmony import */ var _RenderingEngine_VideoViewport__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(32501);
+/* harmony import */ var _RenderingEngine_WSIViewport__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(81466);
+/* harmony import */ var _RenderingEngine_Viewport__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(10056);
+/* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(10364);
+/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(39536);
+/* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(58927);
+/* harmony import */ var _cache_cache__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(49038);
+/* harmony import */ var _requestPool_imageRetrievalPoolManager__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(91073);
+/* harmony import */ var _requestPool_imageLoadPoolManager__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(51159);
+/* harmony import */ var _getEnabledElement__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(86846);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(74876);
+/* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(59693);
+/* harmony import */ var _Settings__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(57308);
+/* harmony import */ var _loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(39561);
+/* harmony import */ var _loaders_imageLoader__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(80068);
+/* harmony import */ var _loaders_geometryLoader__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(89926);
+/* harmony import */ var _loaders_ProgressiveRetrieveImages__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(36822);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(98866);
+/* harmony import */ var _utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(69372);
+/* harmony import */ var _loaders_cornerstoneStreamingImageVolumeLoader__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(55500);
+/* harmony import */ var _loaders_cornerstoneStreamingDynamicImageVolumeLoader__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(55509);
+/* harmony import */ var _RenderingEngine_helpers__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(40661);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 82918:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _spatialRegistrationMetadataProvider__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(40239);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(74876);
+
+
+
+const ALLOWED_DELTA = 0.05;
+function calculateViewportsSpatialRegistration(viewport1, viewport2) {
+    const imageId1 = viewport1.getSliceIndex();
+    const imageId2 = viewport2.getSliceIndex();
+    const imagePlaneModule1 = (0,_metaData__WEBPACK_IMPORTED_MODULE_2__.get)('imagePlaneModule', imageId1.toString());
+    const imagePlaneModule2 = (0,_metaData__WEBPACK_IMPORTED_MODULE_2__.get)('imagePlaneModule', imageId2.toString());
+    if (!imagePlaneModule1 || !imagePlaneModule2) {
+        console.log('Viewport spatial registration requires image plane module');
+        return;
+    }
+    const { imageOrientationPatient: iop2 } = imagePlaneModule2;
+    const isSameImagePlane = imagePlaneModule1.imageOrientationPatient.every((v, i) => Math.abs(v - iop2[i]) < ALLOWED_DELTA);
+    if (!isSameImagePlane) {
+        console.log('Viewport spatial registration only supported for same orientation (hence translation only) for now', imagePlaneModule1?.imageOrientationPatient, imagePlaneModule2?.imageOrientationPatient);
+        return;
+    }
+    const imagePositionPatient1 = imagePlaneModule1.imagePositionPatient;
+    const imagePositionPatient2 = imagePlaneModule2.imagePositionPatient;
+    const translation = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), imagePositionPatient1, imagePositionPatient2);
+    const mat = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat4.fromTranslation */ .pB.fromTranslation(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat4.create */ .pB.create(), translation);
+    _spatialRegistrationMetadataProvider__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.add([viewport1.id, viewport2.id], mat);
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (calculateViewportsSpatialRegistration);
+
+
+/***/ }),
+
+/***/ 73822:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _imageIdToURI__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(39537);
+
+const state = {};
+const metadataProvider = {
+    add: (imageId, payload) => {
+        const imageURI = (0,_imageIdToURI__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(imageId);
+        state[imageURI] = payload;
+    },
+    get: (type, imageId) => {
+        if (type === 'calibratedPixelSpacing') {
+            const imageURI = (0,_imageIdToURI__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(imageId);
+            return state[imageURI];
+        }
+    },
+};
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (metadataProvider);
+
+
+/***/ }),
+
+/***/ 84061:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ clamp),
+/* harmony export */   q: () => (/* binding */ clamp)
+/* harmony export */ });
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+
+
+
+/***/ }),
+
+/***/ 25534:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* unused harmony exports clip, clipToBox */
+function clip(val, low, high) {
+    return Math.min(Math.max(low, val), high);
+}
+function clipToBox(point, box) {
+    point.x = clip(point.x, 0, box.width);
+    point.y = clip(point.y, 0, box.height);
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (clip);
+
+
+/***/ }),
+
+/***/ 79717:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   hexToRgb: () => (/* binding */ hexToRgb),
+/* harmony export */   rgbToHex: () => (/* binding */ rgbToHex)
+/* harmony export */ });
+function componentToHex(c) {
+    const hex = c.toString(16);
+    return hex.length == 1 ? '0' + hex : hex;
+}
+function rgbToHex(r, g, b) {
+    return '#' + componentToHex(r) + componentToHex(g) + componentToHex(b);
+}
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : null;
+}
+
+
+
+/***/ }),
+
+/***/ 13859:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   findMatchingColormap: () => (/* binding */ findMatchingColormap),
+/* harmony export */   getColormap: () => (/* binding */ getColormap),
+/* harmony export */   getColormapNames: () => (/* binding */ getColormapNames),
+/* harmony export */   registerColormap: () => (/* binding */ registerColormap)
+/* harmony export */ });
+/* harmony import */ var _kitware_vtk_js_Rendering_Core_ColorTransferFunction_ColorMaps__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(660);
+/* harmony import */ var _isEqual__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74638);
+/* harmony import */ var _actorCheck__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(98039);
+
+
+
+const _colormaps = new Map();
+function registerColormap(colormap) {
+    _colormaps.set(colormap.Name, colormap);
+}
+function getColormap(name) {
+    return _colormaps.get(name);
+}
+function getColormapNames() {
+    return Array.from(_colormaps.keys());
+}
+function findMatchingColormap(rgbPoints, actor) {
+    const colormapsVTK = _kitware_vtk_js_Rendering_Core_ColorTransferFunction_ColorMaps__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.rgbPresetNames.map((presetName) => _kitware_vtk_js_Rendering_Core_ColorTransferFunction_ColorMaps__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.getPresetByName(presetName));
+    const colormapsCS3D = getColormapNames().map((colormapName) => getColormap(colormapName));
+    const colormaps = colormapsVTK.concat(colormapsCS3D);
+    const matchedColormap = colormaps.find((colormap) => {
+        const { RGBPoints: presetRGBPoints } = colormap;
+        if (presetRGBPoints.length !== rgbPoints.length) {
+            return false;
+        }
+        for (let i = 0; i < presetRGBPoints.length; i += 4) {
+            if (!(0,_isEqual__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay)(presetRGBPoints.slice(i + 1, i + 4), rgbPoints.slice(i + 1, i + 4))) {
+                return false;
+            }
+        }
+        return true;
+    });
+    if (!matchedColormap) {
+        return null;
+    }
+    const opacity = [];
+    if ((0,_actorCheck__WEBPACK_IMPORTED_MODULE_2__/* .actorIsA */ .N)(actor, 'vtkVolume')) {
+        const opacityPoints = actor
+            .getProperty()
+            .getScalarOpacity(0)
+            .getDataPointer();
+        if (!opacityPoints) {
+            return {
+                name: matchedColormap.Name,
+            };
+        }
+        for (let i = 0; i < opacityPoints.length; i += 2) {
+            opacity.push({
+                value: opacityPoints[i],
+                opacity: opacityPoints[i + 1],
+            });
+        }
+    }
+    return {
+        name: matchedColormap.Name,
+        opacity,
+    };
+}
+
+
+
+/***/ }),
+
+/***/ 86888:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   h: () => (/* binding */ convertStackToVolumeViewport)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40661);
+/* harmony import */ var _loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(39561);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(31749);
+/* harmony import */ var _uuidv4__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(80221);
+
+
+
+
+async function convertStackToVolumeViewport({ viewport, options = {}, }) {
+    const renderingEngine = viewport.getRenderingEngine();
+    let volumeId = options.volumeId || `${(0,_uuidv4__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)()}`;
+    if (volumeId.split(':').length === 0) {
+        const schema = (0,_loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_1__.getUnknownVolumeLoaderSchema)();
+        volumeId = `${schema}:${volumeId}`;
+    }
+    const { id, element } = viewport;
+    const viewportId = options.viewportId || id;
+    const imageIds = viewport.getImageIds();
+    const prevViewPresentation = viewport.getViewPresentation();
+    const prevViewReference = viewport.getViewReference();
+    renderingEngine.enableElement({
+        viewportId,
+        type: _enums__WEBPACK_IMPORTED_MODULE_2__.ViewportType.ORTHOGRAPHIC,
+        element,
+        defaultOptions: {
+            background: options.background,
+            orientation: options.orientation,
+        },
+    });
+    const volume = (await (0,_loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_1__.createAndCacheVolume)(volumeId, {
+        imageIds,
+    }));
+    volume.load();
+    const volumeViewport = renderingEngine.getViewport(viewportId);
+    await (0,_RenderingEngine_helpers__WEBPACK_IMPORTED_MODULE_0__/* .setVolumesForViewports */ .A7)(renderingEngine, [
+        {
+            volumeId,
+        },
+    ], [viewportId]);
+    const volumeViewportNewVolumeHandler = () => {
+        volumeViewport.render();
+        element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_2__.Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
+    };
+    const addVolumeViewportNewVolumeListener = () => {
+        element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_2__.Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
+    };
+    addVolumeViewportNewVolumeListener();
+    volumeViewport.setViewPresentation(prevViewPresentation);
+    volumeViewport.setViewReference(prevViewReference);
+    volumeViewport.render();
+    return volumeViewport;
+}
+
+
+
+/***/ }),
+
+/***/ 2397:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ convertToGrayscale)
+/* harmony export */ });
+function convertToGrayscale(scalarData, width, height) {
+    const isRGBA = scalarData.length === width * height * 4;
+    const isRGB = scalarData.length === width * height * 3;
+    if (isRGBA || isRGB) {
+        const newScalarData = new Float32Array(width * height);
+        let offset = 0;
+        let destOffset = 0;
+        const increment = isRGBA ? 4 : 3;
+        for (let x = 0; x < width; x++) {
+            for (let y = 0; y < height; y++) {
+                const r = scalarData[offset];
+                const g = scalarData[offset + 1];
+                const b = scalarData[offset + 2];
+                newScalarData[destOffset] = (r + g + b) / 3;
+                offset += increment;
+                destOffset++;
+            }
+        }
+        return newScalarData;
+    }
+    else {
+        return scalarData;
+    }
+}
+
+
+/***/ }),
+
+/***/ 47442:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   n: () => (/* binding */ convertVolumeToStackViewport)
+/* harmony export */ });
+/* harmony import */ var _cache_cache__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(49038);
+/* harmony import */ var _cache_classes_ImageVolume__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(86252);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(31749);
+
+
+
+async function convertVolumeToStackViewport({ viewport, options, }) {
+    const volumeViewport = viewport;
+    const { id, element } = volumeViewport;
+    const renderingEngine = viewport.getRenderingEngine();
+    const { background } = options;
+    const viewportId = options.viewportId || id;
+    const volume = _cache_cache__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Ay.getVolume(volumeViewport.getVolumeId());
+    if (!(volume instanceof _cache_classes_ImageVolume__WEBPACK_IMPORTED_MODULE_1__/* .ImageVolume */ .Q)) {
+        throw new Error('Currently, you cannot decache a volume that is not an ImageVolume. So, unfortunately, volumes such as nifti  (which are basic Volume, without imageIds) cannot be decached.');
+    }
+    const viewportInput = {
+        viewportId,
+        type: _enums__WEBPACK_IMPORTED_MODULE_2__.ViewportType.STACK,
+        element,
+        defaultOptions: {
+            background,
+        },
+    };
+    const prevView = volumeViewport.getViewReference();
+    renderingEngine.enableElement(viewportInput);
+    const stackViewport = renderingEngine.getViewport(viewportId);
+    await stackViewport.setStack(volume.imageIds);
+    stackViewport.setViewReference(prevView);
+    stackViewport.render();
+    return stackViewport;
+}
+
+
+
+/***/ }),
+
+/***/ 23586:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ createSubVolume)
+/* harmony export */ });
+/* unused harmony export createSubVolume */
+/* harmony import */ var _transformWorldToIndex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(38669);
+/* harmony import */ var _transformIndexToWorld__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(94741);
+/* harmony import */ var _uuidv4__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(80221);
+/* harmony import */ var _loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(39561);
+/* harmony import */ var _cache_cache__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(49038);
+
+
+
+
+
+function createSubVolume(referencedVolumeId, boundsIJK, options = {}) {
+    const referencedVolume = _cache_cache__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Ay.getVolume(referencedVolumeId);
+    if (!referencedVolume) {
+        throw new Error(`Referenced volume with id ${referencedVolumeId} does not exist.`);
+    }
+    const { metadata, spacing, direction, dimensions: refVolumeDim, } = referencedVolume;
+    const { minX, maxX, minY, maxY, minZ, maxZ } = boundsIJK;
+    const ijkTopLeft = [
+        Math.min(minX, maxX),
+        Math.min(minY, maxY),
+        Math.min(minZ, maxZ),
+    ];
+    const boundingBoxOriginWorld = (0,_transformIndexToWorld__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(referencedVolume.imageData, ijkTopLeft);
+    const dimensions = [
+        Math.abs(maxX - minX) + 1,
+        Math.abs(maxY - minY) + 1,
+        Math.abs(maxZ - minZ) + 1,
+    ];
+    const { targetBuffer } = options;
+    const subVolumeOptions = {
+        metadata,
+        dimensions,
+        spacing,
+        origin: boundingBoxOriginWorld,
+        direction,
+        targetBuffer,
+        scalarData: targetBuffer?.type === 'Float32Array'
+            ? new Float32Array(dimensions[0] * dimensions[1] * dimensions[2])
+            : undefined,
+    };
+    const subVolume = (0,_loaders_volumeLoader__WEBPACK_IMPORTED_MODULE_3__.createLocalVolume)((0,_uuidv4__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(), subVolumeOptions);
+    const subVolumeData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const subVolumeSliceSize = dimensions[0] * dimensions[1];
+    const refVolumeSliceSize = refVolumeDim[0] * refVolumeDim[1];
+    const refVolumeData = referencedVolume.voxelManager.getCompleteScalarDataArray();
+    for (let z = 0; z < dimensions[2]; z++) {
+        for (let y = 0; y < dimensions[1]; y++) {
+            const rowStartWorld = (0,_transformIndexToWorld__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(subVolume.imageData, [
+                0,
+                y,
+                z,
+            ]);
+            const refVolumeRowStartIJK = (0,_transformWorldToIndex__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(referencedVolume.imageData, rowStartWorld);
+            const refVolumeRowStartOffset = refVolumeRowStartIJK[2] * refVolumeSliceSize +
+                refVolumeRowStartIJK[1] * refVolumeDim[0] +
+                refVolumeRowStartIJK[0];
+            const rowData = refVolumeData.slice(refVolumeRowStartOffset, refVolumeRowStartOffset + dimensions[0]);
+            const subVolumeLineStartOffset = z * subVolumeSliceSize + y * dimensions[0];
+            subVolumeData.set(rowData, subVolumeLineStartOffset);
+        }
+    }
+    subVolume.voxelManager.setCompleteScalarDataArray(subVolumeData);
+    return subVolume;
+}
+
+
+
+/***/ }),
+
+/***/ 13148:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   b: () => (/* binding */ deepEqual)
+/* harmony export */ });
+function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 == null || obj2 == null) {
+        return false;
+    }
+    try {
+        return JSON.stringify(obj1) === JSON.stringify(obj2);
+    }
+    catch (error) {
+        console.debug('Error in JSON.stringify during deep comparison:', error);
+        return obj1 === obj2;
+    }
+}
+
+
+/***/ }),
+
+/***/ 94015:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  MultiTargetEventListenerManager: () => (/* reexport */ MultiTargetEventListenerManager),
+  TargetEventListeners: () => (/* reexport */ TargetEventListeners)
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/eventListener/TargetEventListeners.js
+var EventListenerPhases;
+(function (EventListenerPhases) {
+    EventListenerPhases[EventListenerPhases["None"] = 0] = "None";
+    EventListenerPhases[EventListenerPhases["Capture"] = 1] = "Capture";
+    EventListenerPhases[EventListenerPhases["Bubble"] = 2] = "Bubble";
+})(EventListenerPhases || (EventListenerPhases = {}));
+class TargetEventListeners {
+    constructor(target) {
+        this._eventListeners = new Map();
+        this._children = new Map();
+        this._target = target;
+    }
+    get isEmpty() {
+        return this._eventListeners.size === 0 && this._children.size === 0;
+    }
+    addEventListener(type, callback, options) {
+        const dotIndex = type.indexOf('.');
+        const isNamespace = dotIndex !== -1;
+        if (isNamespace) {
+            const namespaceToken = type.substring(0, dotIndex);
+            let childElementEventListener = this._children.get(namespaceToken);
+            if (!childElementEventListener) {
+                childElementEventListener = new TargetEventListeners(this._target);
+                this._children.set(namespaceToken, childElementEventListener);
+            }
+            type = type.substring(dotIndex + 1);
+            childElementEventListener.addEventListener(type, callback, options);
+        }
+        else {
+            this._addEventListener(type, callback, options);
+        }
+    }
+    removeEventListener(type, callback, options) {
+        const dotIndex = type.indexOf('.');
+        const isNamespace = dotIndex !== -1;
+        if (isNamespace) {
+            const namespaceToken = type.substring(0, dotIndex);
+            const childElementEventListener = this._children.get(namespaceToken);
+            if (!childElementEventListener) {
+                return;
+            }
+            type = type.substring(dotIndex + 1);
+            childElementEventListener.removeEventListener(type, callback, options);
+            if (childElementEventListener.isEmpty) {
+                this._children.delete(namespaceToken);
+            }
+        }
+        else {
+            this._removeEventListener(type, callback, options);
+        }
+    }
+    reset() {
+        Array.from(this._children.entries()).forEach(([namespace, child]) => {
+            child.reset();
+            if (child.isEmpty) {
+                this._children.delete(namespace);
+            }
+            else {
+                throw new Error('Child is not empty and cannot be removed');
+            }
+        });
+        this._unregisterAllEvents();
+    }
+    _addEventListener(type, callback, options) {
+        let listenersMap = this._eventListeners.get(type);
+        if (!listenersMap) {
+            listenersMap = new Map();
+            this._eventListeners.set(type, listenersMap);
+        }
+        const useCapture = options?.capture ?? false;
+        const listenerPhase = useCapture
+            ? EventListenerPhases.Capture
+            : EventListenerPhases.Bubble;
+        const registeredPhases = listenersMap.get(callback) ?? EventListenerPhases.None;
+        if (registeredPhases & listenerPhase) {
+            console.warn('A listener is already registered for this phase');
+            return;
+        }
+        listenersMap.set(callback, registeredPhases | listenerPhase);
+        this._target.addEventListener(type, callback, options);
+    }
+    _removeEventListener(type, callback, options) {
+        const useCapture = options?.capture ?? false;
+        const listenerPhase = useCapture
+            ? EventListenerPhases.Capture
+            : EventListenerPhases.Bubble;
+        const listenersMap = this._eventListeners.get(type);
+        if (!listenersMap) {
+            return;
+        }
+        const callbacks = callback ? [callback] : Array.from(listenersMap.keys());
+        callbacks.forEach((callbackItem) => {
+            const registeredPhases = listenersMap.get(callbackItem) ?? EventListenerPhases.None;
+            const phaseRegistered = !!(registeredPhases & listenerPhase);
+            if (!phaseRegistered) {
+                return;
+            }
+            this._target.removeEventListener(type, callbackItem, options);
+            const newListenerPhase = registeredPhases ^ listenerPhase;
+            if (newListenerPhase === EventListenerPhases.None) {
+                listenersMap.delete(callbackItem);
+            }
+            else {
+                listenersMap.set(callbackItem, newListenerPhase);
+            }
+        });
+        if (!listenersMap.size) {
+            this._eventListeners.delete(type);
+        }
+    }
+    _unregisterAllListeners(type, listenersMap) {
+        Array.from(listenersMap.entries()).forEach(([listener, eventPhases]) => {
+            const startPhase = EventListenerPhases.Capture;
+            for (let currentPhase = startPhase; eventPhases; currentPhase <<= 1) {
+                if (!(eventPhases & currentPhase)) {
+                    continue;
+                }
+                const useCapture = currentPhase === EventListenerPhases.Capture ? true : false;
+                this.removeEventListener(type, listener, { capture: useCapture });
+                eventPhases ^= currentPhase;
+            }
+        });
+    }
+    _unregisterAllEvents() {
+        Array.from(this._eventListeners.entries()).forEach(([type, listenersMap]) => {
+            this._unregisterAllListeners(type, listenersMap);
+        });
+    }
+}
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/eventListener/MultiTargetEventListenerManager.js
+
+class MultiTargetEventListenerManager {
+    constructor() {
+        this._targetsEventListeners = new Map();
+    }
+    addEventListener(target, type, callback, options) {
+        let eventListeners = this._targetsEventListeners.get(target);
+        if (!eventListeners) {
+            eventListeners = new TargetEventListeners(target);
+            this._targetsEventListeners.set(target, eventListeners);
+        }
+        eventListeners.addEventListener(type, callback, options);
+    }
+    removeEventListener(target, type, callback, options) {
+        const eventListeners = this._targetsEventListeners.get(target);
+        if (!eventListeners) {
+            return;
+        }
+        eventListeners.removeEventListener(type, callback, options);
+        if (eventListeners.isEmpty) {
+            this._targetsEventListeners.delete(target);
+        }
+    }
+    reset() {
+        Array.from(this._targetsEventListeners.entries()).forEach(([target, targetEventListeners]) => {
+            targetEventListeners.reset();
+            this._targetsEventListeners.delete(target);
+        });
+    }
+}
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/eventListener/index.js
+
+
+
+
+/***/ }),
+
+/***/ 27699:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getClosestStackImageIndexForPoint)
+/* harmony export */ });
+/* unused harmony export calculateMinimalDistanceForStackViewport */
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _planar__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(52268);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(74876);
+
+
+
+function getClosestStackImageIndexForPoint(point, viewport) {
+    const minimalDistance = calculateMinimalDistanceForStackViewport(point, viewport);
+    return minimalDistance ? minimalDistance.index : null;
+}
+function calculateMinimalDistanceForStackViewport(point, viewport) {
+    const imageIds = viewport.getImageIds();
+    const currentImageIdIndex = viewport.getCurrentImageIdIndex();
+    if (imageIds.length === 0) {
+        return null;
+    }
+    const getDistance = (imageId) => {
+        const planeMetadata = getPlaneMetadata(imageId);
+        if (!planeMetadata) {
+            return null;
+        }
+        const plane = _planar__WEBPACK_IMPORTED_MODULE_1__.planeEquation(planeMetadata.planeNormal, planeMetadata.imagePositionPatient);
+        const distance = _planar__WEBPACK_IMPORTED_MODULE_1__.planeDistanceToPoint(plane, point);
+        return distance;
+    };
+    const closestStack = {
+        distance: getDistance(imageIds[currentImageIdIndex]) ?? Infinity,
+        index: currentImageIdIndex,
+    };
+    const higherImageIds = imageIds.slice(currentImageIdIndex + 1);
+    for (let i = 0; i < higherImageIds.length; i++) {
+        const id = higherImageIds[i];
+        const distance = getDistance(id);
+        if (distance === null) {
+            continue;
+        }
+        if (distance <= closestStack.distance) {
+            closestStack.distance = distance;
+            closestStack.index = i + currentImageIdIndex + 1;
+        }
+        else {
+            break;
+        }
+    }
+    const lowerImageIds = imageIds.slice(0, currentImageIdIndex);
+    for (let i = lowerImageIds.length - 1; i >= 0; i--) {
+        const id = lowerImageIds[i];
+        const distance = getDistance(id);
+        if (distance === null || distance === closestStack.distance) {
+            continue;
+        }
+        if (distance < closestStack.distance) {
+            closestStack.distance = distance;
+            closestStack.index = i;
+        }
+        else {
+            break;
+        }
+    }
+    return closestStack.distance === Infinity ? null : closestStack;
+}
+function getPlaneMetadata(imageId) {
+    const targetImagePlane = _metaData__WEBPACK_IMPORTED_MODULE_2__.get('imagePlaneModule', imageId);
+    if (!targetImagePlane ||
+        !(targetImagePlane.rowCosines instanceof Array &&
+            targetImagePlane.rowCosines.length === 3) ||
+        !(targetImagePlane.columnCosines instanceof Array &&
+            targetImagePlane.columnCosines.length === 3) ||
+        !(targetImagePlane.imagePositionPatient instanceof Array &&
+            targetImagePlane.imagePositionPatient.length === 3)) {
+        return null;
+    }
+    const { rowCosines, columnCosines, imagePositionPatient, } = targetImagePlane;
+    const rowVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.set */ .eR.set(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), ...rowCosines);
+    const colVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.set */ .eR.set(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), ...columnCosines);
+    const planeNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), rowVec, colVec);
+    return { rowCosines, columnCosines, imagePositionPatient, planeNormal };
+}
+
+
+/***/ }),
+
+/***/ 70683:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getCurrentVolumeViewportSlice)
+/* harmony export */ });
+/* unused harmony export getCurrentVolumeViewportSlice */
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _transformCanvasToIJK__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(51919);
+
+
+function getCurrentVolumeViewportSlice(viewport) {
+    const { width: canvasWidth, height: canvasHeight } = viewport.getCanvas();
+    const { sliceToIndexMatrix, indexToSliceMatrix } = viewport.getSliceViewInfo();
+    const ijkOriginPoint = (0,_transformCanvasToIJK__WEBPACK_IMPORTED_MODULE_1__/* .transformCanvasToIJK */ .e)(viewport, [0, 0]);
+    const ijkRowPoint = (0,_transformCanvasToIJK__WEBPACK_IMPORTED_MODULE_1__/* .transformCanvasToIJK */ .e)(viewport, [canvasWidth - 1, 0]);
+    const ijkColPoint = (0,_transformCanvasToIJK__WEBPACK_IMPORTED_MODULE_1__/* .transformCanvasToIJK */ .e)(viewport, [0, canvasHeight - 1]);
+    const ijkRowVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), ijkRowPoint, ijkOriginPoint);
+    const ijkColVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), ijkColPoint, ijkOriginPoint);
+    const ijkSliceVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), ijkRowVec, ijkColVec);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(ijkRowVec, ijkRowVec);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(ijkColVec, ijkColVec);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(ijkSliceVec, ijkSliceVec);
+    const maxIJKRowVec = Math.max(Math.abs(ijkRowVec[0]), Math.abs(ijkRowVec[1]), Math.abs(ijkRowVec[2]));
+    const maxIJKColVec = Math.max(Math.abs(ijkColVec[0]), Math.abs(ijkColVec[1]), Math.abs(ijkColVec[2]));
+    if (!gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .glMatrix.equals */ .Fd.equals(1, maxIJKRowVec) || !gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .glMatrix.equals */ .Fd.equals(1, maxIJKColVec)) {
+        throw new Error('Livewire is not available for rotate/oblique viewports');
+    }
+    const { voxelManager } = viewport.getImageData();
+    const sliceViewInfo = viewport.getSliceViewInfo();
+    const scalarData = voxelManager.getSliceData(sliceViewInfo);
+    return {
+        width: sliceViewInfo.width,
+        height: sliceViewInfo.height,
+        scalarData,
+        sliceToIndexMatrix,
+        indexToSliceMatrix,
+    };
+}
+
+
+
+/***/ }),
+
+/***/ 75283:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _splitImageIdsBy4DTags__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31215);
+
+function getDynamicVolumeInfo(imageIds) {
+    const { imageIdGroups: timePoints, splittingTag } = (0,_splitImageIdsBy4DTags__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(imageIds);
+    const isDynamicVolume = timePoints.length > 1;
+    return { isDynamicVolume, timePoints, splittingTag };
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getDynamicVolumeInfo);
+
+
+/***/ }),
+
+/***/ 87594:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_StackViewport__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(58165);
+/* harmony import */ var _getEnabledElement__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(86846);
+
+
+function getImageLegacy(element) {
+    const enabledElement = (0,_getEnabledElement__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay)(element);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    if (!(viewport instanceof _RenderingEngine_StackViewport__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)) {
+        throw new Error(`An image can only be fetched for a stack viewport and not for a viewport of type: ${viewport.type}`);
+    }
+    return viewport.getCornerstoneImage();
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getImageLegacy);
+
+
+/***/ }),
+
+/***/ 25308:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getMinMax)
+/* harmony export */ });
+function getMinMax(storedPixelData) {
+    let min = storedPixelData[0];
+    let max = storedPixelData[0];
+    let storedPixel;
+    const numPixels = storedPixelData.length;
+    for (let index = 1; index < numPixels; index++) {
+        storedPixel = storedPixelData[index];
+        min = Math.min(min, storedPixel);
+        max = Math.max(max, storedPixel);
+    }
+    return {
+        min,
+        max,
+    };
+}
+
+
+/***/ }),
+
+/***/ 49398:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   p: () => (/* binding */ getRandomSampleFromArray)
+/* harmony export */ });
+function getRandomSampleFromArray(array, size) {
+    const clonedArray = [...array];
+    if (size >= clonedArray.length) {
+        shuffleArray(clonedArray);
+        return clonedArray;
+    }
+    shuffleArray(clonedArray);
+    return clonedArray.slice(0, size);
+}
+function shuffleArray(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+}
+
+
+/***/ }),
+
+/***/ 10145:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getRuntimeId)
+/* harmony export */ });
+const LAST_RUNTIME_ID = Symbol('LastRuntimeId');
+const GLOBAL_CONTEXT = {};
+const DEFAULT_MAX = 0xffffffff;
+const DEFAULT_SEPARATOR = '-';
+function getRuntimeId(context, separator, max) {
+    return getNextRuntimeId(context !== null && typeof context === 'object' ? context : GLOBAL_CONTEXT, LAST_RUNTIME_ID, (typeof max === 'number' && max > 0 ? max : DEFAULT_MAX) >>> 0).join(typeof separator === 'string' ? separator : DEFAULT_SEPARATOR);
+}
+function getNextRuntimeId(context, symbol, max) {
+    let idComponents = context[symbol];
+    if (!(idComponents instanceof Array)) {
+        idComponents = [0];
+        Object.defineProperty(context, symbol, { value: idComponents });
+    }
+    for (let carry = true, i = 0; carry && i < idComponents.length; ++i) {
+        let n = idComponents[i] | 0;
+        if (n < max) {
+            carry = false;
+            n = n + 1;
+        }
+        else {
+            n = 0;
+            if (i + 1 === idComponents.length) {
+                idComponents.push(0);
+            }
+        }
+        idComponents[i] = n;
+    }
+    return idComponents;
+}
+
+
+/***/ }),
+
+/***/ 64448:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getViewportImageCornersInWorld)
+/* harmony export */ });
+function getViewportImageCornersInWorld(viewport) {
+    const { imageData, dimensions } = viewport.getImageData() || {};
+    if (!imageData || !dimensions) {
+        return [];
+    }
+    const { canvas } = viewport;
+    const ratio = window.devicePixelRatio;
+    const topLeftCanvas = [0, 0];
+    const topRightCanvas = [canvas.width / ratio, 0];
+    const bottomRightCanvas = [
+        canvas.width / ratio,
+        canvas.height / ratio,
+    ];
+    const bottomLeftCanvas = [0, canvas.height / ratio];
+    const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
+    const topRightWorld = viewport.canvasToWorld(topRightCanvas);
+    const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+    const bottomLeftWorld = viewport.canvasToWorld(bottomLeftCanvas);
+    const topLeftImage = imageData.worldToIndex(topLeftWorld);
+    const topRightImage = imageData.worldToIndex(topRightWorld);
+    const bottomRightImage = imageData.worldToIndex(bottomRightWorld);
+    const bottomLeftImage = imageData.worldToIndex(bottomLeftWorld);
+    return _getStackViewportImageCorners({
+        dimensions,
+        imageData,
+        topLeftImage,
+        topRightImage,
+        bottomRightImage,
+        bottomLeftImage,
+        topLeftWorld,
+        topRightWorld,
+        bottomRightWorld,
+        bottomLeftWorld,
+    });
+}
+function _getStackViewportImageCorners({ dimensions, imageData, topLeftImage, topRightImage, bottomRightImage, bottomLeftImage, topLeftWorld, topRightWorld, bottomRightWorld, bottomLeftWorld, }) {
+    const topLeftImageWorld = _isInBounds(topLeftImage, dimensions)
+        ? topLeftWorld
+        : imageData.indexToWorld([0, 0, 0]);
+    const topRightImageWorld = _isInBounds(topRightImage, dimensions)
+        ? topRightWorld
+        : imageData.indexToWorld([dimensions[0] - 1, 0, 0]);
+    const bottomRightImageWorld = _isInBounds(bottomRightImage, dimensions)
+        ? bottomRightWorld
+        : imageData.indexToWorld([
+            dimensions[0] - 1,
+            dimensions[1] - 1,
+            0,
+        ]);
+    const bottomLeftImageWorld = _isInBounds(bottomLeftImage, dimensions)
+        ? bottomLeftWorld
+        : imageData.indexToWorld([0, dimensions[1] - 1, 0]);
+    return [
+        topLeftImageWorld,
+        topRightImageWorld,
+        bottomLeftImageWorld,
+        bottomRightImageWorld,
+    ];
+}
+function _isInBounds(imageCoord, dimensions) {
+    return (imageCoord[0] > 0 ||
+        imageCoord[0] < dimensions[0] - 1 ||
+        imageCoord[1] > 0 ||
+        imageCoord[1] < dimensions[1] - 1 ||
+        imageCoord[2] > 0 ||
+        imageCoord[2] < dimensions[2] - 1);
+}
+
+
+/***/ }),
+
+/***/ 9973:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(56706);
+/* harmony import */ var _cache_cache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49038);
+
+
+function getViewportImageIds(viewport) {
+    if (viewport instanceof _RenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .VolumeViewport */ .PX) {
+        const volume = _cache_cache__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.getVolume(viewport.getVolumeId());
+        return volume.imageIds;
+    }
+    else if (viewport.getImageIds) {
+        return viewport.getImageIds();
+    }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getViewportImageIds);
+
+
+/***/ }),
+
+/***/ 30439:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   p: () => (/* binding */ _getViewportModality)
+/* harmony export */ });
+function _getViewportModality(viewport, volumeId, getVolume) {
+    if (!getVolume) {
+        throw new Error('getVolume is required, use the utilities export instead ');
+    }
+    if (viewport.modality) {
+        return viewport.modality;
+    }
+    if (viewport.setVolumes) {
+        volumeId = volumeId ?? viewport.getVolumeId();
+        if (!volumeId || !getVolume) {
+            return;
+        }
+        const volume = getVolume(volumeId);
+        return volume.metadata.Modality;
+    }
+    throw new Error('Invalid viewport type');
+}
+
+
+
+/***/ }),
+
+/***/ 13382:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getViewportsWithImageURI)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(39536);
+
+function getViewportsWithImageURI(imageURI) {
+    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .qO)();
+    const viewports = [];
+    renderingEngines.forEach((renderingEngine) => {
+        const viewportsForRenderingEngine = renderingEngine.getViewports();
+        viewportsForRenderingEngine.forEach((viewport) => {
+            if (viewport.hasImageURI(imageURI)) {
+                viewports.push(viewport);
+            }
+        });
+    });
+    return viewports;
+}
+
+
+/***/ }),
+
+/***/ 93475:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getVolumeDirectionVectors)
+/* harmony export */ });
+/* unused harmony export getVolumeDirectionVectors */
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _transformWorldToIndex__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(38669);
+
+
+function getVolumeDirectionVectors(imageData, camera) {
+    const { viewUp, viewPlaneNormal } = camera;
+    const ijkOrigin = (0,_transformWorldToIndex__WEBPACK_IMPORTED_MODULE_1__/* .transformWorldToIndexContinuous */ .p)(imageData, [0, 0, 0]);
+    const worldVecColDir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.negate */ .eR.negate(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), viewUp);
+    const worldVecSliceDir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.negate */ .eR.negate(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), viewPlaneNormal);
+    const worldVecRowDir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), worldVecColDir, worldVecSliceDir);
+    const ijkVecColDir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), (0,_transformWorldToIndex__WEBPACK_IMPORTED_MODULE_1__/* .transformWorldToIndexContinuous */ .p)(imageData, worldVecColDir), ijkOrigin);
+    const ijkVecSliceDir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), (0,_transformWorldToIndex__WEBPACK_IMPORTED_MODULE_1__/* .transformWorldToIndexContinuous */ .p)(imageData, worldVecSliceDir), ijkOrigin);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(ijkVecColDir, ijkVecColDir);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(ijkVecSliceDir, ijkVecSliceDir);
+    const ijkVecRowDir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), ijkVecColDir, ijkVecSliceDir);
+    return {
+        worldVecRowDir,
+        worldVecColDir,
+        worldVecSliceDir,
+        ijkVecRowDir,
+        ijkVecColDir,
+        ijkVecSliceDir,
+    };
+}
+
+
+
+/***/ }),
+
+/***/ 15388:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(39536);
+
+function getVolumeViewportsContainingSameVolumes(targetViewport, renderingEngineId) {
+    let renderingEngines;
+    if (renderingEngineId) {
+        renderingEngines = [(0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngine */ .lD)(renderingEngineId)];
+    }
+    else {
+        renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .qO)();
+    }
+    const sameVolumesViewports = [];
+    renderingEngines.forEach((renderingEngine) => {
+        const targetActors = targetViewport.getActors();
+        const viewports = renderingEngine.getVolumeViewports();
+        for (const vp of viewports) {
+            const vpActors = vp.getActors();
+            if (vpActors.length !== targetActors.length) {
+                continue;
+            }
+            const sameVolumes = targetActors.every(({ uid }) => vpActors.find((vpActor) => uid === vpActor.uid));
+            if (sameVolumes) {
+                sameVolumesViewports.push(vp);
+            }
+        }
+    });
+    return sameVolumesViewports;
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getVolumeViewportsContainingSameVolumes);
+
+
+/***/ }),
+
+/***/ 36527:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DefaultHistoryMemo: () => (/* binding */ DefaultHistoryMemo),
+/* harmony export */   HistoryMemo: () => (/* binding */ HistoryMemo)
+/* harmony export */ });
+class HistoryMemo {
+    constructor(label = 'Tools', size = 50) {
+        this.position = -1;
+        this.redoAvailable = 0;
+        this.undoAvailable = 0;
+        this.ring = new Array();
+        this.label = label;
+        this._size = size;
+    }
+    get size() {
+        return this._size;
+    }
+    set size(newSize) {
+        this.ring = new Array(newSize);
+        this._size = newSize;
+        this.position = -1;
+        this.redoAvailable = 0;
+        this.undoAvailable = 0;
+    }
+    undo(items = 1) {
+        while (items > 0 && this.undoAvailable > 0) {
+            const item = this.ring[this.position];
+            item.restoreMemo(true);
+            items--;
+            this.redoAvailable++;
+            this.undoAvailable--;
+            this.position = (this.position - 1 + this.size) % this.size;
+        }
+    }
+    redo(items = 1) {
+        while (items > 0 && this.redoAvailable > 0) {
+            const newPosition = (this.position + 1) % this.size;
+            const item = this.ring[newPosition];
+            item.restoreMemo(false);
+            items--;
+            this.position = newPosition;
+            this.undoAvailable++;
+            this.redoAvailable--;
+        }
+    }
+    push(item) {
+        if (!item) {
+            return;
+        }
+        const memo = item.restoreMemo
+            ? item
+            : item.createMemo?.();
+        if (!memo) {
+            return;
+        }
+        this.redoAvailable = 0;
+        if (this.undoAvailable < this._size) {
+            this.undoAvailable++;
+        }
+        this.position = (this.position + 1) % this._size;
+        this.ring[this.position] = memo;
+        return memo;
+    }
+}
+const DefaultHistoryMemo = new HistoryMemo();
+
+
+
+/***/ }),
+
+/***/ 79518:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ imageToWorldCoords)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74876);
+
+
+function imageToWorldCoords(imageId, imageCoords) {
+    const imagePlaneModule = (0,_metaData__WEBPACK_IMPORTED_MODULE_1__.get)('imagePlaneModule', imageId);
+    if (!imagePlaneModule) {
+        throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
+    }
+    const { columnCosines, rowCosines, imagePositionPatient: origin, } = imagePlaneModule;
+    let { columnPixelSpacing, rowPixelSpacing } = imagePlaneModule;
+    columnPixelSpacing ||= 1;
+    rowPixelSpacing ||= 1;
+    const imageCoordsInWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(imageCoordsInWorld, origin, rowCosines, rowPixelSpacing * (imageCoords[0] - 0.5));
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(imageCoordsInWorld, imageCoordsInWorld, columnCosines, columnPixelSpacing * (imageCoords[1] - 0.5));
+    return Array.from(imageCoordsInWorld);
+}
+
+
+/***/ }),
+
+/***/ 57092:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ indexWithinDimensions)
+/* harmony export */ });
+function indexWithinDimensions(index, dimensions) {
+    if (index[0] < 0 ||
+        index[0] >= dimensions[0] ||
+        index[1] < 0 ||
+        index[1] >= dimensions[1] ||
+        index[2] < 0 ||
+        index[2] >= dimensions[2]) {
+        return false;
+    }
+    return true;
+}
+
+
+/***/ }),
+
+/***/ 74638:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (/* binding */ isEqual),
+/* harmony export */   Ph: () => (/* binding */ isEqualAbs),
+/* harmony export */   WC: () => (/* binding */ isEqualNegative),
+/* harmony export */   n4: () => (/* binding */ isEqual)
+/* harmony export */ });
+function areNumbersEqualWithTolerance(num1, num2, tolerance) {
+    return Math.abs(num1 - num2) <= tolerance;
+}
+function areArraysEqual(arr1, arr2, tolerance = 1e-5) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; i++) {
+        if (!areNumbersEqualWithTolerance(arr1[i], arr2[i], tolerance)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isNumberType(value) {
+    return typeof value === 'number';
+}
+function isNumberArrayLike(value) {
+    return (value &&
+        typeof value === 'object' &&
+        'length' in value &&
+        typeof value.length === 'number' &&
+        value.length > 0 &&
+        typeof value[0] === 'number');
+}
+function isEqual(v1, v2, tolerance = 1e-5) {
+    if (typeof v1 !== typeof v2 || v1 === null || v2 === null) {
+        return false;
+    }
+    if (isNumberType(v1) && isNumberType(v2)) {
+        return areNumbersEqualWithTolerance(v1, v2, tolerance);
+    }
+    if (isNumberArrayLike(v1) && isNumberArrayLike(v2)) {
+        return areArraysEqual(v1, v2, tolerance);
+    }
+    return false;
+}
+const negative = (v) => typeof v === 'number' ? -v : v?.map ? v.map(negative) : !v;
+const abs = (v) => typeof v === 'number' ? Math.abs(v) : v?.map ? v.map(abs) : v;
+const isEqualNegative = (v1, v2, tolerance = undefined) => isEqual(v1, negative(v2), tolerance);
+const isEqualAbs = (v1, v2, tolerance = undefined) => isEqual(abs(v1), abs(v2), tolerance);
+
+
+
+/***/ }),
+
+/***/ 37657:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ isOpposite)
+/* harmony export */ });
+function isOpposite(v1, v2, tolerance = 1e-5) {
+    return (Math.abs(v1[0] + v2[0]) < tolerance &&
+        Math.abs(v1[1] + v2[1]) < tolerance &&
+        Math.abs(v1[2] + v2[2]) < tolerance);
+}
+
+
+/***/ }),
+
+/***/ 55947:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+const isPTPrescaledWithSUV = (image) => {
+    return image.preScale.scaled && image.preScale.scalingParameters.suvbw;
+};
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isPTPrescaledWithSUV);
+
+
+/***/ }),
+
+/***/ 77854:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   p: () => (/* binding */ isValidVolume)
+/* harmony export */ });
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(74876);
+/* harmony import */ var _isEqual__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74638);
+
+
+function isValidVolume(imageIds) {
+    const imageId0 = imageIds[0];
+    const { modality, seriesInstanceUID } = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('generalSeriesModule', imageId0);
+    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, } = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('imagePlaneModule', imageId0);
+    const baseMetadata = {
+        modality,
+        imageOrientationPatient,
+        pixelSpacing,
+        frameOfReferenceUID,
+        columns,
+        rows,
+        seriesInstanceUID,
+    };
+    const validVolume = imageIds.every((imageId) => {
+        const { modality, seriesInstanceUID } = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('generalSeriesModule', imageId);
+        const { imageOrientationPatient, pixelSpacing, columns, rows } = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('imagePlaneModule', imageId);
+        return (seriesInstanceUID === baseMetadata.seriesInstanceUID &&
+            modality === baseMetadata.modality &&
+            columns === baseMetadata.columns &&
+            rows === baseMetadata.rows &&
+            (0,_isEqual__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay)(imageOrientationPatient, baseMetadata.imageOrientationPatient) &&
+            (0,_isEqual__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay)(pixelSpacing, baseMetadata.pixelSpacing));
+    });
+    return validVolume;
+}
+
+
+
+/***/ }),
+
+/***/ 79697:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ isVideoTransferSyntax)
+/* harmony export */ });
+/* unused harmony export videoUIDs */
+const videoUIDs = new Set([
+    '1.2.840.10008.1.2.4.100',
+    '1.2.840.10008.1.2.4.100.1',
+    '1.2.840.10008.1.2.4.101',
+    '1.2.840.10008.1.2.4.101.1',
+    '1.2.840.10008.1.2.4.102',
+    '1.2.840.10008.1.2.4.102.1',
+    '1.2.840.10008.1.2.4.103',
+    '1.2.840.10008.1.2.4.103.1',
+    '1.2.840.10008.1.2.4.104',
+    '1.2.840.10008.1.2.4.104.1',
+    '1.2.840.10008.1.2.4.105',
+    '1.2.840.10008.1.2.4.105.1',
+    '1.2.840.10008.1.2.4.106',
+    '1.2.840.10008.1.2.4.106.1',
+    '1.2.840.10008.1.2.4.107',
+    '1.2.840.10008.1.2.4.108',
+]);
+function isVideoTransferSyntax(uidOrUids) {
+    if (!uidOrUids) {
+        return false;
+    }
+    const uids = Array.isArray(uidOrUids) ? uidOrUids : [uidOrUids];
+    return uids.find((uid) => videoUIDs.has(uid));
+}
+
+
+/***/ }),
+
+/***/ 86391:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   e: () => (/* binding */ jumpToSlice)
+/* harmony export */ });
+/* harmony import */ var _clip__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(25534);
+/* harmony import */ var _scroll__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(36277);
+/* harmony import */ var _getEnabledElement__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(86846);
+/* harmony import */ var _RenderingEngine_StackViewport__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(58165);
+
+
+
+
+async function jumpToSlice(element, options = {}) {
+    const { imageIndex, debounceLoading, volumeId } = options;
+    const enabledElement = (0,_getEnabledElement__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Ay)(element);
+    if (!enabledElement) {
+        throw new Error('Element has been disabled');
+    }
+    const { viewport } = enabledElement;
+    const { imageIndex: currentImageIndex, numberOfSlices } = _getImageSliceData(viewport, debounceLoading);
+    const imageIndexToJump = _getImageIndexToJump(numberOfSlices, imageIndex);
+    const delta = imageIndexToJump - currentImageIndex;
+    (0,_scroll__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(viewport, { delta, debounceLoading, volumeId });
+}
+function _getImageSliceData(viewport, debounceLoading) {
+    if (viewport instanceof _RenderingEngine_StackViewport__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A) {
+        return {
+            numberOfSlices: viewport.getImageIds().length,
+            imageIndex: debounceLoading
+                ? viewport.getTargetImageIdIndex()
+                : viewport.getCurrentImageIdIndex(),
+        };
+    }
+    return {
+        numberOfSlices: viewport.getNumberOfSlices(),
+        imageIndex: viewport.getSliceIndex(),
+    };
+}
+function _getImageIndexToJump(numberOfSlices, imageIndex) {
+    const lastSliceIndex = numberOfSlices - 1;
+    return (0,_clip__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Ay)(imageIndex, 0, lastSliceIndex);
+}
+
+
+
+/***/ }),
+
+/***/ 24662:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ loadImageToCanvas)
+/* harmony export */ });
+/* harmony import */ var _loaders_imageLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(80068);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74876);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(31749);
+/* harmony import */ var _requestPool_imageLoadPoolManager__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(51159);
+/* harmony import */ var _renderToCanvasGPU__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(3667);
+/* harmony import */ var _renderToCanvasCPU__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(38583);
+/* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(59693);
+/* harmony import */ var _cache_cache__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(49038);
+
+
+
+
+
+
+
+
+function loadImageToCanvas(options) {
+    const { canvas, imageId, viewReference, requestType = _enums__WEBPACK_IMPORTED_MODULE_2__.RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, thumbnail = false, imageAspect = false, viewportOptions: baseViewportOptions, } = options;
+    const volumeId = viewReference?.volumeId;
+    const isVolume = volumeId && !imageId;
+    const viewportOptions = viewReference && baseViewportOptions
+        ? { ...baseViewportOptions, viewReference }
+        : baseViewportOptions;
+    const renderFn = useCPURendering ? _renderToCanvasCPU__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A : _renderToCanvasGPU__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A;
+    return new Promise((resolve, reject) => {
+        function successCallback(imageOrVolume, imageId) {
+            const { modality } = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('generalSeriesModule', imageId) || {};
+            const image = !isVolume && imageOrVolume;
+            const volume = isVolume && imageOrVolume;
+            if (image) {
+                image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
+            }
+            if (thumbnail) {
+                canvas.height = 256;
+                canvas.width = 256;
+            }
+            if (imageAspect && image) {
+                canvas.width = image && (canvas.height * image.width) / image.height;
+            }
+            canvas.style.width = `${canvas.width / devicePixelRatio}px`;
+            canvas.style.height = `${canvas.height / devicePixelRatio}px`;
+            if (volume && useCPURendering) {
+                reject(new Error('CPU rendering of volume not supported'));
+            }
+            renderFn(canvas, imageOrVolume, modality, renderingEngineId, viewportOptions).then(resolve);
+        }
+        function errorCallback(error, imageId) {
+            console.error(error, imageId);
+            reject(error);
+        }
+        function sendRequest(imageId, imageIdIndex, options) {
+            return (0,_loaders_imageLoader__WEBPACK_IMPORTED_MODULE_0__.loadAndCacheImage)(imageId, options).then((image) => {
+                successCallback.call(this, image, imageId);
+            }, (error) => {
+                errorCallback.call(this, error, imageId);
+            });
+        }
+        const options = {
+            useRGBA: !!useCPURendering,
+            requestType,
+        };
+        if (volumeId) {
+            const volume = _cache_cache__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Ay.getVolume(volumeId);
+            if (!volume) {
+                reject(new Error(`Volume id ${volumeId} not found in cache`));
+            }
+            const useImageId = volume.imageIds[0];
+            successCallback(volume, useImageId);
+        }
+        else {
+            _requestPool_imageLoadPoolManager__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        }
+    });
+}
+
+
+/***/ }),
+
+/***/ 52268:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   linePlaneIntersection: () => (/* binding */ linePlaneIntersection),
+/* harmony export */   planeDistanceToPoint: () => (/* binding */ planeDistanceToPoint),
+/* harmony export */   planeEquation: () => (/* binding */ planeEquation),
+/* harmony export */   threePlaneIntersection: () => (/* binding */ threePlaneIntersection)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+
+function linePlaneIntersection(p0, p1, plane) {
+    const [x0, y0, z0] = p0;
+    const [x1, y1, z1] = p1;
+    const [A, B, C, D] = plane;
+    const a = x1 - x0;
+    const b = y1 - y0;
+    const c = z1 - z0;
+    const t = (-1 * (A * x0 + B * y0 + C * z0 - D)) / (A * a + B * b + C * c);
+    const X = a * t + x0;
+    const Y = b * t + y0;
+    const Z = c * t + z0;
+    return [X, Y, Z];
+}
+function planeEquation(normal, point, normalized = false) {
+    const [A, B, C] = normal;
+    const D = A * point[0] + B * point[1] + C * point[2];
+    if (normalized) {
+        const length = Math.sqrt(A * A + B * B + C * C);
+        return [A / length, B / length, C / length, D / length];
+    }
+    return [A, B, C, D];
+}
+function threePlaneIntersection(firstPlane, secondPlane, thirdPlane) {
+    const [A1, B1, C1, D1] = firstPlane;
+    const [A2, B2, C2, D2] = secondPlane;
+    const [A3, B3, C3, D3] = thirdPlane;
+    const m0 = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.fromValues */ .w0.fromValues(A1, A2, A3, B1, B2, B3, C1, C2, C3);
+    const m1 = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.fromValues */ .w0.fromValues(D1, D2, D3, B1, B2, B3, C1, C2, C3);
+    const m2 = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.fromValues */ .w0.fromValues(A1, A2, A3, D1, D2, D3, C1, C2, C3);
+    const m3 = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.fromValues */ .w0.fromValues(A1, A2, A3, B1, B2, B3, D1, D2, D3);
+    const x = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.determinant */ .w0.determinant(m1) / gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.determinant */ .w0.determinant(m0);
+    const y = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.determinant */ .w0.determinant(m2) / gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.determinant */ .w0.determinant(m0);
+    const z = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.determinant */ .w0.determinant(m3) / gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat3.determinant */ .w0.determinant(m0);
+    return [x, y, z];
+}
+function planeDistanceToPoint(plane, point, signed = false) {
+    const [A, B, C, D] = plane;
+    const [x, y, z] = point;
+    const numerator = A * x + B * y + C * z - D;
+    const distance = Math.abs(numerator) / Math.sqrt(A * A + B * B + C * C);
+    const sign = signed ? Math.sign(numerator) : 1;
+    return sign * distance;
+}
+
+
+
+/***/ }),
+
+/***/ 38583:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ renderToCanvasCPU)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_helpers_cpuFallback_rendering_getDefaultViewport__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36931);
+/* harmony import */ var _RenderingEngine_helpers_cpuFallback_rendering_calculateTransform__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7808);
+/* harmony import */ var _RenderingEngine_helpers_cpuFallback_drawImageSync__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5057);
+
+
+
+function renderToCanvasCPU(canvas, imageOrVolume, modality, _renderingEngineId, _viewportOptions) {
+    const volume = imageOrVolume;
+    if (volume.volumeId) {
+        throw new Error('Unsupported volume rendering for CPU');
+    }
+    const image = imageOrVolume;
+    const viewport = (0,_RenderingEngine_helpers_cpuFallback_rendering_getDefaultViewport__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(canvas, image, modality);
+    const enabledElement = {
+        canvas,
+        viewport,
+        image,
+        renderingTools: {},
+    };
+    enabledElement.transform = (0,_RenderingEngine_helpers_cpuFallback_rendering_calculateTransform__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(enabledElement);
+    const invalidated = true;
+    return new Promise((resolve, reject) => {
+        (0,_RenderingEngine_helpers_cpuFallback_drawImageSync__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(enabledElement, invalidated);
+        resolve(null);
+    });
+}
+
+
+/***/ }),
+
+/***/ 3667:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ renderToCanvasGPU)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_helpers_getOrCreateCanvas__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(30135);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(31749);
+/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(39536);
+/* harmony import */ var _RenderingEngine__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(56706);
+/* harmony import */ var _isPTPrescaledWithSUV__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(55947);
+
+
+
+
+
+function renderToCanvasGPU(canvas, imageOrVolume, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = {
+    displayArea: { imageArea: [1, 1] },
+}) {
+    if (!canvas || !(canvas instanceof HTMLCanvasElement)) {
+        throw new Error('canvas element is required');
+    }
+    const isVolume = !imageOrVolume.imageId;
+    const image = !isVolume && imageOrVolume;
+    const volume = isVolume && imageOrVolume;
+    const imageIdToPrint = image.imageId || volume.volumeId;
+    const viewportId = `renderGPUViewport-${imageIdToPrint}`;
+    const element = document.createElement('div');
+    const devicePixelRatio = window.devicePixelRatio || 1;
+    if (!viewportOptions.displayArea) {
+        viewportOptions.displayArea = { imageArea: [1, 1] };
+    }
+    const originalWidth = canvas.width;
+    const originalHeight = canvas.height;
+    element.style.width = `${originalWidth / devicePixelRatio + _RenderingEngine_helpers_getOrCreateCanvas__WEBPACK_IMPORTED_MODULE_0__/* .EPSILON */ .p8}px`;
+    element.style.height = `${originalHeight / devicePixelRatio + _RenderingEngine_helpers_getOrCreateCanvas__WEBPACK_IMPORTED_MODULE_0__/* .EPSILON */ .p8}px`;
+    element.style.visibility = 'hidden';
+    element.style.position = 'absolute';
+    document.body.appendChild(element);
+    const uniqueId = viewportId.split(':').join('-');
+    element.setAttribute('viewport-id-for-remove', uniqueId);
+    const temporaryCanvas = (0,_RenderingEngine_helpers_getOrCreateCanvas__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Ay)(element);
+    const renderingEngine = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_2__/* .getRenderingEngine */ .lD)(renderingEngineId) ||
+        new _RenderingEngine__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Ay(renderingEngineId);
+    let viewport = renderingEngine.getViewport(viewportId);
+    if (!viewport) {
+        const viewportInput = {
+            viewportId,
+            type: isVolume ? _enums__WEBPACK_IMPORTED_MODULE_1__.ViewportType.ORTHOGRAPHIC : _enums__WEBPACK_IMPORTED_MODULE_1__.ViewportType.STACK,
+            element,
+            defaultOptions: {
+                ...viewportOptions,
+                suppressEvents: true,
+            },
+        };
+        renderingEngine.enableElement(viewportInput);
+        viewport = renderingEngine.getViewport(viewportId);
+    }
+    return new Promise((resolve) => {
+        let elementRendered = false;
+        let { viewReference } = viewportOptions;
+        const onImageRendered = (eventDetail) => {
+            if (elementRendered) {
+                return;
+            }
+            if (viewReference) {
+                const useViewRef = viewReference;
+                viewReference = null;
+                viewport.setViewReference(useViewRef);
+                viewport.render();
+                return;
+            }
+            const context = canvas.getContext('2d');
+            context.drawImage(temporaryCanvas, 0, 0, temporaryCanvas.width, temporaryCanvas.height, 0, 0, canvas.width, canvas.height);
+            const origin = viewport.canvasToWorld([0, 0]);
+            const topRight = viewport.canvasToWorld([
+                temporaryCanvas.width / devicePixelRatio,
+                0,
+            ]);
+            const bottomLeft = viewport.canvasToWorld([
+                0,
+                temporaryCanvas.height / devicePixelRatio,
+            ]);
+            const thicknessMm = 1;
+            elementRendered = true;
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_1__.Events.IMAGE_RENDERED, onImageRendered);
+            setTimeout(() => {
+                renderingEngine.disableElement(viewportId);
+                const elements = document.querySelectorAll(`[viewport-id-for-remove="${uniqueId}"]`);
+                elements.forEach((element) => {
+                    element.remove();
+                });
+            }, 0);
+            resolve({
+                origin,
+                bottomLeft,
+                topRight,
+                thicknessMm,
+            });
+        };
+        element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_1__.Events.IMAGE_RENDERED, onImageRendered);
+        if (isVolume) {
+            viewport.setVolumes([volume], false, true);
+        }
+        else {
+            viewport.renderImageObject(imageOrVolume);
+        }
+        viewport.resetCamera();
+        if (modality === 'PT' && !(0,_isPTPrescaledWithSUV__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(image)) {
+            viewport.setProperties({
+                voiRange: {
+                    lower: image.minPixelValue,
+                    upper: image.maxPixelValue,
+                },
+            });
+        }
+        viewport.render();
+    });
+}
+
+
+/***/ }),
+
+/***/ 1587:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   C: () => (/* binding */ roundToPrecision)
+/* harmony export */ });
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(19325);
+
+function roundNumber(value, precision = 2) {
+    if (Array.isArray(value)) {
+        return value.map((v) => roundNumber(v, precision)).join(', ');
+    }
+    if (value === undefined || value === null || value === '') {
+        return 'NaN';
+    }
+    value = Number(value);
+    const absValue = Math.abs(value);
+    if (absValue < 0.0001) {
+        return `${value}`;
+    }
+    const fixedPrecision = absValue >= 100
+        ? precision - 2
+        : absValue >= 10
+            ? precision - 1
+            : absValue >= 1
+                ? precision
+                : absValue >= 0.1
+                    ? precision + 1
+                    : absValue >= 0.01
+                        ? precision + 2
+                        : absValue >= 0.001
+                            ? precision + 3
+                            : precision + 4;
+    return value.toFixed(fixedPrecision);
+}
+function roundToPrecision(value) {
+    return Math.round(value / _constants__WEBPACK_IMPORTED_MODULE_0__.EPSILON) * _constants__WEBPACK_IMPORTED_MODULE_0__.EPSILON;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (roundNumber);
+
+
+/***/ }),
+
+/***/ 44335:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ scaleArray)
+/* harmony export */ });
+function scaleArray(array, scalingParameters) {
+    const arrayLength = array.length;
+    const { rescaleSlope, rescaleIntercept, suvbw } = scalingParameters;
+    if (scalingParameters.modality === 'PT' && typeof suvbw === 'number') {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = suvbw * (array[i] * rescaleSlope + rescaleIntercept);
+        }
+    }
+    else {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = array[i] * rescaleSlope + rescaleIntercept;
+        }
+    }
+    return array;
+}
+
+
+/***/ }),
+
+/***/ 44134:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ scaleRGBTransferFunction)
+/* harmony export */ });
+function scaleRGBTransferFunction(rgbTransferFunction, scalingFactor) {
+    const size = rgbTransferFunction.getSize();
+    for (let index = 0; index < size; index++) {
+        const nodeValue1 = [];
+        rgbTransferFunction.getNodeValue(index, nodeValue1);
+        nodeValue1[1] = nodeValue1[1] * scalingFactor;
+        nodeValue1[2] = nodeValue1[2] * scalingFactor;
+        nodeValue1[3] = nodeValue1[3] * scalingFactor;
+        rgbTransferFunction.setNodeValue(index, nodeValue1);
+    }
+}
+
+
+/***/ }),
+
+/***/ 36277:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ scroll)
+/* harmony export */ });
+/* unused harmony export scrollVolume */
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31749);
+/* harmony import */ var _RenderingEngine__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(56706);
+/* harmony import */ var _getVolumeViewportScrollInfo__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(61375);
+/* harmony import */ var _snapFocalPointToSlice__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(80500);
+/* harmony import */ var _getEnabledElement__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(86846);
+/* harmony import */ var _triggerEvent__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(69372);
+/* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(10364);
+
+
+
+
+
+
+
+function scroll(viewport, options) {
+    const enabledElement = (0,_getEnabledElement__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Ay)(viewport.element);
+    if (!enabledElement) {
+        throw new Error('Scroll::Viewport is not enabled (it might be disabled)');
+    }
+    if (viewport instanceof _RenderingEngine__WEBPACK_IMPORTED_MODULE_1__/* .StackViewport */ .hS &&
+        viewport.getImageIds().length === 0) {
+        throw new Error('Scroll::Stack Viewport has no images');
+    }
+    const { volumeId, delta, scrollSlabs } = options;
+    if (viewport instanceof _RenderingEngine__WEBPACK_IMPORTED_MODULE_1__/* .VolumeViewport */ .PX) {
+        scrollVolume(viewport, volumeId, delta, scrollSlabs);
+    }
+    else {
+        const imageIdIndex = viewport.getCurrentImageIdIndex();
+        if (imageIdIndex + delta >
+            viewport.getImageIds().length - 1 ||
+            imageIdIndex + delta < 0) {
+            const eventData = {
+                imageIdIndex,
+                direction: delta,
+            };
+            (0,_triggerEvent__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)(_eventTarget__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A, _enums__WEBPACK_IMPORTED_MODULE_0__.Events.STACK_SCROLL_OUT_OF_BOUNDS, eventData);
+        }
+        viewport.scroll(delta, options.debounceLoading, options.loop);
+    }
+}
+function scrollVolume(viewport, volumeId, delta, scrollSlabs = false) {
+    const useSlabThickness = scrollSlabs;
+    const { numScrollSteps, currentStepIndex, sliceRangeInfo } = (0,_getVolumeViewportScrollInfo__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(viewport, volumeId, useSlabThickness);
+    if (!sliceRangeInfo) {
+        return;
+    }
+    const { sliceRange, spacingInNormalDirection, camera } = sliceRangeInfo;
+    const { focalPoint, viewPlaneNormal, position } = camera;
+    const { newFocalPoint, newPosition } = (0,_snapFocalPointToSlice__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, delta);
+    viewport.setCamera({
+        focalPoint: newFocalPoint,
+        position: newPosition,
+    });
+    viewport.render();
+    const desiredStepIndex = currentStepIndex + delta;
+    const VolumeScrollEventDetail = {
+        volumeId,
+        viewport,
+        delta,
+        desiredStepIndex,
+        currentStepIndex,
+        numScrollSteps,
+        currentImageId: viewport.getCurrentImageId(),
+    };
+    if ((desiredStepIndex > numScrollSteps || desiredStepIndex < 0) &&
+        viewport.getCurrentImageId()) {
+        (0,_triggerEvent__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)(_eventTarget__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A, _enums__WEBPACK_IMPORTED_MODULE_0__.Events.VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS, VolumeScrollEventDetail);
+    }
+    else {
+        (0,_triggerEvent__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)(_eventTarget__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A, _enums__WEBPACK_IMPORTED_MODULE_0__.Events.VOLUME_VIEWPORT_SCROLL, VolumeScrollEventDetail);
+    }
+}
+
+
+/***/ }),
+
+/***/ 40239:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74876);
+
+
+const state = {};
+const spatialRegistrationMetadataProvider = {
+    add: (query, payload) => {
+        const [viewportId1, viewportId2] = query;
+        const entryId = `${viewportId1}_${viewportId2}`;
+        if (!state[entryId]) {
+            state[entryId] = {};
+        }
+        state[entryId] = payload;
+    },
+    get: (type, viewportId1, viewportId2) => {
+        if (type !== 'spatialRegistrationModule') {
+            return;
+        }
+        const entryId = `${viewportId1}_${viewportId2}`;
+        if (state[entryId]) {
+            return state[entryId];
+        }
+        const entryIdReverse = `${viewportId2}_${viewportId1}`;
+        if (state[entryIdReverse]) {
+            return gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat4.invert */ .pB.invert(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .mat4.create */ .pB.create(), state[entryIdReverse]);
+        }
+    },
+};
+(0,_metaData__WEBPACK_IMPORTED_MODULE_1__.addProvider)(spatialRegistrationMetadataProvider.get.bind(spatialRegistrationMetadataProvider));
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (spatialRegistrationMetadataProvider);
+
+
+/***/ }),
+
+/***/ 31215:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(74876);
+
+const groupBy = (array, key) => {
+    return array.reduce((rv, x) => {
+        (rv[x[key]] = rv[x[key]] || []).push(x);
+        return rv;
+    }, {});
+};
+function getIPPGroups(imageIds) {
+    const ippMetadata = imageIds.map((imageId) => {
+        const { imagePositionPatient } = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('imagePlaneModule', imageId) || {};
+        return { imageId, imagePositionPatient };
+    });
+    if (!ippMetadata.every((item) => item.imagePositionPatient)) {
+        return null;
+    }
+    const positionGroups = groupBy(ippMetadata, 'imagePositionPatient');
+    const positions = Object.keys(positionGroups);
+    const frame_count = positionGroups[positions[0]].length;
+    if (frame_count === 1) {
+        return null;
+    }
+    const frame_count_equal = positions.every((k) => positionGroups[k].length === frame_count);
+    if (!frame_count_equal) {
+        return null;
+    }
+    return positionGroups;
+}
+function test4DTag(IPPGroups, value_getter) {
+    const frame_groups = {};
+    let first_frame_value_set = [];
+    const positions = Object.keys(IPPGroups);
+    for (let i = 0; i < positions.length; i++) {
+        const frame_value_set = new Set();
+        const frames = IPPGroups[positions[i]];
+        for (let j = 0; j < frames.length; j++) {
+            const frame_value = value_getter(frames[j].imageId) || 0;
+            frame_groups[frame_value] = frame_groups[frame_value] || [];
+            frame_groups[frame_value].push({ imageId: frames[j].imageId });
+            frame_value_set.add(frame_value);
+            if (frame_value_set.size - 1 < j) {
+                return undefined;
+            }
+        }
+        if (i == 0) {
+            first_frame_value_set = Array.from(frame_value_set);
+        }
+        else if (!setEquals(first_frame_value_set, frame_value_set)) {
+            return undefined;
+        }
+    }
+    return frame_groups;
+}
+function getTagValue(imageId, tag) {
+    const value = _metaData__WEBPACK_IMPORTED_MODULE_0__.get(tag, imageId);
+    try {
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getPhilipsPrivateBValue(imageId) {
+    const value = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('20011003', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            const value_bytes = atob(InlineBinary);
+            const ary_buf = new ArrayBuffer(value_bytes.length);
+            const dv = new DataView(ary_buf);
+            for (let i = 0; i < value_bytes.length; i++) {
+                dv.setUint8(i, value_bytes.charCodeAt(i));
+            }
+            return new Float32Array(ary_buf)[0];
+        }
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getSiemensPrivateBValue(imageId) {
+    let value = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('0019100c', imageId) || _metaData__WEBPACK_IMPORTED_MODULE_0__.get('0019100C', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            value = atob(InlineBinary);
+        }
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getGEPrivateBValue(imageId) {
+    let value = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('00431039', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            value = atob(InlineBinary).split('//');
+        }
+        return parseFloat(value[0]) % 100000;
+    }
+    catch {
+        return undefined;
+    }
+}
+function setEquals(set_a, set_b) {
+    if (set_a.length != set_b.size) {
+        return false;
+    }
+    for (let i = 0; i < set_a.length; i++) {
+        if (!set_b.has(set_a[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function getPetFrameReferenceTime(imageId) {
+    const moduleInfo = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('petImageModule', imageId);
+    return moduleInfo ? moduleInfo['frameReferenceTime'] : 0;
+}
+function splitImageIdsBy4DTags(imageIds) {
+    const positionGroups = getIPPGroups(imageIds);
+    if (!positionGroups) {
+        return { imageIdGroups: [imageIds], splittingTag: null };
+    }
+    const tags = [
+        'TemporalPositionIdentifier',
+        'DiffusionBValue',
+        'TriggerTime',
+        'EchoTime',
+        'EchoNumber',
+        'PhilipsPrivateBValue',
+        'SiemensPrivateBValue',
+        'GEPrivateBValue',
+        'PetFrameReferenceTime',
+    ];
+    const fncList2 = [
+        (imageId) => getTagValue(imageId, tags[0]),
+        (imageId) => getTagValue(imageId, tags[1]),
+        (imageId) => getTagValue(imageId, tags[2]),
+        (imageId) => getTagValue(imageId, tags[3]),
+        (imageId) => getTagValue(imageId, tags[4]),
+        getPhilipsPrivateBValue,
+        getSiemensPrivateBValue,
+        getGEPrivateBValue,
+        getPetFrameReferenceTime,
+    ];
+    for (let i = 0; i < fncList2.length; i++) {
+        const frame_groups = test4DTag(positionGroups, fncList2[i]);
+        if (frame_groups) {
+            const sortedKeys = Object.keys(frame_groups)
+                .map(Number.parseFloat)
+                .sort((a, b) => a - b);
+            const imageIdGroups = sortedKeys.map((key) => frame_groups[key].map((item) => item.imageId));
+            return { imageIdGroups, splittingTag: tags[i] };
+        }
+    }
+    return { imageIdGroups: [imageIds], splittingTag: null };
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (splitImageIdsBy4DTags);
+
+
+/***/ }),
+
+/***/ 85745:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getTransferFunctionNodes: () => (/* binding */ getTransferFunctionNodes),
+/* harmony export */   setTransferFunctionNodes: () => (/* binding */ setTransferFunctionNodes)
+/* harmony export */ });
+function getTransferFunctionNodes(transferFunction) {
+    const size = transferFunction.getSize();
+    const values = [];
+    for (let index = 0; index < size; index++) {
+        const nodeValue1 = [];
+        transferFunction.getNodeValue(index, nodeValue1);
+        values.push(nodeValue1);
+    }
+    return values;
+}
+function setTransferFunctionNodes(transferFunction, nodes) {
+    if (!nodes?.length) {
+        return;
+    }
+    transferFunction.removeAllPoints();
+    nodes.forEach((node) => {
+        transferFunction.addRGBPoint(...node);
+    });
+}
+
+
+
+/***/ }),
+
+/***/ 38669:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ transformWorldToIndex),
+/* harmony export */   p: () => (/* binding */ transformWorldToIndexContinuous)
+/* harmony export */ });
+function transformWorldToIndex(imageData, worldPos) {
+    const continuousIndex = imageData.worldToIndex(worldPos);
+    const index = continuousIndex.map(Math.round);
+    return index;
+}
+function transformWorldToIndexContinuous(imageData, worldPos) {
+    return imageData.worldToIndex(worldPos);
+}
+
+
+/***/ }),
+
+/***/ 68136:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   toLowHighRange: () => (/* binding */ toLowHighRange),
+/* harmony export */   toWindowLevel: () => (/* binding */ toWindowLevel)
+/* harmony export */ });
+/* harmony import */ var _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(82501);
+/* harmony import */ var _logit__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(58977);
+
+
+function toWindowLevel(low, high) {
+    const windowWidth = Math.abs(high - low) + 1;
+    const windowCenter = (low + high + 1) / 2;
+    return { windowWidth, windowCenter };
+}
+function toLowHighRange(windowWidth, windowCenter, voiLUTFunction = _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.LINEAR) {
+    if (voiLUTFunction === _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.LINEAR) {
+        return {
+            lower: windowCenter - 0.5 - (windowWidth - 1) / 2,
+            upper: windowCenter - 0.5 + (windowWidth - 1) / 2,
+        };
+    }
+    else if (voiLUTFunction === _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.LINEAR_EXACT) {
+        return {
+            lower: windowCenter - windowWidth / 2,
+            upper: windowCenter + windowWidth / 2,
+        };
+    }
+    else if (voiLUTFunction === _enums_VOILUTFunctionType__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.SAMPLED_SIGMOID) {
+        const xLower = (0,_logit__WEBPACK_IMPORTED_MODULE_1__/* .logit */ .i)(0.01, windowCenter, windowWidth);
+        const xUpper = (0,_logit__WEBPACK_IMPORTED_MODULE_1__/* .logit */ .i)(0.99, windowCenter, windowWidth);
+        return {
+            lower: xLower,
+            upper: xUpper,
+        };
+    }
+    else {
+        throw new Error('Invalid VOI LUT function');
+    }
+}
+
+
+
+/***/ }),
+
+/***/ 79988:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74876);
+
+
+function worldToImageCoords(imageId, worldCoords) {
+    const imagePlaneModule = (0,_metaData__WEBPACK_IMPORTED_MODULE_1__.get)('imagePlaneModule', imageId);
+    if (!imagePlaneModule) {
+        throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
+    }
+    const { columnCosines, rowCosines, imagePositionPatient: origin, } = imagePlaneModule;
+    let { columnPixelSpacing, rowPixelSpacing } = imagePlaneModule;
+    columnPixelSpacing ||= 1;
+    rowPixelSpacing ||= 1;
+    const newOrigin = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(newOrigin, origin, columnCosines, -columnPixelSpacing / 2);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(newOrigin, newOrigin, rowCosines, -rowPixelSpacing / 2);
+    const sub = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(sub, worldCoords, newOrigin);
+    const rowDistance = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(sub, rowCosines);
+    const columnDistance = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(sub, columnCosines);
+    const imageCoords = [
+        rowDistance / rowPixelSpacing,
+        columnDistance / columnPixelSpacing,
+    ];
+    return imageCoords;
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (worldToImageCoords);
+
+
+/***/ }),
+
+/***/ 4667:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   utilities: () => (/* reexport module object */ _utilities__WEBPACK_IMPORTED_MODULE_6__)
+/* harmony export */ });
+/* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(23391);
+/* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15900);
+/* harmony import */ var _store_state__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(85204);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(47085);
+/* harmony import */ var _synchronizers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(93106);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(89578);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(23566);
+/* harmony import */ var _cursors__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(79475);
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(13369);
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(_types__WEBPACK_IMPORTED_MODULE_8__);
+/* harmony import */ var _stateManagement_annotation__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(32102);
+/* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(44595);
+/* harmony import */ var _tools_annotation_splines__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(30453);
+/* harmony import */ var _tools__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(67460);
+/* harmony import */ var _tools_annotation_VideoRedactionTool__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(11811);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(99737);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 53005:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getState: () => (/* reexport safe */ _getState__WEBPACK_IMPORTED_MODULE_0__.A),
+/* harmony export */   style: () => (/* reexport safe */ _ToolStyle__WEBPACK_IMPORTED_MODULE_2__.A)
+/* harmony export */ });
+/* harmony import */ var _getState__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(75892);
+/* harmony import */ var _getFont__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(61816);
+/* harmony import */ var _ToolStyle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8710);
+
+
+
+
+
+
+/***/ }),
+
+/***/ 32102:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   config: () => (/* reexport module object */ _config__WEBPACK_IMPORTED_MODULE_0__),
+/* harmony export */   state: () => (/* binding */ state)
+/* harmony export */ });
+/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(53005);
+/* harmony import */ var _annotationLocking__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2076);
+/* harmony import */ var _annotationSelection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(17343);
+/* harmony import */ var _annotationState__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(82056);
+/* harmony import */ var _helpers_state__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(44049);
+/* harmony import */ var _annotationVisibility__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(29601);
+/* harmony import */ var _FrameOfReferenceSpecificAnnotationManager__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(67013);
+/* harmony import */ var _AnnotationGroup__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(90826);
+/* harmony import */ var _resetAnnotationManager__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(97);
+
+
+
+
+
+
+
+
+
+const state = {
+    ..._annotationState__WEBPACK_IMPORTED_MODULE_3__,
+    ..._helpers_state__WEBPACK_IMPORTED_MODULE_4__,
+    resetAnnotationManager: _resetAnnotationManager__WEBPACK_IMPORTED_MODULE_8__/* .resetAnnotationManager */ .c,
+};
+
+
+
+/***/ }),
+
+/***/ 24917:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   fy: () => (/* binding */ triggerSegmentationRenderBySegmentationId),
+/* harmony export */   h6: () => (/* binding */ triggerSegmentationRender)
+/* harmony export */ });
+/* unused harmony export segmentationRenderingEngine */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99737);
+/* harmony import */ var _enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(18682);
+/* harmony import */ var _getSegmentationRepresentation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(93210);
+/* harmony import */ var _tools_displayTools_Surface_surfaceDisplay__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(67014);
+/* harmony import */ var _tools_displayTools_Contour_contourDisplay__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(25894);
+/* harmony import */ var _tools_displayTools_Labelmap_labelmapDisplay__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(684);
+/* harmony import */ var _store_addTool__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(68040);
+/* harmony import */ var _store_state__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(85204);
+/* harmony import */ var _tools_annotation_PlanarFreehandContourSegmentationTool__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(37590);
+/* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(7754);
+
+
+
+
+
+
+
+
+
+
+
+const renderers = {
+    [_enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.Labelmap]: _tools_displayTools_Labelmap_labelmapDisplay__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Ay,
+    [_enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.Contour]: _tools_displayTools_Contour_contourDisplay__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A,
+    [_enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.Surface]: _tools_displayTools_Surface_surfaceDisplay__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Ay,
+};
+const planarContourToolName = _tools_annotation_PlanarFreehandContourSegmentationTool__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A.toolName;
+class SegmentationRenderingEngine {
+    constructor() {
+        this._needsRender = new Set();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._getAllViewports = () => {
+            const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getRenderingEngines)();
+            return renderingEngine.flatMap((renderingEngine) => renderingEngine.getViewports());
+        };
+        this._renderFlaggedSegmentations = () => {
+            this._throwIfDestroyed();
+            const viewportIds = Array.from(this._needsRender);
+            viewportIds.forEach((viewportId) => {
+                this._triggerRender(viewportId);
+            });
+            this._needsRender.clear();
+            this._animationFrameSet = false;
+            this._animationFrameHandle = null;
+        };
+    }
+    renderSegmentationsForViewport(viewportId) {
+        const viewportIds = viewportId
+            ? [viewportId]
+            : this._getViewportIdsForSegmentation();
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
+    }
+    renderSegmentation(segmentationId) {
+        const viewportIds = this._getViewportIdsForSegmentation(segmentationId);
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
+    }
+    _getViewportIdsForSegmentation(segmentationId) {
+        const viewports = this._getAllViewports();
+        const viewportIds = [];
+        for (const viewport of viewports) {
+            const viewportId = viewport.id;
+            if (segmentationId) {
+                const segmentationRepresentations = (0,_getSegmentationRepresentation__WEBPACK_IMPORTED_MODULE_3__/* .getSegmentationRepresentations */ .r$)(viewportId, { segmentationId });
+                if (segmentationRepresentations?.length > 0) {
+                    viewportIds.push(viewportId);
+                }
+            }
+            else {
+                const segmentationRepresentations = (0,_getSegmentationRepresentation__WEBPACK_IMPORTED_MODULE_3__/* .getSegmentationRepresentations */ .r$)(viewportId);
+                if (segmentationRepresentations?.length > 0) {
+                    viewportIds.push(viewportId);
+                }
+            }
+        }
+        return viewportIds;
+    }
+    _throwIfDestroyed() {
+        if (this.hasBeenDestroyed) {
+            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
+        }
+    }
+    _setViewportsToBeRenderedNextFrame(viewportIds) {
+        viewportIds.forEach((viewportId) => {
+            this._needsRender.add(viewportId);
+        });
+        this._render();
+    }
+    _render() {
+        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedSegmentations);
+            this._animationFrameSet = true;
+        }
+    }
+    _triggerRender(viewportId) {
+        const segmentationRepresentations = (0,_getSegmentationRepresentation__WEBPACK_IMPORTED_MODULE_3__/* .getSegmentationRepresentations */ .r$)(viewportId);
+        if (!segmentationRepresentations?.length) {
+            return;
+        }
+        const { viewport } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId) || {};
+        if (!viewport) {
+            return;
+        }
+        const viewportRenderList = [];
+        const segmentationRenderList = segmentationRepresentations.map((representation) => {
+            if (representation.type === _enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Contour) {
+                this._addPlanarFreeHandToolIfAbsent(viewport);
+            }
+            const display = renderers[representation.type];
+            try {
+                const viewportId = display.render(viewport, representation);
+                viewportRenderList.push(viewportId);
+            }
+            catch (error) {
+                console.error(error);
+            }
+            return Promise.resolve({
+                segmentationId: representation.segmentationId,
+                type: representation.type,
+            });
+        });
+        Promise.allSettled(segmentationRenderList).then((results) => {
+            const segmentationDetails = results
+                .filter((r) => r.status === 'fulfilled')
+                .map((r) => r.value);
+            function onSegmentationRender(evt) {
+                const { element, viewportId } = evt.detail;
+                element.removeEventListener(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.Events.IMAGE_RENDERED, onSegmentationRender);
+                segmentationDetails.forEach((detail) => {
+                    const eventDetail = {
+                        viewportId,
+                        segmentationId: detail.segmentationId,
+                        type: detail.type,
+                    };
+                    (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_1__.Events.SEGMENTATION_RENDERED, {
+                        ...eventDetail,
+                    });
+                });
+            }
+            const element = viewport.element;
+            element.addEventListener(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.Events.IMAGE_RENDERED, onSegmentationRender);
+            viewport.render();
+        });
+    }
+    _addPlanarFreeHandToolIfAbsent(viewport) {
+        if (!(planarContourToolName in _store_state__WEBPACK_IMPORTED_MODULE_8__/* .state */ .wk.tools)) {
+            (0,_store_addTool__WEBPACK_IMPORTED_MODULE_7__/* .addTool */ .Gx)(_tools_annotation_PlanarFreehandContourSegmentationTool__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A);
+        }
+        const toolGroup = (0,_store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_10__.getToolGroupForViewport)(viewport.id);
+        if (!toolGroup.hasTool(planarContourToolName)) {
+            toolGroup.addTool(planarContourToolName);
+            toolGroup.setToolPassive(planarContourToolName);
+        }
+    }
+}
+function triggerSegmentationRender(viewportId) {
+    segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
+}
+function triggerSegmentationRenderBySegmentationId(segmentationId) {
+    segmentationRenderingEngine.renderSegmentation(segmentationId);
+}
+const segmentationRenderingEngine = new SegmentationRenderingEngine();
+
+
+
+/***/ }),
+
+/***/ 25072:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40230);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(81985);
+/* harmony import */ var _utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4096);
+/* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(85817);
+/* harmony import */ var _utilities_throttle__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(27730);
+/* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(82056);
+/* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(2076);
+/* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(29601);
+/* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(44049);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(89578);
+/* harmony import */ var _store_state__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(85204);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(99737);
+/* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(60810);
+/* harmony import */ var _utilities_math_line__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(5956);
+/* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(66990);
+/* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(7001);
+/* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(58640);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const { transformWorldToIndex } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities;
+class BidirectionalTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationTool */ .EC {
+    static { this.toolName = 'Bidirectional'; }
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            preventHandleOutsideImage: false,
+            getTextLines: defaultGetTextLines,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const { data } = annotation;
+            const { points } = data.handles;
+            let canvasPoint1 = viewport.worldToCanvas(points[0]);
+            let canvasPoint2 = viewport.worldToCanvas(points[1]);
+            let line = {
+                start: {
+                    x: canvasPoint1[0],
+                    y: canvasPoint1[1],
+                },
+                end: {
+                    x: canvasPoint2[0],
+                    y: canvasPoint2[1],
+                },
+            };
+            let distanceToPoint = _utilities_math_line__WEBPACK_IMPORTED_MODULE_13__.distanceToPoint([line.start.x, line.start.y], [line.end.x, line.end.y], [canvasCoords[0], canvasCoords[1]]);
+            if (distanceToPoint <= proximity) {
+                return true;
+            }
+            canvasPoint1 = viewport.worldToCanvas(points[2]);
+            canvasPoint2 = viewport.worldToCanvas(points[3]);
+            line = {
+                start: {
+                    x: canvasPoint1[0],
+                    y: canvasPoint1[1],
+                },
+                end: {
+                    x: canvasPoint2[0],
+                    y: canvasPoint2[1],
+                },
+            };
+            distanceToPoint = _utilities_math_line__WEBPACK_IMPORTED_MODULE_13__.distanceToPoint([line.start.x, line.start.y], [line.end.x, line.end.y], [canvasCoords[0], canvasCoords[1]]);
+            if (distanceToPoint <= proximity) {
+                return true;
+            }
+            return false;
+        };
+        this.toolSelectedCallback = (evt, annotation) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            annotation.highlighted = true;
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_12__.getViewportIdsWithToolToRender)(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                movingTextBox: false,
+            };
+            this._activateModify(element);
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)(viewportIdsToRender);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__.hideElementCursor)(element);
+            evt.preventDefault();
+        };
+        this.handleSelectedCallback = (evt, annotation, handle) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const data = annotation.data;
+            annotation.highlighted = true;
+            let movingTextBox = false;
+            let handleIndex;
+            if (handle.worldPosition) {
+                movingTextBox = true;
+            }
+            else {
+                handleIndex = data.handles.points.findIndex((p) => p === handle);
+            }
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_12__.getViewportIdsWithToolToRender)(element, this.getToolName());
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__.hideElementCursor)(element);
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                handleIndex,
+                movingTextBox,
+            };
+            this._activateModify(element);
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)(viewportIdsToRender);
+            evt.preventDefault();
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, newAnnotation, hasMoved } = this.editData;
+            const { data } = annotation;
+            if (newAnnotation && !hasMoved) {
+                return;
+            }
+            this.doneEditMemo();
+            data.handles.activeHandleIndex = null;
+            this._deactivateModify(element);
+            this._deactivateDraw(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__.resetElementCursor)(element);
+            const { renderingEngine } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            if (this.editData.handleIndex !== undefined) {
+                const { points } = data.handles;
+                const firstLineSegmentLength = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.distance */ .eR.distance(points[0], points[1]);
+                const secondLineSegmentLength = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.distance */ .eR.distance(points[2], points[3]);
+                if (secondLineSegmentLength > firstLineSegmentLength) {
+                    const longAxis = [[...points[2]], [...points[3]]];
+                    const shortAxisPoint0 = [...points[0]];
+                    const shortAxisPoint1 = [...points[1]];
+                    const longAxisVector = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.set */ .Zc.set(longAxisVector, longAxis[1][0] - longAxis[0][0], longAxis[1][1] - longAxis[1][0]);
+                    const counterClockWisePerpendicularToLongAxis = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.set */ .Zc.set(counterClockWisePerpendicularToLongAxis, -longAxisVector[1], longAxisVector[0]);
+                    const currentShortAxisVector = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.set */ .Zc.set(currentShortAxisVector, shortAxisPoint1[0] - shortAxisPoint0[0], shortAxisPoint1[1] - shortAxisPoint0[0]);
+                    let shortAxis;
+                    if (gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.dot */ .Zc.dot(currentShortAxisVector, counterClockWisePerpendicularToLongAxis) > 0) {
+                        shortAxis = [shortAxisPoint0, shortAxisPoint1];
+                    }
+                    else {
+                        shortAxis = [shortAxisPoint1, shortAxisPoint0];
+                    }
+                    data.handles.points = [
+                        longAxis[0],
+                        longAxis[1],
+                        shortAxis[0],
+                        shortAxis[1],
+                    ];
+                }
+            }
+            if (this.isHandleOutsideImage &&
+                this.configuration.preventHandleOutsideImage) {
+                (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.removeAnnotation)(annotation.annotationUID);
+            }
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)(viewportIdsToRender);
+            if (newAnnotation) {
+                (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__.triggerAnnotationCompleted)(annotation);
+            }
+            this.editData = null;
+            this.isDrawing = false;
+        };
+        this._dragDrawCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const { worldToCanvas } = viewport;
+            const { annotation, viewportIdsToRender, handleIndex, newAnnotation } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
+            const { data } = annotation;
+            const worldPos = currentPoints.world;
+            data.handles.points[handleIndex] = [...worldPos];
+            const canvasCoordPoints = data.handles.points.map(worldToCanvas);
+            const canvasCoords = {
+                longLineSegment: {
+                    start: {
+                        x: canvasCoordPoints[0][0],
+                        y: canvasCoordPoints[0][1],
+                    },
+                    end: {
+                        x: canvasCoordPoints[1][0],
+                        y: canvasCoordPoints[1][1],
+                    },
+                },
+                shortLineSegment: {
+                    start: {
+                        x: canvasCoordPoints[2][0],
+                        y: canvasCoordPoints[2][1],
+                    },
+                    end: {
+                        x: canvasCoordPoints[3][0],
+                        y: canvasCoordPoints[3][1],
+                    },
+                },
+            };
+            const dist = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.distance */ .Zc.distance(canvasCoordPoints[0], canvasCoordPoints[1]);
+            const shortAxisDistFromCenter = dist / 3;
+            const dx = canvasCoords.longLineSegment.start.x - canvasCoords.longLineSegment.end.x;
+            const dy = canvasCoords.longLineSegment.start.y - canvasCoords.longLineSegment.end.y;
+            const length = Math.sqrt(dx * dx + dy * dy);
+            const vectorX = dx / length;
+            const vectorY = dy / length;
+            const xMid = (canvasCoords.longLineSegment.start.x +
+                canvasCoords.longLineSegment.end.x) /
+                2;
+            const yMid = (canvasCoords.longLineSegment.start.y +
+                canvasCoords.longLineSegment.end.y) /
+                2;
+            const startX = xMid + shortAxisDistFromCenter * vectorY;
+            const startY = yMid - shortAxisDistFromCenter * vectorX;
+            const endX = xMid - shortAxisDistFromCenter * vectorY;
+            const endY = yMid + shortAxisDistFromCenter * vectorX;
+            data.handles.points[2] = viewport.canvasToWorld([startX, startY]);
+            data.handles.points[3] = viewport.canvasToWorld([endX, endY]);
+            annotation.invalidated = true;
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)(viewportIdsToRender);
+            this.editData.hasMoved = true;
+        };
+        this._dragModifyCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
+            this.createMemo(element, annotation, { newAnnotation });
+            const { data } = annotation;
+            if (movingTextBox) {
+                const { deltaPoints } = eventDetail;
+                const worldPosDelta = deltaPoints.world;
+                const { textBox } = data.handles;
+                const { worldPosition } = textBox;
+                worldPosition[0] += worldPosDelta[0];
+                worldPosition[1] += worldPosDelta[1];
+                worldPosition[2] += worldPosDelta[2];
+                textBox.hasMoved = true;
+            }
+            else if (handleIndex === undefined) {
+                const { deltaPoints } = eventDetail;
+                const worldPosDelta = deltaPoints.world;
+                const points = data.handles.points;
+                points.forEach((point) => {
+                    point[0] += worldPosDelta[0];
+                    point[1] += worldPosDelta[1];
+                    point[2] += worldPosDelta[2];
+                });
+                annotation.invalidated = true;
+            }
+            else {
+                this._dragModifyHandle(evt);
+                annotation.invalidated = true;
+            }
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)(viewportIdsToRender);
+        };
+        this._dragModifyHandle = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const { annotation, handleIndex: movingHandleIndex } = this.editData;
+            const { data } = annotation;
+            const worldPos = currentPoints.world;
+            const canvasCoordHandlesCurrent = [
+                viewport.worldToCanvas(data.handles.points[0]),
+                viewport.worldToCanvas(data.handles.points[1]),
+                viewport.worldToCanvas(data.handles.points[2]),
+                viewport.worldToCanvas(data.handles.points[3]),
+            ];
+            const firstLineSegment = {
+                start: {
+                    x: canvasCoordHandlesCurrent[0][0],
+                    y: canvasCoordHandlesCurrent[0][1],
+                },
+                end: {
+                    x: canvasCoordHandlesCurrent[1][0],
+                    y: canvasCoordHandlesCurrent[1][1],
+                },
+            };
+            const secondLineSegment = {
+                start: {
+                    x: canvasCoordHandlesCurrent[2][0],
+                    y: canvasCoordHandlesCurrent[2][1],
+                },
+                end: {
+                    x: canvasCoordHandlesCurrent[3][0],
+                    y: canvasCoordHandlesCurrent[3][1],
+                },
+            };
+            const proposedPoint = [...worldPos];
+            const proposedCanvasCoord = viewport.worldToCanvas(proposedPoint);
+            if (movingHandleIndex === 0 || movingHandleIndex === 1) {
+                const fixedHandleIndex = movingHandleIndex === 0 ? 1 : 0;
+                const fixedHandleCanvasCoord = canvasCoordHandlesCurrent[fixedHandleIndex];
+                const fixedHandleToProposedCoordVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.set */ .Zc.set(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create(), proposedCanvasCoord[0] - fixedHandleCanvasCoord[0], proposedCanvasCoord[1] - fixedHandleCanvasCoord[1]);
+                const fixedHandleToOldCoordVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.set */ .Zc.set(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create(), canvasCoordHandlesCurrent[movingHandleIndex][0] -
+                    fixedHandleCanvasCoord[0], canvasCoordHandlesCurrent[movingHandleIndex][1] -
+                    fixedHandleCanvasCoord[1]);
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.normalize */ .Zc.normalize(fixedHandleToProposedCoordVec, fixedHandleToProposedCoordVec);
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.normalize */ .Zc.normalize(fixedHandleToOldCoordVec, fixedHandleToOldCoordVec);
+                const proposedFirstLineSegment = {
+                    start: {
+                        x: fixedHandleCanvasCoord[0],
+                        y: fixedHandleCanvasCoord[1],
+                    },
+                    end: {
+                        x: proposedCanvasCoord[0],
+                        y: proposedCanvasCoord[1],
+                    },
+                };
+                if (this._movingLongAxisWouldPutItThroughShortAxis(proposedFirstLineSegment, secondLineSegment)) {
+                    return;
+                }
+                const centerOfRotation = fixedHandleCanvasCoord;
+                const angle = this._getSignedAngle(fixedHandleToOldCoordVec, fixedHandleToProposedCoordVec);
+                let firstPointX = canvasCoordHandlesCurrent[2][0];
+                let firstPointY = canvasCoordHandlesCurrent[2][1];
+                let secondPointX = canvasCoordHandlesCurrent[3][0];
+                let secondPointY = canvasCoordHandlesCurrent[3][1];
+                firstPointX -= centerOfRotation[0];
+                firstPointY -= centerOfRotation[1];
+                secondPointX -= centerOfRotation[0];
+                secondPointY -= centerOfRotation[1];
+                const rotatedFirstPoint = firstPointX * Math.cos(angle) - firstPointY * Math.sin(angle);
+                const rotatedFirstPointY = firstPointX * Math.sin(angle) + firstPointY * Math.cos(angle);
+                const rotatedSecondPoint = secondPointX * Math.cos(angle) - secondPointY * Math.sin(angle);
+                const rotatedSecondPointY = secondPointX * Math.sin(angle) + secondPointY * Math.cos(angle);
+                firstPointX = rotatedFirstPoint + centerOfRotation[0];
+                firstPointY = rotatedFirstPointY + centerOfRotation[1];
+                secondPointX = rotatedSecondPoint + centerOfRotation[0];
+                secondPointY = rotatedSecondPointY + centerOfRotation[1];
+                const newFirstPoint = viewport.canvasToWorld([firstPointX, firstPointY]);
+                const newSecondPoint = viewport.canvasToWorld([
+                    secondPointX,
+                    secondPointY,
+                ]);
+                data.handles.points[movingHandleIndex] = proposedPoint;
+                data.handles.points[2] = newFirstPoint;
+                data.handles.points[3] = newSecondPoint;
+            }
+            else {
+                const translateHandleIndex = movingHandleIndex === 2 ? 3 : 2;
+                const canvasCoordsCurrent = {
+                    longLineSegment: {
+                        start: firstLineSegment.start,
+                        end: firstLineSegment.end,
+                    },
+                    shortLineSegment: {
+                        start: secondLineSegment.start,
+                        end: secondLineSegment.end,
+                    },
+                };
+                const longLineSegmentVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.subtract */ .Zc.subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create(), [
+                    canvasCoordsCurrent.longLineSegment.end.x,
+                    canvasCoordsCurrent.longLineSegment.end.y,
+                ], [
+                    canvasCoordsCurrent.longLineSegment.start.x,
+                    canvasCoordsCurrent.longLineSegment.start.y,
+                ]);
+                const longLineSegmentVecNormalized = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.normalize */ .Zc.normalize(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create(), longLineSegmentVec);
+                const proposedToCurrentVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.subtract */ .Zc.subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create(), [proposedCanvasCoord[0], proposedCanvasCoord[1]], [
+                    canvasCoordHandlesCurrent[movingHandleIndex][0],
+                    canvasCoordHandlesCurrent[movingHandleIndex][1],
+                ]);
+                const movementLength = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.length */ .Zc.length(proposedToCurrentVec);
+                const angle = this._getSignedAngle(longLineSegmentVecNormalized, proposedToCurrentVec);
+                const movementAlongLineSegmentLength = Math.cos(angle) * movementLength;
+                const newTranslatedPoint = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.scaleAndAdd */ .Zc.scaleAndAdd(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create(), [
+                    canvasCoordHandlesCurrent[translateHandleIndex][0],
+                    canvasCoordHandlesCurrent[translateHandleIndex][1],
+                ], longLineSegmentVecNormalized, movementAlongLineSegmentLength);
+                if (this._movingLongAxisWouldPutItThroughShortAxis({
+                    start: {
+                        x: proposedCanvasCoord[0],
+                        y: proposedCanvasCoord[1],
+                    },
+                    end: {
+                        x: newTranslatedPoint[0],
+                        y: newTranslatedPoint[1],
+                    },
+                }, {
+                    start: {
+                        x: canvasCoordsCurrent.longLineSegment.start.x,
+                        y: canvasCoordsCurrent.longLineSegment.start.y,
+                    },
+                    end: {
+                        x: canvasCoordsCurrent.longLineSegment.end.x,
+                        y: canvasCoordsCurrent.longLineSegment.end.y,
+                    },
+                })) {
+                    return;
+                }
+                const intersectionPoint = _utilities_math_line__WEBPACK_IMPORTED_MODULE_13__.intersectLine([proposedCanvasCoord[0], proposedCanvasCoord[1]], [newTranslatedPoint[0], newTranslatedPoint[1]], [firstLineSegment.start.x, firstLineSegment.start.y], [firstLineSegment.end.x, firstLineSegment.end.y]);
+                if (!intersectionPoint) {
+                    return;
+                }
+                data.handles.points[translateHandleIndex] = viewport.canvasToWorld(newTranslatedPoint);
+                data.handles.points[movingHandleIndex] = proposedPoint;
+            }
+        };
+        this.cancel = (element) => {
+            if (this.isDrawing) {
+                this.isDrawing = false;
+                this._deactivateDraw(element);
+                this._deactivateModify(element);
+                (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__.resetElementCursor)(element);
+                const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
+                const { data } = annotation;
+                annotation.highlighted = false;
+                data.handles.activeHandleIndex = null;
+                (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)(viewportIdsToRender);
+                if (newAnnotation) {
+                    (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__.triggerAnnotationCompleted)(annotation);
+                }
+                this.editData = null;
+                return annotation.annotationUID;
+            }
+        };
+        this._activateDraw = (element) => {
+            _store_state__WEBPACK_IMPORTED_MODULE_10__/* .state */ .wk.isInteractingWithTool = true;
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_DRAG, this._dragDrawCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_MOVE, this._dragDrawCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_TAP, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_END, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_DRAG, this._dragDrawCallback);
+        };
+        this._deactivateDraw = (element) => {
+            _store_state__WEBPACK_IMPORTED_MODULE_10__/* .state */ .wk.isInteractingWithTool = false;
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_DRAG, this._dragDrawCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_MOVE, this._dragDrawCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_TAP, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_DRAG, this._dragDrawCallback);
+        };
+        this._activateModify = (element) => {
+            _store_state__WEBPACK_IMPORTED_MODULE_10__/* .state */ .wk.isInteractingWithTool = true;
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_DRAG, this._dragModifyCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_END, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_DRAG, this._dragModifyCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateModify = (element) => {
+            _store_state__WEBPACK_IMPORTED_MODULE_10__/* .state */ .wk.isInteractingWithTool = false;
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_DRAG, this._dragModifyCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_DRAG, this._dragModifyCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_11__.Events.TOUCH_TAP, this._endCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = true;
+            const { viewport } = enabledElement;
+            const { element } = viewport;
+            let annotations = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.getAnnotations)(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const targetId = this.getTargetId(viewport);
+            const renderingEngine = viewport.getRenderingEngine();
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID, data } = annotation;
+                const { points, activeHandleIndex } = data.handles;
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                styleSpecifier.annotationUID = annotationUID;
+                const { color, lineWidth, lineDash, shadow } = this.getAnnotationStyle({
+                    annotation,
+                    styleSpecifier,
+                });
+                if (!data.cachedStats[targetId] ||
+                    data.cachedStats[targetId].unit == null) {
+                    data.cachedStats[targetId] = {
+                        length: null,
+                        width: null,
+                        unit: null,
+                    };
+                    this._calculateCachedStats(annotation, renderingEngine, enabledElement);
+                }
+                else if (annotation.invalidated) {
+                    this._throttledCalculateCachedStats(annotation, renderingEngine, enabledElement);
+                }
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                let activeHandleCanvasCoords;
+                if (!(0,_stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_7__.isAnnotationVisible)(annotationUID)) {
+                    continue;
+                }
+                if (!(0,_stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_6__.isAnnotationLocked)(annotationUID) &&
+                    !this.editData &&
+                    activeHandleIndex !== null) {
+                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                }
+                if (activeHandleCanvasCoords) {
+                    const handleGroupUID = '0';
+                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_9__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, activeHandleCanvasCoords, {
+                        color,
+                    });
+                }
+                const dataId1 = `${annotationUID}-line-1`;
+                const dataId2 = `${annotationUID}-line-2`;
+                const lineUID = '0';
+                (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_9__.drawLine)(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates[0], canvasCoordinates[1], {
+                    color,
+                    lineDash,
+                    lineWidth,
+                    shadow,
+                }, dataId1);
+                const secondLineUID = '1';
+                (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_9__.drawLine)(svgDrawingHelper, annotationUID, secondLineUID, canvasCoordinates[2], canvasCoordinates[3], {
+                    color,
+                    lineDash,
+                    lineWidth,
+                    shadow,
+                }, dataId2);
+                renderStatus = true;
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.handles.textBox = {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    };
+                    continue;
+                }
+                const textLines = this.configuration.getTextLines(data, targetId);
+                if (!textLines || textLines.length === 0) {
+                    continue;
+                }
+                let canvasTextBoxCoords;
+                if (!data.handles.textBox.hasMoved) {
+                    canvasTextBoxCoords = (0,_utilities_drawing__WEBPACK_IMPORTED_MODULE_14__.getTextBoxCoordsCanvas)(canvasCoordinates);
+                    data.handles.textBox.worldPosition =
+                        viewport.canvasToWorld(canvasTextBoxCoords);
+                }
+                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+                const textBoxUID = '1';
+                const boundingBox = (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_9__.drawLinkedTextBox)(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
+                const { x: left, y: top, width, height } = boundingBox;
+                data.handles.textBox.worldBoundingBox = {
+                    topLeft: viewport.canvasToWorld([left, top]),
+                    topRight: viewport.canvasToWorld([left + width, top]),
+                    bottomLeft: viewport.canvasToWorld([left, top + height]),
+                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
+                };
+            }
+            return renderStatus;
+        };
+        this._movingLongAxisWouldPutItThroughShortAxis = (firstLineSegment, secondLineSegment) => {
+            const vectorInSecondLineDirection = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+            gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.set */ .Zc.set(vectorInSecondLineDirection, secondLineSegment.end.x - secondLineSegment.start.x, secondLineSegment.end.y - secondLineSegment.start.y);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.normalize */ .Zc.normalize(vectorInSecondLineDirection, vectorInSecondLineDirection);
+            const extendedSecondLineSegment = {
+                start: {
+                    x: secondLineSegment.start.x - vectorInSecondLineDirection[0] * 10,
+                    y: secondLineSegment.start.y - vectorInSecondLineDirection[1] * 10,
+                },
+                end: {
+                    x: secondLineSegment.end.x + vectorInSecondLineDirection[0] * 10,
+                    y: secondLineSegment.end.y + vectorInSecondLineDirection[1] * 10,
+                },
+            };
+            const proposedIntersectionPoint = _utilities_math_line__WEBPACK_IMPORTED_MODULE_13__.intersectLine([extendedSecondLineSegment.start.x, extendedSecondLineSegment.start.y], [extendedSecondLineSegment.end.x, extendedSecondLineSegment.end.y], [firstLineSegment.start.x, firstLineSegment.start.y], [firstLineSegment.end.x, firstLineSegment.end.y]);
+            const wouldPutThroughShortAxis = !proposedIntersectionPoint;
+            return wouldPutThroughShortAxis;
+        };
+        this._calculateCachedStats = (annotation, renderingEngine, enabledElement) => {
+            const { data } = annotation;
+            const { element } = enabledElement.viewport;
+            const worldPos1 = data.handles.points[0];
+            const worldPos2 = data.handles.points[1];
+            const worldPos3 = data.handles.points[2];
+            const worldPos4 = data.handles.points[3];
+            const { cachedStats } = data;
+            const targetIds = Object.keys(cachedStats);
+            for (let i = 0; i < targetIds.length; i++) {
+                const targetId = targetIds[i];
+                const image = this.getTargetImageData(targetId);
+                if (!image) {
+                    continue;
+                }
+                const { imageData, dimensions } = image;
+                const index1 = transformWorldToIndex(imageData, worldPos1);
+                const index2 = transformWorldToIndex(imageData, worldPos2);
+                const index3 = transformWorldToIndex(imageData, worldPos3);
+                const index4 = transformWorldToIndex(imageData, worldPos4);
+                const handles1 = [index1, index2];
+                const handles2 = [index3, index4];
+                const { scale: scale1, unit: units1 } = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .Op)(image, handles1);
+                const { scale: scale2, unit: units2 } = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .Op)(image, handles2);
+                const dist1 = this._calculateLength(worldPos1, worldPos2) / scale1;
+                const dist2 = this._calculateLength(worldPos3, worldPos4) / scale2;
+                const length = dist1 > dist2 ? dist1 : dist2;
+                const width = dist1 > dist2 ? dist2 : dist1;
+                const unit = dist1 > dist2 ? units1 : units2;
+                const widthUnit = dist1 > dist2 ? units2 : units1;
+                this._isInsideVolume(index1, index2, index3, index4, dimensions)
+                    ? (this.isHandleOutsideImage = false)
+                    : (this.isHandleOutsideImage = true);
+                cachedStats[targetId] = {
+                    length,
+                    width,
+                    unit,
+                    widthUnit,
+                };
+            }
+            annotation.invalidated = false;
+            (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__.triggerAnnotationModified)(annotation, element);
+            return cachedStats;
+        };
+        this._isInsideVolume = (index1, index2, index3, index4, dimensions) => {
+            return (_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.indexWithinDimensions(index1, dimensions) &&
+                _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.indexWithinDimensions(index2, dimensions) &&
+                _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.indexWithinDimensions(index3, dimensions) &&
+                _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.indexWithinDimensions(index4, dimensions));
+        };
+        this._getSignedAngle = (vector1, vector2) => {
+            return Math.atan2(vector1[0] * vector2[1] - vector1[1] * vector2[0], vector1[0] * vector2[0] + vector1[1] * vector2[1]);
+        };
+        this._throttledCalculateCachedStats = (0,_utilities_throttle__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(this._calculateCachedStats, 100, { trailing: true });
+    }
+    addNewAnnotation(evt) {
+        const eventDetail = evt.detail;
+        const { currentPoints, element } = eventDetail;
+        const worldPos = currentPoints.world;
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+        const { viewport, renderingEngine } = enabledElement;
+        this.isDrawing = true;
+        const camera = viewport.getCamera();
+        const { viewPlaneNormal, viewUp } = camera;
+        const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const annotation = {
+            highlighted: true,
+            invalidated: true,
+            metadata: {
+                toolName: this.getToolName(),
+                viewPlaneNormal: [...viewPlaneNormal],
+                viewUp: [...viewUp],
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...viewport.getViewReference({ points: [worldPos] }),
+            },
+            data: {
+                handles: {
+                    points: [
+                        [...worldPos],
+                        [...worldPos],
+                        [...worldPos],
+                        [...worldPos],
+                    ],
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                    activeHandleIndex: null,
+                },
+                label: '',
+                cachedStats: {},
+            },
+        };
+        (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.addAnnotation)(annotation, element);
+        const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_12__.getViewportIdsWithToolToRender)(element, this.getToolName());
+        this.editData = {
+            annotation,
+            viewportIdsToRender,
+            handleIndex: 1,
+            movingTextBox: false,
+            newAnnotation: true,
+            hasMoved: false,
+        };
+        this._activateDraw(element);
+        (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__.hideElementCursor)(element);
+        evt.preventDefault();
+        (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)(viewportIdsToRender);
+        return annotation;
+    }
+    _calculateLength(pos1, pos2) {
+        const dx = pos1[0] - pos2[0];
+        const dy = pos1[1] - pos2[1];
+        const dz = pos1[2] - pos2[2];
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+}
+function defaultGetTextLines(data, targetId) {
+    const { cachedStats, label } = data;
+    const { length, width, unit } = cachedStats[targetId];
+    const textLines = [];
+    if (label) {
+        textLines.push(label);
+    }
+    if (length === undefined) {
+        return textLines;
+    }
+    textLines.push(`L: ${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.roundNumber(length)} ${unit || unit}`, `W: ${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.roundNumber(width)} ${unit}`);
+    return textLines;
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (BidirectionalTool);
+
+
+/***/ }),
+
+/***/ 67847:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
+/* harmony import */ var _utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4096);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(40230);
+/* harmony import */ var _stateManagement__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6802);
+/* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(2076);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(89578);
+/* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(60810);
+/* harmony import */ var _utilities_throttle__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(27730);
+/* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(66990);
+/* harmony import */ var _utilities_planar_getWorldWidthAndHeightFromCorners__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(35489);
+/* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(29601);
+/* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(7001);
+/* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(58640);
+/* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(44049);
+/* harmony import */ var _annotation_RectangleROITool__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(4010);
+/* harmony import */ var _utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(18990);
+/* harmony import */ var _utilities_math_basic__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(73262);
+/* harmony import */ var _utilities_planar__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(93395);
+/* harmony import */ var _utilities_getPixelValueUnits__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(40634);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const { transformWorldToIndex } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
+class RectangleROIStartEndThresholdTool extends _annotation_RectangleROITool__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .A {
+    constructor(toolProps = {}, defaultToolProps = {
+        configuration: {
+            storePointData: false,
+            numSlicesToPropagate: 10,
+            computePointsInsideVolume: false,
+            getTextLines: defaultGetTextLines,
+            statsCalculator: _utilities_math_basic__WEBPACK_IMPORTED_MODULE_16__.BasicStatsCalculator,
+            showTextBox: false,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+            const { viewport, renderingEngine } = enabledElement;
+            this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            let referencedImageId, imageVolume, volumeId;
+            if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.StackViewport) {
+                throw new Error('Stack Viewport Not implemented');
+            }
+            else {
+                const targetId = this.getTargetId(viewport);
+                volumeId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getVolumeId(targetId);
+                imageVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+                referencedImageId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);
+            }
+            const spacingInNormal = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
+            const startCoord = this._getStartCoordinate(worldPos, viewPlaneNormal);
+            const endCoord = this._getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
+            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            const annotation = {
+                highlighted: true,
+                invalidated: true,
+                metadata: {
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    enabledElement,
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID,
+                    referencedImageId,
+                    toolName: this.getToolName(),
+                    volumeId,
+                    spacingInNormal,
+                },
+                data: {
+                    label: '',
+                    startCoordinate: startCoord,
+                    endCoordinate: endCoord,
+                    cachedStats: {
+                        pointsInVolume: [],
+                        projectionPoints: [],
+                        projectionPointsImageIds: [referencedImageId],
+                        statistics: [],
+                    },
+                    handles: {
+                        textBox: {
+                            hasMoved: false,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
+                        },
+                        points: [
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                        ],
+                        activeHandleIndex: null,
+                    },
+                    labelmapUID: null,
+                },
+            };
+            this._computeProjectionPoints(annotation, imageVolume);
+            (0,_stateManagement__WEBPACK_IMPORTED_MODULE_3__/* .addAnnotation */ .lC)(annotation, element);
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_6__.getViewportIdsWithToolToRender)(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                handleIndex: 3,
+                newAnnotation: true,
+                hasMoved: false,
+            };
+            this._activateDraw(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_11__.hideElementCursor)(element);
+            evt.preventDefault();
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_12__/* ["default"] */ .A)(viewportIdsToRender);
+            return annotation;
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, newAnnotation, hasMoved } = this.editData;
+            const { data } = annotation;
+            if (newAnnotation && !hasMoved) {
+                return;
+            }
+            data.handles.activeHandleIndex = null;
+            this._deactivateModify(element);
+            this._deactivateDraw(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_11__.resetElementCursor)(element);
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+            this.editData = null;
+            this.isDrawing = false;
+            if (this.isHandleOutsideImage &&
+                this.configuration.preventHandleOutsideImage) {
+                (0,_stateManagement__WEBPACK_IMPORTED_MODULE_3__/* .removeAnnotation */ .O8)(annotation.annotationUID);
+            }
+            const targetId = this.getTargetId(enabledElement.viewport);
+            const imageVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
+            if (this.configuration.calculatePointsInsideVolume) {
+                this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
+            }
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_12__/* ["default"] */ .A)(viewportIdsToRender);
+            if (newAnnotation) {
+                (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_13__.triggerAnnotationCompleted)(annotation);
+            }
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport } = enabledElement;
+            let annotations = (0,_stateManagement__WEBPACK_IMPORTED_MODULE_3__/* .getAnnotations */ .Rh)(this.getToolName(), viewport.element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = (0,_utilities_planar__WEBPACK_IMPORTED_MODULE_17__.filterAnnotationsWithinSamePlane)(annotations, viewport.getCamera());
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID, data, metadata } = annotation;
+                const { startCoordinate, endCoordinate } = data;
+                const { points, activeHandleIndex } = data.handles;
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                styleSpecifier.annotationUID = annotationUID;
+                const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
+                const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
+                const color = this.getStyle('color', styleSpecifier, annotation);
+                const focalPoint = viewport.getCamera().focalPoint;
+                const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
+                let startCoord = startCoordinate;
+                let endCoord = endCoordinate;
+                if (Array.isArray(startCoordinate)) {
+                    startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                    data.startCoordinate = startCoord;
+                    data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = startCoord;
+                    data.startCoordinate = startCoord;
+                    data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = startCoord;
+                }
+                if (Array.isArray(endCoordinate)) {
+                    endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                    data.endCoordinate = endCoord;
+                    data.endCoordinate = endCoord;
+                }
+                const roundedStartCoord = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.roundToPrecision(startCoord);
+                const roundedEndCoord = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.roundToPrecision(endCoord);
+                const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCoord = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.roundToPrecision(coord);
+                if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
+                    roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
+                    continue;
+                }
+                if (annotation.invalidated) {
+                    this._throttledCalculateCachedStats(annotation, enabledElement);
+                }
+                let firstOrLastSlice = false;
+                if (roundedCoord === roundedStartCoord ||
+                    roundedCoord === roundedEndCoord) {
+                    firstOrLastSlice = true;
+                }
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                let activeHandleCanvasCoords;
+                if (!(0,_stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_10__.isAnnotationVisible)(annotationUID)) {
+                    continue;
+                }
+                if (!(0,_stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_4__.isAnnotationLocked)(annotationUID) &&
+                    !this.editData &&
+                    activeHandleIndex !== null &&
+                    firstOrLastSlice) {
+                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                }
+                if (activeHandleCanvasCoords) {
+                    const handleGroupUID = '0';
+                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_5__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, activeHandleCanvasCoords, {
+                        color,
+                    });
+                }
+                let lineDashToUse = lineDash;
+                if (!firstOrLastSlice) {
+                    lineDashToUse = 2;
+                }
+                const rectangleUID = '0';
+                (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_5__.drawRect)(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates[0], canvasCoordinates[3], {
+                    color,
+                    lineDash: lineDashToUse,
+                    lineWidth,
+                });
+                renderStatus = true;
+                if (this.configuration.showTextBox &&
+                    this.configuration.calculatePointsInsideVolume) {
+                    const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                    if (!options.visibility) {
+                        data.handles.textBox = {
+                            hasMoved: false,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
+                        };
+                        continue;
+                    }
+                    const textLines = this.configuration.getTextLines(data, { metadata });
+                    if (!textLines || textLines.length === 0) {
+                        continue;
+                    }
+                    if (!data.handles.textBox.hasMoved) {
+                        const canvasTextBoxCoords = (0,_utilities_drawing__WEBPACK_IMPORTED_MODULE_8__.getTextBoxCoordsCanvas)(canvasCoordinates);
+                        data.handles.textBox.worldPosition =
+                            viewport.canvasToWorld(canvasTextBoxCoords);
+                    }
+                    const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+                    const textBoxUID = '1';
+                    const boundingBox = (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_5__.drawLinkedTextBox)(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
+                    const { x: left, y: top, width, height } = boundingBox;
+                    data.handles.textBox.worldBoundingBox = {
+                        topLeft: viewport.canvasToWorld([left, top]),
+                        topRight: viewport.canvasToWorld([left + width, top]),
+                        bottomLeft: viewport.canvasToWorld([left, top + height]),
+                        bottomRight: viewport.canvasToWorld([left + width, top + height]),
+                    };
+                }
+            }
+            return renderStatus;
+        };
+        this._throttledCalculateCachedStats = (0,_utilities_throttle__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A)(this._calculateCachedStatsTool, 100, { trailing: true });
+    }
+    _computeProjectionPoints(annotation, imageVolume) {
+        const { data, metadata } = annotation;
+        const { viewPlaneNormal, spacingInNormal } = metadata;
+        const { imageData } = imageVolume;
+        const { startCoordinate, endCoordinate } = data;
+        const { points } = data.handles;
+        const startIJK = transformWorldToIndex(imageData, points[0]);
+        const endIJK = transformWorldToIndex(imageData, points[0]);
+        const startWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_2__/* .vec3.create */ .eR.create();
+        imageData.indexToWorldVec3(startIJK, startWorld);
+        const endWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_2__/* .vec3.create */ .eR.create();
+        imageData.indexToWorldVec3(endIJK, endWorld);
+        if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 2) {
+            startWorld[2] = startCoordinate;
+            endWorld[2] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 0) {
+            startWorld[0] = startCoordinate;
+            endWorld[0] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 1) {
+            startWorld[1] = startCoordinate;
+            endWorld[1] = endCoordinate;
+        }
+        const distance = gl_matrix__WEBPACK_IMPORTED_MODULE_2__/* .vec3.distance */ .eR.distance(startWorld, endWorld);
+        const newProjectionPoints = [];
+        for (let dist = 0; dist < distance; dist += spacingInNormal) {
+            newProjectionPoints.push(points.map((point) => {
+                const newPoint = gl_matrix__WEBPACK_IMPORTED_MODULE_2__/* .vec3.create */ .eR.create();
+                gl_matrix__WEBPACK_IMPORTED_MODULE_2__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(newPoint, point, viewPlaneNormal, dist);
+                return Array.from(newPoint);
+            }));
+        }
+        data.cachedStats.projectionPoints = newProjectionPoints;
+    }
+    _computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement) {
+        const { data, metadata } = annotation;
+        const { viewPlaneNormal, viewUp } = metadata;
+        const { viewport } = enabledElement;
+        const projectionPoints = data.cachedStats.projectionPoints;
+        const pointsInsideVolume = [[]];
+        const image = this.getTargetImageData(targetId);
+        const worldPos1 = data.handles.points[0];
+        const worldPos2 = data.handles.points[3];
+        const { worldWidth, worldHeight } = (0,_utilities_planar_getWorldWidthAndHeightFromCorners__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+        const measureInfo = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_1__/* .getCalibratedLengthUnitsAndScale */ .Op)(image, data.habdles);
+        const area = Math.abs(worldWidth * worldHeight) /
+            (measureInfo.scale * measureInfo.scale);
+        const modalityUnitOptions = {
+            isPreScaled: (0,_utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_15__/* .isViewportPreScaled */ .u)(viewport, targetId),
+            isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+        };
+        const modalityUnit = (0,_utilities_getPixelValueUnits__WEBPACK_IMPORTED_MODULE_18__/* .getPixelValueUnits */ .j)(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+        for (let i = 0; i < projectionPoints.length; i++) {
+            if (!imageVolume) {
+                continue;
+            }
+            const projectionPoint = projectionPoints[i][0];
+            const { dimensions, imageData, voxelManager } = imageVolume;
+            const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
+            const worldProjectionPointIndex = transformWorldToIndex(imageData, projectionPoint);
+            const indexOfProjection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
+            worldPos1Index[0] = Math.floor(worldPos1Index[0]);
+            worldPos1Index[1] = Math.floor(worldPos1Index[1]);
+            worldPos1Index[2] = Math.floor(worldPos1Index[2]);
+            worldPos1Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
+            const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
+            worldPos2Index[0] = Math.floor(worldPos2Index[0]);
+            worldPos2Index[1] = Math.floor(worldPos2Index[1]);
+            worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+            worldPos2Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
+            if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
+                this.isHandleOutsideImage = false;
+                const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
+                const iMax = Math.max(worldPos1Index[0], worldPos2Index[0]);
+                const jMin = Math.min(worldPos1Index[1], worldPos2Index[1]);
+                const jMax = Math.max(worldPos1Index[1], worldPos2Index[1]);
+                const kMin = Math.min(worldPos1Index[2], worldPos2Index[2]);
+                const kMax = Math.max(worldPos1Index[2], worldPos2Index[2]);
+                const boundsIJK = [
+                    [iMin, iMax],
+                    [jMin, jMax],
+                    [kMin, kMax],
+                ];
+                const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                    boundsIJK,
+                    imageData,
+                    returnPoints: this.configuration.storePointData,
+                });
+                pointsInsideVolume.push(pointsInShape);
+            }
+        }
+        const stats = this.configuration.statsCalculator.getStatistics();
+        data.cachedStats.pointsInVolume = pointsInsideVolume;
+        data.cachedStats.statistics = {
+            Modality: metadata.Modality,
+            area,
+            mean: stats.mean?.value,
+            stdDev: stats.stdDev?.value,
+            max: stats.max?.value,
+            statsArray: stats.array,
+            areaUnit: measureInfo.areaUnit,
+            modalityUnit,
+        };
+    }
+    _calculateCachedStatsTool(annotation, enabledElement) {
+        const data = annotation.data;
+        const { viewport } = enabledElement;
+        const { cachedStats } = data;
+        const targetId = this.getTargetId(viewport);
+        const imageVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
+        this._computeProjectionPoints(annotation, imageVolume);
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
+        }
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
+        }
+        annotation.invalidated = false;
+        (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_13__.triggerAnnotationModified)(annotation, viewport.element);
+        return cachedStats;
+    }
+    _getStartCoordinate(worldPos, viewPlaneNormal) {
+        const startPos = worldPos;
+        const startCoord = this._getCoordinateForViewplaneNormal(startPos, viewPlaneNormal);
+        return startCoord;
+    }
+    _getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal) {
+        const numSlicesToPropagate = this.configuration.numSlicesToPropagate;
+        const endPos = gl_matrix__WEBPACK_IMPORTED_MODULE_2__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_2__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(endPos, worldPos, viewPlaneNormal, numSlicesToPropagate * spacingInNormal);
+        const endCoord = this._getCoordinateForViewplaneNormal(endPos, viewPlaneNormal);
+        return endCoord;
+    }
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) {
+        const viewplaneNormalAbs = [
+            Math.abs(viewPlaneNormal[0]),
+            Math.abs(viewPlaneNormal[1]),
+            Math.abs(viewPlaneNormal[2]),
+        ];
+        const indexOfDirection = viewplaneNormalAbs.indexOf(Math.max(...viewplaneNormalAbs));
+        return indexOfDirection;
+    }
+    _getCoordinateForViewplaneNormal(pos, viewPlaneNormal) {
+        const indexOfDirection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
+        return pos[indexOfDirection];
+    }
+}
+function defaultGetTextLines(data, _context = {}) {
+    const cachedVolumeStats = data.cachedStats.statistics;
+    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+    if (mean === undefined) {
+        return;
+    }
+    const textLines = [];
+    textLines.push(`Area: ${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.roundNumber(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.roundNumber(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.roundNumber(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.roundNumber(stdDev)} ${modalityUnit}`);
+    return textLines;
+}
+RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (RectangleROIStartEndThresholdTool);
+
+
+/***/ }),
+
+/***/ 40336:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
+/* harmony import */ var _stateManagement__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6802);
+/* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2076);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(89578);
+/* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(60810);
+/* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7001);
+/* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(58640);
+/* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(29601);
+/* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(44049);
+/* harmony import */ var _annotation_RectangleROITool__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(4010);
+
+
+
+
+
+
+
+
+
+
+class RectangleROIThresholdTool extends _annotation_RectangleROITool__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            shadow: true,
+            preventHandleOutsideImage: false,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+            const { viewport, renderingEngine } = enabledElement;
+            this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            const targetId = this.getTargetId(viewport);
+            let referencedImageId, volumeId;
+            if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.StackViewport) {
+                referencedImageId = targetId.split('imageId:')[1];
+            }
+            else {
+                volumeId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getVolumeId(targetId);
+                const imageVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+                referencedImageId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);
+            }
+            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            const annotation = {
+                highlighted: true,
+                invalidated: true,
+                metadata: {
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    enabledElement,
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID,
+                    referencedImageId,
+                    toolName: this.getToolName(),
+                    volumeId,
+                },
+                data: {
+                    label: '',
+                    handles: {
+                        textBox: {
+                            hasMoved: false,
+                            worldPosition: null,
+                            worldBoundingBox: null,
+                        },
+                        points: [
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                        ],
+                        activeHandleIndex: null,
+                    },
+                    segmentationId: null,
+                },
+            };
+            (0,_stateManagement__WEBPACK_IMPORTED_MODULE_1__/* .addAnnotation */ .lC)(annotation, element);
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_4__.getViewportIdsWithToolToRender)(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                handleIndex: 3,
+                newAnnotation: true,
+                hasMoved: false,
+            };
+            this._activateDraw(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_5__.hideElementCursor)(element);
+            evt.preventDefault();
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A)(viewportIdsToRender);
+            return annotation;
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport } = enabledElement;
+            const { element } = viewport;
+            let annotations = (0,_stateManagement__WEBPACK_IMPORTED_MODULE_1__/* .getAnnotations */ .Rh)(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID, data } = annotation;
+                const { points, activeHandleIndex } = data.handles;
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                styleSpecifier.annotationUID = annotationUID;
+                const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
+                const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
+                const color = this.getStyle('color', styleSpecifier, annotation);
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__.triggerAnnotationModified)(annotation, element);
+                let activeHandleCanvasCoords;
+                if (!(0,_stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_7__.isAnnotationVisible)(annotationUID)) {
+                    continue;
+                }
+                if (!(0,_stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_2__.isAnnotationLocked)(annotationUID) &&
+                    !this.editData &&
+                    activeHandleIndex !== null) {
+                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                }
+                if (activeHandleCanvasCoords) {
+                    const handleGroupUID = '0';
+                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_3__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, activeHandleCanvasCoords, {
+                        color,
+                    });
+                }
+                const rectangleUID = '0';
+                (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_3__.drawRect)(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates[0], canvasCoordinates[3], {
+                    color,
+                    lineDash,
+                    lineWidth,
+                });
+                renderStatus = true;
+            }
+            return renderStatus;
+        };
+    }
+}
+RectangleROIThresholdTool.toolName = 'RectangleROIThreshold';
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (RectangleROIThresholdTool);
+
+
+/***/ }),
+
+/***/ 64843:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   addContourSegmentationAnnotation: () => (/* reexport safe */ _addContourSegmentationAnnotation__WEBPACK_IMPORTED_MODULE_2__.V),
+/* harmony export */   areSameSegment: () => (/* reexport safe */ _areSameSegment__WEBPACK_IMPORTED_MODULE_0__.A),
+/* harmony export */   isContourSegmentationAnnotation: () => (/* reexport safe */ _isContourSegmentationAnnotation__WEBPACK_IMPORTED_MODULE_1__.A),
+/* harmony export */   removeContourSegmentationAnnotation: () => (/* reexport safe */ _removeContourSegmentationAnnotation__WEBPACK_IMPORTED_MODULE_3__.M)
+/* harmony export */ });
+/* harmony import */ var _areSameSegment__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62854);
+/* harmony import */ var _isContourSegmentationAnnotation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(78130);
+/* harmony import */ var _addContourSegmentationAnnotation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(85263);
+/* harmony import */ var _removeContourSegmentationAnnotation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(37354);
+
+
+
+
+
+
+/***/ }),
+
+/***/ 13054:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   AnnotationToPointData: () => (/* reexport safe */ _AnnotationToPointData__WEBPACK_IMPORTED_MODULE_5__.A),
+/* harmony export */   acceptAutogeneratedInterpolations: () => (/* reexport safe */ _interpolation_acceptAutogeneratedInterpolations__WEBPACK_IMPORTED_MODULE_9__.A),
+/* harmony export */   areCoplanarContours: () => (/* reexport safe */ _areCoplanarContours__WEBPACK_IMPORTED_MODULE_0__.A),
+/* harmony export */   calculatePerimeter: () => (/* reexport safe */ _calculatePerimeter__WEBPACK_IMPORTED_MODULE_11__.A),
+/* harmony export */   contourFinder: () => (/* reexport safe */ _contourFinder__WEBPACK_IMPORTED_MODULE_1__.Ay),
+/* harmony export */   detectContourHoles: () => (/* reexport safe */ _detectContourHoles__WEBPACK_IMPORTED_MODULE_3__.A),
+/* harmony export */   findHandlePolylineIndex: () => (/* reexport safe */ _findHandlePolylineIndex__WEBPACK_IMPORTED_MODULE_10__.A),
+/* harmony export */   generateContourSetsFromLabelmap: () => (/* reexport safe */ _generateContourSetsFromLabelmap__WEBPACK_IMPORTED_MODULE_4__.d),
+/* harmony export */   getContourHolesDataCanvas: () => (/* reexport safe */ _getContourHolesDataCanvas__WEBPACK_IMPORTED_MODULE_7__.A),
+/* harmony export */   getContourHolesDataWorld: () => (/* reexport safe */ _getContourHolesDataWorld__WEBPACK_IMPORTED_MODULE_6__.A),
+/* harmony export */   getDeduplicatedVTKPolyDataPoints: () => (/* reexport safe */ _getDeduplicatedVTKPolyDataPoints__WEBPACK_IMPORTED_MODULE_2__.v),
+/* harmony export */   updateContourPolyline: () => (/* reexport safe */ _updateContourPolyline__WEBPACK_IMPORTED_MODULE_8__.A)
+/* harmony export */ });
+/* harmony import */ var _areCoplanarContours__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40825);
+/* harmony import */ var _contourFinder__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(46228);
+/* harmony import */ var _getDeduplicatedVTKPolyDataPoints__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(37546);
+/* harmony import */ var _detectContourHoles__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(69814);
+/* harmony import */ var _generateContourSetsFromLabelmap__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(81688);
+/* harmony import */ var _AnnotationToPointData__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(29632);
+/* harmony import */ var _getContourHolesDataWorld__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(55659);
+/* harmony import */ var _getContourHolesDataCanvas__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(15451);
+/* harmony import */ var _updateContourPolyline__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(72967);
+/* harmony import */ var _interpolation_acceptAutogeneratedInterpolations__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(67192);
+/* harmony import */ var _findHandlePolylineIndex__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(98013);
+/* harmony import */ var _calculatePerimeter__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(93843);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 23566:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  AnnotationMultiSlice: () => (/* reexport */ AnnotationMultiSlice/* default */.A),
+  IslandRemoval: () => (/* reexport */ islandRemoval/* default */.A),
+  annotationHydration: () => (/* reexport */ annotationHydration/* annotationHydration */.i),
+  boundingBox: () => (/* reexport */ boundingBox),
+  calibrateImageSpacing: () => (/* reexport */ calibrateImageSpacing/* default */.A),
+  cine: () => (/* reexport */ cine),
+  contourSegmentation: () => (/* reexport */ contourSegmentation),
+  contours: () => (/* reexport */ contours),
+  debounce: () => (/* reexport */ debounce/* default */.A),
+  drawing: () => (/* reexport */ drawing),
+  dynamicVolume: () => (/* reexport */ dynamicVolume),
+  geometricSurfaceUtils: () => (/* reexport */ geometricSurfaceUtils),
+  getAnnotationNearPoint: () => (/* reexport */ getAnnotationNearPoint/* getAnnotationNearPoint */.S),
+  getAnnotationNearPointOnEnabledElement: () => (/* reexport */ getAnnotationNearPoint/* getAnnotationNearPointOnEnabledElement */.s),
+  getCalibratedAspect: () => (/* reexport */ getCalibratedUnits/* getCalibratedAspect */.CQ),
+  getCalibratedLengthUnitsAndScale: () => (/* reexport */ getCalibratedUnits/* getCalibratedLengthUnitsAndScale */.Op),
+  getCalibratedProbeUnitsAndValue: () => (/* reexport */ getCalibratedUnits/* getCalibratedProbeUnitsAndValue */.Xw),
+  getClosestImageIdForStackViewport: () => (/* reexport */ annotationHydration/* getClosestImageIdForStackViewport */.x),
+  getPixelValueUnits: () => (/* reexport */ getPixelValueUnits/* getPixelValueUnits */.j),
+  getPixelValueUnitsImageId: () => (/* reexport */ getPixelValueUnits/* getPixelValueUnitsImageId */.N),
+  getSphereBoundsInfo: () => (/* reexport */ getSphereBoundsInfo/* getSphereBoundsInfo */.R),
+  getViewportForAnnotation: () => (/* reexport */ getViewportForAnnotation/* default */.A),
+  isObject: () => (/* reexport */ isObject/* default */.A),
+  math: () => (/* reexport */ math),
+  normalizeViewportPlane: () => (/* reexport */ normalizeViewportPlane/* default */.A),
+  orientation: () => (/* reexport */ orientation_namespaceObject),
+  planar: () => (/* reexport */ planar),
+  planarFreehandROITool: () => (/* reexport */ planarFreehandROITool),
+  pointInSurroundingSphereCallback: () => (/* reexport */ pointInSurroundingSphereCallback/* pointInSurroundingSphereCallback */.i),
+  pointToString: () => (/* reexport */ pointToString/* pointToString */.l),
+  polyDataUtils: () => (/* reexport */ utils),
+  rectangleROITool: () => (/* reexport */ rectangleROITool),
+  roundNumber: () => (/* binding */ roundNumber),
+  segmentation: () => (/* reexport */ segmentation),
+  stackContextPrefetch: () => (/* reexport */ stackPrefetch/* stackContextPrefetch */.N),
+  stackPrefetch: () => (/* reexport */ stackPrefetch/* stackPrefetch */.S),
+  throttle: () => (/* reexport */ throttle/* default */.A),
+  touch: () => (/* reexport */ touch),
+  triggerAnnotationRender: () => (/* reexport */ triggerAnnotationRender/* default */.A),
+  triggerAnnotationRenderForToolGroupIds: () => (/* reexport */ triggerAnnotationRenderForToolGroupIds/* default */.A),
+  triggerAnnotationRenderForViewportIds: () => (/* reexport */ triggerAnnotationRenderForViewportIds/* default */.A),
+  triggerEvent: () => (/* reexport */ esm.triggerEvent),
+  viewport: () => (/* reexport */ viewport),
+  viewportFilters: () => (/* reexport */ viewportFilters),
+  voi: () => (/* reexport */ voi)
+});
+
+// NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/orientation/index.js
+var orientation_namespaceObject = {};
+__webpack_require__.r(orientation_namespaceObject);
+__webpack_require__.d(orientation_namespaceObject, {
+  getOrientationStringLPS: () => (getOrientationStringLPS/* default */.A),
+  invertOrientationStringLPS: () => (invertOrientationStringLPS/* default */.A)
+});
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js
+var esm = __webpack_require__(81985);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getAnnotationNearPoint.js
+var getAnnotationNearPoint = __webpack_require__(41293);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/debounce.js
+var debounce = __webpack_require__(52905);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/throttle.js
+var throttle = __webpack_require__(27730);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/isObject.js
+var isObject = __webpack_require__(45217);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/calibrateImageSpacing.js
+var calibrateImageSpacing = __webpack_require__(58271);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getCalibratedUnits.js
+var getCalibratedUnits = __webpack_require__(4096);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/triggerAnnotationRenderForViewportIds.js
+var triggerAnnotationRenderForViewportIds = __webpack_require__(58640);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/triggerAnnotationRenderForToolGroupIds.js
+var triggerAnnotationRenderForToolGroupIds = __webpack_require__(94779);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/triggerAnnotationRender.js
+var triggerAnnotationRender = __webpack_require__(56069);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getSphereBoundsInfo.js
+var getSphereBoundsInfo = __webpack_require__(4296);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/pointToString.js
+var pointToString = __webpack_require__(38726);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/AnnotationMultiSlice.js
+var AnnotationMultiSlice = __webpack_require__(16678);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getViewportForAnnotation.js
+var getViewportForAnnotation = __webpack_require__(40133);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/annotationHydration.js
+var annotationHydration = __webpack_require__(64485);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contours/index.js
+var contours = __webpack_require__(13054);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/index.js
+var segmentation = __webpack_require__(93759);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/drawing/index.js + 1 modules
+var drawing = __webpack_require__(66990);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/index.js
+var math = __webpack_require__(95527);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planar/index.js + 3 modules
+var planar = __webpack_require__(93395);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewportFilters/index.js
+var viewportFilters = __webpack_require__(60810);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/orientation/getOrientationStringLPS.js
+var getOrientationStringLPS = __webpack_require__(7193);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/orientation/invertOrientationStringLPS.js
+var invertOrientationStringLPS = __webpack_require__(80405);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/orientation/index.js
+
+
+
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/cine/index.js + 3 modules
+var cine = __webpack_require__(43488);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/boundingBox/index.js
+var boundingBox = __webpack_require__(72282);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planarFreehandROITool/index.js
+var planarFreehandROITool = __webpack_require__(55002);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/rectangleROITool/index.js
+var rectangleROITool = __webpack_require__(74866);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/stackPrefetch/index.js + 2 modules
+var stackPrefetch = __webpack_require__(82295);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewport/index.js
+var viewport = __webpack_require__(19027);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/touch/index.js
+var touch = __webpack_require__(76260);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/dynamicVolume/index.js + 2 modules
+var dynamicVolume = __webpack_require__(74609);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/polyData/utils.js
+var utils = __webpack_require__(32994);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/voi/index.js + 4 modules
+var voi = __webpack_require__(93575);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contourSegmentation/index.js
+var contourSegmentation = __webpack_require__(64843);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/pointInSurroundingSphereCallback.js
+var pointInSurroundingSphereCallback = __webpack_require__(10261);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/normalizeViewportPlane.js
+var normalizeViewportPlane = __webpack_require__(27963);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/islandRemoval.js
+var islandRemoval = __webpack_require__(67912);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getPixelValueUnits.js
+var getPixelValueUnits = __webpack_require__(40634);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/geometricSurfaceUtils.js
+var geometricSurfaceUtils = __webpack_require__(5565);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const roundNumber = esm.utilities.roundNumber;
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 93759:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   IslandRemoval: () => (/* reexport safe */ _islandRemoval__WEBPACK_IMPORTED_MODULE_21__.A),
+/* harmony export */   LabelmapMemo: () => (/* reexport module object */ _createLabelmapMemo__WEBPACK_IMPORTED_MODULE_20__),
+/* harmony export */   VolumetricCalculator: () => (/* reexport safe */ _VolumetricCalculator__WEBPACK_IMPORTED_MODULE_8__.A),
+/* harmony export */   computeStackLabelmapFromVolume: () => (/* reexport safe */ _stateManagement_segmentation_helpers_computeStackLabelmapFromVolume__WEBPACK_IMPORTED_MODULE_25__._),
+/* harmony export */   computeVolumeLabelmapFromStack: () => (/* reexport safe */ _stateManagement_segmentation_helpers_computeVolumeLabelmapFromStack__WEBPACK_IMPORTED_MODULE_26__.a),
+/* harmony export */   contourAndFindLargestBidirectional: () => (/* reexport safe */ _contourAndFindLargestBidirectional__WEBPACK_IMPORTED_MODULE_10__.A),
+/* harmony export */   createBidirectionalToolData: () => (/* reexport safe */ _createBidirectionalToolData__WEBPACK_IMPORTED_MODULE_11__.A),
+/* harmony export */   createLabelmapVolumeForViewport: () => (/* reexport safe */ _createLabelmapVolumeForViewport__WEBPACK_IMPORTED_MODULE_3__.A),
+/* harmony export */   createMergedLabelmapForIndex: () => (/* reexport safe */ _createMergedLabelmapForIndex__WEBPACK_IMPORTED_MODULE_2__.A),
+/* harmony export */   floodFill: () => (/* reexport safe */ _floodFill__WEBPACK_IMPORTED_MODULE_5__.A),
+/* harmony export */   getBrushSizeForToolGroup: () => (/* reexport safe */ _brushSizeForToolGroup__WEBPACK_IMPORTED_MODULE_6__.A),
+/* harmony export */   getBrushThresholdForToolGroup: () => (/* reexport safe */ _brushThresholdForToolGroup__WEBPACK_IMPORTED_MODULE_7__.Q),
+/* harmony export */   getBrushToolInstances: () => (/* reexport safe */ _getBrushToolInstances__WEBPACK_IMPORTED_MODULE_18__.n),
+/* harmony export */   getHoveredContourSegmentationAnnotation: () => (/* reexport safe */ _getHoveredContourSegmentationAnnotation__WEBPACK_IMPORTED_MODULE_17__.L),
+/* harmony export */   getOrCreateSegmentationVolume: () => (/* reexport safe */ _getOrCreateSegmentationVolume__WEBPACK_IMPORTED_MODULE_22__.A),
+/* harmony export */   getSegmentIndexAtLabelmapBorder: () => (/* reexport safe */ _getSegmentIndexAtLabelmapBorder__WEBPACK_IMPORTED_MODULE_16__.T),
+/* harmony export */   getSegmentIndexAtWorldPoint: () => (/* reexport safe */ _getSegmentIndexAtWorldPoint__WEBPACK_IMPORTED_MODULE_15__.hX),
+/* harmony export */   getStatistics: () => (/* reexport safe */ _getStatistics__WEBPACK_IMPORTED_MODULE_23__.A),
+/* harmony export */   getUniqueSegmentIndices: () => (/* reexport safe */ _getUniqueSegmentIndices__WEBPACK_IMPORTED_MODULE_14__.O),
+/* harmony export */   growCut: () => (/* reexport module object */ _growCut__WEBPACK_IMPORTED_MODULE_19__),
+/* harmony export */   invalidateBrushCursor: () => (/* reexport safe */ _invalidateBrushCursor__WEBPACK_IMPORTED_MODULE_13__.E),
+/* harmony export */   rectangleROIThresholdVolumeByRange: () => (/* reexport safe */ _rectangleROIThresholdVolumeByRange__WEBPACK_IMPORTED_MODULE_1__.A),
+/* harmony export */   segmentContourAction: () => (/* reexport safe */ _segmentContourAction__WEBPACK_IMPORTED_MODULE_12__.A),
+/* harmony export */   setBrushSizeForToolGroup: () => (/* reexport safe */ _brushSizeForToolGroup__WEBPACK_IMPORTED_MODULE_6__.M),
+/* harmony export */   setBrushThresholdForToolGroup: () => (/* reexport safe */ _brushThresholdForToolGroup__WEBPACK_IMPORTED_MODULE_7__.K),
+/* harmony export */   thresholdSegmentationByRange: () => (/* reexport safe */ _thresholdSegmentationByRange__WEBPACK_IMPORTED_MODULE_9__.A),
+/* harmony export */   thresholdVolumeByRange: () => (/* reexport safe */ _thresholdVolumeByRange__WEBPACK_IMPORTED_MODULE_0__.A),
+/* harmony export */   triggerSegmentationRender: () => (/* reexport safe */ _stateManagement_segmentation_SegmentationRenderingEngine__WEBPACK_IMPORTED_MODULE_4__.h6),
+/* harmony export */   triggerSegmentationRenderBySegmentationId: () => (/* reexport safe */ _stateManagement_segmentation_SegmentationRenderingEngine__WEBPACK_IMPORTED_MODULE_4__.fy),
+/* harmony export */   validateLabelmap: () => (/* reexport module object */ _validateLabelmap__WEBPACK_IMPORTED_MODULE_24__)
+/* harmony export */ });
+/* harmony import */ var _thresholdVolumeByRange__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8582);
+/* harmony import */ var _rectangleROIThresholdVolumeByRange__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(52323);
+/* harmony import */ var _createMergedLabelmapForIndex__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4334);
+/* harmony import */ var _createLabelmapVolumeForViewport__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(97492);
+/* harmony import */ var _stateManagement_segmentation_SegmentationRenderingEngine__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(24917);
+/* harmony import */ var _floodFill__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(84882);
+/* harmony import */ var _brushSizeForToolGroup__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(17014);
+/* harmony import */ var _brushThresholdForToolGroup__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(49492);
+/* harmony import */ var _VolumetricCalculator__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(68915);
+/* harmony import */ var _thresholdSegmentationByRange__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(73706);
+/* harmony import */ var _contourAndFindLargestBidirectional__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(35271);
+/* harmony import */ var _createBidirectionalToolData__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(14514);
+/* harmony import */ var _segmentContourAction__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(22592);
+/* harmony import */ var _invalidateBrushCursor__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(35706);
+/* harmony import */ var _getUniqueSegmentIndices__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(25758);
+/* harmony import */ var _getSegmentIndexAtWorldPoint__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(71751);
+/* harmony import */ var _getSegmentIndexAtLabelmapBorder__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(46507);
+/* harmony import */ var _getHoveredContourSegmentationAnnotation__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(20527);
+/* harmony import */ var _getBrushToolInstances__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(14957);
+/* harmony import */ var _growCut__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(97445);
+/* harmony import */ var _createLabelmapMemo__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(24778);
+/* harmony import */ var _islandRemoval__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(67912);
+/* harmony import */ var _getOrCreateSegmentationVolume__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(30722);
+/* harmony import */ var _getStatistics__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(84978);
+/* harmony import */ var _validateLabelmap__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(21345);
+/* harmony import */ var _stateManagement_segmentation_helpers_computeStackLabelmapFromVolume__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(93690);
+/* harmony import */ var _stateManagement_segmentation_helpers_computeVolumeLabelmapFromStack__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(6994);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 64063:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Dm: () => (/* binding */ setCachedSegmentIndices),
+/* harmony export */   HM: () => (/* binding */ setSegmentationDirty),
+/* harmony export */   Q5: () => (/* binding */ getVoxelOverlap),
+/* harmony export */   R1: () => (/* binding */ getCachedSegmentIndices),
+/* harmony export */   zf: () => (/* binding */ processVolumes)
+/* harmony export */ });
+/* unused harmony export setSegmentationClean */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
+/* harmony import */ var _boundingBox_getBoundingBoxAroundShape__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(87063);
+
+
+const equalsCheck = (a, b) => {
+    return JSON.stringify(a) === JSON.stringify(b);
+};
+function getVoxelOverlap(imageData, dimensions, voxelSpacing, voxelCenter) {
+    const halfSpacingX = voxelSpacing[0] / 2;
+    const halfSpacingY = voxelSpacing[1] / 2;
+    const halfSpacingZ = voxelSpacing[2] / 2;
+    const voxelCornersIJK = new Array(8);
+    voxelCornersIJK[0] = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, [
+        voxelCenter[0] - halfSpacingX,
+        voxelCenter[1] - halfSpacingY,
+        voxelCenter[2] - halfSpacingZ,
+    ]);
+    const offsets = [
+        [1, -1, -1],
+        [-1, 1, -1],
+        [1, 1, -1],
+        [-1, -1, 1],
+        [1, -1, 1],
+        [-1, 1, 1],
+        [1, 1, 1],
+    ];
+    for (let i = 0; i < 7; i++) {
+        const [xOff, yOff, zOff] = offsets[i];
+        voxelCornersIJK[i + 1] = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, [
+            voxelCenter[0] + xOff * halfSpacingX,
+            voxelCenter[1] + yOff * halfSpacingY,
+            voxelCenter[2] + zOff * halfSpacingZ,
+        ]);
+    }
+    return (0,_boundingBox_getBoundingBoxAroundShape__WEBPACK_IMPORTED_MODULE_1__/* .getBoundingBoxAroundShapeIJK */ .g)(voxelCornersIJK, dimensions);
+}
+function processVolumes(segmentationVolume, thresholdVolumeInformation) {
+    const { spacing: segmentationSpacing } = segmentationVolume;
+    const scalarDataLength = segmentationVolume.voxelManager.getScalarDataLength();
+    const volumeInfoList = [];
+    let baseVolumeIdx = 0;
+    for (let i = 0; i < thresholdVolumeInformation.length; i++) {
+        const { imageData, spacing, dimensions, voxelManager } = thresholdVolumeInformation[i].volume;
+        const volumeSize = thresholdVolumeInformation[i].volume.voxelManager.getScalarDataLength();
+        if (volumeSize === scalarDataLength &&
+            equalsCheck(spacing, segmentationSpacing)) {
+            baseVolumeIdx = i;
+        }
+        const lower = thresholdVolumeInformation[i].lower;
+        const upper = thresholdVolumeInformation[i].upper;
+        volumeInfoList.push({
+            imageData,
+            lower,
+            upper,
+            spacing,
+            dimensions,
+            volumeSize,
+            voxelManager,
+        });
+    }
+    return {
+        volumeInfoList,
+        baseVolumeIdx,
+    };
+}
+const segmentIndicesCache = new Map();
+const setSegmentationDirty = (segmentationId) => {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached) {
+        cached.isDirty = true;
+    }
+};
+const setSegmentationClean = (segmentationId) => {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached) {
+        cached.isDirty = false;
+    }
+};
+const getCachedSegmentIndices = (segmentationId) => {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached && !cached.isDirty) {
+        return cached.indices;
+    }
+    return null;
+};
+const setCachedSegmentIndices = (segmentationId, indices) => {
+    segmentIndicesCache.set(segmentationId, { indices, isDirty: false });
+};
+
+
+/***/ }),
+
+/***/ 28802:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Colorbar: () => (/* reexport safe */ _Colorbar__WEBPACK_IMPORTED_MODULE_1__.P),
+/* harmony export */   Enums: () => (/* reexport module object */ _enums__WEBPACK_IMPORTED_MODULE_0__),
+/* harmony export */   ViewportColorbar: () => (/* reexport safe */ _ViewportColorbar__WEBPACK_IMPORTED_MODULE_2__.b)
+/* harmony export */ });
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(51807);
+/* harmony import */ var _Colorbar__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4848);
+/* harmony import */ var _ViewportColorbar__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(91994);
+
+
+
+
+
+
+/***/ })
+
+}]);