@ohif/app 3.13.0-beta.35 → 3.13.0-beta.39

package/dist/{933.bundle.ea9db108b8a4e3d51904.js → 9567.bundle.be350438bed4e656f278.js}

@@ -1,9 +1,9 @@
-"use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[933],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[9567],{
 
 /***/ 75183
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
@@ -27,6 +27,7 @@ var ChangeTypes;
 /***/ 74690
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -163,6 +164,7 @@ function keyUp(evt) {
 /***/ 40100
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -527,6 +529,7 @@ function mouseWheel(evt) {
 /***/ 96198
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ customCallbackHandler)
 /* harmony export */ });
@@ -570,6 +573,7 @@ function customCallbackHandler(handlerType, customFunction, evt) {
 /***/ 70333
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getToolsWithModesForMouseEvent)
 /* harmony export */ });
@@ -604,6 +608,7 @@ function getToolsWithModesForMouseEvent(evt, modesFilter, evtButton) {
 /***/ 84971
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -838,6 +843,7 @@ const touchPress = customCallbackHandler/* default */.A.bind(null, 'Touch', 'tou
 /***/ 39595
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
@@ -862,6 +868,7 @@ function disable(element) {
 /***/ 40776
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Ay: () => (__WEBPACK_DEFAULT_EXPORT__),
 /* harmony export */   Ud: () => (/* binding */ resetModifierKey),
@@ -940,6 +947,7 @@ function resetModifierKey() {
 /***/ 99019
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getMouseEventPoints)
 /* harmony export */ });
@@ -982,6 +990,7 @@ function _clientToPoint(evt) {
 /***/ 91099
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
@@ -1027,6 +1036,7 @@ function mouseDoubleClickListener(evt) {
 /***/ 68014
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Ay: () => (__WEBPACK_DEFAULT_EXPORT__),
 /* harmony export */   DF: () => (/* binding */ mouseDoubleClickIgnoreListener),
@@ -1308,6 +1318,7 @@ function mouseDoubleClickIgnoreListener(evt) {
 /***/ 41343
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
@@ -1349,6 +1360,7 @@ function mouseMoveListener(evt) {
 /***/ 41666
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
@@ -1406,6 +1418,7 @@ function enable(element) {
 /***/ 82603
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -1750,6 +1763,7 @@ function _updateTouchEventsLastPoints(element, lastPoints) {
 /***/ 17806
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -1854,6 +1868,7 @@ function wheelListener(evt) {
 /***/ 6802
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   O8: () => (/* reexport safe */ _annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__.removeAnnotation),
 /* harmony export */   Rh: () => (/* reexport safe */ _annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__.getAnnotations),
@@ -1878,6 +1893,7 @@ function wheelListener(evt) {
 /***/ 6273
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   p: () => (/* binding */ convertStackToVolumeLabelmap)
 /* harmony export */ });
@@ -1897,6 +1913,7 @@ async function convertStackToVolumeLabelmap(args) {
 /***/ 98149
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   X: () => (/* binding */ updateStackSegmentationState)
 /* harmony export */ });
@@ -1943,6 +1960,7 @@ async function updateStackSegmentationState({ segmentationId, viewportId, imageI
 /***/ 25972
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ filterMoveableAnnotationTools)
 /* harmony export */ });
@@ -1973,6 +1991,7 @@ function filterMoveableAnnotationTools(element, ToolAndAnnotations, canvasCoords
 /***/ 57725
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ filterToolsWithAnnotationsForElement)
 /* harmony export */ });
@@ -2006,6 +2025,7 @@ function filterToolsWithAnnotationsForElement(element, tools) {
 /***/ 35486
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ filterToolsWithMoveableHandles)
 /* harmony export */ });
@@ -2037,6 +2057,7 @@ function filterToolsWithMoveableHandles(element, ToolAndAnnotations, canvasCoord
 /***/ 16175
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
@@ -2129,6 +2150,7 @@ class CircleSculptCursor {
 /***/ 10639
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
@@ -2429,6 +2451,7 @@ GrowCutBaseTool.toolName = 'GrowCutBaseTool';
 /***/ 13271
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   X: () => (/* binding */ distancePointToContour)
 /* harmony export */ });
@@ -2458,6 +2481,7 @@ const distancePointToContour = (viewport, annotation, coords) => {
 /***/ 47347
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   M: () => (/* binding */ eraseInsideRectangle)
 /* harmony export */ });
@@ -2483,6 +2507,7 @@ function eraseOutsideRectangle(enabledElement, operationData) {
 /***/ 39848
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getToolsWithModesForElement)
 /* harmony export */ });
@@ -2519,6 +2544,7 @@ function getToolsWithModesForElement(element, modesFilter) {
 /***/ 22658
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   j: () => (/* binding */ getVOIMultipliers)
 /* harmony export */ });
@@ -2550,6 +2576,7 @@ function getVOIMultipliers(viewport, volumeId, options) {
 /***/ 38776
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   j: () => (/* binding */ LivewirePath)
 /* harmony export */ });
@@ -2631,6 +2658,7 @@ class LivewirePath {
 /***/ 78044
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -3032,6 +3060,7 @@ class LivewireScissors {
 /***/ 11256
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getCanvasCircleCorners)
 /* harmony export */ });
@@ -3051,6 +3080,7 @@ function getCanvasCircleCorners(circleCanvasPoints) {
 /***/ 76090
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getCanvasCircleRadius)
 /* harmony export */ });
@@ -3067,6 +3097,7 @@ function getCanvasCircleRadius(circleCanvasPoints) {
 /***/ 2222
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getCanvasEllipseCorners)
 /* harmony export */ });
@@ -3083,6 +3114,7 @@ function getCanvasEllipseCorners(ellipseCanvasPoints) {
 /***/ 17787
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   IM: () => (/* binding */ clipInterval),
 /* harmony export */   Mo: () => (/* binding */ calculateInnerFanPercentage),
@@ -3197,6 +3229,7 @@ function calculateInnerFanPercentage(center, outerFanPairs, innerFanPairs) {
 /***/ 82983
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   f: () => (/* binding */ midPoint2)
 /* harmony export */ });
@@ -3222,6 +3255,7 @@ const midPoint2 = midPoint;
 /***/ 5767
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 // ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
 
@@ -3253,6 +3287,7 @@ var mirror = __webpack_require__(83483);
 /***/ 98122
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getAABB)
 /* harmony export */ });
@@ -3303,6 +3338,7 @@ function getAABB(polyline, options) {
 /***/ 50932
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ getLineSegmentIntersectionsCoordinates)
 /* harmony export */ });
@@ -3328,6 +3364,7 @@ function getLineSegmentIntersectionsCoordinates(points, p1, q1, closed = true) {
 /***/ 8361
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   i: () => (/* binding */ isPointInsidePolyline3D)
 /* harmony export */ });
@@ -3365,6 +3402,7 @@ function isPointInsidePolyline3D(point, polyline, options = {}) {
 /***/ 80514
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
@@ -3408,6 +3446,7 @@ const pointCanProjectOnLine = (p, p1, p2, proximity) => {
 /***/ 28502
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   p: () => (/* binding */ projectTo2D)
 /* harmony export */ });
@@ -3444,6 +3483,7 @@ function projectTo2D(polyline) {
 /***/ 61587
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ smoothAnnotation)
 /* harmony export */ });
@@ -3512,6 +3552,7 @@ function smoothAnnotation(annotation, options) {
 /***/ 10564
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   BX: () => (/* binding */ DEFAULT_NEGATIVE_SEED_MARGIN),
 /* harmony export */   Sp: () => (/* binding */ DEFAULT_NEIGHBORHOOD_RADIUS),
@@ -3537,6 +3578,7 @@ const MAX_NEGATIVE_SEED_ATTEMPTS_MULTIPLIER = 50;
 /***/ 94762
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Lr: () => (/* binding */ priority),
 /* harmony export */   Pg: () => (/* binding */ clearFromImageIds),
@@ -3631,6 +3673,7 @@ const clearFromImageIds = (stack) => {
 /***/ 30045
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   P: () => (/* binding */ addToolState),
 /* harmony export */   k: () => (/* binding */ getToolState)
@@ -3656,6 +3699,7 @@ function getToolState(element) {
 /***/ 33517
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -3868,6 +3912,7 @@ class ColorbarCanvas {
 /***/ 62184
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   f: () => (/* binding */ ColorbarTicks)
 /* harmony export */ });
@@ -4174,6 +4219,7 @@ class ColorbarTicks {
 /***/ 57227
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -4219,6 +4265,7 @@ const areColorbarSizesEqual = (a, b) => {
 /***/ 79457
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (/* binding */ isRangeTextPositionValid)
 /* harmony export */ });
@@ -4237,158 +4284,2670 @@ function isRangeTextPositionValid(colorbarWidth, colorbarHeight, rangeTextPositi
 
 /***/ },
 
-/***/ 44845
+/***/ 88380
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ Widget)
-/* harmony export */ });
-/* unused harmony export Widget */
-class Widget {
-    constructor({ id, container }) {
-        this._containerResizeCallback = (entries) => {
-            let width;
-            let height;
-            const { contentRect, contentBoxSize } = entries[0];
-            if (contentRect) {
-                width = contentRect.width;
-                height = contentRect.height;
-            }
-            else if (contentBoxSize?.length) {
-                width = contentBoxSize[0].inlineSize;
-                height = contentBoxSize[0].blockSize;
-            }
-            this._containerSize = { width, height };
-            this.onContainerResize();
-        };
-        this._id = id;
-        this._containerSize = { width: 0, height: 0 };
-        this._rootElement = this.createRootElement(id);
-        this._containerResizeObserver = new ResizeObserver(this._containerResizeCallback);
-        if (container) {
-            this.appendTo(container);
-        }
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  LINE_INTERSECTION_TOLERANCE: () => (/* reexport */ LINE_INTERSECTION_TOLERANCE),
+  NUM_CLIPPING_PLANES: () => (/* reexport */ NUM_CLIPPING_PLANES),
+  PLANEINDEX: () => (/* reexport */ PLANEINDEX),
+  POINT_PROXIMITY_THRESHOLD_PIXELS: () => (/* reexport */ POINT_PROXIMITY_THRESHOLD_PIXELS),
+  SPHEREINDEX: () => (/* reexport */ SPHEREINDEX),
+  computePlanePlaneIntersection: () => (/* reexport */ computePlanePlaneIntersection),
+  copyClippingPlanes: () => (/* reexport */ copyClippingPlanes),
+  extractVolumeDirectionVectors: () => (/* reexport */ extractVolumeDirectionVectors),
+  findLineBoundsIntersection: () => (/* reexport */ findLineBoundsIntersection),
+  getColorKeyForPlaneIndex: () => (/* reexport */ getColorKeyForPlaneIndex),
+  getOrientationFromNormal: () => (/* reexport */ getOrientationFromNormal),
+  parseCornerKey: () => (/* reexport */ parseCornerKey)
+});
+
+// UNUSED EXPORTS: LINE_EXTENSION_DISTANCE, MIN_LINE_LENGTH_PIXELS, ORIENTATION_TOLERANCE, PARALLEL_PLANE_TOLERANCE
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/constants.js
+const PLANEINDEX = {
+    XMIN: 0,
+    XMAX: 1,
+    YMIN: 2,
+    YMAX: 3,
+    ZMIN: 4,
+    ZMAX: 5,
+};
+const SPHEREINDEX = {
+    XMIN: 0,
+    XMAX: 1,
+    YMIN: 2,
+    YMAX: 3,
+    ZMIN: 4,
+    ZMAX: 5,
+    XMIN_YMIN_ZMIN: 6,
+    XMIN_YMIN_ZMAX: 7,
+    XMIN_YMAX_ZMIN: 8,
+    XMIN_YMAX_ZMAX: 9,
+    XMAX_YMIN_ZMIN: 10,
+    XMAX_YMIN_ZMAX: 11,
+    XMAX_YMAX_ZMIN: 12,
+    XMAX_YMAX_ZMAX: 13,
+};
+const NUM_CLIPPING_PLANES = 6;
+const ORIENTATION_TOLERANCE = 1e-2;
+const PARALLEL_PLANE_TOLERANCE = 1e-10;
+const LINE_INTERSECTION_TOLERANCE = 1e-8;
+const LINE_EXTENSION_DISTANCE = 100000;
+const MIN_LINE_LENGTH_PIXELS = 1;
+const POINT_PROXIMITY_THRESHOLD_PIXELS = 6;
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/types.js
+var types = __webpack_require__(22716);
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
+var esm = __webpack_require__(3823);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/extractVolumeDirectionVectors.js
+
+function extractVolumeDirectionVectors(imageData) {
+    const direction = imageData.getDirection();
+    return {
+        xDir: esm/* vec3.normalize */.eR.normalize([0, 0, 0], direction.slice(0, 3)),
+        yDir: esm/* vec3.normalize */.eR.normalize([0, 0, 0], direction.slice(3, 6)),
+        zDir: esm/* vec3.normalize */.eR.normalize([0, 0, 0], direction.slice(6, 9)),
+    };
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/parseCornerKey.js
+function parseCornerKey(uid) {
+    const cornerKey = uid.replace('corner_', '');
+    return {
+        isXMin: cornerKey.includes('XMIN'),
+        isXMax: cornerKey.includes('XMAX'),
+        isYMin: cornerKey.includes('YMIN'),
+        isYMax: cornerKey.includes('YMAX'),
+        isZMin: cornerKey.includes('ZMIN'),
+        isZMax: cornerKey.includes('ZMAX'),
+    };
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/copyClippingPlanes.js
+function copyClippingPlanes(planes) {
+    return planes.map((plane) => ({
+        origin: [...plane.origin],
+        normal: [...plane.normal],
+    }));
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/getColorKeyForPlaneIndex.js
+
+function getColorKeyForPlaneIndex(planeIndex) {
+    if (planeIndex === PLANEINDEX.XMIN || planeIndex === PLANEINDEX.XMAX) {
+        return 'SAGITTAL';
     }
-    get id() {
-        return this._id;
+    else if (planeIndex === PLANEINDEX.YMIN || planeIndex === PLANEINDEX.YMAX) {
+        return 'CORONAL';
     }
-    get rootElement() {
-        return this._rootElement;
+    else if (planeIndex === PLANEINDEX.ZMIN || planeIndex === PLANEINDEX.ZMAX) {
+        return 'AXIAL';
     }
-    appendTo(container) {
-        const { _rootElement: rootElement, _containerResizeObserver: resizeObserver, } = this;
-        const { parentElement: currentContainer } = rootElement;
-        if (!container || container === currentContainer) {
-            return;
-        }
-        if (currentContainer) {
-            resizeObserver.unobserve(currentContainer);
+    return null;
+}
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var dist_esm = __webpack_require__(15327);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/getOrientationFromNormal.js
+
+
+
+function getOrientationFromNormal(normal) {
+    if (!normal) {
+        return null;
+    }
+    const canonical = {
+        AXIAL: [0, 0, 1],
+        CORONAL: [0, 1, 0],
+        SAGITTAL: [1, 0, 0],
+    };
+    for (const [key, value] of Object.entries(canonical)) {
+        if (dist_esm.utilities.isEqualAbs(1, esm/* vec3.dot */.eR.dot(value, normal), ORIENTATION_TOLERANCE)) {
+            return key;
         }
-        container.appendChild(rootElement);
-        resizeObserver.observe(container);
     }
-    destroy() {
-        const { _rootElement: rootElement, _containerResizeObserver: resizeObserver, } = this;
-        const { parentElement } = rootElement;
-        parentElement?.removeChild(rootElement);
-        resizeObserver.disconnect();
+    return null;
+}
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Math.js
+var Core_Math = __webpack_require__(91352);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/computePlanePlaneIntersection.js
+
+
+
+function computePlanePlaneIntersection(clippingPlane, viewPlaneNormal, viewPlanePoint) {
+    const n1 = clippingPlane.normal;
+    const p1 = clippingPlane.origin;
+    const n2 = viewPlaneNormal;
+    const p2 = viewPlanePoint;
+    const dir = esm/* vec3.create */.eR.create();
+    esm/* vec3.cross */.eR.cross(dir, n1, n2);
+    const dirLenSq = esm/* vec3.squaredLength */.eR.squaredLength(dir);
+    if (dirLenSq < PARALLEL_PLANE_TOLERANCE) {
+        return null;
     }
-    get containerSize() {
-        return { ...this._containerSize };
+    const d1 = Core_Math/* default.dot */.Ay.dot(n1, p1);
+    const d2 = Core_Math/* default.dot */.Ay.dot(n2, p2);
+    const term1 = esm/* vec3.create */.eR.create();
+    const term2 = esm/* vec3.create */.eR.create();
+    esm/* vec3.cross */.eR.cross(term1, n2, dir);
+    esm/* vec3.scale */.eR.scale(term1, term1, d1);
+    esm/* vec3.cross */.eR.cross(term2, dir, n1);
+    esm/* vec3.scale */.eR.scale(term2, term2, d2);
+    const point = esm/* vec3.create */.eR.create();
+    esm/* vec3.add */.eR.add(point, term1, term2);
+    esm/* vec3.scale */.eR.scale(point, point, 1 / dirLenSq);
+    if (!Number.isFinite(point[0]) ||
+        !Number.isFinite(point[1]) ||
+        !Number.isFinite(point[2])) {
+        return null;
     }
-    createRootElement(id) {
-        const rootElement = document.createElement('div');
-        rootElement.id = id;
-        rootElement.classList.add('widget');
-        Object.assign(rootElement.style, {
-            width: '100%',
-            height: '100%',
-        });
-        return rootElement;
+    const direction = esm/* vec3.create */.eR.create();
+    esm/* vec3.scale */.eR.scale(direction, dir, 1 / Math.sqrt(dirLenSq));
+    return {
+        direction: direction,
+        point: point,
+    };
+}
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/vec2/liangBarksyClip.js
+var liangBarksyClip = __webpack_require__(35381);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/findLineBoundsIntersection.js
+
+
+
+function findLineBoundsIntersection(linePoint, lineDirection, viewport) {
+    const lineLength = LINE_EXTENSION_DISTANCE;
+    const lineStart = esm/* vec3.scaleAndAdd */.eR.scaleAndAdd([0, 0, 0], linePoint, lineDirection, -lineLength);
+    const lineEnd = esm/* vec3.scaleAndAdd */.eR.scaleAndAdd([0, 0, 0], linePoint, lineDirection, lineLength);
+    const canvasStart = viewport.worldToCanvas(lineStart);
+    const canvasEnd = viewport.worldToCanvas(lineEnd);
+    const { clientWidth, clientHeight } = viewport.canvas;
+    const canvasBox = [0, 0, clientWidth, clientHeight];
+    const clippedStart = esm/* vec2.clone */.Zc.clone(canvasStart);
+    const clippedEnd = esm/* vec2.clone */.Zc.clone(canvasEnd);
+    const startValid = !isNaN(clippedStart[0]) && !isNaN(clippedStart[1]);
+    const endValid = !isNaN(clippedEnd[0]) && !isNaN(clippedEnd[1]);
+    if (!startValid || !endValid) {
+        return null;
     }
-    onContainerResize() {
+    const clipResult = (0,liangBarksyClip/* default */.A)(clippedStart, clippedEnd, canvasBox);
+    if (clipResult === 0) {
+        return null;
+    }
+    const clippedStartValid = !isNaN(clippedStart[0]) && !isNaN(clippedStart[1]);
+    const clippedEndValid = !isNaN(clippedEnd[0]) && !isNaN(clippedEnd[1]);
+    if (!clippedStartValid || !clippedEndValid) {
+        return null;
+    }
+    const [xMin, yMin, xMax, yMax] = canvasBox;
+    const startInBounds = clippedStart[0] >= xMin - 1 &&
+        clippedStart[0] <= xMax + 1 &&
+        clippedStart[1] >= yMin - 1 &&
+        clippedStart[1] <= yMax + 1;
+    const endInBounds = clippedEnd[0] >= xMin - 1 &&
+        clippedEnd[0] <= xMax + 1 &&
+        clippedEnd[1] >= yMin - 1 &&
+        clippedEnd[1] <= yMax + 1;
+    if (!startInBounds || !endInBounds) {
+        return null;
+    }
+    const dx = clippedEnd[0] - clippedStart[0];
+    const dy = clippedEnd[1] - clippedStart[1];
+    const length = Math.sqrt(dx * dx + dy * dy);
+    if (length < MIN_LINE_LENGTH_PIXELS) {
+        return null;
     }
+    return {
+        start: clippedStart,
+        end: clippedEnd,
+    };
 }
 
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/index.js
+
+
+
+
+
+
+
+
+
 
 
 /***/ },
 
-/***/ 73435
-(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/***/ 22716
+() {
 
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Ay: () => (/* binding */ vtkSphereSource$1)
-/* harmony export */ });
-/* unused harmony exports extend, newInstance */
-/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90027);
-/* harmony import */ var _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12548);
-/* harmony import */ var _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(445);
 
 
+/***/ },
+
+/***/ 14770
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  C: () => (/* binding */ vtkOrientationControllerWidget)
+});
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/macros2.js
+var macros2 = __webpack_require__(90027);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/CellTypes.js
+var CellTypes = __webpack_require__(82649);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Line.js
+var Line = __webpack_require__(35856);
+;// ../../../node_modules/@kitware/vtk.js/Rendering/Core/AbstractPicker.js
 
 
 // ----------------------------------------------------------------------------
-// vtkSphereSource methods
+// vtkAbstractPicker methods
 // ----------------------------------------------------------------------------
 
-function vtkSphereSource(publicAPI, model) {
+function vtkAbstractPicker(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkSphereSource');
-  publicAPI.requestData = (inData, outData) => {
-    let dataset = outData[0];
-    const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    dataset = dataset?.initialize() || _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance();
-
-    // ----------------------------------------------------------------------
-    let numPoles = 0;
-
-    // Check data, determine increments, and convert to radians
-    let {
-      thetaResolution
-    } = model;
-    let startTheta = model.startTheta < model.endTheta ? model.startTheta : model.endTheta;
-    startTheta *= Math.PI / 180.0;
-    let endTheta = model.endTheta > model.startTheta ? model.endTheta : model.startTheta;
-    endTheta *= Math.PI / 180.0;
-    let startPhi = model.startPhi < model.endPhi ? model.startPhi : model.endPhi;
-    startPhi *= Math.PI / 180.0;
-    let endPhi = model.endPhi > model.startPhi ? model.endPhi : model.startPhi;
-    endPhi *= Math.PI / 180.0;
-    if (Math.abs(startTheta - endTheta) < 2.0 * Math.PI) {
-      ++thetaResolution;
+  model.classHierarchy.push('vtkAbstractPicker');
+  publicAPI.initialize = () => {
+    model.renderer = null;
+    model.selectionPoint[0] = 0.0;
+    model.selectionPoint[1] = 0.0;
+    model.selectionPoint[2] = 0.0;
+    model.pickPosition[0] = 0.0;
+    model.pickPosition[1] = 0.0;
+    model.pickPosition[2] = 0.0;
+  };
+  publicAPI.initializePickList = () => {
+    model.pickList = [];
+  };
+  publicAPI.addPickList = actor => {
+    model.pickList.push(actor);
+  };
+  publicAPI.deletePickList = actor => {
+    const i = model.pickList.indexOf(actor);
+    if (i !== -1) {
+      model.pickList.splice(i, 1);
     }
-    const deltaTheta = (endTheta - startTheta) / model.thetaResolution;
-    const jStart = model.startPhi <= 0.0 ? 1 : 0;
-    const jEnd = model.phiResolution + (model.endPhi >= 180.0 ? -1 : 0);
-    const numPts = model.phiResolution * thetaResolution + 2;
-    const numPolys = model.phiResolution * 2 * model.thetaResolution;
+  };
+}
 
-    // Points
-    let pointIdx = 0;
-    let points = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newTypedArray(pointDataType, numPts * 3);
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
 
-    // Normals
-    let normals = new Float32Array(numPts * 3);
+const DEFAULT_VALUES = {
+  renderer: null,
+  selectionPoint: [0.0, 0.0, 0.0],
+  pickPosition: [0.0, 0.0, 0.0],
+  pickFromList: false,
+  pickList: []
+};
 
-    // Cells
-    let cellLocation = 0;
-    let polys = new Uint32Array(numPolys * 5);
+// ----------------------------------------------------------------------------
 
-    // Create north pole if needed
-    if (model.startPhi <= 0.0) {
-      points[pointIdx * 3 + 0] = model.center[0];
-      points[pointIdx * 3 + 1] = model.center[1];
-      points[pointIdx * 3 + 2] = model.center[2] + model.radius;
-      normals[pointIdx * 3 + 0] = 0;
-      normals[pointIdx * 3 + 1] = 0;
-      normals[pointIdx * 3 + 2] = 1;
-      pointIdx++;
-      numPoles++;
-    }
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-    // Create south pole if needed
-    if (model.endPhi >= 180.0) {
+  // Build VTK API
+  macros2.m.obj(publicAPI, model);
+  macros2.m.get(publicAPI, model, ['renderer']);
+  macros2.m.getArray(publicAPI, model, ['selectionPoint', 'pickPosition']);
+  macros2.m.setGet(publicAPI, model, ['pickFromList', 'pickList']);
+  vtkAbstractPicker(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macros2.m.newInstance(extend, 'vtkAbstractPicker');
+
+// ----------------------------------------------------------------------------
+
+var vtkAbstractPicker$1 = {
+  newInstance,
+  extend
+};
+
+
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/BoundingBox.js
+var BoundingBox = __webpack_require__(24377);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Math/index.js
+var Core_Math = __webpack_require__(8047);
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
+var esm = __webpack_require__(3823);
+;// ../../../node_modules/@kitware/vtk.js/Rendering/Core/Picker.js
+
+
+
+
+
+
+const {
+  vtkErrorMacro
+} = macros2.m;
+const {
+  vtkWarningMacro
+} = macros2.m;
+
+// ----------------------------------------------------------------------------
+// vtkPicker methods
+// ----------------------------------------------------------------------------
+
+function vtkPicker(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPicker');
+  const superClass = {
+    ...publicAPI
+  };
+  function initialize() {
+    superClass.initialize();
+    model.actors = [];
+    model.pickedPositions = [];
+    model.mapperPosition[0] = 0.0;
+    model.mapperPosition[1] = 0.0;
+    model.mapperPosition[2] = 0.0;
+    model.mapper = null;
+    model.dataSet = null;
+    model.globalTMin = Number.MAX_VALUE;
+  }
+
+  /**
+   * Compute the tolerance in world coordinates.
+   * Do this by determining the world coordinates of the diagonal points of the
+   * window, computing the width of the window in world coordinates, and
+   * multiplying by the tolerance.
+   * @param {Number} selectionZ
+   * @param {Number} aspect
+   * @param {vtkRenderer} renderer
+   * @returns {Number} the computed tolerance
+   */
+  function computeTolerance(selectionZ, aspect, renderer) {
+    let tolerance = 0.0;
+    const view = renderer.getRenderWindow().getViews()[0];
+    const viewport = renderer.getViewport();
+    const winSize = view.getSize();
+    let x = winSize[0] * viewport[0];
+    let y = winSize[1] * viewport[1];
+    const normalizedLeftDisplay = view.displayToNormalizedDisplay(x, y, selectionZ);
+    const windowLowerLeft = renderer.normalizedDisplayToWorld(normalizedLeftDisplay[0], normalizedLeftDisplay[1], normalizedLeftDisplay[2], aspect);
+    x = winSize[0] * viewport[2];
+    y = winSize[1] * viewport[3];
+    const normalizedRightDisplay = view.displayToNormalizedDisplay(x, y, selectionZ);
+    const windowUpperRight = renderer.normalizedDisplayToWorld(normalizedRightDisplay[0], normalizedRightDisplay[1], normalizedRightDisplay[2], aspect);
+    for (let i = 0; i < 3; i++) {
+      tolerance += (windowUpperRight[i] - windowLowerLeft[i]) * (windowUpperRight[i] - windowLowerLeft[i]);
+    }
+    return Math.sqrt(tolerance);
+  }
+
+  /**
+   * Perform picking on the given renderer, given a ray defined in world coordinates.
+   * @param {*} renderer
+   * @param {*} tolerance
+   * @param {*} p1World
+   * @param {*} p2World
+   * @returns true if we picked something else false
+   */
+  function pick3DInternal(renderer, tolerance, p1World, p2World) {
+    const p1Mapper = new Float64Array(4);
+    const p2Mapper = new Float64Array(4);
+    const ray = [];
+    const hitPosition = [];
+    const props = model.pickFromList ? model.pickList : renderer.getActors();
+
+    // pre-allocate some arrays.
+    const transformScale = new Float64Array(3);
+    const pickedPosition = new Float64Array(3);
+
+    // Loop over props.
+    // Transform ray (defined from position of camera to selection point) into coordinates of mapper (not
+    // transformed to actors coordinates!  Reduces overall computation!!!).
+    // Note that only vtkProp3D's can be picked by vtkPicker.
+    props.forEach(prop => {
+      const mapper = prop.getMapper();
+      const propIsFullyTranslucent = prop.getProperty?.().getOpacity?.() === 0.0;
+      const pickable = prop.getNestedPickable() && prop.getNestedVisibility() && !propIsFullyTranslucent;
+      if (!pickable) {
+        // prop cannot be picked
+        return;
+      }
+
+      // The prop is candidate for picking:
+      // - get its composite matrix and invert it
+      // - use the inverted matrix to transform the ray points into mapper coordinates
+      model.transformMatrix = prop.getMatrix().slice(0);
+      esm/* mat4.transpose */.pB.transpose(model.transformMatrix, model.transformMatrix);
+      esm/* mat4.invert */.pB.invert(model.transformMatrix, model.transformMatrix);
+      esm/* vec4.transformMat4 */.ln.transformMat4(p1Mapper, p1World, model.transformMatrix);
+      esm/* vec4.transformMat4 */.ln.transformMat4(p2Mapper, p2World, model.transformMatrix);
+      esm/* vec3.scale */.eR.scale(p1Mapper, p1Mapper, 1 / p1Mapper[3]);
+      esm/* vec3.scale */.eR.scale(p2Mapper, p2Mapper, 1 / p2Mapper[3]);
+      (0,Core_Math.s)(p2Mapper, p1Mapper, ray);
+
+      // We now have the ray endpoints in mapper coordinates.
+      // Compare it with the mapper bounds to check if intersection is possible.
+
+      // Get the bounding box of the mapper.
+      // Note that the tolerance is added to the bounding box to make sure things on the edge of the
+      // bounding box are picked correctly.
+      const bounds = mapper ? BoundingBox/* default */.Ay.inflate(mapper.getBounds(), tolerance) : [...BoundingBox/* default */.Ay.INIT_BOUNDS];
+      if (BoundingBox/* default.intersectBox */.Ay.intersectBox(bounds, p1Mapper, ray, hitPosition, [])) {
+        esm/* mat4.getScaling */.pB.getScaling(transformScale, model.transformMatrix);
+        const t = model.intersectWithLine(p1Mapper, p2Mapper, tolerance * 0.333 * (transformScale[0] + transformScale[1] + transformScale[2]), prop, mapper);
+        if (t < Number.MAX_VALUE) {
+          pickedPosition[0] = (1.0 - t) * p1World[0] + t * p2World[0];
+          pickedPosition[1] = (1.0 - t) * p1World[1] + t * p2World[1];
+          pickedPosition[2] = (1.0 - t) * p1World[2] + t * p2World[2];
+          const actorIndex = model.actors.indexOf(prop);
+          if (actorIndex !== -1) {
+            // If already in list, compare the previous picked position with the new one.
+            // Store the new one if it is closer from the ray endpoint.
+            const previousPickedPosition = model.pickedPositions[actorIndex];
+            if ((0,Core_Math.f)(p1World, pickedPosition) < (0,Core_Math.f)(p1World, previousPickedPosition)) {
+              model.pickedPositions[actorIndex] = pickedPosition.slice(0);
+            }
+          } else {
+            model.actors.push(prop);
+            model.pickedPositions.push(pickedPosition.slice(0));
+          }
+        }
+      }
+    });
+
+    // sort array by distance
+    const tempArray = [];
+    for (let i = 0; i < model.pickedPositions.length; i++) {
+      tempArray.push({
+        actor: model.actors[i],
+        pickedPosition: model.pickedPositions[i],
+        distance2: (0,Core_Math.f)(p1World, model.pickedPositions[i])
+      });
+    }
+    tempArray.sort((a, b) => {
+      const keyA = a.distance2;
+      const keyB = b.distance2;
+      // order the actors based on the distance2 attribute, so the near actors comes
+      // first in the list
+      if (keyA < keyB) return -1;
+      if (keyA > keyB) return 1;
+      return 0;
+    });
+    model.pickedPositions = [];
+    model.actors = [];
+    tempArray.forEach(obj => {
+      model.pickedPositions.push(obj.pickedPosition);
+      model.actors.push(obj.actor);
+    });
+  }
+
+  // Intersect data with specified ray.
+  // Project the center point of the mapper onto the ray and determine its parametric value
+  model.intersectWithLine = (p1, p2, tolerance, prop, mapper) => {
+    if (!mapper) {
+      return Number.MAX_VALUE;
+    }
+    const center = mapper.getCenter();
+    const ray = esm/* vec3.subtract */.eR.subtract(new Float64Array(3), p2, p1);
+    const rayFactor = (0,Core_Math.d)(ray, ray);
+    if (rayFactor === 0.0) {
+      return 2.0;
+    }
+
+    // Project the center point onto the ray and determine its parametric value
+    const t = (ray[0] * (center[0] - p1[0]) + ray[1] * (center[1] - p1[1]) + ray[2] * (center[2] - p1[2])) / rayFactor;
+    return t;
+  };
+
+  // To be overridden in subclasses
+  publicAPI.pick = (selection, renderer) => {
+    if (selection.length !== 3) {
+      vtkWarningMacro('vtkPicker.pick - selection needs three components');
+    }
+    if (!renderer) {
+      vtkErrorMacro('vtkPicker.pick - renderer cannot be null');
+      throw new Error('renderer cannot be null');
+    }
+    initialize();
+    const selectionX = selection[0];
+    const selectionY = selection[1];
+    let selectionZ = selection[2];
+    model.renderer = renderer;
+    model.selectionPoint[0] = selectionX;
+    model.selectionPoint[1] = selectionY;
+    model.selectionPoint[2] = selectionZ;
+    const p1World = new Float64Array(4);
+    const p2World = new Float64Array(4);
+
+    // Get camera focal point and position. Convert to display (screen)
+    // coordinates. We need a depth value for z-buffer.
+    const camera = renderer.getActiveCamera();
+    const cameraPos = camera.getPosition();
+    const cameraFP = camera.getFocalPoint();
+    const view = renderer.getRenderWindow().getViews()[0];
+    const dims = view.getViewportSize(renderer);
+    if (dims[1] === 0) {
+      vtkWarningMacro('vtkPicker.pick - viewport area is 0');
+      return;
+    }
+    const aspect = dims[0] / dims[1];
+    let displayCoords = [];
+    displayCoords = renderer.worldToNormalizedDisplay(cameraFP[0], cameraFP[1], cameraFP[2], aspect);
+    displayCoords = view.normalizedDisplayToDisplay(displayCoords[0], displayCoords[1], displayCoords[2]);
+    selectionZ = displayCoords[2];
+
+    // Convert the selection point into world coordinates.
+    const normalizedDisplay = view.displayToNormalizedDisplay(selectionX, selectionY, selectionZ);
+    const worldCoords = renderer.normalizedDisplayToWorld(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2], aspect);
+    for (let i = 0; i < 3; i++) {
+      model.pickPosition[i] = worldCoords[i];
+    }
+
+    //  Compute the ray endpoints. The ray is along the line running from
+    //  the camera position to the selection point, starting where this line
+    //  intersects the front clipping plane, and terminating where this
+    //  line intersects the back clipping plane.
+    const ray = [];
+    for (let i = 0; i < 3; i++) {
+      ray[i] = model.pickPosition[i] - cameraPos[i];
+    }
+    const cameraDOP = [];
+    for (let i = 0; i < 3; i++) {
+      cameraDOP[i] = cameraFP[i] - cameraPos[i];
+    }
+    (0,Core_Math.l)(cameraDOP);
+    const rayLength = (0,Core_Math.d)(cameraDOP, ray);
+    if (rayLength === 0.0) {
+      vtkWarningMacro('Picker::Pick Cannot process points');
+      return;
+    }
+    const clipRange = camera.getClippingRange();
+    let tF;
+    let tB;
+    if (camera.getParallelProjection()) {
+      tF = clipRange[0] - rayLength;
+      tB = clipRange[1] - rayLength;
+      for (let i = 0; i < 3; i++) {
+        p1World[i] = model.pickPosition[i] + tF * cameraDOP[i];
+        p2World[i] = model.pickPosition[i] + tB * cameraDOP[i];
+      }
+    } else {
+      tF = clipRange[0] / rayLength;
+      tB = clipRange[1] / rayLength;
+      for (let i = 0; i < 3; i++) {
+        p1World[i] = cameraPos[i] + tF * ray[i];
+        p2World[i] = cameraPos[i] + tB * ray[i];
+      }
+    }
+    p1World[3] = 1.0;
+    p2World[3] = 1.0;
+    const tolerance = computeTolerance(selectionZ, aspect, renderer) * model.tolerance;
+    pick3DInternal(model.renderer, tolerance, p1World, p2World);
+  };
+  publicAPI.pick3DPoint = (selectionPoint, focalPoint, renderer) => {
+    if (!renderer) {
+      throw new Error('renderer cannot be null');
+    }
+    initialize();
+    model.renderer = renderer;
+    esm/* vec3.copy */.eR.copy(model.selectionPoint, selectionPoint);
+    const view = renderer.getRenderWindow().getViews()[0];
+    const dims = view.getViewportSize(renderer);
+    if (dims[1] === 0) {
+      vtkWarningMacro('vtkPicker.pick3DPoint - viewport area is 0');
+      return;
+    }
+    const aspect = dims[0] / dims[1];
+    const tolerance = computeTolerance(model.selectionPoint[2], aspect, renderer) * model.tolerance;
+    pick3DInternal(renderer, tolerance, selectionPoint, focalPoint);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const Picker_DEFAULT_VALUES = {
+  tolerance: 0.025,
+  mapperPosition: [0.0, 0.0, 0.0],
+  mapper: null,
+  dataSet: null,
+  actors: [],
+  pickedPositions: [],
+  transformMatrix: null,
+  globalTMin: Number.MAX_VALUE
+};
+
+// ----------------------------------------------------------------------------
+function Picker_extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, Picker_DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  vtkAbstractPicker$1.extend(publicAPI, model, initialValues);
+  macros2.m.setGet(publicAPI, model, ['tolerance']);
+  macros2.m.setGetArray(publicAPI, model, ['mapperPosition'], 3);
+  macros2.m.get(publicAPI, model, ['mapper', 'dataSet', 'actors', 'pickedPositions']);
+  macros2.m.event(publicAPI, model, 'pickChange');
+  vtkPicker(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const Picker_newInstance = macros2.m.newInstance(Picker_extend, 'vtkPicker');
+
+// ----------------------------------------------------------------------------
+
+var vtkPicker$1 = {
+  newInstance: Picker_newInstance,
+  extend: Picker_extend
+};
+
+
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyLine.js
+var PolyLine = __webpack_require__(21186);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Triangle.js
+var Triangle = __webpack_require__(96402);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Quad.js
+var Quad = __webpack_require__(82021);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/CellTypes/Constants.js
+var Constants = __webpack_require__(61091);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/ImplicitFunction.js
+var ImplicitFunction = __webpack_require__(53001);
+;// ../../../node_modules/@kitware/vtk.js/Common/DataModel/Box.js
+
+
+
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+// Bounding box intersection code from David Gobbi.  Go through the
+// bounding planes one at a time and compute the parametric coordinate
+// of each intersection and return the parametric values and the calculated points
+function intersectWithLine(bounds, p1, p2) {
+  let plane1 = -1;
+  let plane2 = -1;
+  let t1 = 0.0;
+  let t2 = 1.0;
+  for (let j = 0; j < 3; j++) {
+    for (let k = 0; k < 2; k++) {
+      // Compute distances of p1 and p2 from the plane along the plane normal
+      const i = 2 * j + k;
+      const d1 = (bounds[i] - p1[j]) * (1 - 2 * k);
+      const d2 = (bounds[i] - p2[j]) * (1 - 2 * k);
+
+      // If both distances are positive, both points are outside
+      if (d1 > 0 && d2 > 0) {
+        return;
+      }
+      // If one of the distances is positive, the line crosses the plane
+      if (d1 > 0 || d2 > 0) {
+        // Compute fractional distance "t" of the crossing between p1 & p2
+        let t = 0.0;
+        if (d1 !== 0) {
+          t = d1 / (d1 - d2);
+        }
+
+        // If point p1 was clipped, adjust t1
+        if (d1 > 0) {
+          if (t >= t1) {
+            t1 = t;
+            plane1 = i;
+          }
+        }
+        // else point p2 was clipped, so adjust t2
+        else if (t <= t2) {
+          t2 = t;
+          plane2 = i;
+        }
+        // If this happens, there's no line left
+        if (t1 > t2) {
+          // Allow for planes that are coincident or slightly inverted
+          if (plane1 < 0 || plane2 < 0) {
+            return;
+          }
+        }
+      }
+    }
+  }
+  function getValues(plane, t) {
+    const x = [0, 0, 0];
+    for (let count = 0; count < 2; count++) {
+      for (let i = 0; i < 3; i++) {
+        if (plane === 2 * i || plane === 2 * i + 1) {
+          x[i] = bounds[plane];
+        } else {
+          x[i] = p1[i] * (1.0 - t) + p2[i] * t;
+          if (x[i] < bounds[2 * i]) {
+            x[i] = bounds[2 * i];
+          }
+          if (x[i] > bounds[2 * i + 1]) {
+            x[i] = bounds[2 * i + 1];
+          }
+        }
+      }
+    }
+    return x;
+  }
+  const x1 = getValues(plane1, t1);
+  const x2 = getValues(plane2, t2);
+  const outObject = {
+    t1,
+    t2,
+    x1,
+    x2
+  };
+
+  // eslint-disable-next-line consistent-return
+  return outObject;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+const STATIC = {};
+
+// ----------------------------------------------------------------------------
+// vtkBox methods
+// ----------------------------------------------------------------------------
+function vtkBox(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkBox');
+
+  // TODO: replace with macro.setArray ?
+  publicAPI.setBounds = function () {
+    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 {
+      for (let i = 0; i < bounds.length; i++) {
+        boundsArray.push(bounds[i]);
+      }
+    }
+    if (boundsArray.length !== 6) {
+      console.log('vtkBox.setBounds', boundsArray, bounds);
+      return;
+    }
+    BoundingBox/* default.setBounds */.Ay.setBounds(model.bbox, boundsArray);
+  };
+  publicAPI.getBounds = () => model.bbox;
+  publicAPI.evaluateFunction = (x, y, z) => {
+    const point = Array.isArray(x) ? x : [x, y, z];
+    let diff;
+    let dist;
+    let t;
+    let minDistance = -Number.MAX_VALUE;
+    let distance = 0;
+    const minPoint = BoundingBox/* default.getMinPoint */.Ay.getMinPoint(model.bbox);
+    const maxPoint = BoundingBox/* default.getMaxPoint */.Ay.getMaxPoint(model.bbox);
+    let inside = 1;
+    for (let i = 0; i < 3; i++) {
+      diff = BoundingBox/* default.getLength */.Ay.getLength(model.bbox, i);
+      if (diff !== 0.0) {
+        t = (point[i] - minPoint[i]) / diff;
+        if (t < 0.0) {
+          inside = 0;
+          dist = minPoint[i] - point[i];
+        } else if (t > 1.0) {
+          inside = 0;
+          dist = point[i] - maxPoint[i];
+        } else {
+          // want negative distance, we are inside
+          if (t <= 0.5) {
+            dist = minPoint[i] - point[i];
+          } else {
+            dist = point[i] - maxPoint[i];
+          }
+          if (dist > minDistance) {
+            // remember, it's negative
+            minDistance = dist;
+          }
+        } // end if inside
+      } else {
+        dist = Math.abs(point[i] - minPoint[i]);
+        if (dist > 0.0) {
+          inside = 0;
+        }
+      }
+      if (dist > 0.0) {
+        distance += dist * dist;
+      }
+    } // end for i
+    distance = Math.sqrt(distance);
+    if (inside) {
+      return minDistance;
+    }
+    return distance;
+  };
+  publicAPI.addBounds = function () {
+    let boundsArray = [];
+    if (Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
+      boundsArray = arguments.length <= 0 ? undefined : arguments[0];
+    } else {
+      for (let i = 0; i < arguments.length; i++) {
+        boundsArray.push(i < 0 || arguments.length <= i ? undefined : arguments[i]);
+      }
+    }
+    if (boundsArray.length !== 6) {
+      return;
+    }
+    BoundingBox/* default.addBounds */.Ay.addBounds(model.bbox, ...boundsArray);
+    publicAPI.modified();
+  };
+  publicAPI.addBox = other => publicAPI.addBounds(other.getBounds());
+  publicAPI.intersectWithLine = (p1, p2) => intersectWithLine(model.bbox, p1, p2);
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const Box_DEFAULT_VALUES = {
+  bbox: [...BoundingBox/* default */.Ay.INIT_BOUNDS]
+};
+
+// ----------------------------------------------------------------------------
+
+function Box_extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, Box_DEFAULT_VALUES, initialValues);
+
+  // Object methods
+  ImplicitFunction/* default.extend */.Ay.extend(publicAPI, model, initialValues);
+  vtkBox(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const Box_newInstance = macros2.m.newInstance(Box_extend, 'vtkBox');
+
+// ----------------------------------------------------------------------------
+
+var vtkBox$1 = {
+  newInstance: Box_newInstance,
+  extend: Box_extend,
+  intersectWithLine,
+  ...STATIC
+};
+
+
+
+;// ../../../node_modules/@kitware/vtk.js/Rendering/Core/CellPicker.js
+
+
+
+
+
+
+
+
+
+
+
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+function createCellMap() {
+  return {
+    [Constants/* CellType */.vZ.VTK_LINE]: Line/* default.newInstance */.Ay.newInstance(),
+    [Constants/* CellType */.vZ.VTK_POLY_LINE]: PolyLine/* default.newInstance */.Ay.newInstance(),
+    [Constants/* CellType */.vZ.VTK_TRIANGLE]: Triangle/* default.newInstance */.Ay.newInstance(),
+    [Constants/* CellType */.vZ.VTK_QUAD]: Quad/* default.newInstance */.Ay.newInstance()
+  };
+}
+function clipLineWithPlane(mapper, matrix, p1, p2) {
+  const outObj = {
+    planeId: -1,
+    t1: 0.0,
+    t2: 1.0,
+    intersect: 0
+  };
+  const nbClippingPlanes = mapper.getNumberOfClippingPlanes();
+  const plane = [];
+  for (let i = 0; i < nbClippingPlanes; i++) {
+    mapper.getClippingPlaneInDataCoords(matrix, i, plane);
+    const d1 = plane[0] * p1[0] + plane[1] * p1[1] + plane[2] * p1[2] + plane[3];
+    const d2 = plane[0] * p2[0] + plane[1] * p2[1] + plane[2] * p2[2] + plane[3];
+
+    // If both distances are negative, both points are outside
+    if (d1 < 0 && d2 < 0) {
+      return 0;
+    }
+    if (d1 < 0 || d2 < 0) {
+      // If only one of the distances is negative, the line crosses the plane
+      // Compute fractional distance "t" of the crossing between p1 & p2
+      let t = 0.0;
+
+      // The "if" here just avoids an expensive division when possible
+      if (d1 !== 0) {
+        // We will never have d1==d2 since they have different signs
+        t = d1 / (d1 - d2);
+      }
+
+      // If point p1 was clipped, adjust t1
+      if (d1 < 0) {
+        if (t >= outObj.t1) {
+          outObj.t1 = t;
+          outObj.planeId = i;
+        }
+      } else if (t <= outObj.t2) {
+        // else point p2 was clipped, so adjust t2
+        outObj.t2 = t;
+      }
+      // If this happens, there's no line left
+      if (outObj.t1 > outObj.t2) {
+        outObj.intersect = 0;
+        return outObj;
+      }
+    }
+  }
+  outObj.intersect = 1;
+  return outObj;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+const CellPicker_STATIC = {
+  clipLineWithPlane
+};
+
+// ----------------------------------------------------------------------------
+// vtkCellPicker methods
+// ----------------------------------------------------------------------------
+
+function vtkCellPicker(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkCellPicker');
+  const superClass = {
+    ...publicAPI
+  };
+  function resetCellPickerInfo() {
+    model.cellId = -1;
+    model.pCoords[0] = 0.0;
+    model.pCoords[1] = 0.0;
+    model.pCoords[2] = 0.0;
+    model.cellIJK[0] = 0.0;
+    model.cellIJK[1] = 0.0;
+    model.cellIJK[2] = 0.0;
+    model.mapperNormal[0] = 0.0;
+    model.mapperNormal[1] = 0.0;
+    model.mapperNormal[2] = 1.0;
+    model.pickNormal[0] = 0.0;
+    model.pickNormal[1] = 0.0;
+    model.pickNormal[2] = 1.0;
+  }
+  function resetPickInfo() {
+    model.dataSet = null;
+    model.mapper = null;
+    resetCellPickerInfo();
+  }
+  publicAPI.initialize = () => {
+    resetPickInfo();
+    superClass.initialize();
+  };
+  publicAPI.computeSurfaceNormal = (data, cell, weights, normal) => {
+    const normals = data.getPointData().getNormals();
+    if (normals) {
+      normal[0] = 0.0;
+      normal[1] = 0.0;
+      normal[2] = 0.0;
+      const pointNormal = [];
+      for (let i = 0; i < 3; i++) {
+        normals.getTuple(cell.getPointsIds()[i], pointNormal);
+        normal[0] += pointNormal[0] * weights[i];
+        normal[1] += pointNormal[1] * weights[i];
+        normal[2] += pointNormal[2] * weights[i];
+      }
+      (0,Core_Math.l)(normal);
+    } else {
+      return 0;
+    }
+    return 1;
+  };
+  publicAPI.pick = (selection, renderer) => {
+    publicAPI.initialize();
+    const pickResult = superClass.pick(selection, renderer);
+    if (pickResult) {
+      const camera = renderer.getActiveCamera();
+      const cameraPos = [];
+      camera.getPosition(cameraPos);
+      if (camera.getParallelProjection()) {
+        // For parallel projection, use -ve direction of projection
+        const cameraFocus = [];
+        camera.getFocalPoint(cameraFocus);
+        model.pickNormal[0] = cameraPos[0] - cameraFocus[0];
+        model.pickNormal[1] = cameraPos[1] - cameraFocus[1];
+        model.pickNormal[2] = cameraPos[2] - cameraFocus[2];
+      } else {
+        // Get the vector from pick position to the camera
+        model.pickNormal[0] = cameraPos[0] - model.pickPosition[0];
+        model.pickNormal[1] = cameraPos[1] - model.pickPosition[1];
+        model.pickNormal[2] = cameraPos[2] - model.pickPosition[2];
+      }
+      (0,Core_Math.l)(model.pickNormal);
+    }
+    return pickResult;
+  };
+  model.intersectWithLine = (p1, p2, tolerance, prop, mapper) => {
+    let tMin = Number.MAX_VALUE;
+    let t1 = 0.0;
+    let t2 = 1.0;
+    const vtkCellPickerPlaneTol = 1e-14;
+    const clipLine = clipLineWithPlane(mapper, model.transformMatrix, p1, p2);
+    if (mapper && !clipLine.intersect) {
+      return Number.MAX_VALUE;
+    }
+    if (mapper.isA('vtkImageMapper') || mapper.isA('vtkImageArrayMapper')) {
+      const pickData = mapper.intersectWithLineForCellPicking(p1, p2);
+      if (pickData) {
+        tMin = pickData.t;
+        model.cellIJK = pickData.ijk;
+        model.pCoords = pickData.pCoords;
+      }
+    } else if (mapper.isA('vtkVolumeMapper')) {
+      // we calculate here the parametric intercept points between the ray and the bounding box, so
+      // if the application defines for some reason a too large ray length (1e6), it restrict the calculation
+      // to the vtkVolume prop bounding box
+      const interceptionObject = vtkBox$1.intersectWithLine(mapper.getBounds(), p1, p2);
+      t1 = interceptionObject?.t1 > clipLine.t1 ? interceptionObject.t1 : clipLine.t1;
+      t2 = interceptionObject?.t2 < clipLine.t2 ? interceptionObject.t2 : clipLine.t2;
+      tMin = model.intersectVolumeWithLine(p1, p2, t1, t2, tolerance, prop);
+    } else if (mapper.isA('vtkMapper')) {
+      tMin = model.intersectActorWithLine(p1, p2, t1, t2, tolerance, mapper);
+    }
+    if (tMin < model.globalTMin) {
+      model.globalTMin = tMin;
+      if (Math.abs(tMin - t1) < vtkCellPickerPlaneTol && clipLine.clippingPlaneId >= 0) {
+        model.mapperPosition[0] = p1[0] * (1 - t1) + p2[0] * t1;
+        model.mapperPosition[1] = p1[1] * (1 - t1) + p2[1] * t1;
+        model.mapperPosition[2] = p1[2] * (1 - t1) + p2[2] * t1;
+        const plane = [];
+        mapper.getClippingPlaneInDataCoords(model.transformMatrix, clipLine.clippingPlaneId, plane);
+        (0,Core_Math.l)(plane);
+        // Want normal outward from the planes, not inward
+        model.mapperNormal[0] = -plane[0];
+        model.mapperNormal[1] = -plane[1];
+        model.mapperNormal[2] = -plane[2];
+      }
+      esm/* vec3.transformMat4 */.eR.transformMat4(model.pickPosition, model.mapperPosition, model.transformMatrix);
+      // Transform vector
+      const mat = model.transformMatrix;
+      model.mapperNormal[0] = mat[0] * model.pickNormal[0] + mat[4] * model.pickNormal[1] + mat[8] * model.pickNormal[2];
+      model.mapperNormal[1] = mat[1] * model.pickNormal[0] + mat[5] * model.pickNormal[1] + mat[9] * model.pickNormal[2];
+      model.mapperNormal[2] = mat[2] * model.pickNormal[0] + mat[6] * model.pickNormal[1] + mat[10] * model.pickNormal[2];
+    }
+    return tMin;
+  };
+  model.intersectVolumeWithLine = (p1, p2, t1, t2, tolerance, volume) => {
+    let tMin = Number.MAX_VALUE;
+    const mapper = volume.getMapper();
+    const imageData = mapper.getInputData();
+    const dims = imageData.getDimensions();
+    const scalars = imageData.getPointData().getScalars().getData();
+    const extent = imageData.getExtent();
+    // get the world to index transform to correctly transform from world to volume index
+    const imageTransform = imageData.getWorldToIndex();
+
+    // calculate opacity table
+    const numIComps = 1;
+    let oWidth = mapper.getOpacityTextureWidth();
+    if (oWidth <= 0) {
+      oWidth = 1024;
+    }
+    const tmpTable = new Float32Array(oWidth);
+    const opacityArray = new Float32Array(oWidth);
+    let ofun;
+    let oRange;
+    const sampleDist = volume.getMapper().getSampleDistance();
+    for (let c = 0; c < numIComps; ++c) {
+      ofun = volume.getProperty().getScalarOpacity(c);
+      oRange = ofun.getRange();
+      ofun.getTable(oRange[0], oRange[1], oWidth, tmpTable, 1);
+      const opacityFactor = sampleDist / volume.getProperty().getScalarOpacityUnitDistance(c);
+
+      // adjust for sample distance etc
+      for (let i = 0; i < oWidth; ++i) {
+        opacityArray[i] = 1.0 - (1.0 - tmpTable[i]) ** opacityFactor;
+      }
+    }
+    const scale = oWidth / (oRange[1] - oRange[0] + 1);
+
+    // Make a new p1 and p2 using the clipped t1 and t2
+    const q1 = [0, 0, 0, 1];
+    const q2 = [0, 0, 0, 1];
+    q1[0] = p1[0];
+    q1[1] = p1[1];
+    q1[2] = p1[2];
+    q2[0] = p2[0];
+    q2[1] = p2[1];
+    q2[2] = p2[2];
+    if (t1 !== 0.0 || t2 !== 1.0) {
+      for (let j = 0; j < 3; j++) {
+        q1[j] = p1[j] * (1.0 - t1) + p2[j] * t1;
+        q2[j] = p1[j] * (1.0 - t2) + p2[j] * t2;
+      }
+    }
+
+    // convert q1, q2 world coordinates to x1, x2 volume index coordinates
+    const x1 = [0, 0, 0, 0];
+    const x2 = [0, 0, 0, 0];
+    esm/* vec4.transformMat4 */.ln.transformMat4(x1, q1, imageTransform);
+    esm/* vec4.transformMat4 */.ln.transformMat4(x2, q2, imageTransform);
+    const x = [0, 0, 0];
+    const xi = [0, 0, 0];
+    const sliceSize = dims[1] * dims[0];
+    const rowSize = dims[0];
+    // here the step is the 1 over the distance between volume index location x1 and x2
+    const step = 1 / Math.sqrt((0,Core_Math.f)(x1, x2));
+    let insideVolume;
+    // here we reinterpret the t value as the distance between x1 and x2
+    // When calculating the tMin, we weight t between t1 and t2 values
+    for (let t = 0; t < 1; t += step) {
+      // calculate the location of the point
+      insideVolume = true;
+      for (let j = 0; j < 3; j++) {
+        // "t" is the fractional distance between endpoints x1 and x2
+        x[j] = x1[j] * (1.0 - t) + x2[j] * t;
+      }
+      for (let j = 0; j < 3; j++) {
+        // Bounds check
+        if (x[j] < extent[2 * j]) {
+          x[j] = extent[2 * j];
+          insideVolume = false;
+        } else if (x[j] > extent[2 * j + 1]) {
+          x[j] = extent[2 * j + 1];
+          insideVolume = false;
+        }
+        xi[j] = Math.round(x[j]);
+      }
+      if (insideVolume) {
+        const index = xi[2] * sliceSize + xi[1] * rowSize + xi[0];
+        let value = scalars[index];
+        if (value < oRange[0]) {
+          value = oRange[0];
+        } else if (value > oRange[1]) {
+          value = oRange[1];
+        }
+        value = Math.floor((value - oRange[0]) * scale);
+        const opacity = tmpTable[value];
+        if (opacity > model.opacityThreshold) {
+          // returning the tMin to the original scale, if t1 > 0 or t2 < 1
+          tMin = t1 * (1.0 - t) + t2 * t;
+          break;
+        }
+      }
+    }
+    return tMin;
+  };
+  model.intersectActorWithLine = (p1, p2, t1, t2, tolerance, mapper) => {
+    let tMin = Number.MAX_VALUE;
+    const minXYZ = [0, 0, 0];
+    let pDistMin = Number.MAX_VALUE;
+    const minPCoords = [0, 0, 0];
+    let minCellId = null;
+    let minCell = null;
+    let minCellType = null;
+    let subId = null;
+    const x = [];
+    const data = mapper.getInputData();
+
+    // Make a new p1 and p2 using the clipped t1 and t2
+    const q1 = [0, 0, 0];
+    const q2 = [0, 0, 0];
+    q1[0] = p1[0];
+    q1[1] = p1[1];
+    q1[2] = p1[2];
+    q2[0] = p2[0];
+    q2[1] = p2[1];
+    q2[2] = p2[2];
+    if (t1 !== 0.0 || t2 !== 1.0) {
+      for (let j = 0; j < 3; j++) {
+        q1[j] = p1[j] * (1.0 - t1) + p2[j] * t1;
+        q2[j] = p1[j] * (1.0 - t2) + p2[j] * t2;
+      }
+    }
+    if (data.getCells) {
+      if (!data.getCells()) {
+        data.buildLinks();
+      }
+      const tempCellMap = createCellMap();
+      const minCellMap = createCellMap();
+      const numberOfCells = data.getNumberOfCells();
+
+      /* eslint-disable no-continue */
+      for (let cellId = 0; cellId < numberOfCells; cellId++) {
+        const pCoords = [0, 0, 0];
+        minCellType = data.getCellType(cellId);
+
+        // Skip cells that are marked as empty
+        if (minCellType === Constants/* CellType */.vZ.VTK_EMPTY_CELL) {
+          continue;
+        }
+        const cell = tempCellMap[minCellType];
+        if (cell == null) {
+          continue;
+        }
+        minCell = minCellMap[minCellType];
+        data.getCell(cellId, cell);
+        let cellPicked;
+        {
+          if (CellTypes/* default */.Ay.hasSubCells(minCellType)) {
+            cellPicked = cell.intersectWithLine(t1, t2, p1, p2, tolerance, x, pCoords);
+          } else {
+            cellPicked = cell.intersectWithLine(p1, p2, tolerance, x, pCoords);
+          }
+        }
+        if (cellPicked.intersect === 1 && cellPicked.t <= tMin + model.tolerance && cellPicked.t >= t1 && cellPicked.t <= t2) {
+          const pDist = cell.getParametricDistance(pCoords);
+          if (pDist < pDistMin || pDist === pDistMin && cellPicked.t < tMin) {
+            tMin = cellPicked.t;
+            pDistMin = pDist;
+            subId = cellPicked.subId;
+            minCellId = cellId;
+            cell.deepCopy(minCell);
+            for (let k = 0; k < 3; k++) {
+              minXYZ[k] = x[k];
+              minPCoords[k] = pCoords[k];
+            }
+          }
+        }
+      }
+      /* eslint-enable no-continue */
+    }
+
+    if (minCellId >= 0 && tMin < model.globalTMin) {
+      resetPickInfo();
+      const nbPointsInCell = minCell.getNumberOfPoints();
+      const weights = new Array(nbPointsInCell);
+      for (let i = 0; i < nbPointsInCell; i++) {
+        weights[i] = 0.0;
+      }
+      const point = [];
+      if (CellTypes/* default */.Ay.hasSubCells(minCellType)) {
+        minCell.evaluateLocation(subId, minPCoords, point, weights);
+      } else {
+        minCell.evaluateLocation(minPCoords, point, weights);
+      }
+
+      // Return the polydata to the user
+      model.dataSet = data;
+      model.cellId = minCellId;
+      model.pCoords[0] = minPCoords[0];
+      model.pCoords[1] = minPCoords[1];
+      model.pCoords[2] = minPCoords[2];
+
+      // Find the point with the maximum weight
+      let maxWeight = 0;
+      let iMaxWeight = -1;
+      for (let i = 0; i < nbPointsInCell; i++) {
+        if (weights[i] > maxWeight) {
+          iMaxWeight = i;
+          maxWeight = weights[i];
+        }
+      }
+
+      // If maximum weight is found, use it to get the PointId
+      if (iMaxWeight !== -1) {
+        model.pointId = minCell.getPointsIds()[iMaxWeight];
+      }
+
+      // Set the mapper position
+      model.mapperPosition[0] = minXYZ[0];
+      model.mapperPosition[1] = minXYZ[1];
+      model.mapperPosition[2] = minXYZ[2];
+
+      // Compute the normal
+      if (!publicAPI.computeSurfaceNormal(data, minCell, weights, model.mapperNormal)) {
+        // By default, the normal points back along view ray
+        model.mapperNormal[0] = p1[0] - p2[0];
+        model.mapperNormal[1] = p1[1] - p2[1];
+        model.mapperNormal[2] = p1[2] - p2[2];
+        (0,Core_Math.l)(model.mapperNormal);
+      }
+    }
+    return tMin;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const CellPicker_DEFAULT_VALUES = {
+  cellId: -1,
+  pCoords: [],
+  cellIJK: [],
+  pickNormal: [],
+  mapperNormal: [],
+  opacityThreshold: 0.2
+};
+
+// ----------------------------------------------------------------------------
+
+function CellPicker_extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, CellPicker_DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  vtkPicker$1.extend(publicAPI, model, initialValues);
+  macros2.m.getArray(publicAPI, model, ['pickNormal', 'mapperNormal', 'pCoords', 'cellIJK']);
+  macros2.m.setGet(publicAPI, model, ['opacityThreshold']);
+  macros2.m.get(publicAPI, model, ['cellId']);
+
+  // Object methods
+  vtkCellPicker(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const CellPicker_newInstance = macros2.m.newInstance(CellPicker_extend, 'vtkCellPicker');
+
+// ----------------------------------------------------------------------------
+
+var vtkCellPicker$1 = {
+  newInstance: CellPicker_newInstance,
+  extend: CellPicker_extend,
+  ...CellPicker_STATIC
+};
+
+
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Actor.js
+var Actor = __webpack_require__(44404);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var dist_esm = __webpack_require__(15327);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/macros.js
+var macros = __webpack_require__(28241);
+// 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/Common/Core/DataArray.js
+var DataArray = __webpack_require__(445);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Texture.js
+var Texture = __webpack_require__(41090);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/ImageHelper.js
+var ImageHelper = __webpack_require__(74821);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/CellArray.js
+var CellArray = __webpack_require__(32461);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/vtkjs/RhombicuboctahedronSource/index.js
+
+
+
+
+const MAIN_FACES = [
+    4, 0, 1, 2, 3, 4, 4, 5, 6, 7, 4, 8, 9, 10, 11, 4, 12, 13, 14, 15, 4, 16, 17,
+    18, 19, 4, 20, 21, 22, 23,
+];
+const CORNER_FACES = [
+    3, 0, 16, 8, 3, 1, 9, 20, 3, 2, 23, 13, 3, 3, 12, 19, 3, 4, 17, 11, 3, 5, 10,
+    21, 3, 6, 14, 22, 3, 7, 18, 15,
+];
+const EDGE_FACES = [
+    4, 0, 1, 9, 8, 4, 1, 2, 23, 20, 4, 2, 3, 12, 13, 4, 3, 0, 16, 19, 4, 4, 5, 10,
+    11, 4, 5, 6, 22, 21, 4, 6, 7, 15, 14, 4, 7, 4, 17, 18, 4, 8, 11, 17, 16, 4, 9,
+    20, 21, 10, 4, 13, 23, 22, 14, 4, 12, 19, 18, 15,
+];
+function vtkRhombicuboctahedronSource(publicAPI, model) {
+    model.classHierarchy.push('vtkRhombicuboctahedronSource');
+    publicAPI.requestData = (inData, outData) => {
+        const polyData = outData[0]?.initialize() || PolyData/* default.newInstance */.Ay.newInstance();
+        outData[0] = polyData;
+        let scale = 1.0;
+        if (model.scale !== undefined && model.scale !== null) {
+            if (Array.isArray(model.scale)) {
+                scale = model.scale[0] || 1.0;
+            }
+            else if (typeof model.scale === 'number') {
+                scale = model.scale;
+            }
+        }
+        const phi = 1.4;
+        const faceSize = 0.88;
+        const vertices = [];
+        vertices.push(-faceSize, -faceSize, -phi);
+        vertices.push(faceSize, -faceSize, -phi);
+        vertices.push(faceSize, faceSize, -phi);
+        vertices.push(-faceSize, faceSize, -phi);
+        vertices.push(-faceSize, -faceSize, phi);
+        vertices.push(faceSize, -faceSize, phi);
+        vertices.push(faceSize, faceSize, phi);
+        vertices.push(-faceSize, faceSize, phi);
+        vertices.push(-faceSize, -phi, -faceSize);
+        vertices.push(faceSize, -phi, -faceSize);
+        vertices.push(faceSize, -phi, faceSize);
+        vertices.push(-faceSize, -phi, faceSize);
+        vertices.push(-faceSize, phi, -faceSize);
+        vertices.push(faceSize, phi, -faceSize);
+        vertices.push(faceSize, phi, faceSize);
+        vertices.push(-faceSize, phi, faceSize);
+        vertices.push(-phi, -faceSize, -faceSize);
+        vertices.push(-phi, -faceSize, faceSize);
+        vertices.push(-phi, faceSize, faceSize);
+        vertices.push(-phi, faceSize, -faceSize);
+        vertices.push(phi, -faceSize, -faceSize);
+        vertices.push(phi, -faceSize, faceSize);
+        vertices.push(phi, faceSize, faceSize);
+        vertices.push(phi, faceSize, -faceSize);
+        let textureCoords = null;
+        if (model.generate3DTextureCoordinates) {
+            textureCoords = new Float64Array(24 * 3);
+            for (let i = 0; i < 24; i++) {
+                const vx = vertices[i * 3];
+                const vy = vertices[i * 3 + 1];
+                const vz = vertices[i * 3 + 2];
+                const len = Math.sqrt(vx * vx + vy * vy + vz * vz) || 1;
+                textureCoords[i * 3] = vx / len;
+                textureCoords[i * 3 + 1] = vy / len;
+                textureCoords[i * 3 + 2] = vz / len;
+            }
+        }
+        for (let i = 0; i < vertices.length; i++) {
+            vertices[i] *= scale;
+        }
+        const vertexArray = Float64Array.from(vertices);
+        polyData.getPoints().setData(vertexArray, 3);
+        const normals = new Float64Array(24 * 3);
+        for (let i = 0; i < 24; i++) {
+            const x = vertexArray[i * 3];
+            const y = vertexArray[i * 3 + 1];
+            const z = vertexArray[i * 3 + 2];
+            const len = Math.sqrt(x * x + y * y + z * z);
+            normals[i * 3] = x / len;
+            normals[i * 3 + 1] = y / len;
+            normals[i * 3 + 2] = z / len;
+        }
+        const normalArray = DataArray/* default.newInstance */.Ay.newInstance({
+            name: 'Normals',
+            values: normals,
+            numberOfComponents: 3,
+        });
+        polyData.getPointData().setNormals(normalArray);
+        if (textureCoords) {
+            const tcoords = DataArray/* default.newInstance */.Ay.newInstance({
+                name: 'TextureCoordinates',
+                values: textureCoords,
+                numberOfComponents: 3,
+            });
+            polyData.getPointData().setTCoords(tcoords);
+        }
+        const allFaces = [];
+        if (model.generateMainFaces) {
+            allFaces.push(...MAIN_FACES);
+        }
+        if (model.generateEdgeFaces) {
+            allFaces.push(...EDGE_FACES);
+        }
+        if (model.generateCornerFaces) {
+            allFaces.push(...CORNER_FACES);
+        }
+        if (allFaces.length > 0) {
+            const polys = CellArray/* default.newInstance */.Ay.newInstance({
+                values: Uint16Array.from(allFaces),
+            });
+            polyData.getPolys().deepCopy(polys);
+        }
+        else {
+            polyData.getPolys().initialize();
+        }
+        polyData.modified();
+    };
+}
+const RhombicuboctahedronSource_DEFAULT_VALUES = {
+    scale: 1.0,
+    generate3DTextureCoordinates: false,
+    generateMainFaces: true,
+    generateEdgeFaces: true,
+    generateCornerFaces: true,
+};
+function RhombicuboctahedronSource_extend(publicAPI, model, initialValues = {}) {
+    Object.assign(model, RhombicuboctahedronSource_DEFAULT_VALUES, initialValues);
+    macros/* default.obj */.Ay.obj(publicAPI, model);
+    macros/* default.setGet */.Ay.setGet(publicAPI, model, [
+        'scale',
+        'generate3DTextureCoordinates',
+        'generateMainFaces',
+        'generateEdgeFaces',
+        'generateCornerFaces',
+    ]);
+    macros/* default.algo */.Ay.algo(publicAPI, model, 0, 1);
+    vtkRhombicuboctahedronSource(publicAPI, model);
+}
+const RhombicuboctahedronSource_newInstance = macros/* default.newInstance */.Ay.newInstance(RhombicuboctahedronSource_extend, 'vtkRhombicuboctahedronSource');
+/* harmony default export */ const RhombicuboctahedronSource = ({ newInstance: RhombicuboctahedronSource_newInstance, extend: RhombicuboctahedronSource_extend });
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/vtkjs/AnnotatedRhombicuboctahedronActor/index.js
+
+
+
+
+
+
+
+function createMainFacesMesh(scale, faceColors, faceTextures) {
+    const source = RhombicuboctahedronSource.newInstance({
+        generate3DTextureCoordinates: false,
+        generateMainFaces: true,
+        generateEdgeFaces: false,
+        generateCornerFaces: false,
+        scale: scale,
+    });
+    source.update();
+    const data = source.getOutputData();
+    if (data) {
+        const tcoords = [];
+        for (let faceIdx = 0; faceIdx < 6; faceIdx++) {
+            const col = faceIdx % 3;
+            const row = Math.floor(faceIdx / 3);
+            const u0 = col / 3.0;
+            const u1 = (col + 1) / 3.0;
+            const v0 = row / 2.0;
+            const v1 = (row + 1) / 2.0;
+            tcoords.push(u0, v0);
+            tcoords.push(u1, v0);
+            tcoords.push(u1, v1);
+            tcoords.push(u0, v1);
+        }
+        const tcoordsArray = DataArray/* default.newInstance */.Ay.newInstance({
+            name: 'TextureCoordinates',
+            values: new Float32Array(tcoords),
+            numberOfComponents: 2,
+        });
+        data.getPointData().setTCoords(tcoordsArray);
+        data.modified();
+    }
+    return data;
+}
+function createEdgeFacesMesh(scale, color) {
+    const source = RhombicuboctahedronSource.newInstance({
+        generate3DTextureCoordinates: false,
+        generateMainFaces: false,
+        generateEdgeFaces: true,
+        generateCornerFaces: false,
+        scale: scale,
+    });
+    source.update();
+    const data = source.getOutputData();
+    if (data) {
+        const colors = [];
+        const numCells = data.getNumberOfCells();
+        for (let i = 0; i < numCells; i++) {
+            colors.push(color[0], color[1], color[2], 255);
+        }
+        const colorsArray = DataArray/* default.newInstance */.Ay.newInstance({
+            name: 'Colors',
+            values: new Uint8Array(colors),
+            numberOfComponents: 4,
+        });
+        data.getCellData().setScalars(colorsArray);
+        data.modified();
+    }
+    return data;
+}
+function createCornerFacesMesh(scale, color) {
+    const source = RhombicuboctahedronSource.newInstance({
+        generate3DTextureCoordinates: false,
+        generateMainFaces: false,
+        generateEdgeFaces: false,
+        generateCornerFaces: true,
+        scale: scale,
+    });
+    source.update();
+    const data = source.getOutputData();
+    if (data) {
+        const colors = [];
+        const numCells = data.getNumberOfCells();
+        for (let i = 0; i < numCells; i++) {
+            colors.push(color[0], color[1], color[2], 255);
+        }
+        const colorsArray = DataArray/* default.newInstance */.Ay.newInstance({
+            name: 'Colors',
+            values: new Uint8Array(colors),
+            numberOfComponents: 4,
+        });
+        data.getCellData().setScalars(colorsArray);
+        data.modified();
+    }
+    return data;
+}
+function createTextureAtlas(faceTextureData) {
+    const faceSize = 256;
+    const canvas = document.createElement('canvas');
+    canvas.width = faceSize * 3;
+    canvas.height = faceSize * 2;
+    const ctx = canvas.getContext('2d');
+    faceTextureData.forEach((data, index) => {
+        const col = index % 3;
+        const row = Math.floor(index / 3);
+        const x = col * faceSize;
+        const y = row * faceSize;
+        ctx.fillStyle = `rgb(${data.faceColor[0]}, ${data.faceColor[1]}, ${data.faceColor[2]})`;
+        ctx.fillRect(x, y, faceSize, faceSize);
+        if (data.text) {
+            ctx.save();
+            ctx.translate(x + faceSize / 2, y + faceSize / 2);
+            if (data.flipVertical) {
+                ctx.scale(1, -1);
+            }
+            if (data.flipHorizontal) {
+                ctx.scale(-1, 1);
+            }
+            ctx.rotate(((data.rotation || 0) * Math.PI) / 180);
+            ctx.fillStyle = `rgb(${data.textColor[0]}, ${data.textColor[1]}, ${data.textColor[2]})`;
+            ctx.font = 'bold 180px Arial';
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'middle';
+            ctx.fillText(data.text, 0, 0);
+            ctx.restore();
+        }
+    });
+    return ImageHelper/* default */.A.canvasToImageData(canvas);
+}
+function vtkAnnotatedRhombicuboctahedronActor(publicAPI, model) {
+    model.classHierarchy.push('vtkAnnotatedRhombicuboctahedronActor');
+    function updateAllFaceTextures() { }
+    function createActors() {
+        let sourceScale = 1.0;
+        if (model.scale !== undefined && model.scale !== null) {
+            if (Array.isArray(model.scale)) {
+                sourceScale = model.scale[0] || 1.0;
+            }
+            else if (typeof model.scale === 'number') {
+                sourceScale = model.scale;
+            }
+        }
+        const actors = [];
+        const hexToRgb = (hex) => {
+            const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+            return result
+                ? result.slice(1, 4).map((n) => parseInt(n, 16))
+                : [255, 255, 255];
+        };
+        const parseFontColor = (color) => {
+            if (!color) {
+                return [0, 0, 0];
+            }
+            const rgbMatch = color.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+            if (rgbMatch) {
+                return [
+                    parseInt(rgbMatch[1], 10),
+                    parseInt(rgbMatch[2], 10),
+                    parseInt(rgbMatch[3], 10),
+                ];
+            }
+            if (color.startsWith('#')) {
+                return hexToRgb(color);
+            }
+            const namedColors = {
+                black: [0, 0, 0],
+                white: [255, 255, 255],
+                red: [255, 0, 0],
+                green: [0, 255, 0],
+                blue: [0, 0, 255],
+            };
+            if (namedColors[color.toLowerCase()]) {
+                return namedColors[color.toLowerCase()];
+            }
+            return [0, 0, 0];
+        };
+        const faceColors = {
+            zMinus: hexToRgb(model.zMinusFaceProperty.faceColor || model.defaultStyle.faceColor),
+            zPlus: hexToRgb(model.zPlusFaceProperty.faceColor || model.defaultStyle.faceColor),
+            yMinus: hexToRgb(model.yMinusFaceProperty.faceColor || model.defaultStyle.faceColor),
+            yPlus: hexToRgb(model.yPlusFaceProperty.faceColor || model.defaultStyle.faceColor),
+            xMinus: hexToRgb(model.xMinusFaceProperty.faceColor || model.defaultStyle.faceColor),
+            xPlus: hexToRgb(model.xPlusFaceProperty.faceColor || model.defaultStyle.faceColor),
+        };
+        if (model.showMainFaces !== false) {
+            const faceTextureData = [
+                {
+                    faceColor: faceColors.zMinus,
+                    text: model.zMinusFaceProperty.text || 'I',
+                    textColor: parseFontColor(model.zMinusFaceProperty.fontColor || model.defaultStyle.fontColor),
+                    rotation: 0,
+                },
+                {
+                    faceColor: faceColors.zPlus,
+                    text: model.zPlusFaceProperty.text || 'S',
+                    textColor: parseFontColor(model.zPlusFaceProperty.fontColor || model.defaultStyle.fontColor),
+                    rotation: 0,
+                    flipVertical: true,
+                },
+                {
+                    faceColor: faceColors.yMinus,
+                    text: model.yMinusFaceProperty.text || 'A',
+                    textColor: parseFontColor(model.yMinusFaceProperty.fontColor || model.defaultStyle.fontColor),
+                    rotation: 180,
+                },
+                {
+                    faceColor: faceColors.yPlus,
+                    text: model.yPlusFaceProperty.text || 'P',
+                    textColor: parseFontColor(model.yPlusFaceProperty.fontColor || model.defaultStyle.fontColor),
+                    rotation: 180,
+                },
+                {
+                    faceColor: faceColors.xMinus,
+                    text: model.xMinusFaceProperty.text || 'L',
+                    textColor: parseFontColor(model.xMinusFaceProperty.fontColor || model.defaultStyle.fontColor),
+                    rotation: 90,
+                    flipVertical: true,
+                },
+                {
+                    faceColor: faceColors.xPlus,
+                    text: model.xPlusFaceProperty.text || 'R',
+                    textColor: parseFontColor(model.xPlusFaceProperty.fontColor || model.defaultStyle.fontColor),
+                    rotation: 90,
+                },
+            ];
+            const atlasImageData = createTextureAtlas(faceTextureData);
+            const mainData = createMainFacesMesh(sourceScale, faceColors, null);
+            if (mainData) {
+                const mainFacesActor = Actor/* default.newInstance */.Ay.newInstance();
+                const mainMapper = Mapper/* default.newInstance */.Ay.newInstance();
+                mainMapper.setInputData(mainData);
+                mainFacesActor.setMapper(mainMapper);
+                const texture = Texture/* default.newInstance */.Ay.newInstance();
+                texture.setInputData(atlasImageData);
+                texture.setInterpolate(true);
+                mainFacesActor.addTexture(texture);
+                const property = mainFacesActor.getProperty();
+                property.setBackfaceCulling(false);
+                property.setFrontfaceCulling(false);
+                property.setLighting(false);
+                property.setAmbient(1.0);
+                property.setDiffuse(0.0);
+                property.setSpecular(0.0);
+                actors.push(mainFacesActor);
+            }
+        }
+        if (model.showEdgeFaces !== false) {
+            const edgeColor = [200, 200, 200];
+            const edgeData = createEdgeFacesMesh(sourceScale, edgeColor);
+            if (edgeData) {
+                const edgeFacesActor = Actor/* default.newInstance */.Ay.newInstance();
+                const edgeMapper = Mapper/* default.newInstance */.Ay.newInstance();
+                edgeMapper.setInputData(edgeData);
+                edgeMapper.setScalarModeToUseCellData();
+                edgeMapper.setScalarVisibility(true);
+                edgeMapper.setColorModeToDirectScalars();
+                edgeFacesActor.setMapper(edgeMapper);
+                const edgeProperty = edgeFacesActor.getProperty();
+                edgeProperty.setBackfaceCulling(false);
+                edgeProperty.setFrontfaceCulling(false);
+                edgeProperty.setLighting(false);
+                edgeProperty.setAmbient(1.0);
+                edgeProperty.setDiffuse(0.0);
+                edgeProperty.setSpecular(0.0);
+                actors.push(edgeFacesActor);
+            }
+        }
+        if (model.showCornerFaces !== false) {
+            const cornerColor = [150, 150, 150];
+            const cornerData = createCornerFacesMesh(sourceScale, cornerColor);
+            if (cornerData) {
+                const cornerFacesActor = Actor/* default.newInstance */.Ay.newInstance();
+                const cornerMapper = Mapper/* default.newInstance */.Ay.newInstance();
+                cornerMapper.setInputData(cornerData);
+                cornerMapper.setScalarModeToUseCellData();
+                cornerMapper.setScalarVisibility(true);
+                cornerMapper.setColorModeToDirectScalars();
+                cornerFacesActor.setMapper(cornerMapper);
+                const cornerProperty = cornerFacesActor.getProperty();
+                cornerProperty.setBackfaceCulling(false);
+                cornerProperty.setFrontfaceCulling(false);
+                cornerProperty.setLighting(false);
+                cornerProperty.setAmbient(1.0);
+                cornerProperty.setDiffuse(0.0);
+                cornerProperty.setSpecular(0.0);
+                actors.push(cornerFacesActor);
+            }
+        }
+        return actors;
+    }
+    publicAPI.setDefaultStyle = (style) => {
+        model.defaultStyle = { ...model.defaultStyle, ...style };
+    };
+    publicAPI.setXPlusFaceProperty = (prop) => {
+        Object.assign(model.xPlusFaceProperty, prop);
+        publicAPI.modified();
+    };
+    publicAPI.setXMinusFaceProperty = (prop) => {
+        Object.assign(model.xMinusFaceProperty, prop);
+        publicAPI.modified();
+    };
+    publicAPI.setYPlusFaceProperty = (prop) => {
+        Object.assign(model.yPlusFaceProperty, prop);
+        publicAPI.modified();
+    };
+    publicAPI.setYMinusFaceProperty = (prop) => {
+        Object.assign(model.yMinusFaceProperty, prop);
+        publicAPI.modified();
+    };
+    publicAPI.setZPlusFaceProperty = (prop) => {
+        Object.assign(model.zPlusFaceProperty, prop);
+        publicAPI.modified();
+    };
+    publicAPI.setZMinusFaceProperty = (prop) => {
+        Object.assign(model.zMinusFaceProperty, prop);
+        publicAPI.modified();
+    };
+    publicAPI.setShowMainFaces = (show) => {
+        if (model.showMainFaces !== show) {
+            model.showMainFaces = show;
+            updateAllFaceTextures();
+        }
+    };
+    publicAPI.setShowEdgeFaces = (show) => {
+        if (model.showEdgeFaces !== show) {
+            model.showEdgeFaces = show;
+            updateAllFaceTextures();
+        }
+    };
+    publicAPI.setShowCornerFaces = (show) => {
+        if (model.showCornerFaces !== show) {
+            model.showCornerFaces = show;
+            updateAllFaceTextures();
+        }
+    };
+    publicAPI.setRhombScale = (scale) => {
+        if (model.scale !== scale) {
+            model.scale = scale;
+        }
+    };
+    publicAPI.getActors = () => {
+        return createActors();
+    };
+}
+const AnnotatedRhombicuboctahedronActor_DEFAULT_VALUES = {
+    defaultStyle: {
+        text: '',
+        faceColor: 'white',
+        faceRotation: 0,
+        fontFamily: 'Arial',
+        fontColor: 'black',
+        fontStyle: 'normal',
+        fontSizeScale: (resolution) => resolution / 1.8,
+        edgeThickness: 0.1,
+        edgeColor: 'black',
+        resolution: 200,
+    },
+    xPlusFaceProperty: {},
+    xMinusFaceProperty: {},
+    yPlusFaceProperty: {},
+    yMinusFaceProperty: {},
+    zPlusFaceProperty: {},
+    zMinusFaceProperty: {},
+    showMainFaces: true,
+    showEdgeFaces: true,
+    showCornerFaces: true,
+    scale: 1.0,
+};
+function AnnotatedRhombicuboctahedronActor_extend(publicAPI, model, initialValues = {}) {
+    Object.assign(model, AnnotatedRhombicuboctahedronActor_DEFAULT_VALUES, initialValues);
+    Actor/* default.extend */.Ay.extend(publicAPI, model, initialValues);
+    model.xPlusFaceProperty = { ...model.xPlusFaceProperty };
+    model.xMinusFaceProperty = { ...model.xMinusFaceProperty };
+    model.yPlusFaceProperty = { ...model.yPlusFaceProperty };
+    model.yMinusFaceProperty = { ...model.yMinusFaceProperty };
+    model.zPlusFaceProperty = { ...model.zPlusFaceProperty };
+    model.zMinusFaceProperty = { ...model.zMinusFaceProperty };
+    macros/* default.get */.Ay.get(publicAPI, model, [
+        'defaultStyle',
+        'xPlusFaceProperty',
+        'xMinusFaceProperty',
+        'yPlusFaceProperty',
+        'yMinusFaceProperty',
+        'zPlusFaceProperty',
+        'zMinusFaceProperty',
+        'showMainFaces',
+        'showEdgeFaces',
+        'showCornerFaces',
+        'scale',
+    ]);
+    vtkAnnotatedRhombicuboctahedronActor(publicAPI, model);
+}
+const AnnotatedRhombicuboctahedronActor_newInstance = macros/* default.newInstance */.Ay.newInstance(AnnotatedRhombicuboctahedronActor_extend, 'vtkAnnotatedRhombicuboctahedronActor');
+/* harmony default export */ const AnnotatedRhombicuboctahedronActor = ({ newInstance: AnnotatedRhombicuboctahedronActor_newInstance, extend: AnnotatedRhombicuboctahedronActor_extend });
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/vtkjs/OrientationControllerWidget/index.js
+
+
+
+
+class vtkOrientationControllerWidget {
+    constructor() {
+        this.actors = new Map();
+        this.pickers = new Map();
+        this.highlightedFace = null;
+        this.mouseHandlers = new Map();
+    }
+    createActors(config) {
+        const rgbToHex = (rgb) => {
+            return `#${rgb
+                .map((x) => {
+                const hex = Math.round(x).toString(16);
+                return hex.length === 1 ? '0' + hex : hex;
+            })
+                .join('')}`;
+        };
+        const rgbToHexColor = (rgb) => {
+            return `rgb(${rgb[0]}, ${rgb[1]}, ${rgb[2]})`;
+        };
+        const actorFactory = AnnotatedRhombicuboctahedronActor.newInstance();
+        const defaultStyle = {
+            fontStyle: 'bold',
+            fontFamily: 'Arial',
+            fontColor: 'black',
+            fontSizeScale: (res) => res / 2,
+            faceColor: rgbToHex(config.faceColors.topBottom),
+            edgeThickness: 0.1,
+            edgeColor: 'black',
+            resolution: 400,
+        };
+        actorFactory.setDefaultStyle(defaultStyle);
+        actorFactory.setXPlusFaceProperty({
+            text: 'L',
+            faceColor: rgbToHex(config.faceColors.leftRight),
+            fontColor: rgbToHexColor(config.letterColors.xPlus),
+            faceRotation: 0,
+        });
+        actorFactory.setXMinusFaceProperty({
+            text: 'R',
+            faceColor: rgbToHex(config.faceColors.leftRight),
+            fontColor: rgbToHexColor(config.letterColors.xMinus),
+            faceRotation: 0,
+        });
+        actorFactory.setYPlusFaceProperty({
+            text: 'P',
+            faceColor: rgbToHex(config.faceColors.frontBack),
+            fontColor: rgbToHexColor(config.letterColors.yPlus),
+            faceRotation: 180,
+        });
+        actorFactory.setYMinusFaceProperty({
+            text: 'A',
+            faceColor: rgbToHex(config.faceColors.frontBack),
+            fontColor: rgbToHexColor(config.letterColors.yMinus),
+            faceRotation: 0,
+        });
+        actorFactory.setZPlusFaceProperty({
+            text: 'S',
+            faceColor: rgbToHex(config.faceColors.topBottom),
+            fontColor: rgbToHexColor(config.letterColors.zPlus),
+        });
+        actorFactory.setZMinusFaceProperty({
+            text: 'I',
+            faceColor: rgbToHex(config.faceColors.topBottom),
+            fontColor: rgbToHexColor(config.letterColors.zMinus),
+        });
+        actorFactory.setShowMainFaces(true);
+        actorFactory.setShowEdgeFaces(config.showEdgeFaces);
+        actorFactory.setShowCornerFaces(config.showCornerFaces);
+        const actors = actorFactory.getActors();
+        actors.forEach((actor) => {
+            const property = actor.getProperty();
+            property.setOpacity(config.opacity);
+            actor.setVisibility(true);
+        });
+        return actors;
+    }
+    addActorsToViewport(viewportId, viewport, actors) {
+        const existingActors = this.actors.get(viewportId);
+        if (existingActors) {
+            this.removeActorsFromViewport(viewportId, viewport);
+        }
+        actors.forEach((actor, index) => {
+            const uid = `orientation-controller-${viewportId}-${index}`;
+            viewport.addActor({ actor, uid });
+        });
+        this.actors.set(viewportId, actors);
+    }
+    removeActorsFromViewport(viewportId, viewport) {
+        const actors = this.actors.get(viewportId);
+        if (actors) {
+            const uids = actors.map((_, index) => `orientation-controller-${viewportId}-${index}`);
+            viewport.removeActors(uids);
+            this.actors.delete(viewportId);
+        }
+    }
+    setupPicker(viewportId, actors) {
+        const picker = vtkCellPicker$1.newInstance({ opacityThreshold: 0.0001 });
+        picker.setPickFromList(true);
+        picker.setTolerance(0.001);
+        picker.initializePickList();
+        actors.forEach((actor) => {
+            picker.addPickList(actor);
+        });
+        this.pickers.set(viewportId, picker);
+        return picker;
+    }
+    pickAtPosition(evt, viewportId, viewport, element, actors) {
+        const picker = this.pickers.get(viewportId);
+        if (!picker) {
+            return null;
+        }
+        const mainRenderer = viewport
+            .getRenderingEngine()
+            ?.getRenderer(viewportId) ?? viewport.getRenderer();
+        const renderer = mainRenderer;
+        if (!renderer) {
+            return null;
+        }
+        const rect = element.getBoundingClientRect();
+        const x = evt.clientX - rect.left;
+        const y = evt.clientY - rect.top;
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const canvasPosWithDPR = [x * devicePixelRatio, y * devicePixelRatio];
+        const canvas = viewport.canvas;
+        const { width, height } = canvas;
+        const [xMin, yMin, xMax, yMax] = renderer.getViewport();
+        const viewportWidth = xMax - xMin;
+        const viewportHeight = yMax - yMin;
+        const scaledX = (canvasPosWithDPR[0] / width) * viewportWidth * width;
+        const scaledY = (canvasPosWithDPR[1] / height) * viewportHeight * height;
+        const displayCoord = [scaledX, viewportHeight * height - scaledY];
+        const displayCoords = [
+            displayCoord[0],
+            displayCoord[1],
+            0,
+        ];
+        picker.pick(displayCoords, renderer);
+        const pickedActors = picker.getActors();
+        if (pickedActors.length === 0) {
+            return null;
+        }
+        const pickedActor = pickedActors[0];
+        const cellId = picker.getCellId();
+        if (actors.includes(pickedActor) && cellId !== -1) {
+            const actorIndex = actors.indexOf(pickedActor);
+            return { pickedActor, cellId, actorIndex };
+        }
+        return null;
+    }
+    calculateMarkerPosition(viewport, position) {
+        const canvas = viewport.canvas;
+        if (!canvas) {
+            return null;
+        }
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const canvasWidth = canvas.clientWidth || canvas.width / devicePixelRatio;
+        const canvasHeight = canvas.clientHeight || canvas.height / devicePixelRatio;
+        const cornerOffset = viewport.type === dist_esm.Enums.ViewportType.VOLUME_3D ? 55 : 35;
+        let canvasX;
+        let canvasY;
+        switch (position) {
+            case 'top-left':
+                canvasX = cornerOffset;
+                canvasY = cornerOffset;
+                break;
+            case 'top-right':
+                canvasX = canvasWidth - cornerOffset;
+                canvasY = cornerOffset;
+                break;
+            case 'bottom-left':
+                canvasX = cornerOffset;
+                canvasY = canvasHeight - cornerOffset;
+                break;
+            default:
+                canvasX = canvasWidth - cornerOffset;
+                canvasY = canvasHeight - cornerOffset;
+        }
+        const canvasPos = [canvasX, canvasY];
+        const worldPos = viewport.canvasToWorld(canvasPos);
+        return [worldPos[0], worldPos[1], worldPos[2]];
+    }
+    positionActors(viewport, actors, config) {
+        const canvas = viewport.canvas;
+        if (!canvas) {
+            console.warn('OrientationControllerWidget: No canvas available');
+            return false;
+        }
+        const mainRenderer = viewport
+            .getRenderingEngine()
+            ?.getRenderer(viewport.id) ?? viewport.getRenderer();
+        const camera = mainRenderer?.getActiveCamera();
+        if (!camera) {
+            return false;
+        }
+        const parallelScale = camera.getParallelScale();
+        const worldHeight = parallelScale * 2;
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const canvasHeight = canvas.clientHeight || canvas.height / devicePixelRatio;
+        const canvasWidth = canvas.clientWidth || canvas.width / devicePixelRatio;
+        const worldUnitsPerPixel = worldHeight / canvasHeight;
+        const canvasSize = Math.min(canvasWidth, canvasHeight);
+        const screenSizePixels = canvasSize * config.size;
+        const markerSize = screenSizePixels * worldUnitsPerPixel;
+        actors.forEach((actor) => {
+            actor.setScale(markerSize, markerSize, markerSize);
+            const worldPos = this.calculateMarkerPosition(viewport, config.position);
+            if (!worldPos) {
+                console.warn('OrientationControllerWidget: Could not get world position');
+                return;
+            }
+            actor.setPosition(worldPos[0], worldPos[1], worldPos[2]);
+            actor.setOrientation(0, 0, 0);
+        });
+        return true;
+    }
+    highlightFace(actor, cellId, viewport, isMainFace = false) {
+        if (this.highlightedFace &&
+            this.highlightedFace.actor === actor &&
+            this.highlightedFace.cellId === cellId &&
+            this.highlightedFace.isMainFace === isMainFace) {
+            return;
+        }
+        this.clearHighlight();
+        if (isMainFace) {
+            return;
+        }
+        const mapper = actor.getMapper();
+        const inputData = mapper.getInputData();
+        if (!inputData) {
+            return;
+        }
+        const cellData = inputData.getCellData();
+        const colors = cellData.getScalars();
+        if (!colors) {
+            return;
+        }
+        const colorArray = colors.getData();
+        const offset = cellId * 4;
+        const originalColor = [
+            colorArray[offset],
+            colorArray[offset + 1],
+            colorArray[offset + 2],
+            colorArray[offset + 3],
+        ];
+        this.highlightedFace = {
+            actor,
+            cellId,
+            originalColor,
+            viewport,
+            isMainFace: false,
+        };
+        colorArray[offset] = 255;
+        colorArray[offset + 1] = 255;
+        colorArray[offset + 2] = 255;
+        colorArray[offset + 3] = 255;
+        colors.modified();
+        inputData.modified();
+        viewport.render();
+    }
+    clearHighlight() {
+        if (!this.highlightedFace) {
+            return;
+        }
+        const { actor, cellId, originalColor, viewport, isMainFace } = this.highlightedFace;
+        if (isMainFace && this.highlightedFace.originalScale) {
+            const scale = this.highlightedFace.originalScale;
+            actor.setScale(scale[0], scale[1], scale[2]);
+            viewport.render();
+            this.highlightedFace = null;
+            return;
+        }
+        const mapper = actor.getMapper();
+        const inputData = mapper.getInputData();
+        if (!inputData) {
+            this.highlightedFace = null;
+            return;
+        }
+        const cellData = inputData.getCellData();
+        const colors = cellData.getScalars();
+        if (!colors) {
+            this.highlightedFace = null;
+            return;
+        }
+        const colorArray = colors.getData();
+        const offset = cellId * 4;
+        colorArray[offset] = originalColor[0];
+        colorArray[offset + 1] = originalColor[1];
+        colorArray[offset + 2] = originalColor[2];
+        colorArray[offset + 3] = originalColor[3];
+        colors.modified();
+        inputData.modified();
+        viewport.render();
+        this.highlightedFace = null;
+    }
+    setupMouseHandlers(viewportId, element, viewport, actors, callbacks) {
+        let isMouseDown = false;
+        const hoverHandler = (evt) => {
+            if (isMouseDown) {
+                return;
+            }
+            const pickResult = this.pickAtPosition(evt, viewportId, viewport, element, actors);
+            if (pickResult) {
+                const { pickedActor, cellId, actorIndex } = pickResult;
+                if (actorIndex !== 0) {
+                    this.highlightFace(pickedActor, cellId, viewport, false);
+                }
+                if (callbacks.onFaceHover) {
+                    callbacks.onFaceHover(pickResult);
+                }
+            }
+            else {
+                this.clearHighlight();
+                if (callbacks.onFaceHover) {
+                    callbacks.onFaceHover(null);
+                }
+            }
+        };
+        const clickHandler = (evt) => {
+            if (evt.button !== 0) {
+                return;
+            }
+            const pickResult = this.pickAtPosition(evt, viewportId, viewport, element, actors);
+            if (!pickResult) {
+                return;
+            }
+            isMouseDown = true;
+            let globalCellId = pickResult.cellId;
+            if (pickResult.actorIndex === 1) {
+                globalCellId = pickResult.cellId + 6;
+            }
+            else if (pickResult.actorIndex === 2) {
+                globalCellId = pickResult.cellId + 18;
+            }
+            callbacks.onFacePicked({
+                ...pickResult,
+                cellId: globalCellId,
+            });
+            evt.preventDefault();
+            evt.stopPropagation();
+        };
+        const mouseUpHandler = () => {
+            isMouseDown = false;
+            this.clearHighlight();
+        };
+        const dblclickHandler = (evt) => {
+            const pickResult = this.pickAtPosition(evt, viewportId, viewport, element, actors);
+            if (pickResult) {
+                evt.preventDefault();
+                evt.stopImmediatePropagation();
+            }
+        };
+        element.addEventListener('mousemove', hoverHandler);
+        element.addEventListener('mousedown', clickHandler);
+        element.addEventListener('mouseup', mouseUpHandler);
+        element.addEventListener('mouseleave', mouseUpHandler);
+        element.addEventListener('dblclick', dblclickHandler, true);
+        const cleanup = () => {
+            element.removeEventListener('mousemove', hoverHandler);
+            element.removeEventListener('mousedown', clickHandler);
+            element.removeEventListener('mouseup', mouseUpHandler);
+            element.removeEventListener('mouseleave', mouseUpHandler);
+            element.removeEventListener('dblclick', dblclickHandler, true);
+        };
+        this.mouseHandlers.set(viewportId, { cleanup });
+        return { cleanup };
+    }
+    getActors(viewportId) {
+        return this.actors.get(viewportId);
+    }
+    syncOverlayViewport(_viewportId, _viewport) {
+    }
+    getOrientationForFace(cellId) {
+        const orientations = new Map();
+        orientations.set(0, { viewPlaneNormal: [0, 0, -1], viewUp: [0, -1, 0] });
+        orientations.set(1, { viewPlaneNormal: [0, 0, 1], viewUp: [0, 1, 0] });
+        orientations.set(2, { viewPlaneNormal: [0, -1, 0], viewUp: [0, 0, 1] });
+        orientations.set(3, { viewPlaneNormal: [0, 1, 0], viewUp: [0, 0, 1] });
+        orientations.set(4, { viewPlaneNormal: [-1, 0, 0], viewUp: [0, 0, 1] });
+        orientations.set(5, { viewPlaneNormal: [1, 0, 0], viewUp: [0, 0, 1] });
+        const sqrt2 = 1 / Math.sqrt(2);
+        orientations.set(6, {
+            viewPlaneNormal: [0, -sqrt2, -sqrt2],
+            viewUp: [0, -sqrt2, sqrt2],
+        });
+        orientations.set(7, {
+            viewPlaneNormal: [sqrt2, 0, -sqrt2],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(8, {
+            viewPlaneNormal: [0, sqrt2, -sqrt2],
+            viewUp: [0, -sqrt2, -sqrt2],
+        });
+        orientations.set(9, {
+            viewPlaneNormal: [-sqrt2, 0, -sqrt2],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(10, {
+            viewPlaneNormal: [0, -sqrt2, sqrt2],
+            viewUp: [0, sqrt2, sqrt2],
+        });
+        orientations.set(11, {
+            viewPlaneNormal: [sqrt2, 0, sqrt2],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(12, {
+            viewPlaneNormal: [0, sqrt2, sqrt2],
+            viewUp: [0, sqrt2, -sqrt2],
+        });
+        orientations.set(13, {
+            viewPlaneNormal: [-sqrt2, 0, sqrt2],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(14, {
+            viewPlaneNormal: [-sqrt2, -sqrt2, 0],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(15, {
+            viewPlaneNormal: [sqrt2, -sqrt2, 0],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(16, {
+            viewPlaneNormal: [sqrt2, sqrt2, 0],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(17, {
+            viewPlaneNormal: [-sqrt2, sqrt2, 0],
+            viewUp: [0, 0, 1],
+        });
+        const sqrt3 = 1 / Math.sqrt(3);
+        orientations.set(18, {
+            viewPlaneNormal: [-sqrt3, -sqrt3, -sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(19, {
+            viewPlaneNormal: [sqrt3, -sqrt3, -sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(20, {
+            viewPlaneNormal: [sqrt3, sqrt3, -sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(21, {
+            viewPlaneNormal: [-sqrt3, sqrt3, -sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(22, {
+            viewPlaneNormal: [-sqrt3, -sqrt3, sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(23, {
+            viewPlaneNormal: [sqrt3, -sqrt3, sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(24, {
+            viewPlaneNormal: [sqrt3, sqrt3, sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(25, {
+            viewPlaneNormal: [-sqrt3, sqrt3, sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        return orientations.get(cellId) || null;
+    }
+    cleanup(viewportId) {
+        if (viewportId) {
+            const handler = this.mouseHandlers.get(viewportId);
+            if (handler) {
+                handler.cleanup();
+                this.mouseHandlers.delete(viewportId);
+            }
+            this.actors.delete(viewportId);
+            this.pickers.delete(viewportId);
+        }
+        else {
+            this.mouseHandlers.forEach((handler) => handler.cleanup());
+            this.mouseHandlers.clear();
+            this.actors.clear();
+            this.pickers.clear();
+        }
+        this.clearHighlight();
+    }
+}
+
+
+/***/ },
+
+/***/ 44845
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ Widget)
+/* harmony export */ });
+/* unused harmony export Widget */
+class Widget {
+    constructor({ id, container }) {
+        this._containerResizeCallback = (entries) => {
+            let width;
+            let height;
+            const { contentRect, contentBoxSize } = entries[0];
+            if (contentRect) {
+                width = contentRect.width;
+                height = contentRect.height;
+            }
+            else if (contentBoxSize?.length) {
+                width = contentBoxSize[0].inlineSize;
+                height = contentBoxSize[0].blockSize;
+            }
+            this._containerSize = { width, height };
+            this.onContainerResize();
+        };
+        this._id = id;
+        this._containerSize = { width: 0, height: 0 };
+        this._rootElement = this.createRootElement(id);
+        this._containerResizeObserver = new ResizeObserver(this._containerResizeCallback);
+        if (container) {
+            this.appendTo(container);
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    get rootElement() {
+        return this._rootElement;
+    }
+    appendTo(container) {
+        const { _rootElement: rootElement, _containerResizeObserver: resizeObserver, } = this;
+        const { parentElement: currentContainer } = rootElement;
+        if (!container || container === currentContainer) {
+            return;
+        }
+        if (currentContainer) {
+            resizeObserver.unobserve(currentContainer);
+        }
+        container.appendChild(rootElement);
+        resizeObserver.observe(container);
+    }
+    destroy() {
+        const { _rootElement: rootElement, _containerResizeObserver: resizeObserver, } = this;
+        const { parentElement } = rootElement;
+        parentElement?.removeChild(rootElement);
+        resizeObserver.disconnect();
+    }
+    get containerSize() {
+        return { ...this._containerSize };
+    }
+    createRootElement(id) {
+        const rootElement = document.createElement('div');
+        rootElement.id = id;
+        rootElement.classList.add('widget');
+        Object.assign(rootElement.style, {
+            width: '100%',
+            height: '100%',
+        });
+        return rootElement;
+    }
+    onContainerResize() {
+    }
+}
+
+
+
+/***/ },
+
+/***/ 74821
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ ImageHelper)
+/* harmony export */ });
+/* harmony import */ var _DataModel_ImageData_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(26393);
+/* harmony import */ var _DataArray_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(445);
+
+
+
+/**
+ * Takes a canvas and converts it to a vtkImageData.
+ *
+ * Optionally supply a bounding box to get a particular subset of the canvas.
+ *
+ * @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];
+  const [top, left, width, height] = boundingBox;
+  const ctxt = canvas.getContext('2d');
+  const idata = ctxt.getImageData(top, left, width || canvas.width, height || canvas.height);
+  const imageData = _DataModel_ImageData_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance({
+    type: 'vtkImageData'
+  });
+  imageData.setOrigin(0, 0, 0);
+  imageData.setSpacing(1, 1, 1);
+  imageData.setExtent(0, (width || canvas.width) - 1, 0, (height || canvas.height) - 1, 0, 0);
+  const scalars = _DataArray_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance({
+    numberOfComponents: 4,
+    values: new Uint8Array(idata.data.buffer)
+  });
+  scalars.setName('scalars');
+  imageData.getPointData().setScalars(scalars);
+  return imageData;
+}
+
+/**
+ * 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
+  };
+  const canvas = document.createElement('canvas');
+  canvas.width = image.width;
+  canvas.height = image.height;
+  const ctx = canvas.getContext('2d');
+  const {
+    flipX,
+    flipY,
+    rotate
+  } = transform;
+  ctx.translate(canvas.width / 2, canvas.height / 2);
+  ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
+  ctx.rotate(rotate * Math.PI / 180);
+  ctx.drawImage(image, -image.width / 2, -image.height / 2);
+  return canvasToImageData(canvas);
+}
+var ImageHelper = {
+  canvasToImageData,
+  imageToImageData
+};
+
+
+
+
+/***/ },
+
+/***/ 73435
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (/* binding */ vtkSphereSource$1)
+/* harmony export */ });
+/* unused harmony exports extend, newInstance */
+/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90027);
+/* harmony import */ var _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(27480);
+/* harmony import */ var _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(445);
+
+
+
+
+// ----------------------------------------------------------------------------
+// vtkSphereSource methods
+// ----------------------------------------------------------------------------
+
+function vtkSphereSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkSphereSource');
+  publicAPI.requestData = (inData, outData) => {
+    let dataset = outData[0];
+    const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
+    dataset = dataset?.initialize() || _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance();
+
+    // ----------------------------------------------------------------------
+    let numPoles = 0;
+
+    // Check data, determine increments, and convert to radians
+    let {
+      thetaResolution
+    } = model;
+    let startTheta = model.startTheta < model.endTheta ? model.startTheta : model.endTheta;
+    startTheta *= Math.PI / 180.0;
+    let endTheta = model.endTheta > model.startTheta ? model.endTheta : model.startTheta;
+    endTheta *= Math.PI / 180.0;
+    let startPhi = model.startPhi < model.endPhi ? model.startPhi : model.endPhi;
+    startPhi *= Math.PI / 180.0;
+    let endPhi = model.endPhi > model.startPhi ? model.endPhi : model.startPhi;
+    endPhi *= Math.PI / 180.0;
+    if (Math.abs(startTheta - endTheta) < 2.0 * Math.PI) {
+      ++thetaResolution;
+    }
+    const deltaTheta = (endTheta - startTheta) / model.thetaResolution;
+    const jStart = model.startPhi <= 0.0 ? 1 : 0;
+    const jEnd = model.phiResolution + (model.endPhi >= 180.0 ? -1 : 0);
+    const numPts = model.phiResolution * thetaResolution + 2;
+    const numPolys = model.phiResolution * 2 * model.thetaResolution;
+
+    // Points
+    let pointIdx = 0;
+    let points = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newTypedArray(pointDataType, numPts * 3);
+
+    // Normals
+    let normals = new Float32Array(numPts * 3);
+
+    // Cells
+    let cellLocation = 0;
+    let polys = new Uint32Array(numPolys * 5);
+
+    // Create north pole if needed
+    if (model.startPhi <= 0.0) {
+      points[pointIdx * 3 + 0] = model.center[0];
+      points[pointIdx * 3 + 1] = model.center[1];
+      points[pointIdx * 3 + 2] = model.center[2] + model.radius;
+      normals[pointIdx * 3 + 0] = 0;
+      normals[pointIdx * 3 + 1] = 0;
+      normals[pointIdx * 3 + 2] = 1;
+      pointIdx++;
+      numPoles++;
+    }
+
+    // Create south pole if needed
+    if (model.endPhi >= 180.0) {
       points[pointIdx * 3 + 0] = model.center[0];
       points[pointIdx * 3 + 1] = model.center[1];
       points[pointIdx * 3 + 2] = model.center[2] - model.radius;
@@ -4542,6 +7101,7 @@ var vtkSphereSource$1 = {
 /***/ 53489
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -4847,9 +7407,10 @@ var vtkOrientationMarkerWidget$1 = {
 
 /***/ },
 
-/***/ 83338
+/***/ 91960
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -4868,73 +7429,8 @@ var Mapper = __webpack_require__(81418);
 var Texture = __webpack_require__(41090);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Filters/Sources/CubeSource.js
 var CubeSource = __webpack_require__(90011);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/ImageData.js
-var ImageData = __webpack_require__(26393);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray.js
-var DataArray = __webpack_require__(445);
-;// ../../../node_modules/@kitware/vtk.js/Common/Core/ImageHelper.js
-
-
-
-/**
- * Takes a canvas and converts it to a vtkImageData.
- *
- * Optionally supply a bounding box to get a particular subset of the canvas.
- *
- * @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];
-  const [top, left, width, height] = boundingBox;
-  const ctxt = canvas.getContext('2d');
-  const idata = ctxt.getImageData(top, left, width || canvas.width, height || canvas.height);
-  const imageData = ImageData/* default.newInstance */.Ay.newInstance({
-    type: 'vtkImageData'
-  });
-  imageData.setOrigin(0, 0, 0);
-  imageData.setSpacing(1, 1, 1);
-  imageData.setExtent(0, (width || canvas.width) - 1, 0, (height || canvas.height) - 1, 0, 0);
-  const scalars = DataArray/* default.newInstance */.Ay.newInstance({
-    numberOfComponents: 4,
-    values: new Uint8Array(idata.data.buffer)
-  });
-  scalars.setName('scalars');
-  imageData.getPointData().setScalars(scalars);
-  return imageData;
-}
-
-/**
- * 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
-  };
-  const canvas = document.createElement('canvas');
-  canvas.width = image.width;
-  canvas.height = image.height;
-  const ctx = canvas.getContext('2d');
-  const {
-    flipX,
-    flipY,
-    rotate
-  } = transform;
-  ctx.translate(canvas.width / 2, canvas.height / 2);
-  ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
-  ctx.rotate(rotate * Math.PI / 180);
-  ctx.drawImage(image, -image.width / 2, -image.height / 2);
-  return canvasToImageData(canvas);
-}
-var ImageHelper = {
-  canvasToImageData,
-  imageToImageData
-};
-
-
-
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/ImageHelper.js
+var ImageHelper = __webpack_require__(74821);
 ;// ../../../node_modules/@kitware/vtk.js/Rendering/Core/AnnotatedCubeActor/Presets.js
 const STYLES = {
   default: {
@@ -5116,7 +7612,7 @@ function vtkAnnotatedCubeActor(publicAPI, model) {
     ctxt.font = `${prop.fontStyle} ${textSize}px "${prop.fontFamily}"`;
     ctxt.fillText(prop.text, 0, 0);
     ctxt.restore();
-    const vtkImage = ImageHelper.canvasToImageData(canvas);
+    const vtkImage = ImageHelper/* default */.A.canvasToImageData(canvas);
     texture.setInputData(vtkImage, FACE_TO_INDEX[faceName]);
     publicAPI.modified();
   }
@@ -5220,6 +7716,7 @@ var vtkAnnotatedCubeActor$1 = {
 /***/ 10341
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -5240,8 +7737,8 @@ var Actor = __webpack_require__(44404);
 var Mapper = __webpack_require__(81418);
 // 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 + 11 modules
-var PolyData = __webpack_require__(12548);
+// 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/DataModel/DataSetAttributes/Constants.js
 var Constants = __webpack_require__(5695);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray/Constants.js