@ohif/app 3.9.0-beta.57 → 3.9.0-beta.59

package/dist/{196.bundle.cf8c2311aafb5312bbf7.js → 579.bundle.0b78fc095924efac431d.js}

@@ -1,5 +1,731 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[196,818,250],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[579,818,250],{
+
+/***/ 49001:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(72076);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7187);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(30023);
+/* harmony import */ var _helpers_cpuFallback_rendering_transform__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(30742);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(56309);
+/* harmony import */ var _Viewport__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(77614);
+/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(25281);
+/* harmony import */ var _CanvasActor__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(40046);
+/* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(82253);
+
+
+
+
+
+
+
+
+
+class VideoViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z {
+    constructor(props) {
+        super({
+            ...props,
+            canvas: props.canvas || (0,_helpers__WEBPACK_IMPORTED_MODULE_6__/* .getOrCreateCanvas */ .uy)(props.element),
+        });
+        this.videoWidth = 0;
+        this.videoHeight = 0;
+        this.loop = true;
+        this.mute = true;
+        this.isPlaying = false;
+        this.scrollSpeed = 1;
+        this.playbackRate = 1;
+        this.frameRange = [0, 0];
+        this.fps = 30;
+        this.videoCamera = {
+            panWorld: [0, 0],
+            parallelScale: 1,
+        };
+        this.voiRange = {
+            lower: 0,
+            upper: 255,
+        };
+        this.getProperties = () => {
+            return {
+                loop: this.videoElement.loop,
+                muted: this.videoElement.muted,
+                playbackRate: this.playbackRate,
+                scrollSpeed: this.scrollSpeed,
+                voiRange: { ...this.voiRange },
+            };
+        };
+        this.resetCamera = () => {
+            this.refreshRenderValues();
+            this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
+            if (this.isPlaying === false) {
+                this.renderFrame();
+            }
+            return true;
+        };
+        this.getNumberOfSlices = () => {
+            const computedSlices = Math.round((this.videoElement.duration * this.fps) / this.scrollSpeed);
+            return isNaN(computedSlices) ? this.numberOfFrames : computedSlices;
+        };
+        this.getFrameOfReferenceUID = () => {
+            return this.videoElement.src;
+        };
+        this.resize = () => {
+            const canvas = this.canvas;
+            const { clientWidth, clientHeight } = canvas;
+            if (canvas.width !== clientWidth || canvas.height !== clientHeight) {
+                canvas.width = clientWidth;
+                canvas.height = clientHeight;
+            }
+            this.refreshRenderValues();
+            if (this.isPlaying === false) {
+                this.renderFrame();
+            }
+        };
+        this.canvasToWorld = (canvasPos, destPos = [0, 0, 0]) => {
+            const pan = this.videoCamera.panWorld;
+            const worldToCanvasRatio = this.getWorldToCanvasRatio();
+            const panOffsetCanvas = [
+                pan[0] * worldToCanvasRatio,
+                pan[1] * worldToCanvasRatio,
+            ];
+            const subCanvasPos = [
+                canvasPos[0] - panOffsetCanvas[0],
+                canvasPos[1] - panOffsetCanvas[1],
+            ];
+            destPos.splice(0, 2, subCanvasPos[0] / worldToCanvasRatio, subCanvasPos[1] / worldToCanvasRatio);
+            return destPos;
+        };
+        this.worldToCanvas = (worldPos) => {
+            const pan = this.videoCamera.panWorld;
+            const worldToCanvasRatio = this.getWorldToCanvasRatio();
+            const canvasPos = [
+                (worldPos[0] + pan[0]) * worldToCanvasRatio,
+                (worldPos[1] + pan[1]) * worldToCanvasRatio,
+            ];
+            return canvasPos;
+        };
+        this.getRotation = () => 0;
+        this.canvasToIndex = (canvasPos) => {
+            const transform = this.getTransform();
+            transform.invert();
+            return transform.transformPoint(canvasPos.map((it) => it * devicePixelRatio));
+        };
+        this.indexToCanvas = (indexPos) => {
+            const transform = this.getTransform();
+            return (transform.transformPoint(indexPos).map((it) => it / devicePixelRatio));
+        };
+        this.customRenderViewportToCanvas = () => {
+            this.renderFrame();
+        };
+        this.renderFrame = () => {
+            const transform = this.getTransform();
+            const transformationMatrix = transform.getMatrix();
+            const ctx = this.canvasContext;
+            ctx.resetTransform();
+            ctx.transform(transformationMatrix[0], transformationMatrix[1], transformationMatrix[2], transformationMatrix[3], transformationMatrix[4], transformationMatrix[5]);
+            ctx.drawImage(this.videoElement, 0, 0, this.videoWidth || 1024, this.videoHeight || 1024);
+            for (const actor of this.getActors()) {
+                actor.actor.render(this, this.canvasContext);
+            }
+            this.canvasContext.resetTransform();
+            (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.triggerEvent)(this.element, _enums__WEBPACK_IMPORTED_MODULE_1__.Events.STACK_NEW_IMAGE, {
+                element: this.element,
+                viewportId: this.id,
+                viewport: this,
+                renderingEngineId: this.renderingEngineId,
+                time: this.videoElement.currentTime,
+                duration: this.videoElement.duration,
+            });
+            (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.triggerEvent)(this.element, _enums__WEBPACK_IMPORTED_MODULE_1__.Events.IMAGE_RENDERED, {
+                element: this.element,
+                viewportId: this.id,
+                viewport: this,
+                imageIndex: this.getCurrentImageIdIndex(),
+                numberOfSlices: this.numberOfFrames,
+                renderingEngineId: this.renderingEngineId,
+                time: this.videoElement.currentTime,
+                duration: this.videoElement.duration,
+            });
+            this.initialRender?.();
+            const frame = this.getFrameNumber();
+            if (this.isPlaying) {
+                if (frame < this.frameRange[0]) {
+                    this.setFrameNumber(this.frameRange[0]);
+                }
+                else if (frame > this.frameRange[1]) {
+                    if (this.loop) {
+                        this.setFrameNumber(this.frameRange[0]);
+                    }
+                    else {
+                        this.pause();
+                    }
+                }
+            }
+        };
+        this.renderWhilstPlaying = () => {
+            this.renderFrame();
+            if (this.isPlaying) {
+                requestAnimationFrame(this.renderWhilstPlaying);
+            }
+        };
+        this.canvasContext = this.canvas.getContext('2d');
+        this.renderingEngineId = props.renderingEngineId;
+        this.element.setAttribute('data-viewport-uid', this.id);
+        this.element.setAttribute('data-rendering-engine-uid', this.renderingEngineId);
+        this.videoElement = document.createElement('video');
+        this.videoElement.muted = this.mute;
+        this.videoElement.loop = this.loop;
+        this.videoElement.autoplay = true;
+        this.videoElement.crossOrigin = 'anonymous';
+        this.addEventListeners();
+        this.resize();
+    }
+    static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
+    static get useCustomRenderingPipeline() {
+        return true;
+    }
+    addEventListeners() {
+        this.canvas.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_1__.Events.ELEMENT_DISABLED, this.elementDisabledHandler);
+    }
+    removeEventListeners() {
+        this.canvas.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_1__.Events.ELEMENT_DISABLED, this.elementDisabledHandler);
+    }
+    elementDisabledHandler() {
+        this.removeEventListeners();
+        this.videoElement.remove();
+    }
+    getImageDataMetadata(image) {
+        const imageId = typeof image === 'string' ? image : image.imageId;
+        const imagePlaneModule = _metaData__WEBPACK_IMPORTED_MODULE_2__.get(_enums__WEBPACK_IMPORTED_MODULE_1__.MetadataModules.IMAGE_PLANE, imageId);
+        let rowCosines = imagePlaneModule.rowCosines;
+        let columnCosines = imagePlaneModule.columnCosines;
+        if (rowCosines == null || columnCosines == null) {
+            rowCosines = [1, 0, 0];
+            columnCosines = [0, 1, 0];
+        }
+        const rowCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .R3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
+        const colCosineVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .R3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+        const { rows, columns } = imagePlaneModule;
+        const scanAxisNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .R3.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .R3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+        let origin = imagePlaneModule.imagePositionPatient;
+        if (origin == null) {
+            origin = [0, 0, 0];
+        }
+        const xSpacing = imagePlaneModule.columnPixelSpacing || 1;
+        const ySpacing = imagePlaneModule.rowPixelSpacing || 1;
+        const xVoxels = imagePlaneModule.columns;
+        const yVoxels = imagePlaneModule.rows;
+        const zSpacing = 1;
+        const zVoxels = 1;
+        this.hasPixelSpacing = !!imagePlaneModule.columnPixelSpacing;
+        return {
+            bitsAllocated: 8,
+            numComps: 3,
+            origin,
+            rows,
+            columns,
+            direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
+            dimensions: [xVoxels, yVoxels, zVoxels],
+            spacing: [xSpacing, ySpacing, zSpacing],
+            hasPixelSpacing: this.hasPixelSpacing,
+            numVoxels: xVoxels * yVoxels * zVoxels,
+            imagePlaneModule,
+        };
+    }
+    setDataIds(imageIds, options) {
+        this.setVideo(imageIds[0], options?.viewReference?.sliceIndex || 1);
+    }
+    setVideo(imageId, frameNumber) {
+        this.imageId = Array.isArray(imageId) ? imageId[0] : imageId;
+        const imageUrlModule = _metaData__WEBPACK_IMPORTED_MODULE_2__.get(_enums__WEBPACK_IMPORTED_MODULE_1__.MetadataModules.IMAGE_URL, imageId);
+        if (!imageUrlModule?.rendered) {
+            throw new Error(`Video Image ID ${imageId} does not have a rendered video view`);
+        }
+        const { rendered } = imageUrlModule;
+        const generalSeries = _metaData__WEBPACK_IMPORTED_MODULE_2__.get(_enums__WEBPACK_IMPORTED_MODULE_1__.MetadataModules.GENERAL_SERIES, imageId);
+        this.modality = generalSeries?.Modality;
+        this.metadata = this.getImageDataMetadata(imageId);
+        let { cineRate, numberOfFrames } = _metaData__WEBPACK_IMPORTED_MODULE_2__.get(_enums__WEBPACK_IMPORTED_MODULE_1__.MetadataModules.CINE, imageId);
+        this.numberOfFrames = numberOfFrames;
+        return this.setVideoURL(rendered).then(() => {
+            if (!numberOfFrames || numberOfFrames === 1) {
+                numberOfFrames = Math.round(this.videoElement.duration * (cineRate || 30));
+            }
+            if (!cineRate) {
+                cineRate = Math.round(numberOfFrames / this.videoElement.duration);
+            }
+            this.fps = cineRate;
+            this.numberOfFrames = numberOfFrames;
+            this.setFrameRange([1, numberOfFrames]);
+            this.initialRender = () => {
+                this.initialRender = null;
+                this.pause();
+                this.setFrameNumber(frameNumber || 1);
+            };
+            return new Promise((resolve) => {
+                window.setTimeout(() => {
+                    this.setFrameNumber(frameNumber || 1);
+                    resolve(this);
+                }, 25);
+            });
+        });
+    }
+    async setVideoURL(videoURL) {
+        return new Promise((resolve) => {
+            this.videoElement.src = videoURL;
+            this.videoElement.preload = 'auto';
+            const loadedMetadataEventHandler = () => {
+                this.videoWidth = this.videoElement.videoWidth;
+                this.videoHeight = this.videoElement.videoHeight;
+                this.videoElement.removeEventListener('loadedmetadata', loadedMetadataEventHandler);
+                this.refreshRenderValues();
+                resolve(true);
+            };
+            this.videoElement.addEventListener('loadedmetadata', loadedMetadataEventHandler);
+        });
+    }
+    getImageIds() {
+        const imageIds = new Array(this.numberOfFrames);
+        const baseImageId = this.imageId.replace(/[0-9]+$/, '');
+        for (let i = 0; i < this.numberOfFrames; i++) {
+            imageIds[i] = `${baseImageId}${i + 1}`;
+        }
+        return imageIds;
+    }
+    togglePlayPause() {
+        if (this.isPlaying) {
+            this.pause();
+            return false;
+        }
+        else {
+            this.play();
+            return true;
+        }
+    }
+    async play() {
+        try {
+            if (!this.isPlaying) {
+                this.isPlaying = true;
+                await this.videoElement.play();
+                this.renderWhilstPlaying();
+            }
+        }
+        catch (e) {
+        }
+    }
+    pause() {
+        try {
+            this.isPlaying = false;
+            this.videoElement.pause();
+        }
+        catch (e) {
+        }
+    }
+    async scroll(delta = 1) {
+        await this.pause();
+        const videoElement = this.videoElement;
+        const renderFrame = this.renderFrame;
+        const currentTime = videoElement.currentTime;
+        const newTime = currentTime + (delta * this.scrollSpeed) / this.fps;
+        videoElement.currentTime = newTime;
+        const seekEventListener = (evt) => {
+            renderFrame();
+            videoElement.removeEventListener('seeked', seekEventListener);
+        };
+        videoElement.addEventListener('seeked', seekEventListener);
+    }
+    async start() {
+        const videoElement = this.videoElement;
+        const renderFrame = this.renderFrame;
+        videoElement.currentTime = 0;
+        if (videoElement.paused) {
+            const seekEventListener = (evt) => {
+                renderFrame();
+                videoElement.removeEventListener('seeked', seekEventListener);
+            };
+            videoElement.addEventListener('seeked', seekEventListener);
+        }
+    }
+    async end() {
+        const videoElement = this.videoElement;
+        const renderFrame = this.renderFrame;
+        videoElement.currentTime = videoElement.duration;
+        if (videoElement.paused) {
+            const seekEventListener = (evt) => {
+                renderFrame();
+                videoElement.removeEventListener('seeked', seekEventListener);
+            };
+            videoElement.addEventListener('seeked', seekEventListener);
+        }
+    }
+    async setTime(timeInSeconds) {
+        const videoElement = this.videoElement;
+        const renderFrame = this.renderFrame;
+        videoElement.currentTime = timeInSeconds;
+        if (videoElement.paused) {
+            const seekEventListener = (evt) => {
+                renderFrame();
+                videoElement.removeEventListener('seeked', seekEventListener);
+            };
+            videoElement.addEventListener('seeked', seekEventListener);
+        }
+    }
+    async setFrameNumber(frame) {
+        this.setTime((frame - 1) / this.fps);
+    }
+    setFrameRange(frameRange) {
+        if (!frameRange) {
+            this.frameRange = [1, this.numberOfFrames];
+            return;
+        }
+        if (frameRange.length !== 2 || frameRange[0] === frameRange[1]) {
+            return;
+        }
+        this.frameRange = [frameRange[0], frameRange[1]];
+    }
+    getFrameRange() {
+        return this.frameRange;
+    }
+    setProperties(props) {
+        if (props.loop !== undefined) {
+            this.videoElement.loop = props.loop;
+        }
+        if (props.muted !== undefined) {
+            this.videoElement.muted = props.muted;
+        }
+        if (props.playbackRate !== undefined) {
+            this.setPlaybackRate(props.playbackRate);
+        }
+        if (props.scrollSpeed !== undefined) {
+            this.setScrollSpeed(props.scrollSpeed);
+        }
+        if (props.voiRange) {
+            this.setVOI(props.voiRange);
+        }
+    }
+    setPlaybackRate(rate = 1) {
+        this.playbackRate = rate;
+        if (rate < 0.0625) {
+            this.pause();
+            return;
+        }
+        if (!this.videoElement) {
+            return;
+        }
+        this.videoElement.playbackRate = rate;
+        this.play();
+    }
+    setScrollSpeed(scrollSpeed = 1, unit = _enums__WEBPACK_IMPORTED_MODULE_1__.VideoEnums.SpeedUnit.FRAME) {
+        this.scrollSpeed =
+            unit === _enums__WEBPACK_IMPORTED_MODULE_1__.VideoEnums.SpeedUnit.SECOND
+                ? scrollSpeed * this.fps
+                : scrollSpeed;
+    }
+    resetProperties() {
+        this.setProperties({
+            loop: false,
+            muted: true,
+        });
+    }
+    getScalarData() {
+        if (this.scalarData?.frameNumber === this.getFrameNumber()) {
+            return this.scalarData;
+        }
+        const canvas = document.createElement('canvas');
+        canvas.width = this.videoWidth;
+        canvas.height = this.videoHeight;
+        const context = canvas.getContext('2d');
+        context.drawImage(this.videoElement, 0, 0);
+        const canvasData = context.getImageData(0, 0, this.videoWidth, this.videoHeight);
+        const scalarData = canvasData.data;
+        scalarData.getRange = () => [0, 255];
+        scalarData.frameNumber = this.getFrameNumber();
+        this.scalarData = scalarData;
+        return scalarData;
+    }
+    getImageData() {
+        const { metadata } = this;
+        const spacing = metadata.spacing;
+        const imageData = {
+            dimensions: metadata.dimensions,
+            spacing,
+            origin: metadata.origin,
+            direction: metadata.direction,
+            metadata: { Modality: this.modality },
+            getScalarData: () => this.getScalarData(),
+            imageData: {
+                getDirection: () => metadata.direction,
+                getDimensions: () => metadata.dimensions,
+                getRange: () => [0, 255],
+                getScalarData: () => this.getScalarData(),
+                getSpacing: () => metadata.spacing,
+                worldToIndex: (point) => {
+                    const canvasPoint = this.worldToCanvas(point);
+                    const pixelCoord = this.canvasToIndex(canvasPoint);
+                    return [pixelCoord[0], pixelCoord[1], 0];
+                },
+                indexToWorld: (point, destPoint) => {
+                    const canvasPoint = this.indexToCanvas([point[0], point[1]]);
+                    return this.canvasToWorld(canvasPoint, destPoint);
+                },
+            },
+            hasPixelSpacing: this.hasPixelSpacing,
+            calibration: this.calibration,
+            preScale: {
+                scaled: false,
+            },
+        };
+        Object.defineProperty(imageData, 'scalarData', {
+            get: () => this.getScalarData(),
+            enumerable: true,
+        });
+        return imageData;
+    }
+    hasImageURI(imageURI) {
+        const framesMatch = imageURI.match(VideoViewport.frameRangeExtractor);
+        const testURI = framesMatch
+            ? imageURI.substring(0, framesMatch.index)
+            : imageURI;
+        return this.imageId.indexOf(testURI) !== -1;
+    }
+    setVOI(voiRange) {
+        this.voiRange = voiRange;
+        this.setColorTransform();
+    }
+    setWindowLevel(windowWidth = 256, windowCenter = 128) {
+        const lower = windowCenter - windowWidth / 2;
+        const upper = windowCenter + windowWidth / 2 - 1;
+        this.setVOI({ lower, upper });
+        this.setColorTransform();
+    }
+    setAverageWhite(averageWhite) {
+        this.averageWhite = averageWhite;
+        this.setColorTransform();
+    }
+    setColorTransform() {
+        if (!this.voiRange && !this.averageWhite) {
+            this.feFilter = null;
+            return;
+        }
+        const white = this.averageWhite || [255, 255, 255];
+        const maxWhite = Math.max(...white);
+        const scaleWhite = white.map((c) => maxWhite / c);
+        const { lower = 0, upper = 255 } = this.voiRange || {};
+        const wlScale = (upper - lower + 1) / 255;
+        const wlDelta = lower / 255;
+        this.feFilter = `url('data:image/svg+xml,\
+      <svg xmlns="http://www.w3.org/2000/svg">\
+        <filter id="colour" color-interpolation-filters="linearRGB">\
+        <feColorMatrix type="matrix" \
+        values="\
+          ${scaleWhite[0] * wlScale} 0 0 0 ${wlDelta} \
+          0 ${scaleWhite[1] * wlScale} 0 0 ${wlDelta} \
+          0 0 ${scaleWhite[2] * wlScale} 0 ${wlDelta} \
+          0 0 0 1 0" />\
+        </filter>\
+      </svg>#colour')`;
+        this.canvas.style.filter = this.feFilter;
+    }
+    setCamera(camera) {
+        const { parallelScale, focalPoint } = camera;
+        if (parallelScale) {
+            this.videoCamera.parallelScale =
+                this.element.clientHeight / 2 / parallelScale;
+        }
+        if (focalPoint !== undefined) {
+            const focalPointCanvas = this.worldToCanvas(focalPoint);
+            const canvasCenter = [
+                this.element.clientWidth / 2,
+                this.element.clientHeight / 2,
+            ];
+            const panWorldDelta = [
+                (focalPointCanvas[0] - canvasCenter[0]) /
+                    this.videoCamera.parallelScale,
+                (focalPointCanvas[1] - canvasCenter[1]) /
+                    this.videoCamera.parallelScale,
+            ];
+            this.videoCamera.panWorld = [
+                this.videoCamera.panWorld[0] - panWorldDelta[0],
+                this.videoCamera.panWorld[1] - panWorldDelta[1],
+            ];
+        }
+        this.canvasContext.fillStyle = 'rgba(0,0,0,1)';
+        this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
+        if (this.isPlaying === false) {
+            this.renderFrame();
+        }
+    }
+    getCurrentImageId() {
+        const current = this.imageId.replace('/frames/1', this.isPlaying
+            ? `/frames/${this.frameRange[0]}-${this.frameRange[1]}`
+            : `/frames/${this.getFrameNumber()}`);
+        return current;
+    }
+    getReferenceId(specifier = {}) {
+        const { sliceIndex: sliceIndex } = specifier;
+        if (sliceIndex === undefined) {
+            return `videoId:${this.getCurrentImageId()}`;
+        }
+        if (Array.isArray(sliceIndex)) {
+            return `videoId:${this.imageId.substring(0, this.imageId.length - 1)}${sliceIndex[0] + 1}-${sliceIndex[1] + 1}`;
+        }
+        const baseTarget = this.imageId.replace('/frames/1', `/frames/${1 + sliceIndex}`);
+        return `videoId:${baseTarget}`;
+    }
+    isReferenceViewable(viewRef, options = {}) {
+        let { imageURI } = options;
+        const { referencedImageId, sliceIndex: sliceIndex } = viewRef;
+        if (!super.isReferenceViewable(viewRef)) {
+            return false;
+        }
+        const imageId = this.getCurrentImageId();
+        if (!imageURI) {
+            const colonIndex = imageId.indexOf(':');
+            imageURI = imageId.substring(colonIndex + 1, imageId.length - 1);
+        }
+        if (options.withNavigation) {
+            return true;
+        }
+        const currentIndex = this.getSliceIndex();
+        if (Array.isArray(sliceIndex)) {
+            return currentIndex >= sliceIndex[0] && currentIndex <= sliceIndex[1];
+        }
+        if (sliceIndex !== undefined) {
+            return currentIndex === sliceIndex;
+        }
+        if (!referencedImageId) {
+            return false;
+        }
+        const match = referencedImageId.match(VideoViewport.frameRangeExtractor);
+        if (!match || !match[2]) {
+            return true;
+        }
+        const range = match[2].split('-').map((it) => Number(it));
+        const frame = currentIndex + 1;
+        return range[0] <= frame && frame <= (range[1] ?? range[0]);
+    }
+    setViewReference(viewRef) {
+        if (typeof viewRef.sliceIndex === 'number') {
+            this.setFrameNumber(viewRef.sliceIndex + 1);
+        }
+        else if (Array.isArray(viewRef.sliceIndex)) {
+            this.setFrameRange(viewRef.sliceIndex);
+        }
+    }
+    getViewReference(viewRefSpecifier) {
+        let sliceIndex = viewRefSpecifier?.sliceIndex;
+        if (!sliceIndex) {
+            sliceIndex = this.isPlaying
+                ? [this.frameRange[0] - 1, this.frameRange[1] - 1]
+                : this.getCurrentImageIdIndex();
+        }
+        return {
+            ...super.getViewReference(viewRefSpecifier),
+            referencedImageId: this.getReferenceId(viewRefSpecifier),
+            sliceIndex: sliceIndex,
+        };
+    }
+    getFrameNumber() {
+        return 1 + this.getCurrentImageIdIndex();
+    }
+    getCurrentImageIdIndex() {
+        return Math.round(this.videoElement.currentTime * this.fps);
+    }
+    getSliceIndex() {
+        return this.getCurrentImageIdIndex() / this.scrollSpeed;
+    }
+    getCamera() {
+        const { parallelScale } = this.videoCamera;
+        const canvasCenter = [
+            this.element.clientWidth / 2,
+            this.element.clientHeight / 2,
+        ];
+        const canvasCenterWorld = this.canvasToWorld(canvasCenter);
+        return {
+            parallelProjection: true,
+            focalPoint: canvasCenterWorld,
+            position: [0, 0, 0],
+            viewUp: [0, -1, 0],
+            parallelScale: this.element.clientHeight / 2 / parallelScale,
+            viewPlaneNormal: [0, 0, 1],
+        };
+    }
+    getFrameRate() {
+        return this.fps;
+    }
+    getPan() {
+        const panWorld = this.videoCamera.panWorld;
+        return [panWorld[0], panWorld[1]];
+    }
+    refreshRenderValues() {
+        let worldToCanvasRatio = this.canvas.offsetWidth / this.videoWidth;
+        if (this.videoHeight * worldToCanvasRatio > this.canvas.height) {
+            worldToCanvasRatio = this.canvas.offsetHeight / this.videoHeight;
+        }
+        const drawWidth = Math.floor(this.videoWidth * worldToCanvasRatio);
+        const drawHeight = Math.floor(this.videoHeight * worldToCanvasRatio);
+        const xOffsetCanvas = (this.canvas.offsetWidth - drawWidth) / 2;
+        const yOffsetCanvas = (this.canvas.offsetHeight - drawHeight) / 2;
+        const xOffsetWorld = xOffsetCanvas / worldToCanvasRatio;
+        const yOffsetWorld = yOffsetCanvas / worldToCanvasRatio;
+        this.videoCamera.panWorld = [xOffsetWorld, yOffsetWorld];
+        this.videoCamera.parallelScale = worldToCanvasRatio;
+    }
+    getWorldToCanvasRatio() {
+        return this.videoCamera.parallelScale;
+    }
+    getCanvasToWorldRatio() {
+        return 1.0 / this.videoCamera.parallelScale;
+    }
+    getTransform() {
+        const panWorld = this.videoCamera.panWorld;
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const worldToCanvasRatio = this.getWorldToCanvasRatio();
+        const canvasToWorldRatio = this.getCanvasToWorldRatio();
+        const halfCanvas = [
+            this.canvas.offsetWidth / 2,
+            this.canvas.offsetHeight / 2,
+        ];
+        const halfCanvasWorldCoordinates = [
+            halfCanvas[0] * canvasToWorldRatio,
+            halfCanvas[1] * canvasToWorldRatio,
+        ];
+        const transform = new _helpers_cpuFallback_rendering_transform__WEBPACK_IMPORTED_MODULE_3__/* .Transform */ .w();
+        transform.scale(devicePixelRatio, devicePixelRatio);
+        transform.translate(halfCanvas[0], halfCanvas[1]);
+        transform.scale(worldToCanvasRatio, worldToCanvasRatio);
+        transform.translate(panWorld[0], panWorld[1]);
+        transform.translate(-halfCanvasWorldCoordinates[0], -halfCanvasWorldCoordinates[1]);
+        return transform;
+    }
+    updateCameraClippingPlanesAndRange() {
+    }
+    addImages(stackInputs) {
+        const actors = this.getActors();
+        stackInputs.forEach((stackInput) => {
+            const image = _cache__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .ZP.getImage(stackInput.imageId);
+            const imageActor = this.createActorMapper(image);
+            if (imageActor) {
+                actors.push({ uid: stackInput.actorUID, actor: imageActor });
+                if (stackInput.callback) {
+                    stackInput.callback({ imageActor, imageId: stackInput.imageId });
+                }
+            }
+        });
+        this.setActors(actors);
+    }
+    createActorMapper(image) {
+        return new _CanvasActor__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z(this, image);
+    }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (VideoViewport);
+
+
+/***/ }),
 
 /***/ 68467:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -1020,8 +1746,8 @@ function storedPixelDataToCanvasImageDataPseudocolorLUTPET(image, lutFunction, c
 }
 /* harmony default export */ const rendering_storedPixelDataToCanvasImageDataPseudocolorLUTPET = (storedPixelDataToCanvasImageDataPseudocolorLUTPET);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 67 modules
-var utilities = __webpack_require__(11723);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 66 modules
+var utilities = __webpack_require__(56309);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/renderPseudoColorImage.js
 
 
@@ -1620,6 +2346,96 @@ function relativeRescale(enabledElement, oldCanvasWidth, oldCanvasHeight) {
 }
 
 
+/***/ }),
+
+/***/ 30742:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   w: () => (/* binding */ Transform)
+/* harmony export */ });
+class Transform {
+    constructor() {
+        this.reset();
+    }
+    getMatrix() {
+        return this.m;
+    }
+    reset() {
+        this.m = [1, 0, 0, 1, 0, 0];
+    }
+    clone() {
+        const transform = new Transform();
+        transform.m[0] = this.m[0];
+        transform.m[1] = this.m[1];
+        transform.m[2] = this.m[2];
+        transform.m[3] = this.m[3];
+        transform.m[4] = this.m[4];
+        transform.m[5] = this.m[5];
+        return transform;
+    }
+    multiply(matrix) {
+        const m11 = this.m[0] * matrix[0] + this.m[2] * matrix[1];
+        const m12 = this.m[1] * matrix[0] + this.m[3] * matrix[1];
+        const m21 = this.m[0] * matrix[2] + this.m[2] * matrix[3];
+        const m22 = this.m[1] * matrix[2] + this.m[3] * matrix[3];
+        const dx = this.m[0] * matrix[4] + this.m[2] * matrix[5] + this.m[4];
+        const dy = this.m[1] * matrix[4] + this.m[3] * matrix[5] + this.m[5];
+        this.m[0] = m11;
+        this.m[1] = m12;
+        this.m[2] = m21;
+        this.m[3] = m22;
+        this.m[4] = dx;
+        this.m[5] = dy;
+    }
+    invert() {
+        const d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
+        const m0 = this.m[3] * d;
+        const m1 = -this.m[1] * d;
+        const m2 = -this.m[2] * d;
+        const m3 = this.m[0] * d;
+        const m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
+        const m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
+        this.m[0] = m0;
+        this.m[1] = m1;
+        this.m[2] = m2;
+        this.m[3] = m3;
+        this.m[4] = m4;
+        this.m[5] = m5;
+    }
+    rotate(rad) {
+        const c = Math.cos(rad);
+        const s = Math.sin(rad);
+        const m11 = this.m[0] * c + this.m[2] * s;
+        const m12 = this.m[1] * c + this.m[3] * s;
+        const m21 = this.m[0] * -s + this.m[2] * c;
+        const m22 = this.m[1] * -s + this.m[3] * c;
+        this.m[0] = m11;
+        this.m[1] = m12;
+        this.m[2] = m21;
+        this.m[3] = m22;
+    }
+    translate(x, y) {
+        this.m[4] += this.m[0] * x + this.m[2] * y;
+        this.m[5] += this.m[1] * x + this.m[3] * y;
+    }
+    scale(sx, sy) {
+        this.m[0] *= sx;
+        this.m[1] *= sx;
+        this.m[2] *= sy;
+        this.m[3] *= sy;
+    }
+    transformPoint(point) {
+        const x = point[0];
+        const y = point[1];
+        return [
+            x * this.m[0] + y * this.m[2] + this.m[4],
+            x * this.m[1] + y * this.m[3] + this.m[5],
+        ];
+    }
+}
+
+
 /***/ }),
 
 /***/ 6737:
@@ -1805,8 +2621,8 @@ var vtkVolume$1 = {
 var volumeLoader = __webpack_require__(18588);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/createVolumeMapper.js
 var createVolumeMapper = __webpack_require__(49046);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 67 modules
-var utilities = __webpack_require__(11723);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 66 modules
+var utilities = __webpack_require__(56309);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js + 4 modules
 var enums = __webpack_require__(7187);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/setDefaultVolumeVOI.js
@@ -1875,7 +2691,7 @@ function triggerVOIModified(element, viewportId, volumeActor, volumeId) {
 /* harmony export */ });
 /* harmony import */ var _loaders_imageLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62990);
 /* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30023);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(56309);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7187);
 /* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(82253);
 
@@ -2055,218 +2871,14 @@ const newInstance = _kitware_vtk_js_macros__WEBPACK_IMPORTED_MODULE_0__/* ["defa
 
 /***/ }),
 
-/***/ 90261:
+/***/ 5287:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (/* binding */ Settings)
-/* harmony export */ });
-const DEFAULT_SETTINGS = Symbol('DefaultSettings');
-const RUNTIME_SETTINGS = Symbol('RuntimeSettings');
-const OBJECT_SETTINGS_MAP = Symbol('ObjectSettingsMap');
-const DICTIONARY = Symbol('Dictionary');
-class Settings {
-    constructor(base) {
-        const dictionary = Object.create((base instanceof Settings && DICTIONARY in base
-            ? base[DICTIONARY]
-            : null));
-        Object.seal(Object.defineProperty(this, DICTIONARY, {
-            value: dictionary,
-        }));
-    }
-    set(key, value) {
-        return set(this[DICTIONARY], key, value, null);
-    }
-    get(key) {
-        return get(this[DICTIONARY], key);
-    }
-    unset(key) {
-        return unset(this[DICTIONARY], key + '');
-    }
-    forEach(callback) {
-        iterate(this[DICTIONARY], callback);
-    }
-    extend() {
-        return new Settings(this);
-    }
-    import(root) {
-        if (isPlainObject(root)) {
-            Object.keys(root).forEach((key) => {
-                set(this[DICTIONARY], key, root[key], null);
-            });
-        }
-    }
-    dump() {
-        const context = {};
-        iterate(this[DICTIONARY], (key, value) => {
-            if (typeof value !== 'undefined') {
-                deepSet(context, key, value);
-            }
-        });
-        return context;
-    }
-    static assert(subject) {
-        return subject instanceof Settings
-            ? subject
-            : Settings.getRuntimeSettings();
-    }
-    static getDefaultSettings(subfield = null) {
-        let defaultSettings = Settings[DEFAULT_SETTINGS];
-        if (!(defaultSettings instanceof Settings)) {
-            defaultSettings = new Settings();
-            Settings[DEFAULT_SETTINGS] = defaultSettings;
-        }
-        if (subfield) {
-            const settingObj = {};
-            defaultSettings.forEach((name) => {
-                if (name.startsWith(subfield)) {
-                    const setting = name.split(`${subfield}.`)[1];
-                    settingObj[setting] = defaultSettings.get(name);
-                }
-            });
-            return settingObj;
-        }
-        return defaultSettings;
-    }
-    static getRuntimeSettings() {
-        let runtimeSettings = Settings[RUNTIME_SETTINGS];
-        if (!(runtimeSettings instanceof Settings)) {
-            runtimeSettings = new Settings(Settings.getDefaultSettings());
-            Settings[RUNTIME_SETTINGS] = runtimeSettings;
-        }
-        return runtimeSettings;
-    }
-    static getObjectSettings(subject, from) {
-        let settings = null;
-        if (subject instanceof Settings) {
-            settings = subject;
-        }
-        else if (typeof subject === 'object' && subject !== null) {
-            let objectSettingsMap = Settings[OBJECT_SETTINGS_MAP];
-            if (!(objectSettingsMap instanceof WeakMap)) {
-                objectSettingsMap = new WeakMap();
-                Settings[OBJECT_SETTINGS_MAP] = objectSettingsMap;
-            }
-            settings = objectSettingsMap.get(subject);
-            if (!(settings instanceof Settings)) {
-                settings = new Settings(Settings.assert(Settings.getObjectSettings(from)));
-                objectSettingsMap.set(subject, settings);
-            }
-        }
-        return settings;
-    }
-    static extendRuntimeSettings() {
-        return Settings.getRuntimeSettings().extend();
-    }
-}
-function unset(dictionary, name) {
-    if (name.endsWith('.')) {
-        let deleteCount = 0;
-        const namespace = name;
-        const base = namespace.slice(0, -1);
-        const deleteAll = base.length === 0;
-        for (const key in dictionary) {
-            if (Object.prototype.hasOwnProperty.call(dictionary, key) &&
-                (deleteAll || key.startsWith(namespace) || key === base)) {
-                delete dictionary[key];
-                ++deleteCount;
-            }
-        }
-        return deleteCount > 0;
-    }
-    return delete dictionary[name];
-}
-function iterate(dictionary, callback) {
-    for (const key in dictionary) {
-        callback(key, dictionary[key]);
-    }
-}
-function setAll(dictionary, prefix, record, references) {
-    let failCount;
-    if (references.has(record)) {
-        return set(dictionary, prefix, null, references);
-    }
-    references.add(record);
-    failCount = 0;
-    for (const field in record) {
-        if (Object.prototype.hasOwnProperty.call(record, field)) {
-            const key = field.length === 0 ? prefix : `${prefix}.${field}`;
-            if (!set(dictionary, key, record[field], references)) {
-                ++failCount;
-            }
-        }
-    }
-    references.delete(record);
-    return failCount === 0;
-}
-function set(dictionary, key, value, references) {
-    if (isValidKey(key)) {
-        if (isPlainObject(value)) {
-            return setAll(dictionary, key, value, references instanceof WeakSet ? references : new WeakSet());
-        }
-        dictionary[key] = value;
-        return true;
-    }
-    return false;
-}
-function get(dictionary, key) {
-    return dictionary[key];
-}
-function isValidKey(key) {
-    let last, current, previous;
-    if (typeof key !== 'string' || (last = key.length - 1) < 0) {
-        return false;
-    }
-    previous = -1;
-    while ((current = key.indexOf('.', previous + 1)) >= 0) {
-        if (current - previous < 2 || current === last) {
-            return false;
-        }
-        previous = current;
-    }
-    return true;
-}
-function isPlainObject(subject) {
-    if (typeof subject === 'object' && subject !== null) {
-        const prototype = Object.getPrototypeOf(subject);
-        if (prototype === Object.prototype || prototype === null) {
-            return true;
-        }
-    }
-    return false;
-}
-function deepSet(context, key, value) {
-    const separator = key.indexOf('.');
-    if (separator >= 0) {
-        const subKey = key.slice(0, separator);
-        let subContext = context[subKey];
-        if (typeof subContext !== 'object' || subContext === null) {
-            const subContextValue = subContext;
-            subContext = {};
-            if (typeof subContextValue !== 'undefined') {
-                subContext[''] = subContextValue;
-            }
-            context[subKey] = subContext;
-        }
-        deepSet(subContext, key.slice(separator + 1, key.length), value);
-    }
-    else {
-        context[key] = value;
-    }
-}
-Settings.getDefaultSettings().set('useCursors', true);
-
-
-/***/ }),
-
-/***/ 5287:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
 /* unused harmony export Cache */
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(56309);
 /* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74238);
 /* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(19546);
 /* harmony import */ var _classes_ImageVolume__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(84326);
@@ -2303,7 +2915,11 @@ class Cache {
         this.getMaxInstanceSize = () => this._maxInstanceSize;
         this.getCacheSize = () => this._imageCacheSize + this._volumeCacheSize;
         this._decacheImage = (imageId) => {
-            const { imageLoadObject } = this._imageCache.get(imageId);
+            const cachedImage = this._imageCache.get(imageId);
+            if (!cachedImage) {
+                return;
+            }
+            const { imageLoadObject } = cachedImage;
             if (imageLoadObject.cancelFn) {
                 imageLoadObject.cancelFn();
             }
@@ -2314,7 +2930,13 @@ class Cache {
         };
         this._decacheVolume = (volumeId) => {
             const cachedVolume = this._volumeCache.get(volumeId);
+            if (!cachedVolume) {
+                return;
+            }
             const { volumeLoadObject, volume } = cachedVolume;
+            if (!volume) {
+                return;
+            }
             if (volume.cancelLoading) {
                 volume.cancelLoading();
             }
@@ -2360,7 +2982,7 @@ class Cache {
                 throw new Error('getVolumeLoadObject: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 return;
             }
             cachedVolume.timeStamp = Date.now();
@@ -2371,7 +2993,7 @@ class Cache {
                 throw new Error('getGeometry: geometryId must not be undefined');
             }
             const cachedGeometry = this._geometryCache.get(geometryId);
-            if (cachedGeometry === undefined) {
+            if (!cachedGeometry) {
                 return;
             }
             cachedGeometry.timeStamp = Date.now();
@@ -2382,7 +3004,7 @@ class Cache {
                 throw new Error('getImage: imageId must not be undefined');
             }
             const cachedImage = this._imageCache.get(imageId);
-            if (cachedImage === undefined) {
+            if (!cachedImage) {
                 return;
             }
             cachedImage.timeStamp = Date.now();
@@ -2393,7 +3015,7 @@ class Cache {
                 throw new Error('getVolume: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 return;
             }
             cachedVolume.timeStamp = Date.now();
@@ -2414,7 +3036,7 @@ class Cache {
                 throw new Error('removeImageLoadObject: imageId must not be undefined');
             }
             const cachedImage = this._imageCache.get(imageId);
-            if (cachedImage === undefined) {
+            if (!cachedImage) {
                 throw new Error('removeImageLoadObject: imageId was not present in imageCache');
             }
             this.incrementImageCacheSize(-cachedImage.sizeInBytes);
@@ -2430,7 +3052,7 @@ class Cache {
                 throw new Error('removeVolumeLoadObject: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
-            if (cachedVolume === undefined) {
+            if (!cachedVolume) {
                 throw new Error('removeVolumeLoadObject: volumeId was not present in volumeCache');
             }
             this.incrementVolumeCacheSize(-cachedVolume.sizeInBytes);
@@ -2597,7 +3219,7 @@ class Cache {
             throw new Error('getImageLoadObject: imageId must not be undefined');
         }
         const cachedImage = this._imageCache.get(imageId);
-        if (cachedImage === undefined) {
+        if (!cachedImage) {
             return;
         }
         cachedImage.timeStamp = Date.now();
@@ -2615,6 +3237,9 @@ class Cache {
         const imageIdToUse = (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.imageIdToURI)(imageId);
         for (const volumeId of volumeIds) {
             const cachedVolume = this._volumeCache.get(volumeId);
+            if (!cachedVolume) {
+                return;
+            }
             const { volume } = cachedVolume;
             if (!volume?.imageIds?.length) {
                 return;
@@ -2720,30 +3345,48 @@ const cache = new Cache();
 
 /***/ }),
 
-/***/ 34061:
+/***/ 19247:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-const EPSILON = 1e-3;
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (EPSILON);
-
 
-/***/ }),
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  EPSILON: () => (/* reexport */ epsilon),
+  MPR_CAMERA_VALUES: () => (/* reexport */ mprCameraValues/* default */.Z),
+  RENDERING_DEFAULTS: () => (/* reexport */ rendering),
+  VIEWPORT_PRESETS: () => (/* reexport */ viewportPresets/* default */.Z)
+});
 
-/***/ 87525:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+// UNUSED EXPORTS: BACKGROUND_COLORS, CPU_COLORMAPS
 
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/cpuColormaps.js
+var cpuColormaps = __webpack_require__(52813);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/rendering.js
 const RENDERING_DEFAULTS = {
     MINIMUM_SLAB_THICKNESS: 5e-2,
     MAXIMUM_RAY_DISTANCE: 1e6,
 };
 Object.freeze(RENDERING_DEFAULTS);
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (RENDERING_DEFAULTS);
+/* harmony default export */ const rendering = (RENDERING_DEFAULTS);
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/epsilon.js
+const EPSILON = 1e-3;
+/* harmony default export */ const epsilon = (EPSILON);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/mprCameraValues.js + 1 modules
+var mprCameraValues = __webpack_require__(21306);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/viewportPresets.js
+var viewportPresets = __webpack_require__(89469);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/backgroundColors.js
+var backgroundColors = __webpack_require__(43220);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/index.js
+
+
+
+
+
+
+
 
 
 /***/ }),
@@ -2807,77 +3450,454 @@ __webpack_require__.d(__webpack_exports__, {
   ViewportType: () => (/* reexport */ ViewportType/* default */.Z)
 });
 
-// UNUSED EXPORTS: ContourType, DynamicOperatorType
+// UNUSED EXPORTS: ContourType, DynamicOperatorType
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/Events.js
+var Events = __webpack_require__(19546);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/RequestType.js
+var RequestType = __webpack_require__(49334);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ViewportType.js
+var ViewportType = __webpack_require__(68032);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/InterpolationType.js
+var InterpolationType = __webpack_require__(75677);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/VolumeMapper/Constants.js
+var Constants = __webpack_require__(83336);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/BlendModes.js
+
+const { BlendMode } = Constants["default"];
+var BlendModes;
+(function (BlendModes) {
+    BlendModes[BlendModes["COMPOSITE"] = 0] = "COMPOSITE";
+    BlendModes[BlendModes["MAXIMUM_INTENSITY_BLEND"] = 1] = "MAXIMUM_INTENSITY_BLEND";
+    BlendModes[BlendModes["MINIMUM_INTENSITY_BLEND"] = 2] = "MINIMUM_INTENSITY_BLEND";
+    BlendModes[BlendModes["AVERAGE_INTENSITY_BLEND"] = 3] = "AVERAGE_INTENSITY_BLEND";
+})(BlendModes || (BlendModes = {}));
+/* harmony default export */ const enums_BlendModes = (BlendModes);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/OrientationAxis.js
+var OrientationAxis = __webpack_require__(96426);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/SharedArrayBufferModes.js
+var SharedArrayBufferModes = __webpack_require__(91799);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/GeometryType.js
+var GeometryType;
+(function (GeometryType) {
+    GeometryType["CONTOUR"] = "contour";
+    GeometryType["SURFACE"] = "Surface";
+})(GeometryType || (GeometryType = {}));
+/* harmony default export */ const enums_GeometryType = (GeometryType);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ContourType.js
+var ContourType = __webpack_require__(2689);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/VOILUTFunctionType.js
+var VOILUTFunctionType = __webpack_require__(67751);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/DynamicOperatorType.js
+var DynamicOperatorType;
+(function (DynamicOperatorType) {
+    DynamicOperatorType["SUM"] = "SUM";
+    DynamicOperatorType["AVERAGE"] = "AVERAGE";
+    DynamicOperatorType["SUBTRACT"] = "SUBTRACT";
+})(DynamicOperatorType || (DynamicOperatorType = {}));
+/* harmony default export */ const enums_DynamicOperatorType = ((/* unused pure expression or super */ null && (DynamicOperatorType)));
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/CalibrationTypes.js
+var CalibrationTypes;
+(function (CalibrationTypes) {
+    CalibrationTypes["NOT_APPLICABLE"] = "";
+    CalibrationTypes["ERMF"] = "ERMF";
+    CalibrationTypes["USER"] = "User";
+    CalibrationTypes["PROJECTION"] = "Proj";
+    CalibrationTypes["REGION"] = "Region";
+    CalibrationTypes["ERROR"] = "Error";
+    CalibrationTypes["UNCALIBRATED"] = "Uncalibrated";
+})(CalibrationTypes || (CalibrationTypes = {}));
+/* harmony default export */ const enums_CalibrationTypes = (CalibrationTypes);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ViewportStatus.js
+var ViewportStatus = __webpack_require__(84659);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ImageQualityStatus.js
+var ImageQualityStatus = __webpack_require__(83521);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/VideoEnums.js
+var VideoEnums = __webpack_require__(40373);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/MetadataModules.js
+var MetadataModules = __webpack_require__(636);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 65279:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   O: () => (/* binding */ getEnabledElementByIds),
+/* harmony export */   Yz: () => (/* binding */ getEnabledElementByViewportId),
+/* harmony export */   ZP: () => (/* binding */ getEnabledElement),
+/* harmony export */   wN: () => (/* binding */ getEnabledElements)
+/* harmony export */ });
+/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9138);
+
+function getEnabledElement(element) {
+    if (!element) {
+        return;
+    }
+    const { viewportUid, renderingEngineUid } = element.dataset;
+    return getEnabledElementByIds(viewportUid, renderingEngineUid);
+}
+function getEnabledElementByIds(viewportId, renderingEngineId) {
+    if (!renderingEngineId || !viewportId) {
+        return;
+    }
+    const renderingEngine = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP)(renderingEngineId);
+    if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
+        return;
+    }
+    const viewport = renderingEngine.getViewport(viewportId);
+    if (!viewport) {
+        return;
+    }
+    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+    return {
+        viewport,
+        renderingEngine,
+        viewportId,
+        renderingEngineId,
+        FrameOfReferenceUID,
+    };
+}
+function getEnabledElementByViewportId(viewportId) {
+    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .Uu)();
+    for (let i = 0; i < renderingEngines.length; i++) {
+        const renderingEngine = renderingEngines[i];
+        const viewport = renderingEngine.getViewport(viewportId);
+        if (viewport) {
+            return getEnabledElementByIds(viewportId, renderingEngine.id);
+        }
+    }
+}
+function getEnabledElements() {
+    const enabledElements = [];
+    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .Uu)();
+    renderingEngines.forEach((renderingEngine) => {
+        const viewports = renderingEngine.getViewports();
+        viewports.forEach(({ element }) => {
+            enabledElements.push(getEnabledElement(element));
+        });
+    });
+    return enabledElements;
+}
+
+
+/***/ }),
+
+/***/ 12651:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  BaseVolumeViewport: () => (/* reexport */ BaseVolumeViewport/* default */.Z),
+  CONSTANTS: () => (/* reexport */ constants),
+  EVENTS: () => (/* reexport */ enums.Events),
+  Enums: () => (/* reexport */ enums),
+  Settings: () => (/* reexport */ Settings),
+  StackViewport: () => (/* reexport */ StackViewport/* default */.Z),
+  VolumeViewport: () => (/* reexport */ VolumeViewport/* default */.Z),
+  VolumeViewport3D: () => (/* reexport */ VolumeViewport3D/* default */.Z),
+  addImageSlicesToViewports: () => (/* reexport */ helpers/* addImageSlicesToViewports */.PN),
+  addVolumesToViewports: () => (/* reexport */ helpers/* addVolumesToViewports */.gc),
+  cache: () => (/* reexport */ cache/* default */.ZP),
+  eventTarget: () => (/* reexport */ eventTarget/* default */.Z),
+  geometryLoader: () => (/* reexport */ geometryLoader),
+  getConfiguration: () => (/* reexport */ init/* getConfiguration */.P_),
+  getEnabledElement: () => (/* reexport */ getEnabledElement/* default */.ZP),
+  getEnabledElementByIds: () => (/* reexport */ getEnabledElement/* getEnabledElementByIds */.O),
+  getEnabledElementByViewportId: () => (/* reexport */ getEnabledElement/* getEnabledElementByViewportId */.Yz),
+  getEnabledElements: () => (/* reexport */ getEnabledElement/* getEnabledElements */.wN),
+  getRenderingEngine: () => (/* reexport */ getRenderingEngine/* getRenderingEngine */.Pr),
+  getRenderingEngines: () => (/* reexport */ getRenderingEngine/* getRenderingEngines */.Uu),
+  getWebWorkerManager: () => (/* reexport */ init/* getWebWorkerManager */.Pt),
+  imageLoadPoolManager: () => (/* reexport */ imageLoadPoolManager/* default */.Z),
+  imageLoader: () => (/* reexport */ imageLoader),
+  metaData: () => (/* reexport */ metaData),
+  triggerEvent: () => (/* reexport */ triggerEvent/* default */.Z),
+  utilities: () => (/* reexport */ utilities),
+  volumeLoader: () => (/* reexport */ volumeLoader)
+});
+
+// UNUSED EXPORTS: ImageVolume, ProgressiveRetrieveImages, RenderingEngine, Surface, VideoViewport, Viewport, WSIViewport, canRenderFloatTextures, createVolumeActor, createVolumeMapper, getOrCreateCanvas, getShouldUseCPURendering, getShouldUseSharedArrayBuffer, imageRetrievalPoolManager, init, isCornerstoneInitialized, peerImport, registerImageLoader, requestPoolManager, resetUseCPURendering, resetUseSharedArrayBuffer, setConfiguration, setPreferSizeOverAccuracy, setUseCPURendering, setUseSharedArrayBuffer, setVolumesForViewports
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js + 4 modules
+var enums = __webpack_require__(7187);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/constants/index.js + 2 modules
+var constants = __webpack_require__(19247);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/index.js + 3 modules
+var RenderingEngine = __webpack_require__(69552);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/VolumeViewport.js
+var VolumeViewport = __webpack_require__(32932);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/VolumeViewport3D.js
+var VolumeViewport3D = __webpack_require__(46190);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/BaseVolumeViewport.js
+var BaseVolumeViewport = __webpack_require__(36205);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/StackViewport.js
+var StackViewport = __webpack_require__(98715);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/VideoViewport.js
+var VideoViewport = __webpack_require__(49001);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/WSIViewport.js
+var WSIViewport = __webpack_require__(86057);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/Viewport.js
+var Viewport = __webpack_require__(77614);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/eventTarget.js
+var eventTarget = __webpack_require__(74238);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/getRenderingEngine.js
+var getRenderingEngine = __webpack_require__(9138);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/cache/index.js
+var cache = __webpack_require__(82253);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/requestPool/imageRetrievalPoolManager.js
+var imageRetrievalPoolManager = __webpack_require__(22717);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/requestPool/imageLoadPoolManager.js
+var imageLoadPoolManager = __webpack_require__(96506);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/getEnabledElement.js
+var getEnabledElement = __webpack_require__(65279);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/metaData.js
+var metaData = __webpack_require__(30023);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/init.js + 1 modules
+var init = __webpack_require__(28719);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/Settings.js
+const DEFAULT_SETTINGS = Symbol('DefaultSettings');
+const RUNTIME_SETTINGS = Symbol('RuntimeSettings');
+const OBJECT_SETTINGS_MAP = Symbol('ObjectSettingsMap');
+const DICTIONARY = Symbol('Dictionary');
+class Settings {
+    constructor(base) {
+        const dictionary = Object.create((base instanceof Settings && DICTIONARY in base
+            ? base[DICTIONARY]
+            : null));
+        Object.seal(Object.defineProperty(this, DICTIONARY, {
+            value: dictionary,
+        }));
+    }
+    set(key, value) {
+        return set(this[DICTIONARY], key, value, null);
+    }
+    get(key) {
+        return get(this[DICTIONARY], key);
+    }
+    unset(key) {
+        return unset(this[DICTIONARY], key + '');
+    }
+    forEach(callback) {
+        iterate(this[DICTIONARY], callback);
+    }
+    extend() {
+        return new Settings(this);
+    }
+    import(root) {
+        if (isPlainObject(root)) {
+            Object.keys(root).forEach((key) => {
+                set(this[DICTIONARY], key, root[key], null);
+            });
+        }
+    }
+    dump() {
+        const context = {};
+        iterate(this[DICTIONARY], (key, value) => {
+            if (typeof value !== 'undefined') {
+                deepSet(context, key, value);
+            }
+        });
+        return context;
+    }
+    static assert(subject) {
+        return subject instanceof Settings
+            ? subject
+            : Settings.getRuntimeSettings();
+    }
+    static getDefaultSettings(subfield = null) {
+        let defaultSettings = Settings[DEFAULT_SETTINGS];
+        if (!(defaultSettings instanceof Settings)) {
+            defaultSettings = new Settings();
+            Settings[DEFAULT_SETTINGS] = defaultSettings;
+        }
+        if (subfield) {
+            const settingObj = {};
+            defaultSettings.forEach((name) => {
+                if (name.startsWith(subfield)) {
+                    const setting = name.split(`${subfield}.`)[1];
+                    settingObj[setting] = defaultSettings.get(name);
+                }
+            });
+            return settingObj;
+        }
+        return defaultSettings;
+    }
+    static getRuntimeSettings() {
+        let runtimeSettings = Settings[RUNTIME_SETTINGS];
+        if (!(runtimeSettings instanceof Settings)) {
+            runtimeSettings = new Settings(Settings.getDefaultSettings());
+            Settings[RUNTIME_SETTINGS] = runtimeSettings;
+        }
+        return runtimeSettings;
+    }
+    static getObjectSettings(subject, from) {
+        let settings = null;
+        if (subject instanceof Settings) {
+            settings = subject;
+        }
+        else if (typeof subject === 'object' && subject !== null) {
+            let objectSettingsMap = Settings[OBJECT_SETTINGS_MAP];
+            if (!(objectSettingsMap instanceof WeakMap)) {
+                objectSettingsMap = new WeakMap();
+                Settings[OBJECT_SETTINGS_MAP] = objectSettingsMap;
+            }
+            settings = objectSettingsMap.get(subject);
+            if (!(settings instanceof Settings)) {
+                settings = new Settings(Settings.assert(Settings.getObjectSettings(from)));
+                objectSettingsMap.set(subject, settings);
+            }
+        }
+        return settings;
+    }
+    static extendRuntimeSettings() {
+        return Settings.getRuntimeSettings().extend();
+    }
+}
+function unset(dictionary, name) {
+    if (name.endsWith('.')) {
+        let deleteCount = 0;
+        const namespace = name;
+        const base = namespace.slice(0, -1);
+        const deleteAll = base.length === 0;
+        for (const key in dictionary) {
+            if (Object.prototype.hasOwnProperty.call(dictionary, key) &&
+                (deleteAll || key.startsWith(namespace) || key === base)) {
+                delete dictionary[key];
+                ++deleteCount;
+            }
+        }
+        return deleteCount > 0;
+    }
+    return delete dictionary[name];
+}
+function iterate(dictionary, callback) {
+    for (const key in dictionary) {
+        callback(key, dictionary[key]);
+    }
+}
+function setAll(dictionary, prefix, record, references) {
+    let failCount;
+    if (references.has(record)) {
+        return set(dictionary, prefix, null, references);
+    }
+    references.add(record);
+    failCount = 0;
+    for (const field in record) {
+        if (Object.prototype.hasOwnProperty.call(record, field)) {
+            const key = field.length === 0 ? prefix : `${prefix}.${field}`;
+            if (!set(dictionary, key, record[field], references)) {
+                ++failCount;
+            }
+        }
+    }
+    references.delete(record);
+    return failCount === 0;
+}
+function set(dictionary, key, value, references) {
+    if (isValidKey(key)) {
+        if (isPlainObject(value)) {
+            return setAll(dictionary, key, value, references instanceof WeakSet ? references : new WeakSet());
+        }
+        dictionary[key] = value;
+        return true;
+    }
+    return false;
+}
+function get(dictionary, key) {
+    return dictionary[key];
+}
+function isValidKey(key) {
+    let last, current, previous;
+    if (typeof key !== 'string' || (last = key.length - 1) < 0) {
+        return false;
+    }
+    previous = -1;
+    while ((current = key.indexOf('.', previous + 1)) >= 0) {
+        if (current - previous < 2 || current === last) {
+            return false;
+        }
+        previous = current;
+    }
+    return true;
+}
+function isPlainObject(subject) {
+    if (typeof subject === 'object' && subject !== null) {
+        const prototype = Object.getPrototypeOf(subject);
+        if (prototype === Object.prototype || prototype === null) {
+            return true;
+        }
+    }
+    return false;
+}
+function deepSet(context, key, value) {
+    const separator = key.indexOf('.');
+    if (separator >= 0) {
+        const subKey = key.slice(0, separator);
+        let subContext = context[subKey];
+        if (typeof subContext !== 'object' || subContext === null) {
+            const subContextValue = subContext;
+            subContext = {};
+            if (typeof subContextValue !== 'undefined') {
+                subContext[''] = subContextValue;
+            }
+            context[subKey] = subContext;
+        }
+        deepSet(subContext, key.slice(separator + 1, key.length), value);
+    }
+    else {
+        context[key] = value;
+    }
+}
+Settings.getDefaultSettings().set('useCursors', true);
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/volumeLoader.js
+var volumeLoader = __webpack_require__(18588);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/imageLoader.js
+var imageLoader = __webpack_require__(62990);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/geometryLoader.js + 26 modules
+var geometryLoader = __webpack_require__(59469);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/ProgressiveRetrieveImages.js + 4 modules
+var ProgressiveRetrieveImages = __webpack_require__(27654);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 66 modules
+var utilities = __webpack_require__(56309);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/triggerEvent.js
+var triggerEvent = __webpack_require__(85041);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/index.js + 1 modules
+var helpers = __webpack_require__(25281);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js
+
+
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/Events.js
-var Events = __webpack_require__(19546);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/RequestType.js
-var RequestType = __webpack_require__(49334);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ViewportType.js
-var ViewportType = __webpack_require__(68032);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/InterpolationType.js
-var InterpolationType = __webpack_require__(75677);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/VolumeMapper/Constants.js
-var Constants = __webpack_require__(83336);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/BlendModes.js
 
-const { BlendMode } = Constants["default"];
-var BlendModes;
-(function (BlendModes) {
-    BlendModes[BlendModes["COMPOSITE"] = 0] = "COMPOSITE";
-    BlendModes[BlendModes["MAXIMUM_INTENSITY_BLEND"] = 1] = "MAXIMUM_INTENSITY_BLEND";
-    BlendModes[BlendModes["MINIMUM_INTENSITY_BLEND"] = 2] = "MINIMUM_INTENSITY_BLEND";
-    BlendModes[BlendModes["AVERAGE_INTENSITY_BLEND"] = 3] = "AVERAGE_INTENSITY_BLEND";
-})(BlendModes || (BlendModes = {}));
-/* harmony default export */ const enums_BlendModes = (BlendModes);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/OrientationAxis.js
-var OrientationAxis = __webpack_require__(96426);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/SharedArrayBufferModes.js
-var SharedArrayBufferModes = __webpack_require__(91799);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/GeometryType.js
-var GeometryType;
-(function (GeometryType) {
-    GeometryType["CONTOUR"] = "contour";
-    GeometryType["SURFACE"] = "Surface";
-})(GeometryType || (GeometryType = {}));
-/* harmony default export */ const enums_GeometryType = (GeometryType);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ContourType.js
-var ContourType = __webpack_require__(2689);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/VOILUTFunctionType.js
-var VOILUTFunctionType = __webpack_require__(67751);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/DynamicOperatorType.js
-var DynamicOperatorType;
-(function (DynamicOperatorType) {
-    DynamicOperatorType["SUM"] = "SUM";
-    DynamicOperatorType["AVERAGE"] = "AVERAGE";
-    DynamicOperatorType["SUBTRACT"] = "SUBTRACT";
-})(DynamicOperatorType || (DynamicOperatorType = {}));
-/* harmony default export */ const enums_DynamicOperatorType = ((/* unused pure expression or super */ null && (DynamicOperatorType)));
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/CalibrationTypes.js
-var CalibrationTypes;
-(function (CalibrationTypes) {
-    CalibrationTypes["NOT_APPLICABLE"] = "";
-    CalibrationTypes["ERMF"] = "ERMF";
-    CalibrationTypes["USER"] = "User";
-    CalibrationTypes["PROJECTION"] = "Proj";
-    CalibrationTypes["REGION"] = "Region";
-    CalibrationTypes["ERROR"] = "Error";
-    CalibrationTypes["UNCALIBRATED"] = "Uncalibrated";
-})(CalibrationTypes || (CalibrationTypes = {}));
-/* harmony default export */ const enums_CalibrationTypes = (CalibrationTypes);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ViewportStatus.js
-var ViewportStatus = __webpack_require__(84659);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/ImageQualityStatus.js
-var ImageQualityStatus = __webpack_require__(83521);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/VideoEnums.js
-var VideoEnums = __webpack_require__(40373);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/MetadataModules.js
-var MetadataModules = __webpack_require__(636);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/enums/index.js
 
 
 
@@ -2897,68 +3917,9 @@ var MetadataModules = __webpack_require__(636);
 
 
 
-/***/ }),
 
-/***/ 65279:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   O: () => (/* binding */ getEnabledElementByIds),
-/* harmony export */   Yz: () => (/* binding */ getEnabledElementByViewportId),
-/* harmony export */   ZP: () => (/* binding */ getEnabledElement),
-/* harmony export */   wN: () => (/* binding */ getEnabledElements)
-/* harmony export */ });
-/* harmony import */ var _RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9138);
 
-function getEnabledElement(element) {
-    if (!element) {
-        return;
-    }
-    const { viewportUid, renderingEngineUid } = element.dataset;
-    return getEnabledElementByIds(viewportUid, renderingEngineUid);
-}
-function getEnabledElementByIds(viewportId, renderingEngineId) {
-    if (!renderingEngineId || !viewportId) {
-        return;
-    }
-    const renderingEngine = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP)(renderingEngineId);
-    if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
-        return;
-    }
-    const viewport = renderingEngine.getViewport(viewportId);
-    if (!viewport) {
-        return;
-    }
-    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-    return {
-        viewport,
-        renderingEngine,
-        viewportId,
-        renderingEngineId,
-        FrameOfReferenceUID,
-    };
-}
-function getEnabledElementByViewportId(viewportId) {
-    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .Uu)();
-    for (let i = 0; i < renderingEngines.length; i++) {
-        const renderingEngine = renderingEngines[i];
-        const viewport = renderingEngine.getViewport(viewportId);
-        if (viewport) {
-            return getEnabledElementByIds(viewportId, renderingEngine.id);
-        }
-    }
-}
-function getEnabledElements() {
-    const enabledElements = [];
-    const renderingEngines = (0,_RenderingEngine_getRenderingEngine__WEBPACK_IMPORTED_MODULE_0__/* .getRenderingEngines */ .Uu)();
-    renderingEngines.forEach((renderingEngine) => {
-        const viewports = renderingEngine.getViewports();
-        viewports.forEach(({ element }) => {
-            enabledElements.push(getEnabledElement(element));
-        });
-    });
-    return enabledElements;
-}
 
 
 /***/ }),
@@ -2987,9 +3948,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(82253);
 /* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(19546);
 /* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(74238);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(56309);
 /* harmony import */ var _requestPool_imageLoadPoolManager__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(96506);
-/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(62709);
+/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(12651);
 
 
 
@@ -3268,7 +4229,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(85041);
 /* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(11677);
 /* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(lodash_clonedeep__WEBPACK_IMPORTED_MODULE_8__);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(56309);
 /* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(28719);
 /* harmony import */ var _utilities_cacheUtils__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(85654);
 
@@ -3589,6 +4550,55 @@ function generateVolumeScalarData(targetBuffer, scalarLength) {
 }
 
 
+/***/ }),
+
+/***/ 30023:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   addProvider: () => (/* binding */ addProvider),
+/* harmony export */   get: () => (/* binding */ getMetaData),
+/* harmony export */   removeAllProviders: () => (/* binding */ removeAllProviders),
+/* harmony export */   removeProvider: () => (/* binding */ removeProvider)
+/* harmony export */ });
+const providers = [];
+function addProvider(provider, priority = 0) {
+    let i;
+    for (i = 0; i < providers.length; i++) {
+        if (providers[i].priority <= priority) {
+            break;
+        }
+    }
+    providers.splice(i, 0, {
+        priority,
+        provider,
+    });
+}
+function removeProvider(provider) {
+    for (let i = 0; i < providers.length; i++) {
+        if (providers[i].provider === provider) {
+            providers.splice(i, 1);
+            break;
+        }
+    }
+}
+function removeAllProviders() {
+    while (providers.length > 0) {
+        providers.pop();
+    }
+}
+function getMetaData(type, ...queries) {
+    for (let i = 0; i < providers.length; i++) {
+        const result = providers[i].provider(type, ...queries);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+}
+
+
+
 /***/ }),
 
 /***/ 96506:
@@ -3618,7 +4628,7 @@ imageLoadPoolManager.setMaxSimultaneousRequests(_enums_RequestType__WEBPACK_IMPO
 /* harmony export */   P: () => (/* binding */ RequestPoolManager)
 /* harmony export */ });
 /* harmony import */ var _enums_RequestType__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(49334);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(11723);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(56309);
 
 
 class RequestPoolManager {
@@ -4448,6 +5458,13 @@ const CursorSVG = {
             y: 24,
         },
     }),
+    Height: extend(BASE, {
+        iconContent: `<path d="m 6 22 l 8.5 0 v -16 h 8" stroke-width="3" fill="none" stroke="{{color}}" />`,
+        viewBox: {
+            x: 24,
+            y: 24,
+        },
+    }),
     Probe: extend(BASE, {
         iconContent: `<path fill="{{color}}" d="M1152 896q0 106-75 181t-181 75-181-75-75-181 75-181 181-75 181 75
     75 181zm-256-544q-148 0-273 73t-198 198-73 273 73 273 198 198 273 73 273-73
@@ -4678,7 +5695,7 @@ const svgCursorNames = Object.keys(CursorSVG);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33232);
 /* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(69562);
 /* harmony import */ var _synchronizers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(93423);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(86785);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(25876);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(42975);
 /* harmony import */ var _cursors__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(60020);
 /* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(35106);
@@ -4751,7 +5768,7 @@ const svgCursorNames = Object.keys(CursorSVG);
 /***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
 
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(72076);
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12651);
 /* harmony import */ var _utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(39661);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(42975);
 /* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(93382);
@@ -4760,7 +5777,7 @@ const svgCursorNames = Object.keys(CursorSVG);
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(11163);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(41836);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(36705);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(86785);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(25876);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(33232);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(68096);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(46966);
@@ -5508,7 +6525,7 @@ BidirectionalTool.toolName = 'Bidirectional';
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72076);
 /* harmony import */ var _AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(92622);
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(11163);
@@ -5755,7 +6772,7 @@ __webpack_require__.d(__webpack_exports__, {
   xX: () => (/* reexport */ SegmentationDisplayTool/* default */.Z)
 });
 
-// UNUSED EXPORTS: AngleTool, AnnotationDisplayTool, ArrowAnnotateTool, BaseTool, BidirectionalTool, BrushTool, CircleROIStartEndThresholdTool, CircleROITool, CircleScissorsTool, CobbAngleTool, CrosshairsTool, DragProbeTool, EllipticalROITool, EraserTool, KeyImageTool, LengthTool, LivewireContourSegmentationTool, LivewireContourTool, MIPJumpToClickTool, MagnifyTool, OrientationMarkerTool, OverlayGridTool, PaintFillTool, PanTool, PlanarRotateTool, ProbeTool, RectangleROIStartEndThresholdTool, RectangleROIThresholdTool, RectangleROITool, RectangleScissorsTool, ReferenceCursors, ReferenceLines, ReferenceLinesTool, ScaleOverlayTool, SculptorTool, SegmentSelectTool, SegmentationIntersectionTool, SphereScissorsTool, SplineContourSegmentationTool, SplineROITool, StackScrollMouseWheelTool, StackScrollTool, TrackballRotateTool, UltrasoundDirectionalTool, VolumeRotateMouseWheelTool, WindowLevelRegionTool, WindowLevelTool, ZoomTool
+// UNUSED EXPORTS: AngleTool, AnnotationDisplayTool, ArrowAnnotateTool, BaseTool, BidirectionalTool, BrushTool, CircleROIStartEndThresholdTool, CircleROITool, CircleScissorsTool, CobbAngleTool, CrosshairsTool, DragProbeTool, EllipticalROITool, EraserTool, HeightTool, KeyImageTool, LengthTool, LivewireContourSegmentationTool, LivewireContourTool, MIPJumpToClickTool, MagnifyTool, OrientationMarkerTool, OverlayGridTool, PaintFillTool, PanTool, PlanarRotateTool, ProbeTool, RectangleROIStartEndThresholdTool, RectangleROIThresholdTool, RectangleROITool, RectangleScissorsTool, ReferenceCursors, ReferenceLines, ReferenceLinesTool, ScaleOverlayTool, SculptorTool, SegmentSelectTool, SegmentationIntersectionTool, SphereScissorsTool, SplineContourSegmentationTool, SplineROITool, StackScrollMouseWheelTool, StackScrollTool, TrackballRotateTool, UltrasoundDirectionalTool, VolumeRotateMouseWheelTool, WindowLevelRegionTool, WindowLevelTool, ZoomTool
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/base/index.js
 var base = __webpack_require__(93382);
@@ -5801,6 +6818,8 @@ var SculptorTool = __webpack_require__(86684);
 var BidirectionalTool = __webpack_require__(56611);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/LengthTool.js
 var LengthTool = __webpack_require__(3098);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/HeightTool.js
+var HeightTool = __webpack_require__(76131);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/ProbeTool.js
 var ProbeTool = __webpack_require__(86479);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/DragProbeTool.js
@@ -5843,14 +6862,14 @@ var RectangleScissorsTool = __webpack_require__(13354);
 var CircleScissorsTool = __webpack_require__(30809);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/SphereScissorsTool.js
 var SphereScissorsTool = __webpack_require__(30862);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/index.js
 var stateManagement = __webpack_require__(50097);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationLocking.js
 var annotationLocking = __webpack_require__(11163);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/index.js + 18 modules
-var drawingSvg = __webpack_require__(86785);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/index.js + 19 modules
+var drawingSvg = __webpack_require__(25876);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewportFilters/index.js + 4 modules
 var viewportFilters = __webpack_require__(46966);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/cursors/elementCursor.js
@@ -6008,12 +7027,26 @@ class RectangleROIThresholdTool extends RectangleROITool/* default */.Z {
 RectangleROIThresholdTool.toolName = 'RectangleROIThreshold';
 /* harmony default export */ const segmentation_RectangleROIThresholdTool = ((/* unused pure expression or super */ null && (RectangleROIThresholdTool)));
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getCalibratedUnits.js
+var getCalibratedUnits = __webpack_require__(39661);
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var gl_matrix_esm = __webpack_require__(72076);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/throttle.js
 var throttle = __webpack_require__(90685);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/drawing/index.js + 1 modules
+var drawing = __webpack_require__(20724);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planar/getWorldWidthAndHeightFromCorners.js
+var getWorldWidthAndHeightFromCorners = __webpack_require__(88582);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/index.js + 1 modules
 var utilities = __webpack_require__(42975);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getModalityUnit.js
+var getModalityUnit = __webpack_require__(15607);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewport/isViewportPreScaled.js
+var isViewportPreScaled = __webpack_require__(20752);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/index.js + 2 modules
+var basic = __webpack_require__(51053);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planar/index.js
+var planar = __webpack_require__(44037);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/RectangleROIStartEndThresholdTool.js
 
 
@@ -6028,6 +7061,13 @@ var utilities = __webpack_require__(42975);
 
 
 
+
+
+
+
+
+
+
 
 const { transformWorldToIndex } = esm.utilities;
 class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z {
@@ -6035,6 +7075,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
         configuration: {
             numSlicesToPropagate: 10,
             computePointsInsideVolume: false,
+            getTextLines: defaultGetTextLines,
+            statsCalculator: basic.BasicStatsCalculator,
+            showTextBox: false,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -6057,12 +7100,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
                 imageVolume = esm.cache.getVolume(volumeId);
                 referencedImageId = esm.utilities.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);
             }
-            if (!referencedImageId) {
-                throw new Error('This tool does not work on non-acquisition planes');
-            }
-            const startIndex = viewport.getCurrentImageIdIndex();
             const spacingInNormal = esm.utilities.getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
-            const endIndex = this._getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal);
+            const startCoord = this._getStartCoordinate(worldPos, viewPlaneNormal);
+            const endCoord = this._getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
             const annotation = {
                 highlighted: true,
@@ -6079,18 +7119,24 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
                 },
                 data: {
                     label: '',
-                    startSlice: startIndex,
-                    endSlice: endIndex,
+                    startCoordinate: startCoord,
+                    endCoordinate: endCoord,
                     cachedStats: {
                         pointsInVolume: [],
                         projectionPoints: [],
                         projectionPointsImageIds: [referencedImageId],
+                        statistics: [],
                     },
                     handles: {
                         textBox: {
                             hasMoved: false,
-                            worldPosition: null,
-                            worldBoundingBox: null,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
                         },
                         points: [
                             [...worldPos],
@@ -6141,7 +7187,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
             const targetId = this.getTargetId(enabledElement.viewport);
             const imageVolume = esm.cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
             if (this.configuration.calculatePointsInsideVolume) {
-                this._computePointsInsideVolume(annotation, imageVolume, enabledElement);
+                this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
             }
             (0,triggerAnnotationRenderForViewportIds/* default */.Z)(enabledElement.renderingEngine, viewportIdsToRender);
             if (newAnnotation) {
@@ -6151,11 +7197,11 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
             let renderStatus = false;
             const { viewport } = enabledElement;
-            const annotations = (0,stateManagement/* getAnnotations */.fy)(this.getToolName(), viewport.element);
+            let annotations = (0,stateManagement/* getAnnotations */.fy)(this.getToolName(), viewport.element);
             if (!annotations?.length) {
                 return renderStatus;
             }
-            const sliceIndex = viewport.getCurrentImageIdIndex();
+            annotations = (0,planar.filterAnnotationsWithinSamePlane)(annotations, viewport.getCamera());
             const styleSpecifier = {
                 toolGroupId: this.toolGroupId,
                 toolName: this.getToolName(),
@@ -6164,22 +7210,37 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
             for (let i = 0; i < annotations.length; i++) {
                 const annotation = annotations[i];
                 const { annotationUID, data } = annotation;
-                const { startSlice, endSlice } = data;
+                const { startCoordinate, endCoordinate } = data;
                 const { points, activeHandleIndex } = data.handles;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 styleSpecifier.annotationUID = annotationUID;
                 const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
                 const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
                 const color = this.getStyle('color', styleSpecifier, annotation);
-                if (sliceIndex < Math.min(startSlice, endSlice) ||
-                    sliceIndex > Math.max(startSlice, endSlice)) {
+                const focalPoint = viewport.getCamera().focalPoint;
+                const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
+                let startCoord = startCoordinate;
+                let endCoord = endCoordinate;
+                if (Array.isArray(startCoordinate)) {
+                    startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                }
+                if (Array.isArray(endCoordinate)) {
+                    endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                }
+                const roundedStartCoord = esm.utilities.roundToPrecision(startCoord);
+                const roundedEndCoord = esm.utilities.roundToPrecision(endCoord);
+                const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCoord = esm.utilities.roundToPrecision(coord);
+                if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
+                    roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
                     continue;
                 }
                 if (annotation.invalidated) {
                     this._throttledCalculateCachedStats(annotation, enabledElement);
                 }
                 let firstOrLastSlice = false;
-                if (sliceIndex === startSlice || sliceIndex === endSlice) {
+                if (roundedCoord === roundedStartCoord ||
+                    roundedCoord === roundedEndCoord) {
                     firstOrLastSlice = true;
                 }
                 if (!viewport.getRenderingEngine()) {
@@ -6213,6 +7274,42 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
                     lineWidth,
                 });
                 renderStatus = true;
+                if (this.configuration.showTextBox &&
+                    this.configuration.calculatePointsInsideVolume) {
+                    const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                    if (!options.visibility) {
+                        data.handles.textBox = {
+                            hasMoved: false,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
+                        };
+                        continue;
+                    }
+                    const textLines = this.configuration.getTextLines(data);
+                    if (!textLines || textLines.length === 0) {
+                        continue;
+                    }
+                    if (!data.handles.textBox.hasMoved) {
+                        const canvasTextBoxCoords = (0,drawing.getTextBoxCoordsCanvas)(canvasCoordinates);
+                        data.handles.textBox.worldPosition =
+                            viewport.canvasToWorld(canvasTextBoxCoords);
+                    }
+                    const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+                    const textBoxUID = '1';
+                    const boundingBox = (0,drawingSvg.drawLinkedTextBox)(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
+                    const { x: left, y: top, width, height } = boundingBox;
+                    data.handles.textBox.worldBoundingBox = {
+                        topLeft: viewport.canvasToWorld([left, top]),
+                        topRight: viewport.canvasToWorld([left + width, top]),
+                        bottomLeft: viewport.canvasToWorld([left, top + height]),
+                        bottomRight: viewport.canvasToWorld([left + width, top + height]),
+                    };
+                }
             }
             return renderStatus;
         };
@@ -6222,17 +7319,26 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
         const { data, metadata } = annotation;
         const { viewPlaneNormal, spacingInNormal } = metadata;
         const { imageData } = imageVolume;
-        const { startSlice, endSlice } = data;
+        const { startCoordinate, endCoordinate } = data;
         const { points } = data.handles;
         const startIJK = transformWorldToIndex(imageData, points[0]);
-        if (startIJK[2] !== startSlice) {
-            throw new Error('Start slice does not match');
-        }
-        const endIJK = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(startIJK[0], startIJK[1], endSlice);
+        const endIJK = transformWorldToIndex(imageData, points[0]);
         const startWorld = gl_matrix_esm/* vec3.create */.R3.create();
         imageData.indexToWorldVec3(startIJK, startWorld);
         const endWorld = gl_matrix_esm/* vec3.create */.R3.create();
         imageData.indexToWorldVec3(endIJK, endWorld);
+        if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 2) {
+            startWorld[2] = startCoordinate;
+            endWorld[2] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 0) {
+            startWorld[0] = startCoordinate;
+            endWorld[0] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 1) {
+            startWorld[1] = startCoordinate;
+            endWorld[1] = endCoordinate;
+        }
         const distance = gl_matrix_esm/* vec3.distance */.R3.distance(startWorld, endWorld);
         const newProjectionPoints = [];
         for (let dist = 0; dist < distance; dist += spacingInNormal) {
@@ -6243,34 +7349,45 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
             }));
         }
         data.cachedStats.projectionPoints = newProjectionPoints;
-        const projectionPointsImageIds = [];
-        for (const RectanglePoints of newProjectionPoints) {
-            const imageId = esm.utilities.getClosestImageId(imageVolume, RectanglePoints[0], viewPlaneNormal);
-            projectionPointsImageIds.push(imageId);
-        }
-        data.cachedStats.projectionPointsImageIds = projectionPointsImageIds;
     }
-    _computePointsInsideVolume(annotation, imageVolume, enabledElement) {
-        const { data } = annotation;
+    _computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement) {
+        const { data, metadata } = annotation;
+        const { viewPlaneNormal, viewUp } = metadata;
+        const { viewport, renderingEngine } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
+        const image = this.getTargetIdImage(targetId, renderingEngine);
+        const worldPos1 = data.handles.points[0];
+        const worldPos2 = data.handles.points[3];
+        const { worldWidth, worldHeight } = (0,getWorldWidthAndHeightFromCorners/* default */.Z)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+        const measureInfo = (0,getCalibratedUnits/* getCalibratedLengthUnitsAndScale */.mh)(image, data.habdles);
+        const area = Math.abs(worldWidth * worldHeight) /
+            (measureInfo.scale * measureInfo.scale);
+        const modalityUnitOptions = {
+            isPreScaled: (0,isViewportPreScaled/* isViewportPreScaled */.P)(viewport, targetId),
+            isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+        };
+        const modalityUnit = (0,getModalityUnit/* getModalityUnit */.F)(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
             }
             const projectionPoint = projectionPoints[i][0];
-            const worldPos1 = data.handles.points[0];
-            const worldPos2 = data.handles.points[3];
             const { dimensions, imageData } = imageVolume;
             const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
             const worldProjectionPointIndex = transformWorldToIndex(imageData, projectionPoint);
+            const indexOfProjection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
             worldPos1Index[0] = Math.floor(worldPos1Index[0]);
             worldPos1Index[1] = Math.floor(worldPos1Index[1]);
-            worldPos1Index[2] = Math.floor(worldProjectionPointIndex[2]);
+            worldPos1Index[2] = Math.floor(worldPos1Index[2]);
+            worldPos1Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
             worldPos2Index[0] = Math.floor(worldPos2Index[0]);
             worldPos2Index[1] = Math.floor(worldPos2Index[1]);
-            worldPos2Index[2] = Math.floor(worldProjectionPointIndex[2]);
+            worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+            worldPos2Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
                 this.isHandleOutsideImage = false;
                 const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
@@ -6284,11 +7401,22 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
                     [jMin, jMax],
                     [kMin, kMax],
                 ];
-                const pointsInShape = (0,utilities.pointInShapeCallback)(imageData, () => true, null, boundsIJK);
+                const pointsInShape = (0,utilities.pointInShapeCallback)(imageData, () => true, this.configuration.statsCalculator.statsCallback, boundsIJK);
                 pointsInsideVolume.push(pointsInShape);
             }
         }
+        const stats = this.configuration.statsCalculator.getStatistics();
         data.cachedStats.pointsInVolume = pointsInsideVolume;
+        data.cachedStats.statistics = {
+            Modality: metadata.Modality,
+            area,
+            mean: stats.mean?.value,
+            stdDev: stats.stdDev?.value,
+            max: stats.max?.value,
+            statsArray: stats.array,
+            areaUnit: measureInfo.areaUnits,
+            modalityUnit,
+        };
     }
     _calculateCachedStatsTool(annotation, enabledElement) {
         const data = annotation.data;
@@ -6301,25 +7429,44 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool/* default */.Z
         (0,state/* triggerAnnotationModified */.hg)(annotation, viewport.element);
         return cachedStats;
     }
-    _getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal) {
+    _getStartCoordinate(worldPos, viewPlaneNormal) {
+        const startPos = worldPos;
+        const startCoord = this._getCoordinateForViewplaneNormal(startPos, viewPlaneNormal);
+        return startCoord;
+    }
+    _getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal) {
         const numSlicesToPropagate = this.configuration.numSlicesToPropagate;
         const endPos = gl_matrix_esm/* vec3.create */.R3.create();
         gl_matrix_esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(endPos, worldPos, viewPlaneNormal, numSlicesToPropagate * spacingInNormal);
-        const halfSpacingInNormalDirection = spacingInNormal / 2;
-        const { imageIds } = imageVolume;
-        let imageIdIndex;
-        for (let i = 0; i < imageIds.length; i++) {
-            const imageId = imageIds[i];
-            const { imagePositionPatient } = esm.metaData.get('imagePlaneModule', imageId);
-            const dir = gl_matrix_esm/* vec3.create */.R3.create();
-            gl_matrix_esm/* vec3.sub */.R3.sub(dir, endPos, imagePositionPatient);
-            const dot = gl_matrix_esm/* vec3.dot */.R3.dot(dir, viewPlaneNormal);
-            if (Math.abs(dot) < halfSpacingInNormalDirection) {
-                imageIdIndex = i;
-            }
-        }
-        return imageIdIndex;
+        const endCoord = this._getCoordinateForViewplaneNormal(endPos, viewPlaneNormal);
+        return endCoord;
+    }
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) {
+        const viewplaneNormalAbs = [
+            Math.abs(viewPlaneNormal[0]),
+            Math.abs(viewPlaneNormal[1]),
+            Math.abs(viewPlaneNormal[2]),
+        ];
+        const indexOfDirection = viewplaneNormalAbs.indexOf(Math.max(...viewplaneNormalAbs));
+        return indexOfDirection;
+    }
+    _getCoordinateForViewplaneNormal(pos, viewPlaneNormal) {
+        const indexOfDirection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
+        return pos[indexOfDirection];
+    }
+}
+function defaultGetTextLines(data) {
+    const cachedVolumeStats = data.cachedStats.statistics;
+    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+    if (mean === undefined) {
+        return;
     }
+    const textLines = [];
+    textLines.push(`Area: ${(0,utilities.roundNumber)(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${(0,utilities.roundNumber)(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${(0,utilities.roundNumber)(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${(0,utilities.roundNumber)(stdDev)} ${modalityUnit}`);
+    return textLines;
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
 /* harmony default export */ const segmentation_RectangleROIStartEndThresholdTool = ((/* unused pure expression or super */ null && (RectangleROIStartEndThresholdTool)));
@@ -6387,6 +7534,7 @@ var SegmentSelectTool = __webpack_require__(45986);
 
 
 
+
 
 
 /***/ }),
@@ -6395,7 +7543,7 @@ var SegmentSelectTool = __webpack_require__(45986);
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* unused harmony export default */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(34539);
 
 
@@ -6450,7 +7598,7 @@ class AnnotationFrameRange {
 /* harmony export */   B: () => (/* binding */ getClosestImageIdForStackViewport)
 /* harmony export */ });
 /* unused harmony export annotationHydration */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _stateManagement__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(50097);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(72076);
 
@@ -6563,7 +7711,7 @@ function extend2DBoundingBoxInViewAxis(boundsIJK, numSlicesToProject) {
 /* harmony export */   g: () => (/* binding */ getBoundingBoxAroundShapeIJK),
 /* harmony export */   o: () => (/* binding */ getBoundingBoxAroundShapeWorld)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 
 const { EPSILON } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.CONSTANTS;
 function calculateBoundingBox(points, dimensions, isWorld = false) {
@@ -6643,7 +7791,7 @@ function getBoundingBoxAroundShapeWorld(points, clipBounds) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* unused harmony export default */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 
 const { calibratedPixelSpacingMetadataProvider } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
 function calibrateImageSpacing(imageId, renderingEngine, calibrationOrScale) {
@@ -6674,8 +7822,8 @@ function calibrateImageSpacing(imageId, renderingEngine, calibrationOrScale) {
 
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var esm = __webpack_require__(72076);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var dist_esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var dist_esm = __webpack_require__(12651);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/cine/events.js
 var Events;
 (function (Events) {
@@ -6793,13 +7941,24 @@ function playClip(element, playClipOptions) {
         }
         const delta = newStepIndex - currentStepIndex;
         if (delta) {
-            playClipContext.scroll(delta);
+            try {
+                playClipContext.scroll(delta);
+            }
+            catch (e) {
+                console.warn('Play clip not scrolling', e);
+                _stopClipWithData(playClipData);
+                triggerEvent(element, CINE_EVENTS.CLIP_STOPPED, eventDetail);
+                return;
+            }
         }
     };
     if (isDynamicCinePlaying) {
         dynamicVolumesPlayingMap.set(volume.volumeId, element);
     }
-    if (playClipTimeouts &&
+    if (playClipContext.play) {
+        playClipData.framesPerSecond = playClipContext.play(playClipOptions.framesPerSecond);
+    }
+    else if (playClipTimeouts &&
         playClipTimeouts.length > 0 &&
         playClipIsTimeVarying) {
         playClipData.usingFrameTimeVector = true;
@@ -6827,6 +7986,7 @@ function _stopClip(element, options = { stopDynamicCine: true, viewportId: undef
     const { stopDynamicCine, viewportId } = options;
     const enabledElement = getEnabledElement(element);
     let toolState;
+    const viewport = enabledElement?.viewport;
     if (!enabledElement) {
         if (viewportId) {
             toolState = getToolStateByViewportId(viewportId);
@@ -6842,8 +8002,10 @@ function _stopClip(element, options = { stopDynamicCine: true, viewportId: undef
     if (toolState) {
         _stopClipWithData(toolState);
     }
-    if (stopDynamicCine &&
-        enabledElement?.viewport instanceof BaseVolumeViewport) {
+    if (viewport instanceof VideoViewport) {
+        viewport.pause();
+    }
+    else if (stopDynamicCine && viewport instanceof BaseVolumeViewport) {
         _stopDynamicVolumeCine(element);
     }
 }
@@ -6938,6 +8100,36 @@ function _createStackViewportCinePlayContext(viewport, waitForRendered) {
         },
     };
 }
+function _createVideoViewportCinePlayContext(viewport, waitForRendered) {
+    return {
+        get numScrollSteps() {
+            return viewport.getNumberOfSlices();
+        },
+        get currentStepIndex() {
+            return viewport.getSliceIndex();
+        },
+        get frameTimeVectorEnabled() {
+            return true;
+        },
+        waitForRenderedCount: 0,
+        scroll(delta) {
+            if (this.waitForRenderedCount <= waitForRendered &&
+                viewport.viewportStatus !== ViewportStatus.RENDERED) {
+                this.waitForRenderedCount++;
+                return;
+            }
+            this.waitForRenderedCount = 0;
+            scroll(viewport, { delta, debounceLoading: debounced });
+        },
+        play(fps) {
+            if (fps) {
+                viewport.setPlaybackRate(fps / 24);
+            }
+            viewport.play();
+            return viewport.getFrameRate();
+        },
+    };
+}
 function _createVolumeViewportCinePlayContext(viewport, volume) {
     const { volumeId } = volume;
     const cachedScrollInfo = {
@@ -7003,6 +8195,9 @@ function _createCinePlayContext(viewport, playClipOptions) {
         }
         return _createVolumeViewportCinePlayContext(viewport, volume);
     }
+    if (viewport instanceof VideoViewport) {
+        return _createVideoViewportCinePlayContext(viewport, playClipOptions.waitForRendered ?? 30);
+    }
     throw new Error('Unknown viewport type');
 }
 
@@ -7171,7 +8366,7 @@ function calculatePerimeter(polyline, closed) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Z: () => (/* binding */ findHandlePolylineIndex)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72076);
 
 
@@ -7425,8 +8620,8 @@ function processContourHoles(contours, points, useXOR = true) {
 }
 /* harmony default export */ const detectContourHoles = ({ processContourHoles });
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var dist_esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var dist_esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/ImageMarchingSquares.js
 var ImageMarchingSquares = __webpack_require__(60318);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray.js
@@ -7667,7 +8862,7 @@ var calculatePerimeter = __webpack_require__(3042);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Z: () => (/* binding */ updateContourPolyline)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(79390);
 /* harmony import */ var _stateManagement__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(50097);
 
@@ -7894,8 +9089,8 @@ function _determineCorners(canvasPoints) {
 
 // UNUSED EXPORTS: generateImageFromTimeData, getDataInTime
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/utilities.js
 var segmentation_utilities = __webpack_require__(89776);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/pointInShapeCallback.js
@@ -8068,7 +9263,7 @@ function generateImageFromTimeData(dynamicVolume, operation, frameNumbers) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* unused harmony exports getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(86614);
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(27078);
 
@@ -8129,7 +9324,7 @@ function findAnnotationNearPointByTool(tool, enabledElement, point, proximity) {
 /* harmony export */   Sh: () => (/* binding */ getCalibratedProbeUnitsAndValue),
 /* harmony export */   mh: () => (/* binding */ getCalibratedLengthUnitsAndScale)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 
 const { CalibrationTypes } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums;
 const PIXEL_UNITS = 'px';
@@ -8143,8 +9338,17 @@ const SUPPORTED_PROBE_VARIANT = [
     '4,3',
 ];
 const UNIT_MAPPING = {
+    0: 'px',
+    1: 'percent',
+    2: 'dB',
     3: 'cm',
     4: 'seconds',
+    5: 'hertz',
+    6: 'dB/seconds',
+    7: 'cm/sec',
+    8: 'cm\xb2',
+    9: 'cm\xb2/s',
+    0xc: 'degrees',
 };
 const EPS = 1e-3;
 const SQUARE = '\xb2';
@@ -8192,10 +9396,10 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
         const physicalDeltaY = Math.abs(region.physicalDeltaY);
         const isSamePhysicalDelta = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(physicalDeltaX, physicalDeltaY, EPS);
         if (isSamePhysicalDelta) {
-            scale = 1 / (physicalDeltaX * 10);
+            scale = 1 / physicalDeltaX;
             calibrationType = 'US Region';
-            units = 'mm';
-            areaUnits = 'mm' + SQUARE;
+            units = UNIT_MAPPING[region.physicalUnitsXDirection] || 'unknown';
+            areaUnits = units + SQUARE;
         }
         else {
             return { units: PIXEL_UNITS, areaUnits: PIXEL_UNITS + SQUARE, scale };
@@ -8273,7 +9477,7 @@ const getCalibratedAspect = (image) => image.calibration?.aspect || 1;
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   v: () => (/* binding */ getSphereBoundsInfo)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72076);
 /* harmony import */ var _boundingBox__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(87758);
 
@@ -8359,8 +9563,8 @@ __webpack_require__.d(__webpack_exports__, {
 
 // UNUSED EXPORTS: annotationFrameRange, annotationHydration, boundingBox, calibrateImageSpacing, cine, contourSegmentation, contours, drawing, dynamicVolume, getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement, getCalibratedAspect, getCalibratedProbeUnitsAndValue, getClosestImageIdForStackViewport, getSphereBoundsInfo, getViewportForAnnotation, isObject, jumpToSlice, orientation, planar, planarFreehandROITool, pointInSurroundingSphereCallback, rectangleROITool, segmentation, stackContextPrefetch, stackPrefetch, touch, triggerAnnotationRender, triggerEvent, viewport, viewportFilters, voi
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getAnnotationNearPoint.js
 var getAnnotationNearPoint = __webpack_require__(62358);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/debounce.js
@@ -8571,8 +9775,8 @@ __webpack_require__.d(__webpack_exports__, {
 
 // UNUSED EXPORTS: Calculator
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/Calculator.js
 class Calculator {
 }
@@ -9610,8 +10814,8 @@ function getClosestLineSegmentIntersection(points, p1, q1, closed = true) {
     };
 }
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var dist_esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var dist_esm = __webpack_require__(12651);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/polyline/getSubPixelSpacingAndXYDirections.js
 
 
@@ -10088,6 +11292,7 @@ function invertOrientationStringLPS(orientationString) {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   filterAnnotationsForDisplay: () => (/* reexport safe */ _filterAnnotationsForDisplay__WEBPACK_IMPORTED_MODULE_2__.Z),
+/* harmony export */   filterAnnotationsWithinSamePlane: () => (/* reexport safe */ _filterAnnotationsWithinPlane__WEBPACK_IMPORTED_MODULE_5__.Q),
 /* harmony export */   getPointInLineOfSightWithCriteria: () => (/* reexport safe */ _getPointInLineOfSightWithCriteria__WEBPACK_IMPORTED_MODULE_3__.Z),
 /* harmony export */   isPlaneIntersectingAABB: () => (/* reexport safe */ _isPlaneIntersectingAABB__WEBPACK_IMPORTED_MODULE_4__.U)
 /* harmony export */ });
@@ -10096,6 +11301,8 @@ function invertOrientationStringLPS(orientationString) {
 /* harmony import */ var _filterAnnotationsForDisplay__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(69943);
 /* harmony import */ var _getPointInLineOfSightWithCriteria__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1023);
 /* harmony import */ var _isPlaneIntersectingAABB__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(61890);
+/* harmony import */ var _filterAnnotationsWithinPlane__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(50630);
+
 
 
 
@@ -10107,6 +11314,7 @@ function invertOrientationStringLPS(orientationString) {
     filterAnnotationsForDisplay: _filterAnnotationsForDisplay__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z,
     getPointInLineOfSightWithCriteria: _getPointInLineOfSightWithCriteria__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z,
     isPlaneIntersectingAABB: _isPlaneIntersectingAABB__WEBPACK_IMPORTED_MODULE_4__/* .isPlaneIntersectingAABB */ .U,
+    filterAnnotationsWithinSamePlane: _filterAnnotationsWithinPlane__WEBPACK_IMPORTED_MODULE_5__/* .filterAnnotationsWithinSamePlane */ .Q,
 });
 
 
@@ -10227,7 +11435,7 @@ function pointInShapeCallback(imageData, pointInShapeFn, callback, boundsIJK) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* unused harmony export default */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72076);
 /* harmony import */ var _math_sphere__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(34603);
 /* harmony import */ var _pointInShapeCallback__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(31955);
@@ -10387,7 +11595,7 @@ function getPolyDataPoints(polyData) {
 /***/ 35765:
 /***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
 
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _boundingBox_getBoundingBoxAroundShape__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(64652);
 /* harmony import */ var _boundingBox_extend2DBoundingBoxInViewAxis__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(93341);
 
@@ -10457,7 +11665,7 @@ function getBoundsIJKFromRectangleAnnotations(annotations, referenceVolume, opti
 /* harmony export */   r: () => (/* binding */ isAxisAlignedRectangle)
 /* harmony export */ });
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(72076);
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12651);
 
 
 const { isEqual } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities;
@@ -10491,7 +11699,7 @@ function calculateAnglesWithAxes(vec, axes) {
 /* harmony export */   Z: () => (/* binding */ scroll)
 /* harmony export */ });
 /* unused harmony export scrollVolume */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 
 function scroll(viewport, options) {
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(viewport.element);
@@ -10552,7 +11760,7 @@ function scrollVolume(viewport, volumeId, delta, scrollSlabs = false) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Z: () => (/* binding */ InterpolationManager)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _stateManagement_annotation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(88706);
 /* harmony import */ var _contours_interpolation_getInterpolationDataCollection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(92472);
 /* harmony import */ var _contours_interpolation_interpolate__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(28898);
@@ -10747,7 +11955,7 @@ function getSliceData(viewport) {
 /* unused harmony exports setBrushSizeForToolGroup, getBrushSizeForToolGroup */
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27078);
 /* harmony import */ var _triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(66878);
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12651);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(89776);
 
 
@@ -10799,7 +12007,7 @@ function getBrushSizeForToolGroup(toolGroupId, toolName) {
 /* unused harmony exports setBrushThresholdForToolGroup, getBrushThresholdForToolGroup */
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27078);
 /* harmony import */ var _triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(66878);
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12651);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(89776);
 
 
@@ -10863,8 +12071,8 @@ var contours = __webpack_require__(11203);
 var SegmentationRepresentations = __webpack_require__(74297);
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var esm = __webpack_require__(72076);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var dist_esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var dist_esm = __webpack_require__(12651);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/isLineInSegment.js
 
 
@@ -11107,7 +12315,7 @@ function createImageIdReferenceMap(imageIdsArray, segmentationImageIds) {
 /* unused harmony export default */
 /* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11677);
 /* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash_clonedeep__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12651);
 
 
 async function createLabelmapVolumeForViewport(input) {
@@ -11144,7 +12352,7 @@ async function createLabelmapVolumeForViewport(input) {
 /***/ 71880:
 /***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
 
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 
 function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'mergedLabelmap') {
     labelmaps.forEach(({ direction, dimensions, origin, spacing }) => {
@@ -11367,7 +12575,7 @@ function getHoveredContourSegmentationAnnotation(segmentationId) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   T: () => (/* binding */ getSegmentAtLabelmapBorder)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _stateManagement_segmentation_segmentationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(14305);
 /* harmony import */ var _tools_segmentation_strategies_utils_stackVolumeCheck__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(88439);
 
@@ -11454,7 +12662,7 @@ function isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, s
 /* harmony export */   uA: () => (/* binding */ getSegmentAtWorldPoint)
 /* harmony export */ });
 /* unused harmony exports getSegmentAtWorldForLabelmap, getSegmentAtWorldForContour */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(68096);
 /* harmony import */ var _stateManagement_segmentation_segmentationState__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(14305);
 /* harmony import */ var _tools_segmentation_strategies_utils_stackVolumeCheck__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(88439);
@@ -11606,7 +12814,7 @@ function getSegmentAtWorldForContour(segmentation, worldPoint, { viewport }) {
 /* harmony export */ });
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27078);
 /* harmony import */ var _triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(66878);
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12651);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(89776);
 
 
@@ -11703,7 +12911,7 @@ function _validateAnnotations(annotations) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* unused harmony exports default, defaultGetSegment */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(95482);
 /* harmony import */ var _stateManagement_annotation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(88706);
 /* harmony import */ var _viewport__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(85217);
@@ -11958,7 +13166,7 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
 /* harmony export */   Xb: () => (/* binding */ getBrushToolInstances)
 /* harmony export */ });
 /* unused harmony exports getVoxelOverlap, processVolumes */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(27078);
 /* harmony import */ var _tools_segmentation_BrushTool__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(95459);
 /* harmony import */ var _boundingBox_getBoundingBoxAroundShape__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(64652);
@@ -12041,8 +13249,8 @@ function processVolumes(segmentationVolume, thresholdVolumeInformation) {
 
 // UNUSED EXPORTS: stackContextPrefetch, stackPrefetch
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/stackPrefetch/state.js
 var state = __webpack_require__(22446);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/stackPrefetch/stackPrefetchUtils.js
@@ -12225,7 +13433,10 @@ let stackContextPrefetch_resetPrefetchTimeout;
 const stackContextPrefetch_resetPrefetchDelay = 5;
 const stackContextPrefetch_enable = (element) => {
     const stack = (0,stackPrefetchUtils/* getStackData */.gf)(element);
-    if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+    if (!stack) {
+        return;
+    }
+    if (!stack.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
     }
@@ -12239,6 +13450,9 @@ const stackContextPrefetch_enable = (element) => {
 };
 function stackContextPrefetch_prefetch(element) {
     const stack = (0,stackPrefetchUtils/* getStackData */.gf)(element);
+    if (!stack) {
+        return;
+    }
     if (!stack?.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
@@ -12347,7 +13561,10 @@ function stackContextPrefetch_onImageUpdated(e) {
 const signum = (x) => (x < 0 ? -1 : 1);
 const updateToolState = (element, usage) => {
     const stack = (0,stackPrefetchUtils/* getStackData */.gf)(element);
-    if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+    if (!stack) {
+        return;
+    }
+    if (!stack.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
     }
@@ -12645,7 +13862,7 @@ function _getDistance3D(point0, point1) {
 /* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
 /* unused harmony export triggerAnnotationRenderForToolGroupIds */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _triggerAnnotationRender__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(64307);
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(27078);
 
@@ -12696,14 +13913,11 @@ function triggerAnnotationRenderForToolGroupIds(toolGroupIds) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   P: () => (/* binding */ isViewportPreScaled)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 
 function isViewportPreScaled(viewport, targetId) {
     if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.BaseVolumeViewport) {
-        const targetIdTokens = targetId.split('volumeId:');
-        const volumeId = targetIdTokens.length > 1
-            ? targetIdTokens[1].split('?')[0]
-            : targetIdTokens[0];
+        const volumeId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getVolumeId(targetId);
         const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
         return !!volume?.scaling && Object.keys(volume.scaling).length > 0;
     }
@@ -12723,7 +13937,7 @@ function isViewportPreScaled(viewport, targetId) {
 /***/ 68009:
 /***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
 
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var _clip__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(70232);
 /* harmony import */ var _scroll__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(63478);
 
@@ -12750,12 +13964,10 @@ function _getImageSliceData(viewport, debounceLoading) {
                 : viewport.getCurrentImageIdIndex(),
         };
     }
-    else if (viewport instanceof VolumeViewport) {
-        return csUtils.getImageSliceDataForVolumeViewport(viewport);
-    }
-    else {
-        throw new Error('Unsupported viewport type');
-    }
+    return {
+        numberOfSlices: viewport.getNumberOfSlices(),
+        imageIndex: viewport.getSliceIndex(),
+    };
 }
 function _getImageIndexToJump(numberOfSlices, imageIndex) {
     const lastSliceIndex = numberOfSlices - 1;
@@ -12772,7 +13984,7 @@ function _getImageIndexToJump(numberOfSlices, imageIndex) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Z: () => (/* binding */ jumpToWorld)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(62709);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72076);
 
 
@@ -12869,8 +14081,8 @@ function _toolGroupHasActiveEnabledOrPassiveTool(toolGroup, toolName) {
     return toolMode === Active || toolMode === Passive || toolMode === Enabled;
 }
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var gl_matrix_esm = __webpack_require__(72076);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewportFilters/filterViewportsWithParallelNormals.js
@@ -12922,8 +14134,8 @@ function getViewportIdsWithToolToRender(element, toolName, requireParallelNormal
 
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var esm = __webpack_require__(72076);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var dist_esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var dist_esm = __webpack_require__(12651);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/voi/colorbar/common/isRangeValid.js
 const isRangeValid_isRangeValid = (range) => {
     return range && range.upper > range.lower;
@@ -13763,8 +14975,8 @@ class Colorbar extends (/* unused pure expression or super */ null && (Widget))
 
 // UNUSED EXPORTS: ViewportColorbar, default
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/voi/colorbar/Colorbar.js + 10 modules
 var colorbar_Colorbar = __webpack_require__(53766);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/viewport/index.js
@@ -14045,8 +15257,8 @@ function calculateMinMaxMean(pixelLuminance, globalMin, globalMax) {
 }
 
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/voi/windowlevel/extractWindowLevelRegionToolData.js
 
 function extractWindowLevelRegionToolData(viewport) {
@@ -14170,8 +15382,8 @@ class ICRPolySeg {
   }
 }
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
-var esm = __webpack_require__(62709);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js
 var Plane = __webpack_require__(3969);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 9 modules