@ohif/app 3.13.0-beta.88 → 3.13.0-beta.89

package/dist/{9567.bundle.ff782480a4c66e306027.js → 650.bundle.5decc3ce72a22162b8f4.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[9567],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[650],{
 
 /***/ 75183
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -930,7 +930,7 @@ function _onKeyUp(evt) {
     document.removeEventListener('keyup', _onKeyUp);
     document.removeEventListener('visibilitychange', _onVisibilityChange);
     state.element.addEventListener('keydown', keyListener);
-    state = structuredClone(defaultState);
+    state = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepClone(defaultState);
     (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(eventDetail.element, _enums_Events__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.KEY_UP, eventDetail);
 }
 function getModifierKey() {
@@ -962,7 +962,10 @@ function getMouseEventPoints(evt, element) {
     const clientPoint = _clientToPoint(evt);
     const pagePoint = _pageToPoint(evt);
     const canvasPoint = _pagePointsToCanvasPoints(elementToUse, pagePoint);
-    const worldPoint = viewport.canvasToWorld(canvasPoint);
+    const worldPoint = getWorldPoint(viewport, canvasPoint);
+    if (!worldPoint) {
+        return;
+    }
     return {
         page: pagePoint,
         client: clientPoint,
@@ -983,6 +986,21 @@ function _pageToPoint(evt) {
 function _clientToPoint(evt) {
     return [evt.clientX, evt.clientY];
 }
+function getWorldPoint(viewport, canvasPoint) {
+    try {
+        return viewport.canvasToWorld(canvasPoint);
+    }
+    catch (error) {
+        if (isNoMountedDataError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isNoMountedDataError(error) {
+    return (error instanceof Error &&
+        error.message.includes('because no data is mounted'));
+}
 
 
 /***/ },
@@ -1002,8 +1020,15 @@ function _clientToPoint(evt) {
 
 function mouseDoubleClickListener(evt) {
     const element = evt.currentTarget;
-    const { viewportId, renderingEngineId } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+    const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewportId, renderingEngineId } = enabledElement;
     const startPoints = (0,_getMouseEventPoints__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(evt, element);
+    if (!startPoints) {
+        return;
+    }
     const deltaPoints = {
         page: [0, 0],
         client: [0, 0],
@@ -1117,12 +1142,21 @@ function mouseDownListener(evt) {
     state.element = evt.currentTarget;
     state.mouseButton = evt.buttons;
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(state.element);
+    if (!enabledElement) {
+        state = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepClone(defaultState);
+        return;
+    }
     const { renderingEngineId, viewportId } = enabledElement;
     state.renderingEngineId = renderingEngineId;
     state.viewportId = viewportId;
     state.preventClickTimeout = setTimeout(_preventClickHandler, state.clickDelay);
-    state.element.removeEventListener('mousemove', _mouseMoveListener__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A);
     const startPoints = (0,_getMouseEventPoints__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(evt, state.element);
+    if (!startPoints) {
+        clearTimeout(state.preventClickTimeout);
+        state = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepClone(defaultState);
+        return;
+    }
+    state.element.removeEventListener('mousemove', _mouseMoveListener__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A);
     state.startPoints = _copyPoints(startPoints);
     state.lastPoints = _copyPoints(startPoints);
     document.addEventListener('mouseup', _onMouseUp);
@@ -1155,6 +1189,9 @@ function _onMouseDrag(evt) {
         return;
     }
     const currentPoints = (0,_getMouseEventPoints__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(evt, state.element);
+    if (!currentPoints) {
+        return;
+    }
     const lastPoints = _updateMouseEventsLastPoints(state.element, state.lastPoints);
     const deltaPoints = _getDeltaPoints(currentPoints, lastPoints);
     if (doubleClickState.doubleClickTimeout) {
@@ -1199,6 +1236,10 @@ function _onMouseUp(evt) {
     else {
         const eventName = state.isClickEvent ? MOUSE_CLICK : MOUSE_UP;
         const currentPoints = (0,_getMouseEventPoints__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(evt, state.element);
+        if (!currentPoints) {
+            _cleanUp();
+            return;
+        }
         const deltaPoints = _getDeltaPoints(currentPoints, state.lastPoints);
         const eventDetail = {
             event: evt,
@@ -1220,6 +1261,9 @@ function _onMouseUp(evt) {
 }
 function _onMouseMove(evt) {
     const currentPoints = (0,_getMouseEventPoints__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(evt, state.element);
+    if (!currentPoints) {
+        return;
+    }
     const lastPoints = _updateMouseEventsLastPoints(state.element, state.lastPoints);
     const deltaPoints = _getDeltaPoints(currentPoints, lastPoints);
     if (!_isDragPastDoubleClickTolerance(deltaPoints.canvas)) {
@@ -1257,17 +1301,26 @@ function _cleanUp() {
     state.element?.removeEventListener('mousemove', _onMouseMove);
     state.element?.addEventListener('mousemove', _mouseMoveListener__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A);
     _clearDoubleClickTimeoutAndEvents();
-    state = JSON.parse(JSON.stringify(defaultState));
+    state = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepClone(defaultState);
 }
 function _copyPoints(points) {
-    return JSON.parse(JSON.stringify(points));
+    return _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepClone(points);
 }
 function _updateMouseEventsLastPoints(element, lastPoints) {
     const { viewport } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element) || {};
     if (!viewport) {
         return lastPoints;
     }
-    const world = viewport.canvasToWorld(lastPoints.canvas);
+    let world;
+    try {
+        world = viewport.canvasToWorld(lastPoints.canvas);
+    }
+    catch (error) {
+        if (isNoMountedDataError(error)) {
+            return lastPoints;
+        }
+        throw error;
+    }
     return {
         page: lastPoints.page,
         client: lastPoints.client,
@@ -1297,6 +1350,10 @@ function _subtractPoints2D(point0, point1) {
 function _subtractPoints3D(point0, point1) {
     return [point0[0] - point1[0], point0[1] - point1[1], point0[2] - point1[2]];
 }
+function isNoMountedDataError(error) {
+    return (error instanceof Error &&
+        error.message.includes('because no data is mounted'));
+}
 function getMouseButton() {
     return state.mouseButton;
 }
@@ -1337,6 +1394,9 @@ function mouseMoveListener(evt) {
     }
     const { renderingEngineId, viewportId } = enabledElement;
     const currentPoints = (0,_getMouseEventPoints__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(evt);
+    if (!currentPoints) {
+        return;
+    }
     const eventDetail = {
         renderingEngineId,
         viewportId,
@@ -1435,13 +1495,20 @@ var Touch = __webpack_require__(10401);
 
 function getTouchEventPoints(evt, element) {
     const elementToUse = element || evt.currentTarget;
+    const { viewport } = (0,esm.getEnabledElement)(elementToUse) || {};
+    if (!viewport) {
+        return [];
+    }
     const touches = evt.type === 'touchend' ? evt.changedTouches : evt.touches;
-    return Object.keys(touches).map((i) => {
+    return Object.keys(touches)
+        .map((i) => {
         const clientPoint = _clientToPoint(touches[i]);
         const pagePoint = _pageToPoint(touches[i]);
         const canvasPoint = _pagePointsToCanvasPoints(elementToUse, pagePoint);
-        const { viewport } = (0,esm.getEnabledElement)(elementToUse);
-        const worldPoint = viewport.canvasToWorld(canvasPoint);
+        const worldPoint = getWorldPoint(viewport, canvasPoint);
+        if (!worldPoint) {
+            return;
+        }
         return {
             page: pagePoint,
             client: clientPoint,
@@ -1455,7 +1522,8 @@ function getTouchEventPoints(evt, element) {
                 rotationAngle: touches[i].rotationAngle,
             },
         };
-    });
+    })
+        .filter(Boolean);
 }
 function _pagePointsToCanvasPoints(element, pagePoint) {
     const rect = element.getBoundingClientRect();
@@ -1470,6 +1538,21 @@ function _pageToPoint(touch) {
 function _clientToPoint(touch) {
     return [touch.clientX, touch.clientY];
 }
+function getWorldPoint(viewport, canvasPoint) {
+    try {
+        return viewport.canvasToWorld(canvasPoint);
+    }
+    catch (error) {
+        if (isNoMountedDataError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isNoMountedDataError(error) {
+    return (error instanceof Error &&
+        error.message.includes('because no data is mounted'));
+}
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/touch/index.js
 var touch = __webpack_require__(76260);
@@ -1535,8 +1618,8 @@ const defaultTapState = {
     tapMaxDistance: 24,
     tapToleranceMs: 300,
 };
-let state = JSON.parse(JSON.stringify(defaultState));
-let tapState = JSON.parse(JSON.stringify(defaultTapState));
+let state = esm.utilities.deepClone(defaultState);
+let tapState = esm.utilities.deepClone(defaultTapState);
 function triggerEventCallback(ele, name, eventDetail) {
     return (0,esm.triggerEvent)(ele, name, eventDetail);
 }
@@ -1670,7 +1753,7 @@ function _onTouchEnd(evt) {
     };
     triggerEventCallback(eventDetail.element, TOUCH_END, eventDetail);
     _checkTouchTap(evt);
-    state = JSON.parse(JSON.stringify(defaultState));
+    state = esm.utilities.deepClone(defaultState);
     document.removeEventListener('touchmove', _onTouchDrag);
     document.removeEventListener('touchend', _onTouchEnd);
 }
@@ -1712,7 +1795,7 @@ function _checkTouchTap(evt) {
             taps: tapState.taps,
         };
         triggerEventCallback(eventDetail.element, TOUCH_TAP, eventDetail);
-        tapState = JSON.parse(JSON.stringify(defaultTapState));
+        tapState = esm.utilities.deepClone(defaultTapState);
     }, tapState.tapToleranceMs);
 }
 function _checkTouchSwipe(evt, deltaPoints) {
@@ -1743,9 +1826,22 @@ function _checkTouchSwipe(evt, deltaPoints) {
     }
 }
 function _updateTouchEventsLastPoints(element, lastPoints) {
-    const { viewport } = (0,esm.getEnabledElement)(element);
-    return lastPoints.map((lp) => {
-        const world = viewport.canvasToWorld(lp.canvas);
+    const { viewport } = (0,esm.getEnabledElement)(element) || {};
+    if (!viewport) {
+        return lastPoints;
+    }
+    return lastPoints
+        .map((lp) => {
+        let world;
+        try {
+            world = viewport.canvasToWorld(lp.canvas);
+        }
+        catch (error) {
+            if (touchStartListener_isNoMountedDataError(error)) {
+                return;
+            }
+            throw error;
+        }
         return {
             page: lp.page,
             client: lp.client,
@@ -1753,7 +1849,12 @@ function _updateTouchEventsLastPoints(element, lastPoints) {
             world,
             touch: lp.touch,
         };
-    });
+    })
+        .filter(Boolean);
+}
+function touchStartListener_isNoMountedDataError(error) {
+    return (error instanceof Error &&
+        error.message.includes('because no data is mounted'));
 }
 /* harmony default export */ const touch_touchStartListener = (touchStartListener);
 
@@ -1838,6 +1939,10 @@ function wheelListener(evt) {
     if (evt.deltaY > -1 && evt.deltaY < 1) {
         return;
     }
+    const points = (0,getMouseEventPoints/* default */.A)(evt);
+    if (!points) {
+        return;
+    }
     evt.preventDefault();
     const { spinX, spinY, pixelX, pixelY } = normalizeWheel(evt);
     const direction = spinY < 0 ? -1 : 1;
@@ -1856,7 +1961,7 @@ function wheelListener(evt) {
             pixelY,
             direction,
         },
-        points: (0,getMouseEventPoints/* default */.A)(evt),
+        points,
     };
     (0,esm.triggerEvent)(element, Events/* default */.A.MOUSE_WHEEL, eventDetail);
 }
@@ -1908,6 +2013,334 @@ async function convertStackToVolumeLabelmap(args) {
 }
 
 
+/***/ },
+
+/***/ 59452
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DU: () => (/* binding */ getSurfaceRepresentationUID),
+/* harmony export */   ED: () => (/* binding */ getLabelmapActorEntries),
+/* harmony export */   Th: () => (/* binding */ getSurfaceActorEntry),
+/* harmony export */   wV: () => (/* binding */ getLabelmapActorEntry)
+/* harmony export */ });
+/* unused harmony export getLabelmapActorUID */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(29857);
+
+
+function getActorEntry(viewportId, segmentationId, filterFn) {
+    const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { renderingEngine, viewport } = enabledElement;
+    if (!renderingEngine || !viewport) {
+        return;
+    }
+    const actors = viewport.getActors();
+    const filteredActors = actors.filter(filterFn);
+    return filteredActors.length > 0 ? filteredActors[0] : undefined;
+}
+function getActorEntries(viewportId, filterFn) {
+    const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { renderingEngine, viewport } = enabledElement;
+    if (!renderingEngine || !viewport) {
+        return;
+    }
+    const actors = viewport.getActors();
+    const filteredActors = actors.filter(filterFn);
+    return filteredActors.length > 0 ? filteredActors : undefined;
+}
+function getLabelmapActorUID(viewportId, segmentationId) {
+    const actorEntry = getLabelmapActorEntry(viewportId, segmentationId);
+    return actorEntry?.uid;
+}
+function getLabelmapActorEntries(viewportId, segmentationId) {
+    return getActorEntries(viewportId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Labelmap}`));
+}
+function getLabelmapActorEntry(viewportId, segmentationId, referencedId) {
+    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Labelmap}`) &&
+        (!referencedId || actor.referencedId === referencedId));
+}
+function getSurfaceActorEntry(viewportId, segmentationId, segmentIndex) {
+    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID ===
+        getSurfaceRepresentationUID(segmentationId, segmentIndex));
+}
+function getSurfaceRepresentationUID(segmentationId, segmentIndex) {
+    return `${segmentationId}-${_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Surface}-${segmentIndex}`;
+}
+
+
+/***/ },
+
+/***/ 78028
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   KM: () => (/* binding */ DIRECTION_ALIGNMENT_TOLERANCE),
+/* harmony export */   QO: () => (/* binding */ canRenderVolumeViewportLabelmapAsImage),
+/* harmony export */   bY: () => (/* binding */ shouldUseSliceRendering),
+/* harmony export */   o: () => (/* binding */ getVolumeViewportLabelmapImageMapperState),
+/* harmony export */   yc: () => (/* binding */ isSliceRenderingEnabled)
+/* harmony export */ });
+/* unused harmony export LABELMAP_IMAGE_MAPPER_URL_PARAM */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3823);
+/* harmony import */ var _labelmapModel_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(80973);
+
+
+
+const DIRECTION_ALIGNMENT_TOLERANCE = 0.999;
+const MINIMUM_SLAB_THICKNESS = 0.1;
+const SLAB_THICKNESS_EPSILON = 1e-3;
+const LABELMAP_IMAGE_MAPPER_URL_PARAM = 'labelmapImageMapper';
+function isSupportedImageMapperBlendMode(blendMode) {
+    return (blendMode === _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.BlendModes.COMPOSITE ||
+        blendMode === _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.BlendModes.AVERAGE_INTENSITY_BLEND);
+}
+function isPlanarGpuVolumeSliceViewport(viewport) {
+    const compatibilityViewport = viewport;
+    if (compatibilityViewport.type !== _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.ViewportType.PLANAR_NEXT) {
+        return false;
+    }
+    return (getPlanarPrimaryRenderMode(compatibilityViewport) ===
+        _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.ActorRenderMode.VTK_VOLUME_SLICE);
+}
+function getPlanarPrimaryRenderMode(viewport) {
+    const primaryDataId = getPlanarPrimaryDataId(viewport);
+    if (primaryDataId) {
+        const renderMode = viewport.getDisplaySetRenderMode?.(primaryDataId);
+        if (renderMode) {
+            return renderMode;
+        }
+    }
+    return viewport.getDefaultActor?.()?.actorMapper?.renderMode;
+}
+function getPlanarVolumeSliceMapper(viewport) {
+    const defaultActor = viewport.getDefaultActor?.();
+    return (defaultActor?.actorMapper?.mapper ??
+        defaultActor?.actorMapper?.actor?.getMapper?.());
+}
+function getPlanarPrimaryDataId(viewport) {
+    const sourceDataId = viewport.getSourceDataId?.();
+    if (sourceDataId) {
+        return sourceDataId;
+    }
+    const renderModes = viewport._debug?.renderModes;
+    if (!renderModes) {
+        return;
+    }
+    return (Object.entries(renderModes).find(([dataId, renderMode]) => viewport.getDisplaySetRole?.(dataId) === 'source' &&
+        renderMode === _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.ActorRenderMode.VTK_VOLUME_SLICE)?.[0] ??
+        Object.entries(renderModes).find(([, renderMode]) => renderMode === _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.ActorRenderMode.VTK_VOLUME_SLICE)?.[0]);
+}
+function getLabelmapImageMapperCamera(viewport) {
+    const compatibilityViewport = viewport;
+    const resolvedCamera = compatibilityViewport
+        .getResolvedView?.()
+        ?.toICamera?.();
+    if (isLabelmapImageMapperCamera(resolvedCamera)) {
+        return resolvedCamera;
+    }
+    const legacyCamera = compatibilityViewport.getCamera?.();
+    return isLabelmapImageMapperCamera(legacyCamera) ? legacyCamera : undefined;
+}
+function isLabelmapImageMapperCamera(camera) {
+    const candidate = camera;
+    return Boolean(candidate &&
+        isPoint3Like(candidate.viewPlaneNormal) &&
+        isPoint3Like(candidate.viewUp));
+}
+function isPoint3Like(value) {
+    const candidate = value;
+    return Boolean(candidate &&
+        typeof candidate.length === 'number' &&
+        candidate.length >= 3 &&
+        Number.isFinite(Number(candidate[0])) &&
+        Number.isFinite(Number(candidate[1])) &&
+        Number.isFinite(Number(candidate[2])));
+}
+function getPlanarVolumeDataPresentation(viewport) {
+    if (!viewport.getDisplaySetPresentation) {
+        return;
+    }
+    const primaryDataId = getPlanarPrimaryDataId(viewport);
+    return primaryDataId
+        ? viewport.getDisplaySetPresentation(primaryDataId)
+        : undefined;
+}
+function getCompatibilityBlendMode(viewport) {
+    if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.VolumeViewport) {
+        return viewport.getBlendMode?.();
+    }
+    if (!isPlanarGpuVolumeSliceViewport(viewport)) {
+        return;
+    }
+    const presentationBlendMode = getPlanarVolumeDataPresentation(viewport)?.blendMode;
+    if (presentationBlendMode !== undefined) {
+        return presentationBlendMode;
+    }
+    return _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.BlendModes.AVERAGE_INTENSITY_BLEND;
+}
+function getCompatibilitySlabThickness(viewport) {
+    if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.VolumeViewport) {
+        return viewport.getSlabThickness?.() ?? MINIMUM_SLAB_THICKNESS;
+    }
+    if (!isPlanarGpuVolumeSliceViewport(viewport)) {
+        return MINIMUM_SLAB_THICKNESS;
+    }
+    const mapperSlabThickness = getPlanarVolumeSliceMapper(viewport)?.getSlabThickness?.();
+    if (typeof mapperSlabThickness === 'number') {
+        return mapperSlabThickness;
+    }
+    return (getPlanarVolumeDataPresentation(viewport)?.slabThickness ??
+        MINIMUM_SLAB_THICKNESS);
+}
+function isSliceRenderingEnabled(options) {
+    if (options?.useSliceRendering) {
+        return true;
+    }
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    const params = new URLSearchParams(window.location.search);
+    if (!params.has(LABELMAP_IMAGE_MAPPER_URL_PARAM)) {
+        return false;
+    }
+    const value = params.get(LABELMAP_IMAGE_MAPPER_URL_PARAM);
+    if (value === null || value === '') {
+        return true;
+    }
+    const normalizedValue = value.trim().toLowerCase();
+    return (normalizedValue !== '0' &&
+        normalizedValue !== 'false' &&
+        normalizedValue !== 'off');
+}
+function shouldUseSliceRendering(segmentation, options) {
+    if (isSliceRenderingEnabled(options)) {
+        return true;
+    }
+    if (!segmentation?.representationData?.Labelmap) {
+        return false;
+    }
+    const layers = (0,_labelmapModel_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_2__/* .getLabelmaps */ .m)(segmentation);
+    return layers.length > 1 && layers.some((layer) => layer.type === 'stack');
+}
+function canRenderVolumeViewportLabelmapAsImage(viewport) {
+    const isLegacyVolumeViewport = viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.VolumeViewport;
+    const isNextPlanarViewport = isPlanarGpuVolumeSliceViewport(viewport);
+    if (!isLegacyVolumeViewport && !isNextPlanarViewport) {
+        return false;
+    }
+    const blendMode = getCompatibilityBlendMode(viewport);
+    if (isLegacyVolumeViewport && !isSupportedImageMapperBlendMode(blendMode)) {
+        return false;
+    }
+    const slabThickness = getCompatibilitySlabThickness(viewport);
+    if (slabThickness > MINIMUM_SLAB_THICKNESS + SLAB_THICKNESS_EPSILON) {
+        return false;
+    }
+    if (isLegacyVolumeViewport) {
+        try {
+            viewport.getSliceViewInfo();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+function getVolumeViewportLabelmapImageMapperState(viewport) {
+    const compatibilityViewport = viewport;
+    const isLegacyVolumeViewport = viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.VolumeViewport;
+    const isNextPlanarViewport = isPlanarGpuVolumeSliceViewport(viewport);
+    if (!isLegacyVolumeViewport && !isNextPlanarViewport) {
+        return {
+            key: 'unsupported:viewport',
+            sliceIndex: NaN,
+            supported: false,
+        };
+    }
+    const camera = getLabelmapImageMapperCamera(viewport);
+    if (!camera) {
+        return {
+            key: 'unsupported:camera',
+            sliceIndex: NaN,
+            supported: false,
+        };
+    }
+    const { viewPlaneNormal, viewUp } = camera;
+    const normalizedNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.normalize */ .eR.normalize(gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create(), viewPlaneNormal);
+    const normalizedViewUp = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.normalize */ .eR.normalize(gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create(), viewUp);
+    let sliceIndex;
+    if (isLegacyVolumeViewport) {
+        try {
+            sliceIndex = viewport.getSliceViewInfo().sliceIndex;
+        }
+        catch {
+            sliceIndex = undefined;
+        }
+    }
+    else {
+        sliceIndex = compatibilityViewport.getCurrentImageIdIndex?.();
+    }
+    const blendMode = getCompatibilityBlendMode(viewport);
+    const slabThickness = getCompatibilitySlabThickness(viewport);
+    const orientationKey = [
+        normalizedNormal.map((value) => value.toFixed(3)).join(','),
+        normalizedViewUp.map((value) => value.toFixed(3)).join(','),
+    ].join('|');
+    if (isLegacyVolumeViewport && !isSupportedImageMapperBlendMode(blendMode)) {
+        return {
+            key: `unsupported:blend:${blendMode}:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    if (slabThickness > MINIMUM_SLAB_THICKNESS + SLAB_THICKNESS_EPSILON) {
+        return {
+            key: `unsupported:slab:${slabThickness.toFixed(3)}:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    if (isLegacyVolumeViewport) {
+        try {
+            viewport.getSliceViewInfo();
+        }
+        catch {
+            return {
+                key: `unsupported:oblique:${orientationKey}`,
+                sliceIndex: sliceIndex ?? NaN,
+                supported: false,
+            };
+        }
+    }
+    if (isNextPlanarViewport &&
+        getPlanarPrimaryRenderMode(compatibilityViewport) !==
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.ActorRenderMode.VTK_VOLUME_SLICE) {
+        return {
+            key: `unsupported:renderMode:${orientationKey}`,
+            sliceIndex: sliceIndex ?? NaN,
+            supported: false,
+        };
+    }
+    return {
+        key: `supported:${orientationKey}:${sliceIndex ?? 0}`,
+        sliceIndex: sliceIndex ?? NaN,
+        supported: true,
+    };
+}
+
+
+
 /***/ },
 
 /***/ 98149
@@ -1957,97 +2390,415 @@ async function updateStackSegmentationState({ segmentationId, viewportId, imageI
 
 /***/ },
 
-/***/ 25972
+/***/ 79663
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ filterMoveableAnnotationTools)
+/* harmony export */   BS: () => (/* reexport safe */ _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__.BS),
+/* harmony export */   Hs: () => (/* reexport safe */ _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__.Hs),
+/* harmony export */   Lp: () => (/* reexport safe */ _labelmapImageReferenceResolver__WEBPACK_IMPORTED_MODULE_6__.A),
+/* harmony export */   M4: () => (/* reexport safe */ _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__.M4),
+/* harmony export */   Mx: () => (/* reexport safe */ _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_3__.Mx),
+/* harmony export */   Nf: () => (/* reexport safe */ _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_3__.Nf),
+/* harmony export */   Pi: () => (/* reexport safe */ _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_3__.Pi),
+/* harmony export */   Qk: () => (/* reexport safe */ _labelmapEditTransaction__WEBPACK_IMPORTED_MODULE_5__.Qk),
+/* harmony export */   Ry: () => (/* reexport safe */ _labelmapEditTransaction__WEBPACK_IMPORTED_MODULE_5__.Ry),
+/* harmony export */   VQ: () => (/* reexport safe */ _labelmapEditTransaction__WEBPACK_IMPORTED_MODULE_5__.VQ),
+/* harmony export */   Zs: () => (/* reexport safe */ _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_3__.Zs),
+/* harmony export */   hM: () => (/* reexport safe */ _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_3__.hM),
+/* harmony export */   kL: () => (/* reexport safe */ _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__.kL),
+/* harmony export */   m: () => (/* reexport safe */ _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__.m),
+/* harmony export */   r: () => (/* reexport safe */ _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_3__.r),
+/* harmony export */   uk: () => (/* reexport safe */ _normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__.uk),
+/* harmony export */   xS: () => (/* reexport safe */ _labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_2__.x)
 /* harmony export */ });
-function filterMoveableAnnotationTools(element, ToolAndAnnotations, canvasCoords, interactionType = 'mouse') {
-    const proximity = interactionType === 'touch' ? 36 : 6;
-    const moveableAnnotationTools = [];
-    ToolAndAnnotations.forEach(({ tool, annotations }) => {
-        for (const annotation of annotations) {
-            if (annotation.isLocked || !annotation.isVisible) {
-                continue;
-            }
-            const near = tool.isPointNearTool(element, annotation, canvasCoords, proximity, interactionType);
-            if (near) {
-                moveableAnnotationTools.push({
-                    tool,
-                    annotation,
-                });
-                break;
-            }
-        }
-    });
-    return moveableAnnotationTools;
-}
+/* harmony import */ var _normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(830);
+/* harmony import */ var _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(80973);
+/* harmony import */ var _labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(91573);
+/* harmony import */ var _labelmapSegmentBindings__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7296);
+/* harmony import */ var _privateLabelmap__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(99380);
+/* harmony import */ var _labelmapEditTransaction__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(72759);
+/* harmony import */ var _labelmapImageReferenceResolver__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(62851);
+
+
 
 
-/***/ },
 
-/***/ 57725
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ filterToolsWithAnnotationsForElement)
-/* harmony export */ });
-/* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(82056);
 
-function filterToolsWithAnnotationsForElement(element, tools) {
-    const result = [];
-    for (let i = 0; i < tools.length; i++) {
-        const tool = tools[i];
-        if (!tool) {
-            console.warn('undefined tool in filterToolsWithAnnotationsForElement');
-            continue;
-        }
-        let annotations = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_0__.getAnnotations)(tool.constructor.toolName, element);
-        if (!annotations?.length) {
-            continue;
-        }
-        if (typeof tool.filterInteractableAnnotationsForElement === 'function') {
-            annotations = tool.filterInteractableAnnotationsForElement(element, annotations);
-        }
-        if (annotations?.length > 0) {
-            result.push({ tool, annotations });
-        }
-    }
-    return result;
-}
 
 
 /***/ },
 
-/***/ 35486
+/***/ 80973
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ filterToolsWithMoveableHandles)
+/* harmony export */   $n: () => (/* binding */ removeLabelmap),
+/* harmony export */   AD: () => (/* binding */ registerLabelmap),
+/* harmony export */   BS: () => (/* binding */ getLabelmapForVolumeId),
+/* harmony export */   Hs: () => (/* binding */ getLabelmap),
+/* harmony export */   M4: () => (/* binding */ getLabelmapForImageId),
+/* harmony export */   kL: () => (/* binding */ getOrCreateLabelmapVolume),
+/* harmony export */   m: () => (/* binding */ getLabelmaps)
 /* harmony export */ });
-function filterToolsWithMoveableHandles(element, ToolAndAnnotations, canvasCoords, interactionType = 'mouse') {
-    const proximity = interactionType === 'touch' ? 36 : 6;
-    const toolsWithMoveableHandles = [];
-    ToolAndAnnotations.forEach(({ tool, annotations }) => {
-        for (const annotation of annotations) {
-            if (annotation.isLocked || !annotation.isVisible) {
-                continue;
-            }
-            const handle = tool.getHandleNearImagePoint(element, annotation, canvasCoords, proximity);
-            if (handle) {
-                toolsWithMoveableHandles.push({
-                    tool,
-                    annotation,
-                    handle,
-                });
-                break;
-            }
-        }
-    });
+/* unused harmony exports getConstructorNameForLabelmap, getLabelmapDataById, getLabelmapIds, getScalarArrayLengthFromLabelmap */
+/* unused harmony import specifier */ var cache;
+/* unused harmony import specifier */ var ensureLabelmapState;
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(830);
+/* harmony import */ var _labelmapImageIdMapping__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(52133);
+
+
+
+function getLabelmap(segmentation, labelmapId) {
+    return (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_1__/* .ensureLabelmapState */ .uk)(segmentation)?.labelmaps?.[labelmapId];
+}
+function getLabelmaps(segmentation) {
+    const labelmapState = (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_1__/* .ensureLabelmapState */ .uk)(segmentation);
+    if (!labelmapState) {
+        return [];
+    }
+    return Object.values(labelmapState.labelmaps);
+}
+function registerLabelmap(segmentation, layer) {
+    const labelmapState = (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_1__/* .ensureLabelmapState */ .uk)(segmentation);
+    if (!labelmapState) {
+        return;
+    }
+    labelmapState.labelmaps[layer.labelmapId] = layer;
+}
+function removeLabelmap(segmentation, labelmapId) {
+    const labelmapState = (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_1__/* .ensureLabelmapState */ .uk)(segmentation);
+    if (!labelmapState) {
+        return;
+    }
+    const layer = labelmapState.labelmaps[labelmapId];
+    if (layer?.geometryVolumeId && _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(layer.geometryVolumeId)) {
+        _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.removeVolumeLoadObject(layer.geometryVolumeId);
+    }
+    delete labelmapState.labelmaps[labelmapId];
+}
+function getOrCreateLabelmapVolume(layer) {
+    const mergedVolume = getOrCreateMergedStackLabelmapVolume(layer);
+    if (mergedVolume) {
+        return mergedVolume;
+    }
+    const existingVolumeId = layer.volumeId ?? layer.geometryVolumeId;
+    if (existingVolumeId) {
+        const cachedVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(existingVolumeId);
+        if (cachedVolume) {
+            return cachedVolume;
+        }
+    }
+    const imageIds = layer.imageIds ?? [];
+    if (!imageIds.length) {
+        return;
+    }
+    const volumeId = layer.volumeId ?? layer.geometryVolumeId ?? `${layer.labelmapId}-geometry`;
+    if (!layer.volumeId) {
+        layer.geometryVolumeId = volumeId;
+    }
+    const cachedVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+    if (cachedVolume) {
+        return cachedVolume;
+    }
+    return _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, imageIds);
+}
+function getOrCreateMergedStackLabelmapVolume(layer) {
+    if (layer.volumeId || !hasDuplicateReferencedImageIds(layer)) {
+        return;
+    }
+    const volumeId = layer.geometryVolumeId ?? `${layer.labelmapId}-geometry`;
+    const cachedVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+    if (cachedVolume) {
+        return cachedVolume;
+    }
+    const imageIdsByReferencedImageId = new Map();
+    (0,_labelmapImageIdMapping__WEBPACK_IMPORTED_MODULE_2__/* .forEachLabelmapImageReference */ .Zd)(layer, (referencedImageId, imageId) => {
+        const imageIdsForReference = imageIdsByReferencedImageId.get(referencedImageId) ?? [];
+        imageIdsForReference.push(imageId);
+        imageIdsByReferencedImageId.set(referencedImageId, imageIdsForReference);
+    });
+    const mergedReferencedImageIds = Array.from(imageIdsByReferencedImageId.keys());
+    if (!mergedReferencedImageIds.length) {
+        return;
+    }
+    let mergedImageIndex = 0;
+    const mergedImages = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.imageLoader.createAndCacheDerivedImages(mergedReferencedImageIds, {
+        getDerivedImageId: () => `${volumeId}-image-${mergedImageIndex++}`,
+        targetBuffer: { type: 'Uint8Array' },
+    });
+    mergedImages.forEach((mergedImage) => {
+        const sourceImageIds = imageIdsByReferencedImageId.get(mergedImage.referencedImageId);
+        if (!sourceImageIds?.length) {
+            return;
+        }
+        const targetVoxelManager = mergedImage.voxelManager;
+        const scalarDataLength = targetVoxelManager.getScalarDataLength();
+        sourceImageIds.forEach((sourceImageId) => {
+            const sourceImage = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(sourceImageId);
+            const sourceVoxelManager = sourceImage?.voxelManager;
+            if (!sourceVoxelManager) {
+                return;
+            }
+            const sourceScalarDataLength = sourceVoxelManager.getScalarDataLength();
+            const length = Math.min(scalarDataLength, sourceScalarDataLength);
+            for (let index = 0; index < length; index++) {
+                const value = Number(sourceVoxelManager.getAtIndex(index));
+                if (value !== 0) {
+                    targetVoxelManager.setAtIndex(index, value);
+                }
+            }
+        });
+    });
+    layer.geometryVolumeId = volumeId;
+    return _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, mergedImages.map((image) => image.imageId));
+}
+function hasDuplicateReferencedImageIds(layer) {
+    return (0,_labelmapImageIdMapping__WEBPACK_IMPORTED_MODULE_2__/* .hasMultipleLabelmapImagesPerReferencedImageId */ .dm)(layer);
+}
+function getLabelmapIds(segmentation) {
+    return getLabelmaps(segmentation).map((layer) => layer.labelmapId);
+}
+function getLabelmapDataById(segmentation, labelmapId) {
+    const labelmapState = ensureLabelmapState(segmentation);
+    const layer = labelmapState?.labelmaps?.[labelmapId];
+    if (!labelmapState || !layer) {
+        return;
+    }
+    return {
+        volumeId: layer.volumeId,
+        referencedVolumeId: layer.referencedVolumeId,
+        imageIds: layer.imageIds,
+        referencedImageIds: layer.referencedImageIds,
+        sourceRepresentationName: labelmapState.sourceRepresentationName,
+        primaryLabelmapId: labelmapId,
+        labelmaps: {
+            [labelmapId]: layer,
+        },
+        segmentBindings: Object.fromEntries(Object.entries(labelmapState.segmentBindings).filter(([, binding]) => binding.labelmapId === labelmapId)),
+    };
+}
+function getScalarArrayLengthFromLabelmap(layer) {
+    if (layer.volumeId) {
+        return cache.getVolume(layer.volumeId)?.voxelManager?.getScalarDataLength();
+    }
+    const firstImageId = layer.imageIds?.[0];
+    const firstImage = firstImageId ? cache.getImage(firstImageId) : null;
+    if (!firstImage || !layer.imageIds?.length) {
+        return 0;
+    }
+    return firstImage.voxelManager.getScalarDataLength() * layer.imageIds.length;
+}
+function getConstructorNameForLabelmap(layer) {
+    if (layer.volumeId) {
+        return cache.getVolume(layer.volumeId)?.voxelManager?.getConstructor()
+            ?.name;
+    }
+    const imageId = layer.imageIds?.[0];
+    return imageId
+        ? cache.getImage(imageId)?.voxelManager?.getConstructor()?.name
+        : undefined;
+}
+function getLabelmapForImageId(segmentation, imageId) {
+    return getLabelmaps(segmentation).find((layer) => layer.imageIds?.includes(imageId));
+}
+function getLabelmapForVolumeId(segmentation, volumeId) {
+    return getLabelmaps(segmentation).find((layer) => layer.volumeId === volumeId || layer.geometryVolumeId === volumeId);
+}
+
+
+
+/***/ },
+
+/***/ 7296
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   I3: () => (/* binding */ getSegmentsOnLabelmap),
+/* harmony export */   Mx: () => (/* binding */ getSegmentIndexForLabelValue),
+/* harmony export */   Nf: () => (/* binding */ resolveLabelmapForSegment),
+/* harmony export */   Pi: () => (/* binding */ removeSegmentBinding),
+/* harmony export */   Zs: () => (/* binding */ setSegmentBinding),
+/* harmony export */   hM: () => (/* binding */ getSegmentBinding),
+/* harmony export */   r: () => (/* binding */ getLabelmapForSegment)
+/* harmony export */ });
+/* unused harmony export getLabelValueForSegment */
+/* harmony import */ var _normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(830);
+/* harmony import */ var _labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(80973);
+/* harmony import */ var _labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(91573);
+
+
+
+function getSegmentBinding(segmentation, segmentIndex) {
+    return (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__/* .ensureLabelmapState */ .uk)(segmentation)?.segmentBindings?.[segmentIndex];
+}
+function setSegmentBinding(segmentation, segmentIndex, binding) {
+    const labelmapState = (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__/* .ensureLabelmapState */ .uk)(segmentation);
+    if (!labelmapState) {
+        return;
+    }
+    const previousBinding = labelmapState.segmentBindings[segmentIndex];
+    if (previousBinding) {
+        const previousLayer = labelmapState.labelmaps[previousBinding.labelmapId];
+        if (previousLayer?.labelToSegmentIndex) {
+            delete previousLayer.labelToSegmentIndex[previousBinding.labelValue];
+        }
+    }
+    labelmapState.segmentBindings[segmentIndex] = binding;
+    const layer = labelmapState.labelmaps[binding.labelmapId];
+    if (layer) {
+        layer.labelToSegmentIndex ||= {};
+        layer.labelToSegmentIndex[binding.labelValue] = segmentIndex;
+    }
+}
+function getSegmentsOnLabelmap(segmentation, labelmapId) {
+    const labelmapState = (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__/* .ensureLabelmapState */ .uk)(segmentation);
+    if (!labelmapState) {
+        return [];
+    }
+    return Object.entries(labelmapState.segmentBindings)
+        .filter(([, binding]) => binding.labelmapId === labelmapId)
+        .map(([segmentIndex]) => Number(segmentIndex))
+        .sort((a, b) => a - b);
+}
+function getSegmentIndexForLabelValue(segmentation, labelmapId, labelValue) {
+    const layer = (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getLabelmap */ .Hs)(segmentation, labelmapId);
+    if (!layer || labelValue == null) {
+        return;
+    }
+    return layer.labelToSegmentIndex?.[labelValue] ?? labelValue;
+}
+function getLabelValueForSegment(segmentation, segmentIndex) {
+    return (getSegmentBinding(segmentation, segmentIndex)?.labelValue ?? segmentIndex);
+}
+function getLabelmapForSegment(segmentation, segmentIndex) {
+    const binding = getSegmentBinding(segmentation, segmentIndex);
+    if (!binding) {
+        return;
+    }
+    return (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getLabelmap */ .Hs)(segmentation, binding.labelmapId);
+}
+function resolveLabelmapForSegment(segmentation, segmentIndex) {
+    return (getLabelmapForSegment(segmentation, segmentIndex) ??
+        (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .getLabelmaps */ .m)(segmentation)[0]);
+}
+function removeSegmentBinding(segmentation, segmentIndex) {
+    const labelmapState = (0,_normalizeLabelmapSegmentationData__WEBPACK_IMPORTED_MODULE_0__/* .ensureLabelmapState */ .uk)(segmentation);
+    const binding = labelmapState?.segmentBindings?.[segmentIndex];
+    if (!labelmapState || !binding) {
+        return;
+    }
+    const layer = labelmapState.labelmaps[binding.labelmapId];
+    if (layer?.labelToSegmentIndex) {
+        delete layer.labelToSegmentIndex[binding.labelValue];
+    }
+    delete labelmapState.segmentBindings[segmentIndex];
+    if (getSegmentsOnLabelmap(segmentation, binding.labelmapId).length === 0) {
+        (0,_labelmapLayerStore__WEBPACK_IMPORTED_MODULE_1__/* .removeLabelmap */ .$n)(segmentation, binding.labelmapId);
+    }
+    (0,_labelmapLegacyAdapter__WEBPACK_IMPORTED_MODULE_2__/* .syncLegacyLabelmapData */ .x)(segmentation);
+}
+
+
+
+/***/ },
+
+/***/ 25972
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ filterMoveableAnnotationTools)
+/* harmony export */ });
+function filterMoveableAnnotationTools(element, ToolAndAnnotations, canvasCoords, interactionType = 'mouse') {
+    const proximity = interactionType === 'touch' ? 36 : 6;
+    const moveableAnnotationTools = [];
+    ToolAndAnnotations.forEach(({ tool, annotations }) => {
+        for (const annotation of annotations) {
+            if (annotation.isLocked || !annotation.isVisible) {
+                continue;
+            }
+            const near = tool.isPointNearTool(element, annotation, canvasCoords, proximity, interactionType);
+            if (near) {
+                moveableAnnotationTools.push({
+                    tool,
+                    annotation,
+                });
+                break;
+            }
+        }
+    });
+    return moveableAnnotationTools;
+}
+
+
+/***/ },
+
+/***/ 57725
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ filterToolsWithAnnotationsForElement)
+/* harmony export */ });
+/* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(82056);
+
+function filterToolsWithAnnotationsForElement(element, tools) {
+    const result = [];
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        if (!tool) {
+            console.warn('undefined tool in filterToolsWithAnnotationsForElement');
+            continue;
+        }
+        let annotations = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_0__.getAnnotations)(tool.constructor.toolName, element);
+        if (!annotations?.length) {
+            continue;
+        }
+        if (typeof tool.filterInteractableAnnotationsForElement === 'function') {
+            annotations = tool.filterInteractableAnnotationsForElement(element, annotations);
+        }
+        if (annotations?.length > 0) {
+            result.push({ tool, annotations });
+        }
+    }
+    return result;
+}
+
+
+/***/ },
+
+/***/ 35486
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ filterToolsWithMoveableHandles)
+/* harmony export */ });
+function filterToolsWithMoveableHandles(element, ToolAndAnnotations, canvasCoords, interactionType = 'mouse') {
+    const proximity = interactionType === 'touch' ? 36 : 6;
+    const toolsWithMoveableHandles = [];
+    ToolAndAnnotations.forEach(({ tool, annotations }) => {
+        for (const annotation of annotations) {
+            if (annotation.isLocked || !annotation.isVisible) {
+                continue;
+            }
+            const handle = tool.getHandleNearImagePoint(element, annotation, canvasCoords, proximity);
+            if (handle) {
+                toolsWithMoveableHandles.push({
+                    tool,
+                    annotation,
+                    handle,
+                });
+                break;
+            }
+        }
+    });
     return toolsWithMoveableHandles;
 }
 
@@ -2079,7 +2830,6 @@ class CircleSculptCursor {
             maxToolSize: null,
         };
     }
-    static { this.shapeName = 'Circle'; }
     renderShape(svgDrawingHelper, canvasLocation, options) {
         const circleUID = '0';
         (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_3__.drawCircle)(svgDrawingHelper, 'SculptorTool', circleUID, canvasLocation, this.toolInfo.toolSize, options);
@@ -2142,6 +2892,7 @@ class CircleSculptCursor {
         return gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.distance */ .eR.distance(point, mousePoint) < this.toolInfo.radius;
     }
 }
+CircleSculptCursor.shapeName = 'Circle';
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (CircleSculptCursor);
 
 
@@ -2176,7 +2927,6 @@ class CircleSculptCursor {
 
 const { transformWorldToIndex, transformIndexToWorld } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
 class GrowCutBaseTool extends _base__WEBPACK_IMPORTED_MODULE_1__/* .BaseTool */ .oS {
-    static { this.lastGrowCutCommand = null; }
     constructor(toolProps, defaultToolProps) {
         const baseToolProps = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepMerge({
             configuration: {
@@ -2354,96 +3104,2128 @@ class GrowCutBaseTool extends _base__WEBPACK_IMPORTED_MODULE_1__/* .BaseTool */
                 ? imageVolume.volumeId
                 : (await _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, referencedImageIds)).volumeId;
         }
-        return {
-            segmentationId,
-            segmentIndex,
-            labelmapVolumeId,
-            referencedVolumeId,
-        };
+        return {
+            segmentationId,
+            segmentIndex,
+            labelmapVolumeId,
+            referencedVolumeId,
+        };
+    }
+    _createFakeVolume(imageIds) {
+        const volumeId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.generateVolumeId(imageIds);
+        const cachedVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+        if (cachedVolume) {
+            return cachedVolume;
+        }
+        const volumeProps = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.generateVolumePropsFromImageIds(imageIds, volumeId);
+        const spacing = volumeProps.spacing;
+        if (spacing[2] === 0) {
+            spacing[2] = 1;
+        }
+        const derivedVolume = new _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.ImageVolume({
+            volumeId,
+            dataType: volumeProps.dataType,
+            metadata: _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepClone(volumeProps.metadata),
+            dimensions: volumeProps.dimensions,
+            spacing: volumeProps.spacing,
+            origin: volumeProps.origin,
+            direction: volumeProps.direction,
+            referencedVolumeId: volumeProps.referencedVolumeId,
+            imageIds: volumeProps.imageIds,
+            referencedImageIds: volumeProps.referencedImageIds,
+        });
+        _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.putVolumeSync(volumeId, derivedVolume);
+        return derivedVolume;
+    }
+    _isOrthogonalView(viewport, referencedVolumeId) {
+        const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(referencedVolumeId);
+        const volumeImageData = volume.imageData;
+        const camera = viewport.getCamera();
+        const { ijkVecColDir, ijkVecSliceDir } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getVolumeDirectionVectors(volumeImageData, camera);
+        return [ijkVecColDir, ijkVecSliceDir].every((vec) => _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[0]), 1) ||
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[1]), 1) ||
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[2]), 1));
+    }
+    getRemoveIslandData(_growCutData) {
+        return;
+    }
+    _removeIslands(growCutData) {
+        const { islandRemoval: config } = this.configuration;
+        if (!config.enabled) {
+            return;
+        }
+        const { segmentation: { segmentIndex, labelmapVolumeId }, renderingEngineId, viewportId, } = growCutData;
+        const labelmap = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(labelmapVolumeId);
+        const removeIslandData = this.getRemoveIslandData(growCutData);
+        if (!removeIslandData) {
+            return;
+        }
+        const [width, height] = labelmap.dimensions;
+        const numPixelsPerSlice = width * height;
+        const { worldIslandPoints = [], islandPointIndexes = [] } = removeIslandData;
+        let ijkIslandPoints = [...(removeIslandData?.ijkIslandPoints ?? [])];
+        const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getRenderingEngine)(renderingEngineId);
+        const viewport = renderingEngine.getViewport(viewportId);
+        const { voxelManager } = labelmap;
+        const islandRemoval = new _utilities_segmentation_islandRemoval__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A();
+        ijkIslandPoints = ijkIslandPoints.concat(worldIslandPoints.map((worldPoint) => transformWorldToIndex(labelmap.imageData, worldPoint)));
+        ijkIslandPoints = ijkIslandPoints.concat(islandPointIndexes.map((pointIndex) => {
+            const x = pointIndex % width;
+            const y = Math.floor(pointIndex / width) % height;
+            const z = Math.floor(pointIndex / numPixelsPerSlice);
+            return [x, y, z];
+        }));
+        islandRemoval.initialize(viewport, voxelManager, {
+            points: ijkIslandPoints,
+            previewSegmentIndex: segmentIndex,
+            segmentIndex,
+        });
+        islandRemoval.floodFillSegmentIsland();
+        islandRemoval.removeExternalIslands();
+        islandRemoval.removeInternalIslands();
+    }
+    getSegmentStyle({ segmentationId, viewportId, segmentIndex }) {
+        return (0,_utilities_segmentation_getSVGStyleForSegment__WEBPACK_IMPORTED_MODULE_6__/* .getSVGStyleForSegment */ .u)({
+            segmentationId,
+            segmentIndex,
+            viewportId,
+        });
+    }
+}
+GrowCutBaseTool.lastGrowCutCommand = null;
+GrowCutBaseTool.toolName = 'GrowCutBaseTool';
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (GrowCutBaseTool);
+
+
+/***/ },
+
+/***/ 92300
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  A: () => (/* binding */ contourDisplay)
+});
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(15327);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/SegmentationRepresentations.js
+var SegmentationRepresentations = __webpack_require__(18682);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationState.js
+var annotationState = __webpack_require__(82056);
+// 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/contourSegmentation/index.js + 1 modules
+var contourSegmentation = __webpack_require__(56534);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/CellArray.js
+var CellArray = __webpack_require__(32461);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Points.js
+var Points = __webpack_require__(74973);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourHandler/utils.js
+/* unused harmony import specifier */ var Enums;
+/* unused harmony import specifier */ var vtkCellArray;
+/* unused harmony import specifier */ var vtkPoints;
+/* unused harmony import specifier */ var vtkPolyData;
+
+
+
+
+function validateGeometry(geometry) {
+    if (!geometry) {
+        throw new Error(`No contours found for geometryId ${geometry.id}`);
+    }
+    const geometryId = geometry.id;
+    if (geometry.type !== esm.Enums.GeometryType.CONTOUR) {
+        throw new Error(`Geometry type ${geometry.type} not supported for rendering.`);
+    }
+    if (!geometry.data) {
+        console.warn(`No contours found for geometryId ${geometryId}. Skipping render.`);
+        return;
+    }
+}
+function getPolyData(contourSet) {
+    const pointArray = [];
+    const points = vtkPoints.newInstance();
+    const lines = vtkCellArray.newInstance();
+    let pointIndex = 0;
+    contourSet.contours.forEach((contour) => {
+        const pointList = contour.points;
+        const flatPoints = contour.flatPointsArray;
+        const type = contour.type;
+        const pointIndexes = pointList.map((_, pointListIndex) => pointListIndex + pointIndex);
+        if (type === Enums.ContourType.CLOSED_PLANAR) {
+            pointIndexes.push(pointIndexes[0]);
+        }
+        const linePoints = Float32Array.from(flatPoints);
+        pointArray.push(...linePoints);
+        lines.insertNextCell([...pointIndexes]);
+        pointIndex = pointIndex + pointList.length;
+    });
+    points.setData(pointArray, 3);
+    const polygon = vtkPolyData.newInstance();
+    polygon.setPoints(points);
+    polygon.setLines(lines);
+    return polygon;
+}
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 3 modules
+var enums = __webpack_require__(29857);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/SegmentationStyle.js
+var SegmentationStyle = __webpack_require__(92686);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.js
+
+
+
+
+
+
+
+function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
+    if (annotationUIDsMap.size) {
+        viewport.render();
+    }
+    else {
+        addContourSetsToElement(viewport, geometryIds, contourRepresentation);
+    }
+}
+function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
+    const { segmentationId } = contourRepresentation;
+    const segmentSpecificMap = new Map();
+    geometryIds.forEach((geometryId) => {
+        const geometry = esm.cache.getGeometry(geometryId);
+        if (!geometry) {
+            console.warn(`No geometry found for geometryId ${geometryId}. Skipping render.`);
+            return;
+        }
+        const segmentIndex = geometry.data.segmentIndex;
+        validateGeometry(geometry);
+        const segmentSpecificConfig = SegmentationStyle/* segmentationStyle */.Y.getStyle({
+            viewportId: viewport.id,
+            segmentationId,
+            type: enums.SegmentationRepresentations.Contour,
+            segmentIndex,
+        });
+        const contourSet = geometry.data;
+        const viewPlaneNormal = viewport.getCamera().viewPlaneNormal;
+        contourSet.contours.forEach((contour) => {
+            const { points, color, id } = contour;
+            const referencedImageId = (0,annotationHydration/* getClosestImageIdForStackViewport */.x)(viewport, points[0], viewPlaneNormal);
+            const contourSegmentationAnnotation = {
+                annotationUID: esm.utilities.uuidv4(),
+                data: {
+                    contour: {
+                        closed: true,
+                        polyline: points,
+                    },
+                    segmentation: {
+                        segmentationId,
+                        segmentIndex,
+                        color,
+                        id,
+                    },
+                    handles: {},
+                },
+                handles: {},
+                highlighted: false,
+                autoGenerated: false,
+                invalidated: false,
+                isLocked: true,
+                isVisible: true,
+                metadata: {
+                    referencedImageId,
+                    toolName: 'PlanarFreehandContourSegmentationTool',
+                    FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+                    viewPlaneNormal: viewport.getCamera().viewPlaneNormal,
+                },
+            };
+            const annotationGroupSelector = viewport.element;
+            (0,annotationState.addAnnotation)(contourSegmentationAnnotation, annotationGroupSelector);
+            (0,contourSegmentation.addContourSegmentationAnnotation)(contourSegmentationAnnotation);
+        });
+        if (segmentSpecificConfig) {
+            segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
+        }
+    });
+    viewport.render();
+}
+
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
+var getSegmentation = __webpack_require__(33283);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/index.js
+var stateManagement = __webpack_require__(6802);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/removeContourFromElement.js
+/* unused harmony import specifier */ var removeContourFromElement_getSegmentation;
+/* unused harmony import specifier */ var removeAnnotation;
+
+
+function removeContourFromElement(viewportId, segmentationId, removeFromCache = false) {
+    const segmentation = removeContourFromElement_getSegmentation(segmentationId);
+    const { annotationUIDsMap } = segmentation.representationData.Contour;
+    annotationUIDsMap.forEach((annotationSet) => {
+        annotationSet.forEach((annotationUID) => {
+            removeAnnotation(annotationUID);
+        });
+    });
+}
+/* harmony default export */ const Contour_removeContourFromElement = ((/* unused pure expression or super */ null && (removeContourFromElement)));
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/config.js
+var config = __webpack_require__(36625);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/computeAndAddRepresentation.js
+var computeAndAddRepresentation = __webpack_require__(27479);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/getUniqueSegmentIndices.js
+var getUniqueSegmentIndices = __webpack_require__(25758);
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
+var gl_matrix_esm = __webpack_require__(3823);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourDisplay.js
+
+
+
+
+
+
+
+
+
+
+const polySegConversionInProgressForViewportId = new Map();
+const processedViewportSegmentations = new Map();
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
+    const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    if (!renderImmediate) {
+        return;
+    }
+    viewport.render();
+}
+async function render(viewport, contourRepresentation) {
+    const { segmentationId } = contourRepresentation;
+    const segmentation = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    let contourData = segmentation.representationData[SegmentationRepresentations/* default */.A.Contour];
+    const polySeg = (0,config/* getPolySeg */.Qy)();
+    if (!contourData &&
+        (0,config/* getPolySeg */.Qy)()?.canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations/* default */.A.Contour) &&
+        !polySegConversionInProgressForViewportId.get(viewport.id)) {
+        polySegConversionInProgressForViewportId.set(viewport.id, true);
+        try {
+            contourData = await (0,computeAndAddRepresentation/* computeAndAddRepresentation */.d)(segmentationId, SegmentationRepresentations/* default */.A.Contour, () => polySeg.computeContourData(segmentationId, { viewport }));
+        }
+        catch (error) {
+            console.warn('Unable to compute contour data for segmentationId', segmentationId, error);
+        }
+        polySegConversionInProgressForViewportId.set(viewport.id, false);
+    }
+    else if (!contourData && !(0,config/* getPolySeg */.Qy)()) {
+        console.debug(`No contour data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to contour. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
+    }
+    if (!contourData) {
+        return;
+    }
+    if (!contourData.geometryIds?.length) {
+        return;
+    }
+    let hasContourDataButNotMatchingViewport = false;
+    const viewportNormal = viewport.getCamera().viewPlaneNormal;
+    if (contourData.annotationUIDsMap) {
+        hasContourDataButNotMatchingViewport = !_checkContourNormalsMatchViewport(contourData.annotationUIDsMap, viewportNormal);
+    }
+    if (contourData.geometryIds.length > 0) {
+        hasContourDataButNotMatchingViewport = !_checkContourGeometryMatchViewport(contourData.geometryIds, viewportNormal);
+    }
+    const viewportProcessed = processedViewportSegmentations.get(viewport.id) || new Set();
+    if (hasContourDataButNotMatchingViewport &&
+        !polySegConversionInProgressForViewportId.get(viewport.id) &&
+        !viewportProcessed.has(segmentationId) &&
+        viewport.viewportStatus === esm.Enums.ViewportStatus.RENDERED) {
+        polySegConversionInProgressForViewportId.set(viewport.id, true);
+        const segmentIndices = (0,getUniqueSegmentIndices/* getUniqueSegmentIndices */.O)(segmentationId);
+        const surfacesInfo = await polySeg.computeSurfaceData(segmentationId, {
+            segmentIndices,
+            viewport,
+        });
+        const geometryIds = surfacesInfo.geometryIds;
+        const pointsAndPolys = [];
+        for (const geometryId of geometryIds.values()) {
+            const geometry = esm.cache.getGeometry(geometryId);
+            const data = geometry.data;
+            pointsAndPolys.push({
+                points: data.points,
+                polys: data.polys,
+                segmentIndex: data.segmentIndex,
+                id: data.segmentIndex,
+            });
+        }
+        const polyDataCache = await polySeg.clipAndCacheSurfacesForViewport(pointsAndPolys, viewport);
+        const rawResults = polySeg.extractContourData(polyDataCache);
+        const annotationUIDsMap = polySeg.createAndAddContourSegmentationsFromClippedSurfaces(rawResults, viewport, segmentationId);
+        contourData.annotationUIDsMap = new Map([
+            ...contourData.annotationUIDsMap,
+            ...annotationUIDsMap,
+        ]);
+        viewportProcessed.add(segmentationId);
+        processedViewportSegmentations.set(viewport.id, viewportProcessed);
+        polySegConversionInProgressForViewportId.set(viewport.id, false);
+    }
+    handleContourSegmentation(viewport, contourData.geometryIds, contourData.annotationUIDsMap, contourRepresentation);
+}
+function _checkContourGeometryMatchViewport(geometryIds, viewportNormal) {
+    let validGeometry = null;
+    let geometryData = null;
+    for (const geometryId of geometryIds) {
+        const geometry = esm.cache.getGeometry(geometryId);
+        if (!geometry) {
+            continue;
+        }
+        const data = geometry.data;
+        if (data.contours?.[0]?.points?.length >= 3) {
+            validGeometry = geometry;
+            geometryData = data;
+            break;
+        }
+    }
+    if (!validGeometry || !geometryData) {
+        return false;
+    }
+    const contours = geometryData.contours;
+    const { points } = contours[0];
+    const [point] = points;
+    const delta = gl_matrix_esm/* vec3.create */.eR.create();
+    const { length } = points;
+    const increment = Math.ceil(length / 25);
+    for (let i = 1; i < length; i += increment) {
+        const point2 = points[i];
+        gl_matrix_esm/* vec3.sub */.eR.sub(delta, point, point2);
+        gl_matrix_esm/* vec3.normalize */.eR.normalize(delta, delta);
+        if (gl_matrix_esm/* vec3.dot */.eR.dot(viewportNormal, delta) > 0.1) {
+            return false;
+        }
+    }
+    return true;
+}
+function _checkContourNormalsMatchViewport(annotationUIDsMap, viewportNormal) {
+    const annotationUIDs = Array.from(annotationUIDsMap.values())
+        .flat()
+        .map((uidSet) => Array.from(uidSet))
+        .flat();
+    const randomAnnotationUIDs = esm.utilities.getRandomSampleFromArray(annotationUIDs, 3);
+    for (const annotationUID of randomAnnotationUIDs) {
+        const annotation = (0,annotationState.getAnnotation)(annotationUID);
+        if (annotation?.metadata) {
+            if (!annotation.metadata.viewPlaneNormal) {
+                continue;
+            }
+            const annotationNormal = annotation.metadata.viewPlaneNormal;
+            const dotProduct = Math.abs(viewportNormal[0] * annotationNormal[0] +
+                viewportNormal[1] * annotationNormal[1] +
+                viewportNormal[2] * annotationNormal[2]);
+            if (Math.abs(dotProduct - 1) > 0.01) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function getUpdateFunction(viewport) {
+    return null;
+}
+/* harmony default export */ const contourDisplay = ({
+    getUpdateFunction,
+    render,
+    removeRepresentation,
+});
+
+
+/***/ },
+
+/***/ 21924
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Ay: () => (/* binding */ labelmapDisplay)
+});
+
+// UNUSED EXPORTS: MAX_NUMBER_COLORS, removeRepresentation, render
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(15327);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
+var getSegmentation = __webpack_require__(33283);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/SegmentationRepresentations.js
+var SegmentationRepresentations = __webpack_require__(18682);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/getSegmentationActor.js
+var getSegmentationActor = __webpack_require__(59452);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/config.js
+var config = __webpack_require__(36625);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/computeAndAddRepresentation.js
+var computeAndAddRepresentation = __webpack_require__(27479);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js
+var triggerSegmentationEvents = __webpack_require__(49906);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/SegmentationStateManager.js
+var SegmentationStateManager = __webpack_require__(59475);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/removeLabelmapRepresentationData.js
+var removeLabelmapRepresentationData = __webpack_require__(24393);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ImageMapper.js
+var ImageMapper = __webpack_require__(23549);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ImageSlice.js
+var ImageSlice = __webpack_require__(94848);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/labelmapImageMapperSupport.js
+var labelmapImageMapperSupport = __webpack_require__(78028);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/labelmapSegmentationState.js
+var labelmapSegmentationState = __webpack_require__(90660);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRepresentationUID.js
+var labelmapRepresentationUID = __webpack_require__(5959);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray.js
+var DataArray = __webpack_require__(445);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/ImageData.js
+var ImageData = __webpack_require__(26393);
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
+var gl_matrix_esm = __webpack_require__(3823);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/volumeLabelmapSliceData.js
+
+
+
+
+
+
+const PLANAR_OVERLAY_DEPTH_EPSILON = 1e-4;
+function applyPlanarOverlayDepthOffset(actor, viewPlaneNormal, overlayOrder) {
+    if (overlayOrder <= 0) {
+        actor.setPosition(0, 0, 0);
+        return;
+    }
+    const [x, y, z] = gl_matrix_esm/* vec3.normalize */.eR.normalize(gl_matrix_esm/* vec3.create */.eR.create(), viewPlaneNormal);
+    const offset = overlayOrder * PLANAR_OVERLAY_DEPTH_EPSILON;
+    actor.setPosition(x * offset, y * offset, z * offset);
+}
+function matchAxis(vector, axes) {
+    let bestAxis = -1;
+    let bestDot = 0;
+    axes.forEach((axisVector, axis) => {
+        const dot = gl_matrix_esm/* vec3.dot */.eR.dot(vector, axisVector);
+        if (Math.abs(dot) > Math.abs(bestDot)) {
+            bestAxis = axis;
+            bestDot = dot;
+        }
+    });
+    if (bestAxis === -1 || Math.abs(bestDot) < labelmapImageMapperSupport/* DIRECTION_ALIGNMENT_TOLERANCE */.KM) {
+        return;
+    }
+    return {
+        axis: bestAxis,
+        sign: bestDot >= 0 ? 1 : -1,
+    };
+}
+function getSliceRenderingCamera(viewport) {
+    const resolvedCamera = viewport.getResolvedView?.()?.toICamera?.();
+    const normalizedResolvedCamera = normalizeSliceRenderingCamera(resolvedCamera);
+    if (normalizedResolvedCamera) {
+        return normalizedResolvedCamera;
+    }
+    const legacyCamera = viewport.getCamera?.();
+    const normalizedLegacyCamera = normalizeSliceRenderingCamera(legacyCamera);
+    return normalizedLegacyCamera;
+}
+function normalizeSliceRenderingCamera(camera) {
+    const candidate = camera;
+    const focalPoint = toPoint3(candidate?.focalPoint);
+    const viewPlaneNormal = toPoint3(candidate?.viewPlaneNormal);
+    const viewUp = toPoint3(candidate?.viewUp);
+    if (!focalPoint || !viewPlaneNormal || !viewUp) {
+        return;
+    }
+    return {
+        focalPoint,
+        viewPlaneNormal,
+        viewUp,
+    };
+}
+function toPoint3(value) {
+    const candidate = value;
+    if (!candidate || typeof candidate.length !== 'number') {
+        return;
+    }
+    if (candidate.length < 3) {
+        return;
+    }
+    const point = [
+        Number(candidate[0]),
+        Number(candidate[1]),
+        Number(candidate[2]),
+    ];
+    return point.every(Number.isFinite) ? point : undefined;
+}
+function getVolumeAxes(volume) {
+    const { direction } = volume;
+    return [
+        [direction[0], direction[1], direction[2]],
+        [direction[3], direction[4], direction[5]],
+        [direction[6], direction[7], direction[8]],
+    ];
+}
+function getSliceState(viewport, volume) {
+    const camera = getSliceRenderingCamera(viewport);
+    if (!camera) {
+        return;
+    }
+    const { viewPlaneNormal, viewUp, focalPoint } = camera;
+    const xDirection = gl_matrix_esm/* vec3.normalize */.eR.normalize(gl_matrix_esm/* vec3.create */.eR.create(), gl_matrix_esm/* vec3.cross */.eR.cross(gl_matrix_esm/* vec3.create */.eR.create(), viewPlaneNormal, viewUp));
+    const yDirection = gl_matrix_esm/* vec3.normalize */.eR.normalize(gl_matrix_esm/* vec3.create */.eR.create(), viewUp);
+    const axes = getVolumeAxes(volume);
+    const xAxis = matchAxis(xDirection, axes);
+    const yAxis = matchAxis(yDirection, axes);
+    const sliceAxis = matchAxis(viewPlaneNormal, axes);
+    if (!xAxis || !yAxis || !sliceAxis) {
+        return;
+    }
+    const distinctAxes = new Set([xAxis.axis, yAxis.axis, sliceAxis.axis]);
+    if (distinctAxes.size !== 3) {
+        return;
+    }
+    const continuousIndex = esm.utilities.transformWorldToIndexContinuous(volume.imageData, focalPoint);
+    const sliceIndex = Math.floor(continuousIndex[sliceAxis.axis] + 0.5 - 1e-6);
+    if (sliceIndex < 0 || sliceIndex >= volume.dimensions[sliceAxis.axis]) {
+        return;
+    }
+    return {
+        key: [
+            sliceAxis.axis,
+            sliceIndex,
+            xAxis.axis,
+            xAxis.sign,
+            yAxis.axis,
+            yAxis.sign,
+        ].join(':'),
+        xAxis: xAxis.axis,
+        xSign: xAxis.sign,
+        yAxis: yAxis.axis,
+        ySign: yAxis.sign,
+        sliceAxis: sliceAxis.axis,
+        sliceIndex,
+    };
+}
+function createSliceImageData(volume, viewport) {
+    const state = getSliceState(viewport, volume);
+    if (!state) {
+        return;
+    }
+    const axisVectors = getVolumeAxes(volume);
+    const { dimensions, spacing, voxelManager } = volume;
+    const width = dimensions[state.xAxis];
+    const height = dimensions[state.yAxis];
+    const SliceDataConstructor = voxelManager.getConstructor();
+    const pixelData = new SliceDataConstructor(width * height);
+    const ijk = [0, 0, 0];
+    ijk[state.sliceAxis] = state.sliceIndex;
+    const xStart = state.xSign > 0 ? 0 : width - 1;
+    const xStep = state.xSign > 0 ? 1 : -1;
+    const yStart = state.ySign > 0 ? 0 : height - 1;
+    const yStep = state.ySign > 0 ? 1 : -1;
+    for (let y = 0, srcY = yStart; y < height; y++, srcY += yStep) {
+        ijk[state.yAxis] = srcY;
+        const rowOffset = y * width;
+        for (let x = 0, srcX = xStart; x < width; x++, srcX += xStep) {
+            ijk[state.xAxis] = srcX;
+            pixelData[rowOffset + x] = Number(voxelManager.getAtIJK(ijk[0], ijk[1], ijk[2]));
+        }
+    }
+    const originIndex = [0, 0, 0];
+    originIndex[state.sliceAxis] = state.sliceIndex;
+    originIndex[state.xAxis] = state.xSign > 0 ? 0 : width - 1;
+    originIndex[state.yAxis] = state.ySign > 0 ? 0 : height - 1;
+    const xDirection = axisVectors[state.xAxis].map((value) => value * state.xSign);
+    const yDirection = axisVectors[state.yAxis].map((value) => value * state.ySign);
+    const camera = getSliceRenderingCamera(viewport);
+    if (!camera) {
+        return;
+    }
+    const zDirection = gl_matrix_esm/* vec3.normalize */.eR.normalize(gl_matrix_esm/* vec3.create */.eR.create(), camera.viewPlaneNormal);
+    const dataType = DataArray/* default */.Ay.getDataType(pixelData);
+    const scalarArray = DataArray/* default.newInstance */.Ay.newInstance({
+        dataType,
+        name: 'Pixels',
+        numberOfComponents: 1,
+        values: pixelData,
+    });
+    const imageData = ImageData/* default.newInstance */.Ay.newInstance();
+    imageData.set({ dataType, numberOfComponents: 1 }, true);
+    imageData.setDimensions(width, height, 1);
+    imageData.setSpacing([spacing[state.xAxis], spacing[state.yAxis], 1]);
+    imageData.setDirection(new Float32Array([
+        ...xDirection,
+        ...yDirection,
+        zDirection[0],
+        zDirection[1],
+        zDirection[2],
+    ]));
+    imageData.setOrigin(esm.utilities.transformIndexToWorld(volume.imageData, originIndex));
+    imageData.getPointData().setScalars(scalarArray);
+    imageData.modified();
+    return {
+        imageData,
+        state,
+    };
+}
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/volumeLabelmapImageMapper.js
+
+
+
+
+
+
+
+const OVERLAY_RENDERER_SUFFIX = 'labelmap-image-mapper-overlay';
+function isPlanarSliceRenderingViewport(viewport) {
+    const compatibilityViewport = viewport;
+    return (compatibilityViewport.type === esm.Enums.ViewportType.PLANAR_NEXT &&
+        typeof compatibilityViewport.addImages === 'function' &&
+        typeof compatibilityViewport.getCurrentImageId === 'function' &&
+        typeof compatibilityViewport.render === 'function');
+}
+function createActorEntry(args) {
+    const mapper = ImageMapper/* default.newInstance */.Ay.newInstance();
+    mapper.setInputData(args.imageData);
+    const actor = ImageSlice/* default.newInstance */.Ay.newInstance();
+    actor.setMapper(mapper);
+    return {
+        uid: args.representationUID,
+        actor,
+        actorMapper: {
+            actor,
+            mapper,
+            renderMode: esm.ActorRenderMode.VTK_IMAGE,
+        },
+        referencedId: args.referencedId,
+        representationUID: args.representationUID,
+    };
+}
+function getOverlayRendererId(viewportId) {
+    return `${viewportId}::${OVERLAY_RENDERER_SUFFIX}`;
+}
+function getOrCreateOverlayRenderer(viewport) {
+    const renderingEngine = viewport.getRenderingEngine();
+    const offscreenMultiRenderWindow = renderingEngine.getOffscreenMultiRenderWindow(viewport.id);
+    const overlayRendererId = getOverlayRendererId(viewport.id);
+    const baseRenderer = viewport.getRenderer();
+    const baseViewport = baseRenderer.getViewport();
+    let overlayRenderer = offscreenMultiRenderWindow.getRenderer(overlayRendererId);
+    if (!overlayRenderer) {
+        const renderWindow = offscreenMultiRenderWindow.getRenderWindow();
+        if (renderWindow.getNumberOfLayers() < 2) {
+            renderWindow.setNumberOfLayers(2);
+        }
+        offscreenMultiRenderWindow.addRenderer({
+            viewport: baseViewport,
+            id: overlayRendererId,
+            background: [0, 0, 0],
+        });
+        overlayRenderer = offscreenMultiRenderWindow.getRenderer(overlayRendererId);
+        overlayRenderer.setLayer(1);
+        overlayRenderer.setPreserveDepthBuffer(false);
+    }
+    overlayRenderer.setActiveCamera(baseRenderer.getActiveCamera());
+    overlayRenderer.setViewport(baseViewport[0], baseViewport[1], baseViewport[2], baseViewport[3]);
+    return overlayRenderer;
+}
+function moveActorToOverlayRenderer(viewport, actorEntry) {
+    const baseRenderer = viewport.getRenderer();
+    const overlayRenderer = getOrCreateOverlayRenderer(viewport);
+    baseRenderer.removeActor(actorEntry.actor);
+    overlayRenderer.addActor(actorEntry.actor);
+}
+function getVolumeLabelmapImageMapperRepresentationUIDs(viewport, segmentationId, segmentation) {
+    if (!(0,labelmapImageMapperSupport/* canRenderVolumeViewportLabelmapAsImage */.QO)(viewport)) {
+        return [];
+    }
+    const useStablePlanarUID = isPlanarSliceRenderingViewport(viewport);
+    return (0,labelmapSegmentationState/* getLabelmaps */.m)(segmentation)
+        .map((layer) => {
+        const volume = (0,labelmapSegmentationState/* getOrCreateLabelmapVolume */.kL)(layer);
+        if (!volume) {
+            return;
+        }
+        const state = getSliceState(viewport, volume);
+        if (!state) {
+            return;
+        }
+        return (0,labelmapRepresentationUID/* createLabelmapRepresentationUID */.Ox)({
+            segmentationId,
+            referencedId: layer.labelmapId,
+            ...(useStablePlanarUID ? {} : { sliceStateKey: state.key }),
+        });
+    })
+        .filter((value) => !!value);
+}
+async function addVolumeLabelmapImageMapperActors(args) {
+    const { viewport, segmentation, segmentationId } = args;
+    if (!(0,labelmapImageMapperSupport/* canRenderVolumeViewportLabelmapAsImage */.QO)(viewport)) {
+        return;
+    }
+    if (isPlanarSliceRenderingViewport(viewport)) {
+        await addPlanarLabelmapImageMapperActors({
+            viewport,
+            segmentation,
+            segmentationId,
+        });
+        return;
+    }
+    (0,labelmapSegmentationState/* getLabelmaps */.m)(segmentation).forEach((layer) => {
+        const volume = (0,labelmapSegmentationState/* getOrCreateLabelmapVolume */.kL)(layer);
+        if (!volume) {
+            return;
+        }
+        const sliceData = createSliceImageData(volume, viewport);
+        if (!sliceData) {
+            return;
+        }
+        const representationUID = (0,labelmapRepresentationUID/* createLabelmapRepresentationUID */.Ox)({
+            segmentationId,
+            referencedId: layer.labelmapId,
+            sliceStateKey: sliceData.state.key,
+        });
+        const actorEntry = createActorEntry({
+            imageData: sliceData.imageData,
+            referencedId: layer.labelmapId,
+            representationUID,
+        });
+        viewport.addActor(actorEntry);
+        moveActorToOverlayRenderer(viewport, actorEntry);
+    });
+}
+function updateVolumeLabelmapImageMapperActors(args) {
+    const { viewport, segmentation, segmentationId, actorEntries } = args;
+    if (!(0,labelmapImageMapperSupport/* canRenderVolumeViewportLabelmapAsImage */.QO)(viewport)) {
+        return;
+    }
+    if (isPlanarSliceRenderingViewport(viewport)) {
+        updatePlanarLabelmapImageMapperActors({
+            viewport,
+            segmentation,
+            segmentationId,
+            actorEntries,
+        });
+        return;
+    }
+    const actorEntriesByLabelmapId = new Map((actorEntries ?? viewport.getActors())
+        .filter((actorEntry) => (0,labelmapRepresentationUID/* isLabelmapRepresentationUID */.qV)(actorEntry.representationUID, segmentationId))
+        .map((actorEntry) => [actorEntry.referencedId, actorEntry]));
+    (0,labelmapSegmentationState/* getLabelmaps */.m)(segmentation).forEach((layer) => {
+        const actorEntry = actorEntriesByLabelmapId.get(layer.labelmapId);
+        if (!actorEntry) {
+            return;
+        }
+        const volume = (0,labelmapSegmentationState/* getOrCreateLabelmapVolume */.kL)(layer);
+        if (!volume) {
+            return;
+        }
+        const sliceData = createSliceImageData(volume, viewport);
+        if (!sliceData) {
+            return;
+        }
+        const mapper = actorEntry.actor.getMapper();
+        mapper.setInputData(sliceData.imageData);
+        mapper.modified();
+        actorEntry.actor.modified?.();
+    });
+}
+function removeVolumeLabelmapImageMapperActors(viewport, segmentationId) {
+    if (!(viewport.type === esm.Enums.ViewportType.ORTHOGRAPHIC)) {
+        return;
+    }
+    if (!(0,labelmapImageMapperSupport/* canRenderVolumeViewportLabelmapAsImage */.QO)(viewport)) {
+        return;
+    }
+    const renderingEngine = viewport.getRenderingEngine();
+    const offscreenMultiRenderWindow = renderingEngine.getOffscreenMultiRenderWindow(viewport.id);
+    const overlayRenderer = offscreenMultiRenderWindow.getRenderer(getOverlayRendererId(viewport.id));
+    if (!overlayRenderer) {
+        return;
+    }
+    viewport
+        .getActors()
+        .filter((actorEntry) => (0,labelmapRepresentationUID/* isLabelmapRepresentationUID */.qV)(actorEntry.representationUID, segmentationId))
+        .forEach((actorEntry) => {
+        overlayRenderer.removeActor(actorEntry.actor);
+    });
+    if (!overlayRenderer.getActors().length) {
+        offscreenMultiRenderWindow.removeRenderer(getOverlayRendererId(viewport.id));
+    }
+}
+function getLabelmapForActorReference(segmentation, referencedId) {
+    if (!referencedId) {
+        return;
+    }
+    return ((0,labelmapSegmentationState/* getLabelmap */.Hs)(segmentation, referencedId) ??
+        (0,labelmapSegmentationState/* getLabelmapForImageId */.M4)(segmentation, referencedId) ??
+        (0,labelmapSegmentationState/* getLabelmapForVolumeId */.BS)(segmentation, referencedId) ??
+        (0,labelmapSegmentationState/* getLabelmaps */.m)(segmentation).find((layer) => layer.volumeId === referencedId));
+}
+async function addPlanarLabelmapImageMapperActors(args) {
+    const { viewport, segmentation, segmentationId } = args;
+    for (const [index, layer] of (0,labelmapSegmentationState/* getLabelmaps */.m)(segmentation).entries()) {
+        const volume = (0,labelmapSegmentationState/* getOrCreateLabelmapVolume */.kL)(layer);
+        if (!volume) {
+            continue;
+        }
+        const sliceData = createSliceImageData(volume, viewport);
+        if (!sliceData) {
+            continue;
+        }
+        const currentImageId = viewport.getCurrentImageId() ??
+            volume.imageIds[Math.min(Math.max(sliceData.state.sliceIndex, 0), Math.max(volume.imageIds.length - 1, 0))];
+        if (!currentImageId) {
+            continue;
+        }
+        const representationUID = (0,labelmapRepresentationUID/* createLabelmapRepresentationUID */.Ox)({
+            segmentationId,
+            referencedId: layer.labelmapId,
+        });
+        await viewport.addImages([
+            {
+                dataId: representationUID,
+                imageId: currentImageId,
+                imageData: sliceData.imageData,
+                reference: {
+                    kind: 'segmentation',
+                    segmentationId,
+                    representationUID,
+                    labelmapId: layer.labelmapId,
+                },
+                useWorldCoordinateImageData: true,
+                callback: ({ imageActor }) => {
+                    const mapper = imageActor.getMapper();
+                    const camera = getSliceRenderingCamera(viewport);
+                    mapper.setInputData(sliceData.imageData);
+                    mapper.modified();
+                    if (camera) {
+                        applyPlanarOverlayDepthOffset(imageActor, camera.viewPlaneNormal, index + 1);
+                    }
+                },
+            },
+        ]);
+    }
+    viewport.render();
+}
+function updatePlanarLabelmapImageMapperActors(args) {
+    const { viewport, segmentation, segmentationId, actorEntries } = args;
+    const actorEntriesByLabelmapId = new Map((actorEntries ?? viewport.getActors())
+        .filter((actorEntry) => (0,labelmapRepresentationUID/* isLabelmapRepresentationUID */.qV)(actorEntry.representationUID, segmentationId))
+        .map((actorEntry) => [actorEntry.referencedId, actorEntry]));
+    (0,labelmapSegmentationState/* getLabelmaps */.m)(segmentation).forEach((layer, index) => {
+        const actorEntry = actorEntriesByLabelmapId.get(layer.labelmapId);
+        if (!actorEntry) {
+            return;
+        }
+        const volume = (0,labelmapSegmentationState/* getOrCreateLabelmapVolume */.kL)(layer);
+        if (!volume) {
+            return;
+        }
+        const sliceData = createSliceImageData(volume, viewport);
+        if (!sliceData) {
+            return;
+        }
+        const mapper = actorEntry.actor.getMapper();
+        mapper.setInputData(sliceData.imageData);
+        mapper.modified();
+        const camera = getSliceRenderingCamera(viewport);
+        if (camera) {
+            applyPlanarOverlayDepthOffset(actorEntry.actor, camera.viewPlaneNormal, index + 1);
+        }
+        actorEntry.actor.modified?.();
+    });
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/removeLabelmapRepresentationFromViewport.js
+
+
+
+function removeLabelmapRepresentationFromViewport(viewport, segmentationId) {
+    removeVolumeLabelmapImageMapperActors(viewport, segmentationId);
+    const labelmapActorEntries = (0,getSegmentationActor/* getLabelmapActorEntries */.ED)(viewport.id, segmentationId) ?? [];
+    const legacyActorEntryUIDs = [];
+    labelmapActorEntries.forEach((actorEntry) => {
+        if ((0,removeLabelmapRepresentationData/* default */.A)(viewport, segmentationId, actorEntry)) {
+            return;
+        }
+        legacyActorEntryUIDs.push(actorEntry.uid);
+    });
+    if (legacyActorEntryUIDs.length) {
+        viewport.removeActors(legacyActorEntryUIDs);
+    }
+}
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/createLabelmapRenderPlan.js
+
+
+function createLabelmapRenderPlan({ isVolumeImageMapper, kind, renderMode, segmentationId, unsupportedStateKey, updateAfterMount = true, useSliceRendering, viewport, canRenderCurrentViewport = () => kind !== 'unsupported', getExpectedRepresentationUIDs = () => [], mount = async () => undefined, update = () => undefined, }) {
+    const remove = () => removeLabelmapRepresentationFromViewport(viewport, segmentationId);
+    const needsRemount = (actorEntries) => haveActorUIDsChanged(actorEntries, getExpectedRepresentationUIDs());
+    return {
+        kind,
+        renderMode,
+        useSliceRendering,
+        isVolumeImageMapper,
+        unsupportedStateKey,
+        getExpectedRepresentationUIDs,
+        mount,
+        needsRemount,
+        remove,
+        update,
+        reconcile: async ({ actorEntries, labelMapData }) => {
+            if (!canRenderCurrentViewport()) {
+                return actorEntries;
+            }
+            let nextActorEntries = actorEntries;
+            if (needsRemount(nextActorEntries) && nextActorEntries?.length) {
+                remove();
+                nextActorEntries = undefined;
+            }
+            const mounted = !nextActorEntries?.length;
+            if (mounted) {
+                await mount({ labelMapData });
+            }
+            nextActorEntries = (0,getSegmentationActor/* getLabelmapActorEntries */.ED)(viewport.id, segmentationId);
+            if (nextActorEntries?.length && (!mounted || updateAfterMount)) {
+                update({ actorEntries: nextActorEntries });
+            }
+            return nextActorEntries;
+        },
+    };
+}
+function haveActorUIDsChanged(actorEntries, expectedRepresentationUIDs) {
+    const actualUIDs = new Set((actorEntries ?? []).map((entry) => entry.representationUID));
+    const expectedUIDs = new Set(expectedRepresentationUIDs);
+    if (actualUIDs.size !== expectedUIDs.size) {
+        return true;
+    }
+    for (const expectedUID of expectedUIDs) {
+        if (!actualUIDs.has(expectedUID)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/getViewportLabelmapRenderMode.js
+var getViewportLabelmapRenderMode = __webpack_require__(33214);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 3 modules
+var enums = __webpack_require__(29857);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/addVolumesAsIndependentComponents.js
+
+
+
+const internalCache = new Map();
+const load = ({ cfun, ofun, actor }) => {
+    actor.getProperty().setRGBTransferFunction(1, cfun);
+    actor.getProperty().setScalarOpacity(1, ofun);
+};
+async function addVolumesAsIndependentComponents({ viewport, volumeInputs, segmentationId, }) {
+    const defaultActor = viewport.getDefaultActor();
+    const { actor } = defaultActor;
+    const { uid } = defaultActor;
+    const referenceVolumeId = viewport.getVolumeId();
+    if (internalCache.get(uid)?.added) {
+        return {
+            uid,
+            actor,
+        };
+    }
+    const volumeInputArray = volumeInputs;
+    const firstImageVolume = esm.cache.getVolume(volumeInputArray[0].volumeId);
+    if (!firstImageVolume) {
+        throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
+    }
+    const { volumeId } = volumeInputArray[0];
+    const segImageVolume = await esm.volumeLoader.loadVolume(volumeId);
+    if (!segImageVolume) {
+        throw new Error(`segImageVolume with id: ${segImageVolume.volumeId} does not exist`);
+    }
+    const segVoxelManager = segImageVolume.voxelManager;
+    const segData = segVoxelManager.getCompleteScalarDataArray();
+    const { imageData: segImageData } = segImageVolume;
+    const baseVolume = esm.cache.getVolume(referenceVolumeId);
+    const volumeTexture = baseVolume.vtkOpenGLTexture;
+    const hasPendingFrames = volumeTexture.hasUpdatedFrames();
+    if (hasPendingFrames) {
+        return;
+    }
+    const baseVoxelManager = baseVolume.voxelManager;
+    const baseData = baseVoxelManager.getCompleteScalarDataArray();
+    const newComp = 2;
+    const cubeData = new Float32Array(newComp * baseVolume.voxelManager.getScalarDataLength());
+    const dims = segImageData.getDimensions();
+    for (let z = 0; z < dims[2]; ++z) {
+        for (let y = 0; y < dims[1]; ++y) {
+            for (let x = 0; x < dims[0]; ++x) {
+                const iTuple = x + dims[0] * (y + dims[1] * z);
+                cubeData[iTuple * newComp + 0] = baseData[iTuple];
+                cubeData[iTuple * newComp + 1] = segData[iTuple];
+            }
+        }
+    }
+    viewport.removeActors([uid]);
+    const oldMapper = actor.getMapper();
+    const mapper = (0,esm.convertMapperToNotSharedMapper)(oldMapper);
+    actor.setMapper(mapper);
+    mapper.setBlendMode(esm.Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND);
+    const arrayAgain = mapper.getInputData().getPointData().getArray(0);
+    arrayAgain.setData(cubeData);
+    arrayAgain.setNumberOfComponents(2);
+    const oldColorMixPreset = actor.getProperty().getColorMixPreset();
+    actor.getProperty().setColorMixPreset(1);
+    const oldForceNearestInterpolation = actor
+        .getProperty()
+        .getForceNearestInterpolation(1);
+    actor.getProperty().setForceNearestInterpolation(1, true);
+    const oldIndependentComponents = actor
+        .getProperty()
+        .getIndependentComponents();
+    actor.getProperty().setIndependentComponents(true);
+    viewport.addActor({
+        ...defaultActor,
+        representationUID: `${segmentationId}-${enums.SegmentationRepresentations.Labelmap}`,
+    });
+    internalCache.set(uid, {
+        added: true,
+        segmentationRepresentationUID: `${segmentationId}`,
+        originalBlendMode: viewport.getBlendMode(),
+    });
+    const oldPreLoad = actor.get('preLoad');
+    actor.set({
+        preLoad: load,
+    });
+    function onSegmentationDataModified(evt) {
+        const { segmentationId } = evt.detail;
+        const { representationData } = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
+        const { volumeId: segVolumeId } = representationData.Labelmap;
+        if (segVolumeId !== segImageVolume.volumeId) {
+            return;
+        }
+        const segmentationVolume = esm.cache.getVolume(segVolumeId);
+        const segVoxelManager = segmentationVolume.voxelManager;
+        const imageData = mapper.getInputData();
+        const array = imageData.getPointData().getArray(0);
+        const baseData = array.getData();
+        const newComp = 2;
+        const dims = segImageData.getDimensions();
+        const slices = Array.from({ length: dims[2] }, (_, i) => i);
+        for (const z of slices) {
+            for (let y = 0; y < dims[1]; ++y) {
+                for (let x = 0; x < dims[0]; ++x) {
+                    const iTuple = x + dims[0] * (y + dims[1] * z);
+                    baseData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
+                }
+            }
+        }
+        array.setData(baseData);
+        imageData.modified();
+        viewport.render();
+    }
+    esm.eventTarget.addEventListenerDebounced(enums.Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified, 200);
+    function onSegmentationRepresentationRemoved(evt) {
+        if (evt.detail.viewportId !== viewport.id) {
+            return;
+        }
+        esm.eventTarget.removeEventListener(enums.Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
+        esm.eventTarget.removeEventListener(enums.Events.SEGMENTATION_REPRESENTATION_REMOVED, onSegmentationRepresentationRemoved);
+        const actorEntry = viewport.getActor(uid);
+        if (actorEntry) {
+            viewport.removeActors([uid]);
+        }
+        internalCache.delete(uid);
+        if (viewport.isDisabled) {
+            return;
+        }
+        actor.setMapper(oldMapper);
+        actor.getProperty().setColorMixPreset(oldColorMixPreset);
+        actor
+            .getProperty()
+            .setForceNearestInterpolation(1, oldForceNearestInterpolation);
+        actor.getProperty().setIndependentComponents(oldIndependentComponents);
+        viewport.addActor({
+            ...defaultActor,
+        });
+        actor.set(oldPreLoad);
+        viewport.render();
+    }
+    esm.eventTarget.addEventListener(enums.Events.SEGMENTATION_REPRESENTATION_REMOVED, onSegmentationRepresentationRemoved);
+    return {
+        uid,
+        actor,
+    };
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/planarGenericVolumeLabelmap.js
+
+
+function isPlanarNextVolumeViewport(viewport) {
+    const genericViewport = viewport;
+    return (genericViewport.type === esm.Enums.ViewportType.PLANAR_NEXT &&
+        typeof genericViewport.getVolumeId === 'function' &&
+        typeof genericViewport.getViewReference === 'function' &&
+        typeof genericViewport.getViewState === 'function' &&
+        typeof genericViewport.addDisplaySet === 'function' &&
+        typeof genericViewport.setDisplaySetPresentation === 'function' &&
+        typeof genericViewport.setViewReference === 'function');
+}
+async function addLabelmapToPlanarGenericViewport(args) {
+    const { blendMode, labelmapLayers, segmentationId, viewport, visibility } = args;
+    const sourceVolumeRenderMode = getPlanarNextVolumeRenderMode(viewport);
+    if (!sourceVolumeRenderMode) {
+        return;
+    }
+    const sourceVolumeId = viewport.getVolumeId();
+    const sourceViewReference = sourceVolumeId
+        ? viewport.getViewReference({ volumeId: sourceVolumeId })
+        : viewport.getViewReference();
+    const requestedOrientation = viewport.getViewState().orientation;
+    const currentImageIdIndex = Math.max(0, viewport.getCurrentImageIdIndex?.() ?? 0);
+    let firstActorEntry;
+    for (const layer of labelmapLayers) {
+        if (!layer.volumeId) {
+            continue;
+        }
+        const volume = esm.cache.getVolume(layer.volumeId);
+        if (!volume) {
+            throw new Error(`imageVolume with id: ${layer.volumeId} does not exist, you need to create/allocate the volume first`);
+        }
+        const representationUID = (0,labelmapRepresentationUID/* createLabelmapRepresentationUID */.Ox)({
+            segmentationId,
+            referencedId: layer.labelmapId,
+        });
+        const dataId = representationUID;
+        esm.utilities.genericViewportDataSetMetadataProvider.add(dataId, {
+            kind: 'planar',
+            imageIds: volume.imageIds,
+            initialImageIdIndex: Math.min(currentImageIdIndex, Math.max(volume.imageIds.length - 1, 0)),
+            reference: {
+                kind: 'segmentation',
+                segmentationId,
+                representationUID,
+                labelmapId: layer.labelmapId,
+            },
+            volumeId: layer.volumeId,
+        });
+        await viewport.addDisplaySet(dataId, {
+            orientation: requestedOrientation,
+            role: 'overlay',
+        });
+        viewport.setDisplaySetPresentation(dataId, {
+            blendMode,
+            visible: visibility,
+        });
+        firstActorEntry ||= viewport
+            .getActors?.()
+            .find((actorEntry) => actorEntry.representationUID === representationUID);
+    }
+    viewport.setViewReference(sourceViewReference);
+    viewport.render?.();
+    if (firstActorEntry) {
+        return {
+            uid: firstActorEntry.uid,
+            actor: firstActorEntry.actor,
+        };
+    }
+}
+function getPlanarNextVolumeRenderMode(viewport) {
+    const renderMode = viewport.getDefaultActor?.()?.actorMapper?.renderMode;
+    if (renderMode === esm.ActorRenderMode.CPU_VOLUME ||
+        renderMode === esm.ActorRenderMode.VTK_VOLUME_SLICE) {
+        return renderMode;
+    }
+}
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/legacyVolumePlan.js
+
+
+
+
+
+
+
+const { uuidv4 } = esm.utilities;
+function createLegacyVolumeLabelmapPlan({ config, isVolumeImageMapper, renderMode, segmentation, segmentationId, useSliceRendering, viewport, }) {
+    return createLabelmapRenderPlan({
+        isVolumeImageMapper,
+        kind: 'legacy-volume',
+        renderMode,
+        segmentationId,
+        useSliceRendering,
+        viewport,
+        getExpectedRepresentationUIDs: () => getExpectedVolumeLabelmapRepresentationUIDs(segmentation, segmentationId),
+        mount: ({ labelMapData }) => mountLegacyVolumeLabelmap({
+            config,
+            labelMapData,
+            segmentation,
+            segmentationId,
+            viewport,
+        }),
+    });
+}
+function getExpectedVolumeLabelmapRepresentationUIDs(segmentation, segmentationId) {
+    return (0,labelmapSegmentationState/* getLabelmaps */.m)(segmentation)
+        .filter(canResolveLayerAsVolume)
+        .map((layer) => (0,labelmapRepresentationUID/* createLabelmapRepresentationUID */.Ox)({
+        segmentationId,
+        referencedId: layer.labelmapId,
+    }));
+}
+async function mountLegacyVolumeLabelmap({ config, labelMapData, segmentation, segmentationId, viewport, }) {
+    const { id: viewportId } = viewport;
+    const visibility = true;
+    const immediateRender = false;
+    const suppressEvents = true;
+    const volumeCompatibleViewport = viewport;
+    const labelmapLayers = getVolumeBackedLabelmapLayers(segmentation);
+    if (!labelmapLayers.length) {
+        const volumeLabelMapData = labelMapData;
+        const volumeId = ensureVolumeHasVolumeId(volumeLabelMapData, segmentation);
+        if (!esm.cache.getVolume(volumeId)) {
+            await handleMissingVolume(labelMapData);
+        }
+        labelmapLayers.push({
+            labelmapId: volumeId,
+            type: 'volume',
+            volumeId,
+            imageIds: esm.cache.getVolume(volumeId)?.imageIds,
+        });
+    }
+    let blendMode = config?.blendMode ?? esm.Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
+    let useIndependentComponents = blendMode === esm.Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
+    if (useIndependentComponents) {
+        const referenceVolumeId = volumeCompatibleViewport.getVolumeId?.();
+        const baseVolume = esm.cache.getVolume(referenceVolumeId);
+        const segVolume = esm.cache.getVolume(labelmapLayers[0]?.volumeId);
+        const segDims = segVolume.dimensions;
+        const refDims = baseVolume.dimensions;
+        if (segDims[0] !== refDims[0] ||
+            segDims[1] !== refDims[1] ||
+            segDims[2] !== refDims[2]) {
+            useIndependentComponents = false;
+            blendMode = esm.Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
+            console.debug('Dimensions mismatch - falling back to regular volume addition');
+        }
+    }
+    const volumeInputs = labelmapLayers.map((layer) => ({
+        volumeId: layer.volumeId,
+        visibility,
+        representationUID: (0,labelmapRepresentationUID/* createLabelmapRepresentationUID */.Ox)({
+            segmentationId,
+            referencedId: layer.labelmapId,
+        }),
+        useIndependentComponents,
+        blendMode,
+    }));
+    if (isPlanarNextVolumeViewport(viewport)) {
+        return addLabelmapToPlanarGenericViewport({
+            blendMode,
+            labelmapLayers,
+            segmentationId,
+            viewport,
+            visibility,
+        });
+    }
+    if (!volumeInputs[0].useIndependentComponents) {
+        await (0,esm.addVolumesToViewports)(viewport.getRenderingEngine(), volumeInputs, [viewportId], immediateRender, suppressEvents);
+        (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentationId);
+        return;
+    }
+    return addVolumesAsIndependentComponents({
+        viewport: volumeCompatibleViewport,
+        volumeInputs,
+        segmentationId,
+    });
+}
+function canResolveLayerAsVolume(layer) {
+    return Boolean(layer.volumeId || layer.geometryVolumeId || layer.imageIds?.length);
+}
+function getVolumeBackedLabelmapLayers(segmentation) {
+    return (0,labelmapSegmentationState/* getLabelmaps */.m)(segmentation)
+        .map((layer) => {
+        if (layer.volumeId) {
+            return layer;
+        }
+        const volume = (0,labelmapSegmentationState/* getOrCreateLabelmapVolume */.kL)(layer);
+        if (!volume?.volumeId) {
+            return;
+        }
+        return {
+            ...layer,
+            volumeId: volume.volumeId,
+        };
+    })
+        .filter((layer) => Boolean(layer));
+}
+function ensureVolumeHasVolumeId(labelMapData, segmentation) {
+    let { volumeId } = labelMapData;
+    if (!volumeId) {
+        volumeId = uuidv4();
+        segmentation.representationData.Labelmap = {
+            ...segmentation.representationData.Labelmap,
+            volumeId,
+        };
+        labelMapData.volumeId = volumeId;
+        (0,triggerSegmentationEvents.triggerSegmentationModified)(segmentation.segmentationId);
+    }
+    return volumeId;
+}
+async function handleMissingVolume(labelMapData) {
+    const stackData = labelMapData;
+    const hasImageIds = stackData.imageIds.length > 0;
+    if (!hasImageIds) {
+        throw new Error('cannot create labelmap, no imageIds found for the volume labelmap');
+    }
+    const volume = await esm.volumeLoader.createAndCacheVolumeFromImages(labelMapData.volumeId ?? uuidv4(), stackData.imageIds);
+    return volume;
+}
+
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getCurrentLabelmapImageIdForViewport.js
+var getCurrentLabelmapImageIdForViewport = __webpack_require__(97577);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/syncStackLabelmapActors.js
+var syncStackLabelmapActors = __webpack_require__(48969);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/stackImagePlan.js
+
+
+
+
+
+function createStackImageLabelmapPlan({ isVolumeImageMapper, renderMode, segmentationId, useSliceRendering, viewport, }) {
+    return createLabelmapRenderPlan({
+        isVolumeImageMapper,
+        kind: 'legacy-stack-image',
+        renderMode,
+        segmentationId,
+        updateAfterMount: false,
+        useSliceRendering,
+        viewport,
+        canRenderCurrentViewport: () => hasCurrentStackLabelmapImageIds(viewport, segmentationId),
+        getExpectedRepresentationUIDs: () => getExpectedStackLabelmapRepresentationUIDs(viewport, segmentationId),
+        mount: () => mountStackLabelmapActors(viewport, segmentationId),
+        update: () => (0,syncStackLabelmapActors/* syncStackLabelmapActors */.k)(viewport, segmentationId),
+    });
+}
+function hasCurrentStackLabelmapImageIds(viewport, segmentationId) {
+    return !!(0,getCurrentLabelmapImageIdForViewport/* getCurrentLabelmapImageIdsForViewport */.aF)(viewport.id, segmentationId)
+        ?.length;
+}
+function getExpectedStackLabelmapRepresentationUIDs(viewport, segmentationId) {
+    return ((0,getCurrentLabelmapImageIdForViewport/* getCurrentLabelmapImageIdsForViewport */.aF)(viewport.id, segmentationId)?.map((imageId) => (0,labelmapRepresentationUID/* createLabelmapRepresentationUID */.Ox)({
+        segmentationId,
+        referencedId: imageId,
+    })) ?? []);
+}
+async function mountStackLabelmapActors(viewport, segmentationId) {
+    (0,syncStackLabelmapActors/* syncStackLabelmapActors */.k)(viewport, segmentationId);
+    (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentationId);
+}
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/volumeSliceImageMapperPlan.js
+
+
+
+function createVolumeSliceImageMapperPlan({ isVolumeImageMapper, renderMode, segmentation, segmentationId, useSliceRendering, viewport, }) {
+    return createLabelmapRenderPlan({
+        isVolumeImageMapper,
+        kind: 'volume-slice-image-mapper',
+        renderMode,
+        segmentationId,
+        useSliceRendering,
+        viewport,
+        getExpectedRepresentationUIDs: () => getVolumeLabelmapImageMapperRepresentationUIDs(viewport, segmentationId, segmentation),
+        mount: () => mountVolumeLabelmapImageMapper({
+            viewport,
+            segmentation,
+            segmentationId,
+        }),
+        update: ({ actorEntries }) => updateVolumeLabelmapImageMapperActors({
+            viewport,
+            segmentation,
+            segmentationId,
+            actorEntries,
+        }),
+    });
+}
+async function mountVolumeLabelmapImageMapper({ viewport, segmentation, segmentationId, }) {
+    await addVolumeLabelmapImageMapperActors({
+        viewport,
+        segmentation,
+        segmentationId,
+    });
+    (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentationId);
+}
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/resolveLabelmapRenderPlan.js
+
+
+
+
+
+
+function resolveLabelmapRenderPlan({ viewport, segmentation, representation, }) {
+    const { segmentationId, config } = representation;
+    const useSliceRendering = (0,labelmapImageMapperSupport/* shouldUseSliceRendering */.bY)(segmentation, config);
+    const renderMode = (0,getViewportLabelmapRenderMode/* default */.A)(viewport, {
+        useSliceRendering,
+    });
+    const isVolumeImageMapper = useSliceRendering && (0,labelmapImageMapperSupport/* canRenderVolumeViewportLabelmapAsImage */.QO)(viewport);
+    if (renderMode === 'unsupported') {
+        return createLabelmapRenderPlan({
+            isVolumeImageMapper,
+            kind: 'unsupported',
+            renderMode,
+            segmentationId,
+            unsupportedStateKey: useSliceRendering
+                ? (0,labelmapImageMapperSupport/* getVolumeViewportLabelmapImageMapperState */.o)(viewport).key
+                : undefined,
+            useSliceRendering,
+            viewport,
+        });
+    }
+    if (isVolumeImageMapper) {
+        return createVolumeSliceImageMapperPlan({
+            isVolumeImageMapper,
+            renderMode,
+            segmentation,
+            segmentationId,
+            useSliceRendering,
+            viewport,
+        });
+    }
+    if (renderMode === 'volume') {
+        return createLegacyVolumeLabelmapPlan({
+            config,
+            isVolumeImageMapper,
+            renderMode,
+            segmentation,
+            segmentationId,
+            useSliceRendering,
+            viewport,
+        });
+    }
+    return createStackImageLabelmapPlan({
+        isVolumeImageMapper,
+        renderMode,
+        segmentationId,
+        useSliceRendering,
+        viewport,
+    });
+}
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/index.js
+
+
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan.js
+
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PiecewiseFunction.js
+var PiecewiseFunction = __webpack_require__(30678);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction.js + 1 modules
+var ColorTransferFunction = __webpack_require__(12408);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/activeSegmentation.js + 1 modules
+var segmentation_activeSegmentation = __webpack_require__(26228);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getActiveSegmentIndex.js
+var getActiveSegmentIndex = __webpack_require__(60740);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getColorLUT.js
+var getColorLUT = __webpack_require__(50409);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices.js
+var internalGetHiddenSegmentIndices = __webpack_require__(47098);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/SegmentationStyle.js
+var SegmentationStyle = __webpack_require__(92686);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapActorStyle.js
+
+
+
+
+
+
+
+
+
+
+
+
+const actorTransferFunctions = new WeakMap();
+const MAX_NUMBER_COLORS = 255;
+function setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, segmentationRepresentation) {
+    const { segmentationId } = segmentationRepresentation;
+    const { colorLUTIndex } = segmentationRepresentation;
+    const activeSegmentation = (0,segmentation_activeSegmentation.getActiveSegmentation)(viewportId);
+    const isActiveLabelmap = activeSegmentation?.segmentationId === segmentationId;
+    const labelmapStyle = SegmentationStyle/* segmentationStyle */.Y.getStyle({
+        viewportId,
+        type: SegmentationRepresentations/* default */.A.Labelmap,
+        segmentationId,
+    });
+    const renderInactiveSegmentations = SegmentationStyle/* segmentationStyle */.Y.getRenderInactiveSegmentations(viewportId);
+    const colorLUT = (0,getColorLUT/* getColorLUT */.B)(colorLUTIndex);
+    const segmentation = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
+    const layer = getLabelmapForActorReference(segmentation, labelmapActorEntry.referencedId);
+    const layerBindings = Object.keys(segmentation.segments)
+        .map(Number)
+        .map((segmentIndex) => ({
+        segmentIndex,
+        binding: (0,labelmapSegmentationState/* getSegmentBinding */.hM)(segmentation, segmentIndex),
+    }))
+        .filter((entry) => !layer || entry.binding?.labelmapId === layer.labelmapId);
+    const maxLabelValue = Math.max(1, ...layerBindings.map((entry) => entry.binding?.labelValue ?? entry.segmentIndex));
+    const numColors = Math.max(colorLUT.length, maxLabelValue + 1);
+    const labelValueEntries = Array.from({ length: numColors - 1 }, (_, index) => {
+        const labelValue = index + 1;
+        const segmentIndex = layer?.labelToSegmentIndex?.[labelValue] ?? labelValue;
+        return {
+            labelValue,
+            segmentIndex,
+        };
+    });
+    const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = getLabelmapConfig(labelmapStyle, isActiveLabelmap);
+    const segmentsHidden = (0,internalGetHiddenSegmentIndices/* internalGetHiddenSegmentIndices */.s)(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations/* default */.A.Labelmap,
+    });
+    const labelmapActor = labelmapActorEntry.actor;
+    const { cfun, ofun } = getOrCreateTransferFunctions(labelmapActor);
+    cfun.removeAllPoints();
+    ofun.removeAllPoints();
+    const colorNodes = [
+        { x: 0, r: 0, g: 0, b: 0, midpoint: 0.5, sharpness: 1.0 },
+    ];
+    const opacityNodes = [{ x: 0, y: 0, midpoint: 0.5, sharpness: 1.0 }];
+    labelValueEntries.forEach(({ labelValue, segmentIndex }) => {
+        const segmentColor = colorLUT[segmentIndex];
+        if (!segmentColor) {
+            return;
+        }
+        const perSegmentStyle = SegmentationStyle/* segmentationStyle */.Y.getStyle({
+            viewportId,
+            type: SegmentationRepresentations/* default */.A.Labelmap,
+            segmentationId,
+            segmentIndex,
+        });
+        const { fillAlpha, renderFill } = getLabelmapConfig(labelmapStyle, isActiveLabelmap, perSegmentStyle);
+        colorNodes.push({
+            x: labelValue,
+            r: segmentColor[0] / MAX_NUMBER_COLORS,
+            g: segmentColor[1] / MAX_NUMBER_COLORS,
+            b: segmentColor[2] / MAX_NUMBER_COLORS,
+            midpoint: 0.5,
+            sharpness: 1.0,
+        });
+        if (renderFill) {
+            const segmentOpacity = segmentsHidden.has(segmentIndex)
+                ? 0
+                : (segmentColor[3] / 255) * fillAlpha;
+            opacityNodes.push({
+                x: labelValue,
+                y: segmentOpacity,
+                midpoint: 0.5,
+                sharpness: 1.0,
+            });
+        }
+        else {
+            opacityNodes.push({
+                x: labelValue,
+                y: 0.01,
+                midpoint: 0.5,
+                sharpness: 1.0,
+            });
+        }
+    });
+    cfun.setNodes(colorNodes);
+    ofun.setNodes(opacityNodes);
+    ofun.setClamping(false);
+    const actorMapper = labelmapActorEntry.actorMapper;
+    const labelmapMapper = actorMapper?.mapper
+        ? actorMapper.mapper
+        : labelmapActor.getMapper();
+    const { preLoad } = labelmapActor.get?.('preLoad') || { preLoad: null };
+    if (preLoad) {
+        preLoad({ cfun, ofun, actor: labelmapActor });
+    }
+    else {
+        labelmapActor.getProperty().setRGBTransferFunction(0, cfun);
+        labelmapActor.getProperty().setScalarOpacity(0, ofun);
+        labelmapActor.getProperty().setInterpolationTypeToNearest();
+    }
+    if (labelmapActorEntry.actorMapper?.renderMode === esm.ActorRenderMode.VTK_IMAGE ||
+        labelmapActorEntry.actorMapper?.renderMode ===
+            esm.ActorRenderMode.VTK_VOLUME_SLICE) {
+        const imageSlice = labelmapActor;
+        imageSlice.setForceTranslucent(true);
+        imageSlice.setForceOpaque(false);
+        imageSlice.getProperty().setUseLookupTableScalarRange(true);
+    }
+    if (renderOutline) {
+        labelmapActor.getProperty().setUseLabelOutline(renderOutline);
+        labelmapActor.getProperty().setLabelOutlineOpacity(outlineOpacity);
+        const activeSegmentIndex = (0,getActiveSegmentIndex/* getActiveSegmentIndex */.Q)(segmentationRepresentation.segmentationId);
+        const outlineWidths = new Array(numColors - 1).fill(0);
+        labelValueEntries.forEach(({ labelValue, segmentIndex }) => {
+            const isHidden = segmentsHidden.has(segmentIndex);
+            if (isHidden) {
+                return;
+            }
+            outlineWidths[labelValue - 1] =
+                segmentIndex === activeSegmentIndex
+                    ? outlineWidth + activeSegmentOutlineWidthDelta
+                    : outlineWidth;
+        });
+        labelmapActor.getProperty().setLabelOutlineThickness(outlineWidths);
+        labelmapActor.modified();
+        labelmapActor.getProperty().modified();
+        labelmapMapper?.modified?.();
+    }
+    else {
+        labelmapActor
+            .getProperty()
+            .setLabelOutlineThickness(new Array(numColors - 1).fill(0));
+    }
+    const visible = isActiveLabelmap || renderInactiveSegmentations;
+    labelmapActor.setVisibility(visible);
+    labelmapActor.modified();
+    labelmapActor.getProperty().modified();
+    labelmapMapper?.modified?.();
+}
+function getOrCreateTransferFunctions(actor) {
+    const existing = actorTransferFunctions.get(actor);
+    if (existing) {
+        return existing;
+    }
+    const cfun = ColorTransferFunction/* default.newInstance */.Ay.newInstance();
+    const ofun = PiecewiseFunction/* default.newInstance */.Ay.newInstance();
+    ofun.addPoint(0, 0);
+    const created = { cfun, ofun };
+    actorTransferFunctions.set(actor, created);
+    return created;
+}
+function getLabelmapConfig(labelmapConfig, isActiveLabelmap, segmentsLabelmapConfig) {
+    const segmentLabelmapConfig = segmentsLabelmapConfig || {};
+    const configToUse = {
+        ...labelmapConfig,
+        ...segmentLabelmapConfig,
+    };
+    return {
+        fillAlpha: isActiveLabelmap
+            ? configToUse.fillAlpha
+            : configToUse.fillAlphaInactive,
+        outlineWidth: isActiveLabelmap
+            ? configToUse.outlineWidth
+            : configToUse.outlineWidthInactive,
+        renderFill: isActiveLabelmap
+            ? configToUse.renderFill
+            : configToUse.renderFillInactive,
+        renderOutline: isActiveLabelmap
+            ? configToUse.renderOutline
+            : configToUse.renderOutlineInactive,
+        outlineOpacity: isActiveLabelmap
+            ? configToUse.outlineOpacity
+            : configToUse.outlineOpacityInactive,
+        activeSegmentOutlineWidthDelta: configToUse.activeSegmentOutlineWidthDelta,
+    };
+}
+
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.js
+
+
+
+
+
+
+
+
+
+
+
+const unsupportedImageMapperStates = new Map();
+let polySegConversionInProgress = false;
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
+    clearUnsupportedImageMapperError(viewportId, segmentationId);
+    const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    removeLabelmapRepresentationFromViewport(viewport, segmentationId);
+    if (!renderImmediate) {
+        return;
+    }
+    viewport.render();
+}
+async function render(viewport, representation) {
+    const { segmentationId } = representation;
+    const segmentation = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
+    if (!segmentation) {
+        console.warn('No segmentation found for segmentationId: ', segmentationId);
+        return;
+    }
+    let labelmapData = segmentation.representationData[SegmentationRepresentations/* default */.A.Labelmap];
+    let labelmapActorEntries = (0,getSegmentationActor/* getLabelmapActorEntries */.ED)(viewport.id, segmentationId);
+    if (!labelmapData &&
+        (0,config/* getPolySeg */.Qy)()?.canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations/* default */.A.Labelmap) &&
+        !polySegConversionInProgress) {
+        polySegConversionInProgress = true;
+        const polySeg = (0,config/* getPolySeg */.Qy)();
+        labelmapData = await (0,computeAndAddRepresentation/* computeAndAddRepresentation */.d)(segmentationId, SegmentationRepresentations/* default */.A.Labelmap, () => polySeg.computeLabelmapData(segmentationId, {
+            viewport: viewport,
+        }), () => {
+            SegmentationStateManager/* defaultSegmentationStateManager */._6.processLabelmapRepresentationAddition(viewport.id, segmentationId);
+            setTimeout(() => {
+                (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentationId);
+            }, 0);
+        });
+        if (!labelmapData) {
+            throw new Error(`No labelmap data found for segmentationId ${segmentationId}.`);
+        }
+        polySegConversionInProgress = false;
     }
-    _createFakeVolume(imageIds) {
-        const volumeId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.generateVolumeId(imageIds);
-        const cachedVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
-        if (cachedVolume) {
-            return cachedVolume;
+    else if (!labelmapData && !(0,config/* getPolySeg */.Qy)()) {
+        console.debug(`No labelmap data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to labelmap. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
+    }
+    if (!labelmapData) {
+        return;
+    }
+    const renderPlan = resolveLabelmapRenderPlan({
+        viewport,
+        segmentation,
+        representation,
+    });
+    if (renderPlan.kind === 'unsupported') {
+        if (labelmapActorEntries?.length) {
+            renderPlan.remove();
         }
-        const volumeProps = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.generateVolumePropsFromImageIds(imageIds, volumeId);
-        const spacing = volumeProps.spacing;
-        if (spacing[2] === 0) {
-            spacing[2] = 1;
+        if (renderPlan.unsupportedStateKey) {
+            reportUnsupportedImageMapperError(viewport.id, segmentationId, renderPlan.unsupportedStateKey);
         }
-        const derivedVolume = new _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.ImageVolume({
-            volumeId,
-            dataType: volumeProps.dataType,
-            metadata: structuredClone(volumeProps.metadata),
-            dimensions: volumeProps.dimensions,
-            spacing: volumeProps.spacing,
-            origin: volumeProps.origin,
-            direction: volumeProps.direction,
-            referencedVolumeId: volumeProps.referencedVolumeId,
-            imageIds: volumeProps.imageIds,
-            referencedImageIds: volumeProps.referencedImageIds,
-        });
-        _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.putVolumeSync(volumeId, derivedVolume);
-        return derivedVolume;
+        return;
     }
-    _isOrthogonalView(viewport, referencedVolumeId) {
-        const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(referencedVolumeId);
-        const volumeImageData = volume.imageData;
-        const camera = viewport.getCamera();
-        const { ijkVecColDir, ijkVecSliceDir } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getVolumeDirectionVectors(volumeImageData, camera);
-        return [ijkVecColDir, ijkVecSliceDir].every((vec) => _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[0]), 1) ||
-            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[1]), 1) ||
-            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[2]), 1));
+    clearUnsupportedImageMapperError(viewport.id, segmentationId);
+    labelmapActorEntries = await renderPlan.reconcile({
+        actorEntries: labelmapActorEntries,
+        labelMapData: labelmapData,
+    });
+    if (!labelmapActorEntries?.length) {
+        return;
     }
-    getRemoveIslandData(_growCutData) {
+    for (const labelmapActorEntry of labelmapActorEntries) {
+        setLabelmapColorAndOpacity(viewport.id, labelmapActorEntry, representation);
+    }
+}
+function getUpdateFunction(_viewport) {
+    return;
+}
+function getUnsupportedImageMapperStateKey(viewportId, segmentationId) {
+    return `${viewportId}:${segmentationId}`;
+}
+function clearUnsupportedImageMapperError(viewportId, segmentationId) {
+    unsupportedImageMapperStates.delete(getUnsupportedImageMapperStateKey(viewportId, segmentationId));
+}
+function reportUnsupportedImageMapperError(viewportId, segmentationId, stateKey) {
+    const cacheKey = getUnsupportedImageMapperStateKey(viewportId, segmentationId);
+    const previousStateKey = unsupportedImageMapperStates.get(cacheKey);
+    if (previousStateKey === stateKey) {
         return;
     }
-    _removeIslands(growCutData) {
-        const { islandRemoval: config } = this.configuration;
-        if (!config.enabled) {
+    unsupportedImageMapperStates.set(cacheKey, stateKey);
+    esm.eventTarget.dispatchEvent(new CustomEvent(esm.Enums.Events.ERROR_EVENT, {
+        detail: {
+            type: 'Segmentation',
+            message: 'Labelmap image-mapper rendering is only supported on legacy orthographic single-slice volume viewports.',
+        },
+        cancelable: true,
+    }));
+}
+/* harmony default export */ const labelmapDisplay = ({
+    getUpdateFunction,
+    render,
+    removeRepresentation,
+});
+
+
+
+/***/ },
+
+/***/ 5959
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ox: () => (/* binding */ createLabelmapRepresentationUID),
+/* harmony export */   qV: () => (/* binding */ isLabelmapRepresentationUID)
+/* harmony export */ });
+/* unused harmony export getLabelmapRepresentationPrefix */
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(29857);
+
+function getLabelmapRepresentationPrefix(segmentationId) {
+    return `${segmentationId}-${_enums__WEBPACK_IMPORTED_MODULE_0__.SegmentationRepresentations.Labelmap}`;
+}
+function createLabelmapRepresentationUID({ segmentationId, referencedId, sliceStateKey, }) {
+    return [
+        getLabelmapRepresentationPrefix(segmentationId),
+        referencedId,
+        sliceStateKey,
+    ]
+        .filter(Boolean)
+        .join('-');
+}
+function isLabelmapRepresentationUID(representationUID, segmentationId) {
+    return (typeof representationUID === 'string' &&
+        representationUID.startsWith(getLabelmapRepresentationPrefix(segmentationId)));
+}
+
+
+
+/***/ },
+
+/***/ 24393
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* 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__(15327);
+/* harmony import */ var _labelmapRepresentationUID__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5959);
+
+
+function removeLabelmapRepresentationData(viewport, segmentationId, actorEntry) {
+    const representationUID = actorEntry.representationUID;
+    if (!(0,_labelmapRepresentationUID__WEBPACK_IMPORTED_MODULE_1__/* .isLabelmapRepresentationUID */ .qV)(representationUID, segmentationId)) {
+        return false;
+    }
+    const dataViewport = viewport;
+    if (typeof dataViewport.removeData !== 'function') {
+        return false;
+    }
+    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.genericViewportDataSetMetadataProvider.remove(representationUID);
+    dataViewport.removeData(representationUID);
+    return true;
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (removeLabelmapRepresentationData);
+
+
+/***/ },
+
+/***/ 94895
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Ay: () => (/* binding */ surfaceDisplay)
+});
+
+// UNUSED EXPORTS: getUpdateFunction, removeRepresentation, render
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(15327);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/SegmentationRepresentations.js
+var SegmentationRepresentations = __webpack_require__(18682);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Surface/removeSurfaceFromElement.js
+
+function removeSurfaceFromElement(element, segmentationId) {
+    const enabledElement = (0,esm.getEnabledElement)(element);
+    const { viewport } = enabledElement;
+    const actorEntries = viewport.getActors();
+    const filteredSurfaceActors = actorEntries.filter((actor) => actor.representationUID &&
+        typeof actor.representationUID === 'string' &&
+        actor.representationUID.startsWith(segmentationId));
+    viewport.removeActors(filteredSurfaceActors.map((actor) => actor.uid));
+}
+/* harmony default export */ const Surface_removeSurfaceFromElement = (removeSurfaceFromElement);
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Mapper.js + 1 modules
+var Mapper = __webpack_require__(81418);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Actor.js
+var Actor = __webpack_require__(44404);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/CellArray.js
+var CellArray = __webpack_require__(32461);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/getSegmentationActor.js
+var getSegmentationActor = __webpack_require__(59452);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Surface/addOrUpdateSurfaceToElement.js
+
+
+
+
+
+
+function addOrUpdateSurfaceToElement(viewport, surface, segmentationId) {
+    const surfaceActorEntry = (0,getSegmentationActor/* getSurfaceActorEntry */.Th)(viewport.id, segmentationId, surface.segmentIndex);
+    const surfaceActor = surfaceActorEntry?.actor;
+    const isVisible = surface.visible;
+    if (surfaceActor) {
+        surfaceActor.setVisibility(isVisible);
+        if (!isVisible) {
             return;
         }
-        const { segmentation: { segmentIndex, labelmapVolumeId }, renderingEngineId, viewportId, } = growCutData;
-        const labelmap = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(labelmapVolumeId);
-        const removeIslandData = this.getRemoveIslandData(growCutData);
-        if (!removeIslandData) {
+        const surfaceMapper = surfaceActor.getMapper();
+        const currentPolyData = surfaceMapper.getInputData();
+        const newPoints = surface.points;
+        const newPolys = surface.polys;
+        const currentPoints = currentPolyData.getPoints().getData();
+        const currentPolys = currentPolyData.getPolys().getData();
+        if (newPoints.length === currentPoints.length &&
+            newPolys.length === currentPolys.length) {
             return;
         }
-        const [width, height] = labelmap.dimensions;
-        const numPixelsPerSlice = width * height;
-        const { worldIslandPoints = [], islandPointIndexes = [] } = removeIslandData;
-        let ijkIslandPoints = [...(removeIslandData?.ijkIslandPoints ?? [])];
-        const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getRenderingEngine)(renderingEngineId);
-        const viewport = renderingEngine.getViewport(viewportId);
-        const { voxelManager } = labelmap;
-        const islandRemoval = new _utilities_segmentation_islandRemoval__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A();
-        ijkIslandPoints = ijkIslandPoints.concat(worldIslandPoints.map((worldPoint) => transformWorldToIndex(labelmap.imageData, worldPoint)));
-        ijkIslandPoints = ijkIslandPoints.concat(islandPointIndexes.map((pointIndex) => {
-            const x = pointIndex % width;
-            const y = Math.floor(pointIndex / width) % height;
-            const z = Math.floor(pointIndex / numPixelsPerSlice);
-            return [x, y, z];
-        }));
-        islandRemoval.initialize(viewport, voxelManager, {
-            points: ijkIslandPoints,
-            previewSegmentIndex: segmentIndex,
-            segmentIndex,
+        const polyData = PolyData/* default.newInstance */.Ay.newInstance();
+        polyData.getPoints().setData(newPoints, 3);
+        const triangles = CellArray/* default.newInstance */.Ay.newInstance({
+            values: Float32Array.from(newPolys),
         });
-        islandRemoval.floodFillSegmentIsland();
-        islandRemoval.removeExternalIslands();
-        islandRemoval.removeInternalIslands();
+        polyData.setPolys(triangles);
+        surfaceMapper.setInputData(polyData);
+        surfaceMapper.modified();
+        viewport.getRenderer().resetCameraClippingRange();
+        return;
     }
-    getSegmentStyle({ segmentationId, viewportId, segmentIndex }) {
-        return (0,_utilities_segmentation_getSVGStyleForSegment__WEBPACK_IMPORTED_MODULE_6__/* .getSVGStyleForSegment */ .u)({
+    const points = surface.points;
+    const polys = surface.polys;
+    const color = surface.color;
+    const surfacePolyData = PolyData/* default.newInstance */.Ay.newInstance();
+    surfacePolyData.getPoints().setData(points, 3);
+    const triangles = CellArray/* default.newInstance */.Ay.newInstance({
+        values: Float32Array.from(polys),
+    });
+    surfacePolyData.setPolys(triangles);
+    const mapper = Mapper/* default.newInstance */.Ay.newInstance({});
+    let clippingFilter;
+    mapper.setInputData(surfacePolyData);
+    const actor = Actor/* default.newInstance */.Ay.newInstance();
+    actor.setMapper(mapper);
+    actor.getProperty().setColor(color[0] / 255, color[1] / 255, color[2] / 255);
+    actor.getProperty().setLineWidth(2);
+    const representationUID = (0,getSegmentationActor/* getSurfaceRepresentationUID */.DU)(segmentationId, surface.segmentIndex);
+    viewport.addActor({
+        uid: esm.utilities.uuidv4(),
+        actor: actor,
+        clippingFilter,
+        representationUID,
+    });
+    viewport.resetCamera();
+    viewport.getRenderer().resetCameraClippingRange();
+    viewport.render();
+}
+/* harmony default export */ const Surface_addOrUpdateSurfaceToElement = (addOrUpdateSurfaceToElement);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
+var getSegmentation = __webpack_require__(33283);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getColorLUT.js
+var getColorLUT = __webpack_require__(50409);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/config.js
+var config = __webpack_require__(36625);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/computeAndAddRepresentation.js
+var computeAndAddRepresentation = __webpack_require__(27479);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices.js
+var internalGetHiddenSegmentIndices = __webpack_require__(47098);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Surface/surfaceDisplay.js
+
+
+
+
+
+
+
+
+
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
+    const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    Surface_removeSurfaceFromElement(viewport.element, segmentationId);
+    if (!renderImmediate) {
+        return;
+    }
+    viewport.render();
+}
+async function render(viewport, representation) {
+    const { segmentationId, type } = representation;
+    const segmentation = (0,getSegmentation/* getSegmentation */.T)(segmentationId);
+    if (!segmentation) {
+        return;
+    }
+    let SurfaceData = segmentation.representationData[SegmentationRepresentations/* default */.A.Surface];
+    if (!SurfaceData &&
+        (0,config/* getPolySeg */.Qy)()?.canComputeRequestedRepresentation(segmentationId, SegmentationRepresentations/* default */.A.Surface)) {
+        const polySeg = (0,config/* getPolySeg */.Qy)();
+        SurfaceData = await (0,computeAndAddRepresentation/* computeAndAddRepresentation */.d)(segmentationId, SegmentationRepresentations/* default */.A.Surface, () => polySeg.computeSurfaceData(segmentationId, { viewport }));
+        if (!SurfaceData) {
+            throw new Error(`No Surface data found for segmentationId ${segmentationId} even we tried to compute it`);
+        }
+    }
+    else if (!SurfaceData && !(0,config/* getPolySeg */.Qy)()) {
+        console.debug(`No surface data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to surface. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
+    }
+    if (!SurfaceData) {
+        console.warn(`No Surface data found for segmentationId ${segmentationId}. Skipping render.`);
+        return;
+    }
+    const { geometryIds } = SurfaceData;
+    if (!geometryIds?.size) {
+        console.warn(`No Surfaces found for segmentationId ${segmentationId}. Skipping render.`);
+    }
+    const { colorLUTIndex } = representation;
+    const colorLUT = (0,getColorLUT/* getColorLUT */.B)(colorLUTIndex);
+    const surfaces = [];
+    geometryIds.forEach((geometryId) => {
+        const geometry = esm.cache.getGeometry(geometryId);
+        if (!geometry?.data) {
+            console.warn(`No Surfaces found for geometryId ${geometryId}. Skipping render.`);
+            return;
+        }
+        const { segmentIndex } = geometry.data;
+        const hiddenSegments = (0,internalGetHiddenSegmentIndices/* internalGetHiddenSegmentIndices */.s)(viewport.id, {
             segmentationId,
-            segmentIndex,
-            viewportId,
+            type,
         });
-    }
+        const isHidden = hiddenSegments.has(segmentIndex);
+        const surface = geometry.data;
+        const color = colorLUT[segmentIndex];
+        surface.color = color.slice(0, 3);
+        surface.visible = !isHidden;
+        surfaces.push(surface);
+        Surface_addOrUpdateSurfaceToElement(viewport, surface, segmentationId);
+    });
+    viewport.render();
 }
-GrowCutBaseTool.toolName = 'GrowCutBaseTool';
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (GrowCutBaseTool);
+function getUpdateFunction(viewport) {
+    const polySeg = (0,config/* getPolySeg */.Qy)();
+    return (segmentationId) => polySeg.updateSurfaceData(segmentationId, { viewport });
+}
+/* harmony default export */ const surfaceDisplay = ({
+    getUpdateFunction,
+    render,
+    removeRepresentation,
+});
+
 
 
 /***/ },
@@ -2502,6 +5284,84 @@ function eraseOutsideRectangle(enabledElement, operationData) {
 }
 
 
+/***/ },
+
+/***/ 88557
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   c: () => (/* binding */ getCenterAndRadiusInCanvas)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3823);
+
+
+const EPSILON = 1e-4;
+function getCenterAndRadiusInCanvas(points, viewport) {
+    const canvasPoints = points.map((p) => viewport.worldToCanvas(p));
+    const [cBottom, cTop, cLeft, cRight] = canvasPoints;
+    const center = [
+        (cBottom[0] + cTop[0]) / 2,
+        (cBottom[1] + cTop[1]) / 2,
+    ];
+    const worldHeight = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .eR.distance(points[0], points[1]);
+    const worldWidth = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .eR.distance(points[2], points[3]);
+    const canvasHeight = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec2.distance */ .Zc.distance(cBottom, cTop);
+    const canvasWidth = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec2.distance */ .Zc.distance(cLeft, cRight);
+    const scaleX = canvasWidth / worldWidth;
+    const scaleY = canvasHeight / worldHeight;
+    const worldRadius = worldHeight / 2;
+    const radius = Math.abs(scaleX - scaleY) > EPSILON
+        ? worldRadius * Math.min(scaleX, scaleY)
+        : canvasHeight / 2;
+    return {
+        center: center,
+        radius: Math.round(radius),
+    };
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getCenterAndRadiusInCanvas);
+
+
+/***/ },
+
+/***/ 77671
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ getEllipseWorldCoordinates)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
+
+function getEllipseWorldCoordinates(points, viewport) {
+    const camera = viewport.getCamera();
+    const { viewUp, viewPlaneNormal } = camera;
+    const viewRight = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(viewRight, viewUp, viewPlaneNormal);
+    const [centerWorld, endWorld] = points;
+    const centerToEndDistance = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.distance */ .eR.distance(centerWorld, endWorld);
+    const bottomWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    const topWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    const leftWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    const rightWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    for (let i = 0; i <= 2; i++) {
+        bottomWorld[i] = centerWorld[i] - viewUp[i] * centerToEndDistance;
+        topWorld[i] = centerWorld[i] + viewUp[i] * centerToEndDistance;
+        leftWorld[i] = centerWorld[i] - viewRight[i] * centerToEndDistance;
+        rightWorld[i] = centerWorld[i] + viewRight[i] * centerToEndDistance;
+    }
+    const ellipseWorldCoordinates = [
+        bottomWorld,
+        topWorld,
+        leftWorld,
+        rightWorld,
+    ];
+    return ellipseWorldCoordinates;
+}
+
+
 /***/ },
 
 /***/ 39848
@@ -3576,6 +6436,30 @@ function smoothAnnotation(annotation, options) {
 }
 
 
+/***/ },
+
+/***/ 27479
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   d: () => (/* binding */ computeAndAddRepresentation)
+/* harmony export */ });
+/* harmony import */ var _stateManagement_segmentation_internalAddRepresentationData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(44188);
+
+async function computeAndAddRepresentation(segmentationId, type, computeFunction, onComputationComplete) {
+    const data = await computeFunction();
+    (0,_stateManagement_segmentation_internalAddRepresentationData__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)({
+        segmentationId,
+        type,
+        data,
+    });
+    onComputationComplete?.();
+    return data;
+}
+
+
+
 /***/ },
 
 /***/ 10564
@@ -4622,8 +7506,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Build VTK API
@@ -4956,8 +7839,7 @@ const Picker_DEFAULT_VALUES = {
 };
 
 // ----------------------------------------------------------------------------
-function Picker_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function Picker_extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, Picker_DEFAULT_VALUES, initialValues);
 
   // Inheritance
@@ -5097,11 +7979,8 @@ function vtkBox(publicAPI, model) {
   model.classHierarchy.push('vtkBox');
 
   // TODO: replace with macro.setArray ?
-  publicAPI.setBounds = function () {
+  publicAPI.setBounds = (...bounds) => {
     let boundsArray = [];
-    for (var _len = arguments.length, bounds = new Array(_len), _key = 0; _key < _len; _key++) {
-      bounds[_key] = arguments[_key];
-    }
     if (Array.isArray(bounds[0])) {
       boundsArray = bounds[0];
     } else {
@@ -5115,7 +7994,7 @@ function vtkBox(publicAPI, model) {
     }
     BoundingBox/* default.setBounds */.Ay.setBounds(model.bbox, boundsArray);
   };
-  publicAPI.getBounds = () => model.bbox;
+  publicAPI.getBounds = () => [...model.bbox];
   publicAPI.evaluateFunction = (x, y, z) => {
     const point = Array.isArray(x) ? x : [x, y, z];
     let diff;
@@ -5164,13 +8043,13 @@ function vtkBox(publicAPI, model) {
     }
     return distance;
   };
-  publicAPI.addBounds = function () {
+  publicAPI.addBounds = (...bounds) => {
     let boundsArray = [];
-    if (Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
-      boundsArray = arguments.length <= 0 ? undefined : arguments[0];
+    if (Array.isArray(bounds[0])) {
+      boundsArray = bounds[0];
     } else {
-      for (let i = 0; i < arguments.length; i++) {
-        boundsArray.push(i < 0 || arguments.length <= i ? undefined : arguments[i]);
+      for (let i = 0; i < bounds.length; i++) {
+        boundsArray.push(bounds[i]);
       }
     }
     if (boundsArray.length !== 6) {
@@ -5193,8 +8072,7 @@ const Box_DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function Box_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function Box_extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, Box_DEFAULT_VALUES, initialValues);
 
   // Object methods
@@ -5603,7 +8481,6 @@ function vtkCellPicker(publicAPI, model) {
       }
       /* eslint-enable no-continue */
     }
-
     if (minCellId >= 0 && tMin < model.globalTMin) {
       resetPickInfo();
       const nbPointsInCell = minCell.getNumberOfPoints();
@@ -5673,8 +8550,7 @@ const CellPicker_DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function CellPicker_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function CellPicker_extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, CellPicker_DEFAULT_VALUES, initialValues);
 
   // Inheritance
@@ -7171,8 +10047,7 @@ class Widget {
  * @param canvas       The HTML canvas to convert
  * @param boundingBox  A bounding box of type [top, left, width, height]
  */
-function canvasToImageData(canvas) {
-  let boundingBox = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0, 0];
+function canvasToImageData(canvas, boundingBox = [0, 0, 0, 0]) {
   const [top, left, width, height] = boundingBox;
   const ctxt = canvas.getContext('2d');
   const idata = ctxt.getImageData(top, left, width || canvas.width, height || canvas.height);
@@ -7194,12 +10069,11 @@ function canvasToImageData(canvas) {
 /**
  * Converts an Image object to a vtkImageData.
  */
-function imageToImageData(image) {
-  let transform = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-    flipX: false,
-    flipY: false,
-    rotate: 0
-  };
+function imageToImageData(image, transform = {
+  flipX: false,
+  flipY: false,
+  rotate: 0
+}) {
   const canvas = document.createElement('canvas');
   canvas.width = image.width;
   canvas.height = image.height;
@@ -7423,8 +10297,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Build VTK API
@@ -7725,8 +10598,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Build VTK API
@@ -7922,8 +10794,7 @@ function vtkAnnotatedCubeActor(publicAPI, model) {
 
   // private methods
 
-  function updateFaceTexture(faceName) {
-    let newProp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  function updateFaceTexture(faceName, newProp = null) {
     if (newProp) {
       Object.assign(model[`${faceName}FaceProperty`], newProp);
     }
@@ -8037,8 +10908,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Inheritance
@@ -8294,8 +11164,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Build VTK API
@@ -8408,8 +11277,7 @@ const ConeSource_DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function ConeSource_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function ConeSource_extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, ConeSource_DEFAULT_VALUES, initialValues);
 
   // Build VTK API
@@ -8607,8 +11475,7 @@ const CylinderSource_DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function CylinderSource_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function CylinderSource_extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, CylinderSource_DEFAULT_VALUES, initialValues);
 
   // Build VTK API
@@ -8709,8 +11576,7 @@ const ArrowSource_DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function ArrowSource_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function ArrowSource_extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, ArrowSource_DEFAULT_VALUES, initialValues);
 
   // Build VTK API
@@ -8750,8 +11616,7 @@ function centerDataSet(ds) {
   const center = [-(bounds[0] + bounds[1]) * 0.5, -(bounds[2] + bounds[3]) * 0.5, -(bounds[4] + bounds[5]) * 0.5];
   MatrixBuilder/* default */.A.buildFromDegree().translate(...center).apply(ds.getPoints().getData());
 }
-function shiftDataset(ds, axis) {
-  let invert = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+function shiftDataset(ds, axis, invert = false) {
   const bounds = ds.getPoints().getBounds();
   const center = [0, 0, 0];
   if (invert) {
@@ -8897,8 +11762,7 @@ function defaultValues(initialValues) {
 
 // ----------------------------------------------------------------------------
 
-function AxesActor_extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function AxesActor_extend(publicAPI, model, initialValues = {}) {
   // Inheritance
   Actor/* default.extend */.Ay.extend(publicAPI, model, defaultValues(initialValues));
   macros2.m.setGet(publicAPI, model, ['config', 'xConfig', 'yConfig', 'zConfig']);