@ohif/app 3.13.0-beta.119 → 3.13.0-beta.120

package/dist/{9560.bundle.bb39f946ea79cf0e.js → 9560.bundle.517f0ef7ee3a20bf.js}

@@ -1596,10 +1596,11 @@ function beginLabelmapEditTransaction(segmentation, options) {
         isInObject: options.isInObject,
         isInObjectBoundsIJK: options.isInObjectBoundsIJK,
     });
+    let moveStep;
     if (shouldMoveSegment) {
         const moveSegmentToPrivateLabelmap = options.moveSegmentToPrivateLabelmap ??
             _privateLabelmap_js__rspack_import_3/* .moveSegmentToPrivateLabelmap */.J;
-        const privateLayer = moveSegmentToPrivateLabelmap(segmentation, segmentIndex);
+        const privateLayer = moveSegmentToPrivateLabelmap(segmentation, segmentIndex, { moveStepCallback: (step) => (moveStep = step) });
         const privateBinding = (0,_labelmapSegmentBindings_js__rspack_import_2/* .getSegmentBinding */.hM)(segmentation, segmentIndex);
         if (privateLayer && privateBinding) {
             activeLayer = privateLayer;
@@ -1624,6 +1625,7 @@ function beginLabelmapEditTransaction(segmentation, options) {
         protectedSegmentIndices,
         crossLayerEraseBindings: collectCrossLayerEraseBindings(segmentation, labelmapId, overwriteSegmentIndices),
         movedSegment,
+        moveStep,
     };
 }
 function getViewportImageIds(viewport) {
@@ -1682,6 +1684,7 @@ function eraseVolumeLayer(layer, binding, options, modifiedSlices) {
     if (!volume) {
         return;
     }
+    const erasedIndices = [];
     volume.voxelManager.forEach(({ value, index, pointIJK }) => {
         if (value !== binding.labelValue) {
             return;
@@ -1691,10 +1694,18 @@ function eraseVolumeLayer(layer, binding, options, modifiedSlices) {
             return;
         }
         volume.voxelManager.setAtIndex(index, 0);
+        erasedIndices.push(index);
     }, {
         imageData: volume.imageData,
         boundsIJK: options.isInObjectBoundsIJK,
     });
+    if (erasedIndices.length) {
+        options.crossLayerEraseCallback?.({
+            voxelManager: volume.voxelManager,
+            labelValue: binding.labelValue,
+            indices: erasedIndices,
+        });
+    }
     volume.voxelManager
         ?.getArrayOfModifiedSlices?.()
         ?.forEach((sliceIndex) => modifiedSlices.add(sliceIndex));
@@ -1709,6 +1720,7 @@ function eraseStackLayer(layer, binding, options, modifiedSlices) {
     if (!image || !voxelManager) {
         return;
     }
+    const erasedIndices = [];
     voxelManager.forEach(({ value, index, pointIJK }) => {
         if (value !== binding.labelValue) {
             return;
@@ -1718,10 +1730,18 @@ function eraseStackLayer(layer, binding, options, modifiedSlices) {
             return;
         }
         voxelManager.setAtIndex(index, 0);
+        erasedIndices.push(index);
     }, {
         imageData: options.referenceImageData,
         boundsIJK: options.isInObjectBoundsIJK,
     });
+    if (erasedIndices.length) {
+        options.crossLayerEraseCallback?.({
+            voxelManager,
+            labelValue: binding.labelValue,
+            indices: erasedIndices,
+        });
+    }
     const currentSlice = stackViewport.getCurrentImageIdIndex?.();
     if (typeof currentSlice === 'number') {
         modifiedSlices.add(currentSlice);
@@ -1822,15 +1842,18 @@ class LabelmapImageReferenceResolver {
         this.stackLabelmapImageIdReferenceMap = new Map();
         this.labelmapImageIdReferenceMap = new Map();
         this.keysBySegmentationId = new Map();
+        this.completedScanResultsBySegmentationId = new Map();
         this.getSegmentation = getSegmentation;
     }
     reset() {
         this.stackLabelmapImageIdReferenceMap.clear();
         this.labelmapImageIdReferenceMap.clear();
         this.keysBySegmentationId.clear();
+        this.completedScanResultsBySegmentationId.clear();
     }
     removeSegmentation(segmentationId) {
         this.stackLabelmapImageIdReferenceMap.delete(segmentationId);
+        this.completedScanResultsBySegmentationId.delete(segmentationId);
         const keys = this.keysBySegmentationId.get(segmentationId);
         if (keys) {
             for (const key of keys) {
@@ -1904,7 +1927,43 @@ class LabelmapImageReferenceResolver {
         if (!enabledElement || !labelmapImageIds?.length) {
             return;
         }
-        return this.updateLabelmapSegmentationReferences(segmentationId, enabledElement.viewport, labelmapImageIds);
+        const viewport = enabledElement.viewport;
+        const scanKey = this.generateScanKey('current', viewport, labelmapImageIds);
+        if (scanKey && this.hasCompletedScan(segmentationId, scanKey)) {
+            return this.getCompletedScanResult(segmentationId, scanKey);
+        }
+        const result = this.updateLabelmapSegmentationReferences(segmentationId, viewport, labelmapImageIds);
+        if (scanKey) {
+            this.markCompletedScan(segmentationId, scanKey, result);
+        }
+        return result;
+    }
+    generateScanKey(kind, viewport, labelmapImageIds) {
+        const referenceImageId = typeof viewport.getCurrentImageId === 'function'
+            ? viewport.getCurrentImageId()
+            : undefined;
+        if (!referenceImageId) {
+            return;
+        }
+        return `${kind}|${viewport.id}|${referenceImageId}|${labelmapImageIds.length}|${labelmapImageIds[0]}|${labelmapImageIds[labelmapImageIds.length - 1]}`;
+    }
+    hasCompletedScan(segmentationId, scanKey) {
+        return !!this.completedScanResultsBySegmentationId
+            .get(segmentationId)
+            ?.has(scanKey);
+    }
+    getCompletedScanResult(segmentationId, scanKey) {
+        return this.completedScanResultsBySegmentationId
+            .get(segmentationId)
+            ?.get(scanKey);
+    }
+    markCompletedScan(segmentationId, scanKey, result) {
+        let results = this.completedScanResultsBySegmentationId.get(segmentationId);
+        if (!results) {
+            results = new Map();
+            this.completedScanResultsBySegmentationId.set(segmentationId, results);
+        }
+        results.set(scanKey, result);
     }
     getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
         const enabledElement = (0,_cornerstonejs_core__rspack_import_0.getEnabledElementByViewportId)(viewportId);
@@ -2045,6 +2104,13 @@ class LabelmapImageReferenceResolver {
             return;
         }
         const stackViewport = enabledElement.viewport;
+        const scanKey = this.generateScanKey('all', stackViewport, labelmapImageIds);
+        if (scanKey && this.hasCompletedScan(segmentationId, scanKey)) {
+            return;
+        }
+        if (scanKey) {
+            this.markCompletedScan(segmentationId, scanKey);
+        }
         this.updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, (stackViewport, segmentationId, labelmapImageIds) => {
             const imageIds = stackViewport.getImageIds();
             imageIds.forEach((referenceImageId, index) => {
@@ -2284,7 +2350,7 @@ function createPrivateLabelmap(segmentation, sourceLabelmap) {
     }
     return createPrivateStackLabelmap(segmentation, sourceLabelmap);
 }
-function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
+function moveSegmentToPrivateLabelmap(segmentation, segmentIndex, options = {}) {
     const binding = (0,_labelmapSegmentBindings_js__rspack_import_2/* .getSegmentBinding */.hM)(segmentation, segmentIndex);
     if (!binding) {
         return;
@@ -2298,16 +2364,26 @@ function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
     }
     const privateLabelmap = createPrivateLabelmap(segmentation, sourceLabelmap);
     (0,_labelmapLayerStore_js__rspack_import_1/* .registerLabelmap */.AD)(segmentation, privateLabelmap);
+    const movedVoxels = [];
     if (sourceLabelmap.volumeId && privateLabelmap.volumeId) {
         const sourceVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(sourceLabelmap.volumeId);
         const targetVolume = _cornerstonejs_core__rspack_import_0.cache.getVolume(privateLabelmap.volumeId);
+        const indices = [];
         sourceVolume.voxelManager.forEach(({ value, index }) => {
             if (value !== binding.labelValue) {
                 return;
             }
             targetVolume.voxelManager.setAtIndex(index, 1);
             sourceVolume.voxelManager.setAtIndex(index, 0);
+            indices.push(index);
         });
+        if (indices.length) {
+            movedVoxels.push({
+                source: sourceVolume.voxelManager,
+                target: targetVolume.voxelManager,
+                indices,
+            });
+        }
     }
     else {
         const sourceImageIds = sourceLabelmap.imageIds ?? [];
@@ -2318,20 +2394,55 @@ function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
             if (!sourceImage || !targetImage) {
                 return;
             }
+            const indices = [];
             sourceImage.voxelManager.forEach(({ value, index }) => {
                 if (value !== binding.labelValue) {
                     return;
                 }
                 targetImage.voxelManager.setAtIndex(index, 1);
                 sourceImage.voxelManager.setAtIndex(index, 0);
+                indices.push(index);
             });
+            if (indices.length) {
+                movedVoxels.push({
+                    source: sourceImage.voxelManager,
+                    target: targetImage.voxelManager,
+                    indices,
+                });
+            }
         });
     }
-    (0,_labelmapSegmentBindings_js__rspack_import_2/* .setSegmentBinding */.Zs)(segmentation, segmentIndex, {
+    const previousBinding = { ...binding };
+    const newBinding = {
         labelmapId: privateLabelmap.labelmapId,
         labelValue: 1,
-    });
+    };
+    (0,_labelmapSegmentBindings_js__rspack_import_2/* .setSegmentBinding */.Zs)(segmentation, segmentIndex, { ...newBinding });
     (0,_labelmapLegacyAdapter_js__rspack_import_3/* .syncLegacyLabelmapData */.x)(segmentation);
+    options.moveStepCallback?.({
+        undo: () => {
+            for (const { source, target, indices } of movedVoxels) {
+                for (const index of indices) {
+                    target.setAtIndex(index, 0);
+                    source.setAtIndex(index, previousBinding.labelValue);
+                }
+            }
+            (0,_labelmapSegmentBindings_js__rspack_import_2/* .setSegmentBinding */.Zs)(segmentation, segmentIndex, { ...previousBinding });
+            (0,_labelmapLayerStore_js__rspack_import_1/* .removeLabelmap */.$n)(segmentation, privateLabelmap.labelmapId);
+            (0,_labelmapLegacyAdapter_js__rspack_import_3/* .syncLegacyLabelmapData */.x)(segmentation);
+        },
+        redo: () => {
+            (0,_labelmapLayerStore_js__rspack_import_1/* .registerLabelmap */.AD)(segmentation, privateLabelmap);
+            for (const { source, target, indices } of movedVoxels) {
+                for (const index of indices) {
+                    source.setAtIndex(index, 0);
+                    target.setAtIndex(index, 1);
+                }
+            }
+            (0,_labelmapSegmentBindings_js__rspack_import_2/* .setSegmentBinding */.Zs)(segmentation, segmentIndex, { ...newBinding });
+            (0,_labelmapLegacyAdapter_js__rspack_import_3/* .syncLegacyLabelmapData */.x)(segmentation);
+        },
+    });
     return privateLabelmap;
 }
 
@@ -4323,6 +4434,8 @@ var compositions = __webpack_require__(30207);
 var getStrategyData = __webpack_require__(66340);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 3 modules
 var enums = __webpack_require__(53870);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/createLabelmapMemo.js
+var createLabelmapMemo = __webpack_require__(1732);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
 var segmentation_getSegmentation = __webpack_require__(99212);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/labelmapSegmentationState.js
@@ -4330,6 +4443,7 @@ var labelmapSegmentationState = __webpack_require__(89615);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/crossLayerErase.js
 
 
+
 function collectCrossLayerEraseBindingsForOperation(operationData) {
     const { segmentationId, labelmapId, overwriteSegmentIndices } = operationData;
     const segmentation = getSegmentation(segmentationId);
@@ -4342,12 +4456,31 @@ function eraseCrossLayerOverwrites(operationData) {
     if (!segmentation) {
         return [];
     }
+    const { memo } = operationData;
     return (0,labelmapSegmentationState/* .eraseLabelmapEditTransactionOverwrites */.Ry)(segmentation, operationData.labelmapEditTransaction, {
         viewport: operationData.viewport,
         referenceImageData: operationData.segmentationImageData,
         isInObject: operationData.isInObject,
         isInObjectBoundsIJK: operationData.isInObjectBoundsIJK,
         imageId: operationData.imageId,
+        crossLayerEraseCallback: memo
+            ? ({ voxelManager, labelValue, indices }) => {
+                (memo.postSteps ||= []).push({
+                    undo: () => {
+                        for (const index of indices) {
+                            voxelManager.setAtIndex(index, labelValue);
+                        }
+                        (0,triggerSegmentationEvents.triggerSegmentationDataModified)(operationData.segmentationId);
+                    },
+                    redo: () => {
+                        for (const index of indices) {
+                            voxelManager.setAtIndex(index, 0);
+                        }
+                        (0,triggerSegmentationEvents.triggerSegmentationDataModified)(operationData.segmentationId);
+                    },
+                });
+            }
+            : undefined,
     });
 }
 
@@ -4441,6 +4574,7 @@ var shouldUseLazyLabelmapEditing = __webpack_require__(46787);
 
 
 
+
 class BrushStrategy {
     constructor(name, ...initializers) {
         this._initialize = [];
@@ -4460,7 +4594,27 @@ class BrushStrategy {
             }
             if (initializedData.memo?.segmentationVoxelManager !==
                 initializedData.segmentationVoxelManager) {
+                const previousMemo = initializedData.memo;
                 initializedData.memo = initializedData.createMemo(initializedData.segmentationId, initializedData.segmentationVoxelManager);
+                if (previousMemo &&
+                    previousMemo !== initializedData.memo &&
+                    previousMemo.commitMemo?.()) {
+                    (initializedData.memo.priorSteps ||= []).push((0,createLabelmapMemo.memoAsStep)(previousMemo));
+                }
+            }
+            const moveStep = initializedData.labelmapEditTransaction?.moveStep;
+            if (moveStep && initializedData.memo) {
+                const { segmentationId } = initializedData;
+                (initializedData.memo.priorSteps ||= []).push({
+                    undo: () => {
+                        moveStep.undo();
+                        (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentationId);
+                    },
+                    redo: () => {
+                        moveStep.redo();
+                        (0,triggerSegmentationEvents.triggerSegmentationDataModified)(segmentationId);
+                    },
+                });
             }
             if (initializedData.segmentationVoxelManager !==
                 originalSegmentationVoxelManager ||
@@ -7624,197 +7778,6 @@ function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
 /* export default */ const __rspack_default_export = (getStatistics);
 
 
-},
-29827(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
-"use strict";
-__webpack_require__.d(__webpack_exports__, {
-  A: () => (IslandRemoval)
-});
-/* import */ var _cornerstonejs_core__rspack_import_0 = __webpack_require__(88479);
-/* import */ var _normalizeViewportPlane_js__rspack_import_1 = __webpack_require__(95972);
-
-
-const { RLEVoxelMap, VoxelManager } = _cornerstonejs_core__rspack_import_0.utilities;
-const MAX_IMAGE_SIZE = 65535;
-var SegmentationEnum;
-(function (SegmentationEnum) {
-    SegmentationEnum[SegmentationEnum["SEGMENT"] = -1] = "SEGMENT";
-    SegmentationEnum[SegmentationEnum["ISLAND"] = -2] = "ISLAND";
-    SegmentationEnum[SegmentationEnum["INTERIOR"] = -3] = "INTERIOR";
-    SegmentationEnum[SegmentationEnum["EXTERIOR"] = -4] = "EXTERIOR";
-    SegmentationEnum[SegmentationEnum["INTERIOR_SMALL"] = -5] = "INTERIOR_SMALL";
-    SegmentationEnum[SegmentationEnum["INTERIOR_TEST"] = -6] = "INTERIOR_TEST";
-})(SegmentationEnum || (SegmentationEnum = {}));
-class IslandRemoval {
-    constructor(options) {
-        this.fillInternalEdge = false;
-        this.maxInternalRemove = 128;
-        this.maxInternalRemove =
-            options?.maxInternalRemove ?? this.maxInternalRemove;
-        this.fillInternalEdge = options?.fillInternalEdge ?? this.fillInternalEdge;
-    }
-    initialize(viewport, segmentationVoxels, options) {
-        const hasSource = !!segmentationVoxels.sourceVoxelManager;
-        const segmentationVoxelManager = hasSource
-            ? segmentationVoxels.sourceVoxelManager
-            : segmentationVoxels;
-        const previewVoxelManager = hasSource
-            ? segmentationVoxels
-            : VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
-        const { segmentIndex = 1, previewSegmentIndex = 1 } = options;
-        const clickedPoints = options.points || segmentationVoxelManager.getPoints();
-        if (!clickedPoints?.length) {
-            return;
-        }
-        const boundsIJK = segmentationVoxelManager
-            .getBoundsIJK()
-            .map((bound, i) => [
-            Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
-            Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
-        ]);
-        if (boundsIJK.find((it) => it[0] < 0 || it[1] > MAX_IMAGE_SIZE)) {
-            return;
-        }
-        const { toIJK, fromIJK, boundsIJKPrime, error } = (0,_normalizeViewportPlane_js__rspack_import_1/* ["default"] */.A)(viewport, boundsIJK);
-        if (error) {
-            console.warn('Not performing island removal for planes not orthogonal to acquisition plane', error);
-            return;
-        }
-        const [width, height, depth] = fromIJK(segmentationVoxelManager.dimensions);
-        const segmentSet = new RLEVoxelMap(width, height, depth);
-        const getter = (i, j, k) => {
-            const index = segmentationVoxelManager.toIndex(toIJK([i, j, k]));
-            const oldVal = segmentationVoxelManager.getAtIndex(index);
-            if (oldVal === previewSegmentIndex || oldVal === segmentIndex) {
-                return SegmentationEnum.SEGMENT;
-            }
-        };
-        segmentSet.fillFrom(getter, boundsIJKPrime);
-        segmentSet.normalizer = { toIJK, fromIJK, boundsIJKPrime };
-        this.segmentSet = segmentSet;
-        this.previewVoxelManager = previewVoxelManager;
-        this.segmentIndex = segmentIndex;
-        this.previewSegmentIndex = previewSegmentIndex ?? segmentIndex;
-        this.selectedPoints = clickedPoints;
-        return true;
-    }
-    floodFillSegmentIsland() {
-        const { selectedPoints: clickedPoints, segmentSet } = this;
-        let floodedCount = 0;
-        const { fromIJK } = segmentSet.normalizer;
-        clickedPoints.forEach((clickedPoint) => {
-            const ijkPrime = fromIJK(clickedPoint);
-            const index = segmentSet.toIndex(ijkPrime);
-            const [iPrime, jPrime, kPrime] = ijkPrime;
-            if (segmentSet.get(index) === SegmentationEnum.SEGMENT) {
-                floodedCount += segmentSet.floodFill(iPrime, jPrime, kPrime, SegmentationEnum.ISLAND);
-            }
-        });
-        return floodedCount;
-    }
-    removeExternalIslands() {
-        const { previewVoxelManager, segmentSet } = this;
-        const { toIJK } = segmentSet.normalizer;
-        const callback = (index, rle) => {
-            const [, jPrime, kPrime] = segmentSet.toIJK(index);
-            if (rle.value !== SegmentationEnum.ISLAND) {
-                for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
-                    const clearPoint = toIJK([iPrime, jPrime, kPrime]);
-                    const v = previewVoxelManager.getAtIJKPoint(clearPoint);
-                    previewVoxelManager.setAtIJKPoint(clearPoint, v === undefined ? 0 : null);
-                }
-            }
-        };
-        segmentSet.forEach(callback, { rowModified: true });
-    }
-    removeInternalIslands() {
-        const { segmentSet, previewVoxelManager, previewSegmentIndex } = this;
-        const { height, normalizer, width } = segmentSet;
-        const { toIJK } = normalizer;
-        segmentSet.forEachRow((baseIndex, row) => {
-            let lastRle;
-            for (const rle of [...row]) {
-                if (rle.value !== SegmentationEnum.ISLAND) {
-                    continue;
-                }
-                if (!lastRle) {
-                    if (this.fillInternalEdge && rle.start > 0) {
-                        for (let iPrime = 0; iPrime < rle.start; iPrime++) {
-                            segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
-                        }
-                    }
-                    lastRle = rle;
-                    continue;
-                }
-                for (let iPrime = lastRle.end; iPrime < rle.start; iPrime++) {
-                    segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
-                }
-                lastRle = rle;
-            }
-            if (this.fillInternalEdge && lastRle?.end < width) {
-                for (let iPrime = lastRle.end; iPrime < width; iPrime++) {
-                    segmentSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
-                }
-            }
-        });
-        segmentSet.forEach((baseIndex, rle) => {
-            if (rle.value !== SegmentationEnum.INTERIOR) {
-                return;
-            }
-            const [, jPrime, kPrime] = segmentSet.toIJK(baseIndex);
-            const rowPrev = jPrime > 0 ? segmentSet.getRun(jPrime - 1, kPrime) : null;
-            const rowNext = jPrime + 1 < height ? segmentSet.getRun(jPrime + 1, kPrime) : null;
-            const isLast = jPrime === height - 1;
-            const isFirst = jPrime === 0;
-            const prevCovers = IslandRemoval.covers(rle, rowPrev) ||
-                (isFirst && this.fillInternalEdge);
-            const nextCovers = IslandRemoval.covers(rle, rowNext) || (isLast && this.fillInternalEdge);
-            if (rle.end - rle.start > 2 && (!prevCovers || !nextCovers)) {
-                segmentSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.EXTERIOR, { singlePlane: true });
-            }
-        });
-        segmentSet.forEach((baseIndex, rle) => {
-            if (rle.value !== SegmentationEnum.INTERIOR) {
-                return;
-            }
-            const [, jPrime, kPrime] = segmentSet.toIJK(baseIndex);
-            const size = segmentSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.INTERIOR_TEST);
-            const isBig = size > this.maxInternalRemove;
-            const newType = isBig
-                ? SegmentationEnum.EXTERIOR
-                : SegmentationEnum.INTERIOR_SMALL;
-            segmentSet.floodFill(rle.start, jPrime, kPrime, newType);
-        });
-        segmentSet.forEach((baseIndex, rle) => {
-            if (rle.value !== SegmentationEnum.INTERIOR_SMALL) {
-                return;
-            }
-            for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
-                const clearPoint = toIJK(segmentSet.toIJK(baseIndex + iPrime));
-                previewVoxelManager.setAtIJKPoint(clearPoint, previewSegmentIndex);
-            }
-        });
-        return previewVoxelManager.getArrayOfModifiedSlices();
-    }
-    static covers(rle, row) {
-        if (!row) {
-            return false;
-        }
-        let { start } = rle;
-        const { end } = rle;
-        for (const rowRle of row) {
-            if (start >= rowRle.start && start < rowRle.end) {
-                start = rowRle.end;
-                if (start >= end) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-}
-
-
 },
 72788(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 "use strict";