@cornerstonejs/adapters 4.22.7 → 4.22.8

package/dist/esm/adapters/Cornerstone/MeasurementReport.js

@@ -1,25 +1,17 @@
 import { utilities, derivations, normalizers, data } from 'dcmjs';
 import { toArray } from '../helpers/toArray.js';
 import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
-import '@cornerstonejs/core';
-
-const {
-  TID1500,
-  addAccessors
-} = utilities;
-const {
-  StructuredReport
-} = derivations;
-const {
-  Normalizer
-} = normalizers;
-const {
-  TID1500MeasurementReport,
-  TID1501MeasurementGroup
-} = TID1500;
-const {
-  DicomMetaDictionary
-} = data;
+import '../helpers/downloadDICOMData.js';
+import '../helpers/toScoordType.js';
+import '../helpers/scoordToWorld.js';
+
+const TID1500 = utilities.TID1500,
+  addAccessors = utilities.addAccessors;
+const StructuredReport = derivations.StructuredReport;
+const Normalizer = normalizers.Normalizer;
+const TID1500MeasurementReport = TID1500.TID1500MeasurementReport,
+  TID1501MeasurementGroup = TID1500.TID1501MeasurementGroup;
+const DicomMetaDictionary = data.DicomMetaDictionary;
 const FINDING = {
   CodingSchemeDesignator: 'DCM',
   CodeValue: '121071'
@@ -33,16 +25,12 @@ const FINDING_SITE_OLD = {
   CodeValue: 'G-C0E3'
 };
 const codeValueMatch = (group, code, oldCode) => {
-  const {
-    ConceptNameCodeSequence
-  } = group;
+  const ConceptNameCodeSequence = group.ConceptNameCodeSequence;
   if (!ConceptNameCodeSequence) {
     return;
   }
-  const {
-    CodingSchemeDesignator,
-    CodeValue
-  } = ConceptNameCodeSequence;
+  const CodingSchemeDesignator = ConceptNameCodeSequence.CodingSchemeDesignator,
+    CodeValue = ConceptNameCodeSequence.CodeValue;
   return CodingSchemeDesignator == code.CodingSchemeDesignator && CodeValue == code.CodeValue || oldCode && CodingSchemeDesignator == oldCode.CodingSchemeDesignator && CodeValue == oldCode.CodeValue;
 };
 function getTID300ContentItem(tool, ReferencedSOPSequence, adapterClass) {
@@ -68,21 +56,15 @@ function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence) {
 }
 class MeasurementReport {
   static getSetupMeasurementData(MeasurementGroup) {
-    const {
-      ContentSequence
-    } = MeasurementGroup;
+    const ContentSequence = MeasurementGroup.ContentSequence;
     const contentSequenceArr = toArray(ContentSequence);
     const findingGroup = contentSequenceArr.find(group => codeValueMatch(group, FINDING));
     const findingSiteGroups = contentSequenceArr.filter(group => codeValueMatch(group, FINDING_SITE, FINDING_SITE_OLD)) || [];
     const NUMGroup = contentSequenceArr.find(group => group.ValueType === 'NUM');
     const SCOORDGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === 'SCOORD');
-    const {
-      ReferencedSOPSequence
-    } = SCOORDGroup.ContentSequence;
-    const {
-      ReferencedSOPInstanceUID,
-      ReferencedFrameNumber
-    } = ReferencedSOPSequence;
+    const ReferencedSOPSequence = SCOORDGroup.ContentSequence.ReferencedSOPSequence;
+    const ReferencedSOPInstanceUID = ReferencedSOPSequence.ReferencedSOPInstanceUID,
+      ReferencedFrameNumber = ReferencedSOPSequence.ReferencedFrameNumber;
     const defaultState = {
       sopInstanceUid: ReferencedSOPInstanceUID,
       frameIndex: ReferencedFrameNumber || 1,
@@ -133,10 +115,8 @@ class MeasurementReport {
     // NOTE: We are getting the Series and Study UIDs from the first imageId of the toolState
     // which means that if the toolState is for multiple series, the report will have the incorrect
     // SeriesInstanceUIDs
-    const {
-      studyInstanceUID,
-      seriesInstanceUID
-    } = generalSeriesModule;
+    const studyInstanceUID = generalSeriesModule.studyInstanceUID,
+      seriesInstanceUID = generalSeriesModule.seriesInstanceUID;
 
     // Loop through each image in the toolData
     Object.keys(toolState).forEach(imageId => {

package/dist/esm/adapters/Cornerstone/ParametricMap.js

@@ -1,14 +1,10 @@
-import { log, data, normalizers } from 'dcmjs';
+import { data, normalizers, log } from 'dcmjs';
 import checkOrientation from '../helpers/checkOrientation.js';
 import { utilities } from '@cornerstonejs/core';
 
-const {
-  DicomMessage,
-  DicomMetaDictionary
-} = data;
-const {
-  Normalizer
-} = normalizers;
+const DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
 async function generateToolState(imageIds, arrayBuffer, metadataProvider) {
   let tolerance = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1e-3;
   const dicomData = DicomMessage.readFile(arrayBuffer);
@@ -24,9 +20,8 @@ async function generateToolState(imageIds, arrayBuffer, metadataProvider) {
   const pixelData = getPixelData(multiframe);
   const orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, imageIds.length], tolerance);
   const sopUIDImageIdIndexMap = imageIds.reduce((acc, imageId) => {
-    const {
-      sopInstanceUID
-    } = metadataProvider.get('generalImageModule', imageId);
+    const _metadataProvider$get = metadataProvider.get('generalImageModule', imageId),
+      sopInstanceUID = _metadataProvider$get.sopInstanceUID;
     acc[sopInstanceUID] = imageId;
     return acc;
   }, {});
@@ -52,11 +47,9 @@ async function generateToolState(imageIds, arrayBuffer, metadataProvider) {
 }
 function insertPixelDataPlanar(sourcePixelData, multiframe, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap, imageIdMaps) {
   const targetPixelData = new sourcePixelData.constructor(sourcePixelData.length);
-  const {
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  const PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
   const sliceLength = Columns * Rows;
   const numSlices = PerFrameFunctionalGroupsSequence.length;
   for (let i = 0; i < numSlices; i++) {
@@ -105,12 +98,10 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
   if (!multiframe) {
     return imageId;
   }
-  const {
-    FrameOfReferenceUID,
-    PerFrameFunctionalGroupsSequence,
-    SourceImageSequence,
-    ReferencedSeriesSequence
-  } = multiframe;
+  const FrameOfReferenceUID = multiframe.FrameOfReferenceUID,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SourceImageSequence = multiframe.SourceImageSequence,
+    ReferencedSeriesSequence = multiframe.ReferencedSeriesSequence;
   if (!PerFrameFunctionalGroupsSequence || PerFrameFunctionalGroupsSequence.length === 0) {
     return imageId;
   }
@@ -153,10 +144,8 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
   return imageId;
 }
 function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
-  const {
-    ReferencedSOPInstanceUID,
-    ReferencedFrameNumber
-  } = SourceImageSequence;
+  const ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
+    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
   return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, sopUIDImageIdIndexMap) : sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
 }
 function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance) {

package/dist/esm/adapters/Cornerstone/RectangleRoi.js

@@ -1,3 +1,4 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { utilities } from 'dcmjs';
 import MeasurementReport from './MeasurementReport.js';
@@ -5,16 +6,13 @@ import CORNERSTONE_4_TAG from './cornerstone4Tag.js';
 
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-const {
-  Polyline: TID300Polyline
-} = utilities.TID300;
+const TID300Polyline = utilities.TID300.Polyline;
 class RectangleRoi {
   static getMeasurementData(MeasurementGroup) {
-    const {
-      defaultState,
-      SCOORDGroup,
-      NUMGroup
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup);
+    const _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup),
+      defaultState = _MeasurementReport$ge.defaultState,
+      SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+      NUMGroup = _MeasurementReport$ge.NUMGroup;
     const state = _objectSpread(_objectSpread({}, defaultState), {}, {
       toolType: RectangleRoi.toolType,
       handles: {
@@ -36,21 +34,23 @@ class RectangleRoi {
       color: undefined,
       invalidated: true
     });
-    const intermediate = {};
-    [state.handles.start.x, state.handles.start.y, intermediate.x, intermediate.y, state.handles.end.x, state.handles.end.y] = SCOORDGroup.GraphicData;
+    var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 6);
+    state.handles.start.x = _SCOORDGroup$GraphicD[0];
+    state.handles.start.y = _SCOORDGroup$GraphicD[1];
+    _SCOORDGroup$GraphicD[2];
+    _SCOORDGroup$GraphicD[3];
+    state.handles.end.x = _SCOORDGroup$GraphicD[4];
+    state.handles.end.y = _SCOORDGroup$GraphicD[5];
     return state;
   }
   static getTID300RepresentationArguments(tool) {
-    const {
-      finding,
-      findingSites,
-      cachedStats = {},
-      handles
-    } = tool;
-    const {
-      start,
-      end
-    } = handles;
+    const finding = tool.finding,
+      findingSites = tool.findingSites,
+      _tool$cachedStats = tool.cachedStats,
+      cachedStats = _tool$cachedStats === void 0 ? {} : _tool$cachedStats,
+      handles = tool.handles;
+    const start = handles.start,
+      end = handles.end;
     const points = [start, {
       x: start.x,
       y: end.y
@@ -58,10 +58,8 @@ class RectangleRoi {
       x: end.x,
       y: start.y
     }];
-    const {
-      area,
-      perimeter
-    } = cachedStats;
+    const area = cachedStats.area,
+      perimeter = cachedStats.perimeter;
     const trackingIdentifierTextValue = 'cornerstoneTools@^4.0.0:RectangleRoi';
     return {
       points,
@@ -80,7 +78,10 @@ RectangleRoi.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
   if (!TrackingIdentifier.includes(':')) {
     return false;
   }
-  const [cornerstone4Tag, toolType] = TrackingIdentifier.split(':');
+  const _TrackingIdentifier$s = TrackingIdentifier.split(':'),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
   if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
     return false;
   }

package/dist/esm/adapters/Cornerstone/Segmentation_3X.js

@@ -1,25 +1,18 @@
-import { utilities, log, normalizers, derivations } from 'dcmjs';
+import { utilities, normalizers, derivations, log } from 'dcmjs';
 import ndarray from 'ndarray';
 import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
 
-const {
-  rotateDirectionCosinesInPlane,
-  flipImageOrientationPatient: flipIOP,
-  flipMatrix2D,
-  rotateMatrix902D
-} = utilities.orientation;
-const {
-  datasetToBlob,
-  BitArray,
-  DicomMessage,
-  DicomMetaDictionary
-} = utilities;
-const {
-  Normalizer
-} = normalizers;
-const {
-  Segmentation: SegmentationDerivation
-} = derivations;
+const _utilities$orientatio = utilities.orientation,
+  rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
+  flipIOP = _utilities$orientatio.flipImageOrientationPatient,
+  flipMatrix2D = _utilities$orientatio.flipMatrix2D,
+  rotateMatrix902D = _utilities$orientatio.rotateMatrix902D;
+const datasetToBlob = utilities.datasetToBlob,
+  BitArray = utilities.BitArray,
+  DicomMessage = utilities.DicomMessage,
+  DicomMetaDictionary = utilities.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
+const SegmentationDerivation = derivations.Segmentation;
 const Segmentation = {
   generateSegmentation,
   generateToolState
@@ -45,10 +38,8 @@ function generateSegmentation(images, brushData) {
   let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
     includeSliceSpacing: true
   };
-  const {
-    toolState,
-    segments
-  } = brushData;
+  const toolState = brushData.toolState,
+    segments = brushData.segments;
 
   // Calculate the dimensions of the data cube.
   const image0 = images[0];
@@ -64,10 +55,9 @@ function generateSegmentation(images, brushData) {
   }
   const isMultiframe = image0.imageId.includes('?frame');
   const seg = _createSegFromImages(images, isMultiframe, options);
-  const {
-    referencedFramesPerSegment,
-    segmentIndicies
-  } = _getNumberOfFramesPerSegment(toolState, images, segments);
+  const _getNumberOfFramesPer = _getNumberOfFramesPerSegment(toolState, images, segments),
+    referencedFramesPerSegment = _getNumberOfFramesPer.referencedFramesPerSegment,
+    segmentIndicies = _getNumberOfFramesPer.segmentIndicies;
   let NumberOfFrames = 0;
   for (let i = 0; i < referencedFramesPerSegment.length; i++) {
     NumberOfFrames += referencedFramesPerSegment[i].length;
@@ -274,10 +264,8 @@ function addImageIdSpecificBrushToolState(toolState, imageId, segmentIndex, pixe
  * @return {String}                     The corresponding imageId.
  */
 function getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider) {
-  const {
-    ReferencedSOPInstanceUID,
-    ReferencedFrameNumber
-  } = SourceImageSequence;
+  const ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
+    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
   return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance(ReferencedSOPInstanceUID, imageIds, metadataProvider);
 }
 

package/dist/esm/adapters/Cornerstone/Segmentation_4X.js

@@ -1,31 +1,24 @@
-import { utilities, log, data, normalizers, derivations } from 'dcmjs';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import { utilities, data, normalizers, derivations, log } from 'dcmjs';
 import ndarray from 'ndarray';
 import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
 import checkOrientation from '../helpers/checkOrientation.js';
 import { utilities as utilities$1 } from '@cornerstonejs/core';
 import { Events } from '../enums/Events.js';
 
-const {
-  rotateDirectionCosinesInPlane,
-  flipImageOrientationPatient: flipIOP,
-  flipMatrix2D,
-  rotateMatrix902D
-} = utilities.orientation;
-const {
-  BitArray,
-  DicomMessage,
-  DicomMetaDictionary
-} = data;
-const {
-  Normalizer
-} = normalizers;
-const {
-  Segmentation: SegmentationDerivation
-} = derivations;
-const {
-  encode,
-  decode
-} = utilities.compression;
+const _utilities$orientatio = utilities.orientation,
+  rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
+  flipIOP = _utilities$orientatio.flipImageOrientationPatient,
+  flipMatrix2D = _utilities$orientatio.flipMatrix2D,
+  rotateMatrix902D = _utilities$orientatio.rotateMatrix902D;
+const BitArray = data.BitArray,
+  DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
+const SegmentationDerivation = derivations.Segmentation;
+const _utilities$compressio = utilities.compression,
+  encode = _utilities$compressio.encode,
+  decode = _utilities$compressio.decode;
 
 /**
  *
@@ -75,10 +68,8 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
   const referencedFramesPerLabelmap = [];
   for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
     const labelmap3D = labelmaps3D[labelmapIndex];
-    const {
-      labelmaps2D,
-      metadata
-    } = labelmap3D;
+    const labelmaps2D = labelmap3D.labelmaps2D,
+      metadata = labelmap3D.metadata;
     const referencedFramesPerSegment = [];
     for (let i = 1; i < metadata.length; i++) {
       if (metadata[i]) {
@@ -88,9 +79,7 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
     for (let i = 0; i < labelmaps2D.length; i++) {
       const labelmap2D = labelmaps2D[i];
       if (labelmaps2D[i]) {
-        const {
-          segmentsOnLabelmap
-        } = labelmap2D;
+        const segmentsOnLabelmap = labelmap2D.segmentsOnLabelmap;
         segmentsOnLabelmap.forEach(segmentIndex => {
           if (segmentIndex !== 0) {
             referencedFramesPerSegment[segmentIndex].push(i);
@@ -105,9 +94,7 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
   for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
     const referencedFramesPerSegment = referencedFramesPerLabelmap[labelmapIndex];
     const labelmap3D = labelmaps3D[labelmapIndex];
-    const {
-      metadata
-    } = labelmap3D;
+    const metadata = labelmap3D.metadata;
     for (let segmentIndex = 1; segmentIndex < referencedFramesPerSegment.length; segmentIndex++) {
       const referencedFrameIndicies = referencedFramesPerSegment[segmentIndex];
       if (referencedFrameIndicies) {
@@ -149,9 +136,7 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
   return segmentation;
 }
 function _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies) {
-  const {
-    labelmaps2D
-  } = labelmap3D;
+  const labelmaps2D = labelmap3D.labelmaps2D;
   const labelmaps = [];
   for (let i = 0; i < referencedFrameIndicies.length; i++) {
     const frame = referencedFrameIndicies[i];
@@ -188,14 +173,18 @@ function _createSegFromImages(images, isMultiframe, options) {
  *                  (available only for the overlapping case).
  */
 async function generateToolState(referencedImageIds, arrayBuffer, metadataProvider, options) {
-  const {
-    skipOverlapping = false,
-    tolerance = 1e-3,
-    TypedArrayConstructor = Uint8Array,
-    maxBytesPerChunk = 199000000,
-    eventTarget = null,
-    triggerEvent = null
-  } = options;
+  const _options$skipOverlapp = options.skipOverlapping,
+    skipOverlapping = _options$skipOverlapp === void 0 ? false : _options$skipOverlapp,
+    _options$tolerance = options.tolerance,
+    tolerance = _options$tolerance === void 0 ? 1e-3 : _options$tolerance,
+    _options$TypedArrayCo = options.TypedArrayConstructor,
+    TypedArrayConstructor = _options$TypedArrayCo === void 0 ? Uint8Array : _options$TypedArrayCo,
+    _options$maxBytesPerC = options.maxBytesPerChunk,
+    maxBytesPerChunk = _options$maxBytesPerC === void 0 ? 199000000 : _options$maxBytesPerC,
+    _options$eventTarget = options.eventTarget,
+    eventTarget = _options$eventTarget === void 0 ? null : _options$eventTarget,
+    _options$triggerEvent = options.triggerEvent,
+    triggerEvent = _options$triggerEvent === void 0 ? null : _options$triggerEvent;
   const dicomData = DicomMessage.readFile(arrayBuffer);
   const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
   dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
@@ -239,9 +228,8 @@ async function generateToolState(referencedImageIds, arrayBuffer, metadataProvid
   // we don't have to call metadataProvider.get() for each imageId over
   // and over again.
   const sopUIDImageIdIndexMap = referencedImageIds.reduce((acc, imageId) => {
-    const {
-      sopInstanceUID
-    } = metadataProvider.get('generalImageModule', imageId);
+    const _metadataProvider$get = metadataProvider.get('generalImageModule', imageId),
+      sopInstanceUID = _metadataProvider$get.sopInstanceUID;
     acc[sopInstanceUID] = imageId;
     return acc;
   }, {});
@@ -499,12 +487,10 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
   if (!multiframe) {
     return imageId;
   }
-  const {
-    FrameOfReferenceUID,
-    PerFrameFunctionalGroupsSequence,
-    SourceImageSequence,
-    ReferencedSeriesSequence
-  } = multiframe;
+  const FrameOfReferenceUID = multiframe.FrameOfReferenceUID,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SourceImageSequence = multiframe.SourceImageSequence,
+    ReferencedSeriesSequence = multiframe.ReferencedSeriesSequence;
   if (!PerFrameFunctionalGroupsSequence || PerFrameFunctionalGroupsSequence.length === 0) {
     return imageId;
   }
@@ -553,13 +539,11 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
  */
 
 function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap) {
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    SegmentSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SegmentSequence = multiframe.SegmentSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
   let numberOfSegs = SegmentSequence.length;
   if (numberOfSegs < 2) {
     return false;
@@ -597,7 +581,9 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
       frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
     }
   }
-  for (let [, role] of frameSegmentsMapping.entries()) {
+  for (let _ref of frameSegmentsMapping.entries()) {
+    var _ref2 = _slicedToArray(_ref, 2);
+    let role = _ref2[1];
     let temp2DArray = new TypedArrayConstructor(sliceLength).fill(0);
     for (let i = 0; i < role.length; ++i) {
       const frameSegment = role[i];
@@ -624,12 +610,10 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
   return false;
 }
 function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap) {
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
   const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
   const sliceLength = Columns * Rows;
   const arrayBufferLength = sliceLength * imageIds.length * TypedArrayConstructor.BYTES_PER_ELEMENT;
@@ -728,20 +712,16 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
   }
 }
 const getSegmentIndex = (multiframe, frame) => {
-  const {
-    PerFrameFunctionalGroupsSequence,
-    SharedFunctionalGroupsSequence
-  } = multiframe;
+  const PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence;
   const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frame];
   return PerFrameFunctionalGroups && PerFrameFunctionalGroups.SegmentIdentificationSequence ? PerFrameFunctionalGroups.SegmentIdentificationSequence.ReferencedSegmentNumber : SharedFunctionalGroupsSequence.SegmentIdentificationSequence ? SharedFunctionalGroupsSequence.SegmentIdentificationSequence.ReferencedSegmentNumber : undefined;
 };
 function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent) {
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
   const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
   const sliceLength = Columns * Rows;
   let i = 0;
@@ -901,10 +881,8 @@ function getUnpackedChunks(data, maxBytesPerChunk) {
  * @return {String}                        The corresponding imageId.
  */
 function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
-  const {
-    ReferencedSOPInstanceUID,
-    ReferencedFrameNumber
-  } = SourceImageSequence;
+  const ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
+    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
   const baseImageId = sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
   if (!baseImageId) {
     console.warn("No imageId found for SOPInstanceUID: ".concat(ReferencedSOPInstanceUID));
@@ -970,8 +948,8 @@ function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfR
 
     // For multiframe images, check each frame's position
     if (isMultiframe) {
-      var _metadataProvider$get;
-      const framePosition = (_metadataProvider$get = metadataProvider.get('imagePlaneModule', imageId)) === null || _metadataProvider$get === void 0 ? void 0 : _metadataProvider$get.imagePositionPatient;
+      var _metadataProvider$get2;
+      const framePosition = (_metadataProvider$get2 = metadataProvider.get('imagePlaneModule', imageId)) === null || _metadataProvider$get2 === void 0 ? void 0 : _metadataProvider$get2.imagePositionPatient;
       if (framePosition && utilities$1.isEqual(segFramePosition, framePosition, tolerance)) {
         return imageId;
       }
@@ -1134,7 +1112,10 @@ function calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider
   let worldYAcc = 0;
   let worldZAcc = 0;
   let count = 0;
-  for (const [imageIdIndex, bufferIndices] of Object.entries(imageIdIndexBufferIndex)) {
+  for (const _ref3 of Object.entries(imageIdIndexBufferIndex)) {
+    var _ref4 = _slicedToArray(_ref3, 2);
+    const imageIdIndex = _ref4[0];
+    const bufferIndices = _ref4[1];
     const z = Number(imageIdIndex);
     if (!bufferIndices || bufferIndices.length === 0) {
       continue;
@@ -1147,13 +1128,11 @@ function calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider
       console.debug('Missing imagePlaneModule metadata for centroid calculation');
       continue;
     }
-    const {
-      imagePositionPatient,
-      rowCosines,
-      columnCosines,
-      rowPixelSpacing,
-      columnPixelSpacing
-    } = imagePlaneModule;
+    const imagePositionPatient = imagePlaneModule.imagePositionPatient,
+      rowCosines = imagePlaneModule.rowCosines,
+      columnCosines = imagePlaneModule.columnCosines,
+      rowPixelSpacing = imagePlaneModule.rowPixelSpacing,
+      columnPixelSpacing = imagePlaneModule.columnPixelSpacing;
     for (const bufferIndex of bufferIndices) {
       const y = Math.floor(bufferIndex / multiframe.Rows);
       const x = bufferIndex % multiframe.Rows;