@cornerstonejs/adapters 4.22.6 → 4.22.8

package/dist/esm/adapters/Cornerstone3D/Segmentation/labelmapImagesFromBuffer.js

@@ -1,40 +1,30 @@
 import { triggerEvent, eventTarget, imageLoader } from '@cornerstonejs/core';
 import { utilities as utilities$1 } from '@cornerstonejs/tools';
-import { utilities, data, normalizers } from 'dcmjs';
+import { data, normalizers, utilities } from 'dcmjs';
 import ndarray from 'ndarray';
 import checkOrientation from '../../helpers/checkOrientation.js';
 import { getValidOrientations, getSegmentMetadata, unpackPixelData, calculateCentroid, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
 import { compactMergeSegmentDataWithoutInformationLoss } from './compactMergeSegData.js';
 import { Events } from '../../enums/Events.js';
 
-const {
-  DicomMessage,
-  DicomMetaDictionary
-} = data;
-const {
-  Normalizer
-} = normalizers;
-const {
-  decode
-} = utilities.compression;
+const DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
+const decode = utilities.compression.decode;
 const updateSegmentsOnFrame = _ref => {
-  let {
-    segmentsOnFrame,
-    imageIdIndex,
-    segmentIndex
-  } = _ref;
+  let segmentsOnFrame = _ref.segmentsOnFrame,
+    imageIdIndex = _ref.imageIdIndex,
+    segmentIndex = _ref.segmentIndex;
   if (!segmentsOnFrame[imageIdIndex]) {
     segmentsOnFrame[imageIdIndex] = [];
   }
   segmentsOnFrame[imageIdIndex].push(segmentIndex);
 };
 const updateSegmentsPixelIndices = _ref2 => {
-  let {
-    segmentsPixelIndices,
-    segmentIndex,
-    imageIdIndex,
-    indexCache
-  } = _ref2;
+  let segmentsPixelIndices = _ref2.segmentsPixelIndices,
+    segmentIndex = _ref2.segmentIndex,
+    imageIdIndex = _ref2.imageIdIndex,
+    indexCache = _ref2.indexCache;
   if (!segmentsPixelIndices.has(segmentIndex)) {
     segmentsPixelIndices.set(segmentIndex, {});
   }
@@ -43,12 +33,10 @@ const updateSegmentsPixelIndices = _ref2 => {
   segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
 };
 const extractInfoFromPerFrameFunctionalGroups = _ref3 => {
-  let {
-    PerFrameFunctionalGroups,
-    sequenceIndex,
-    sopUIDImageIdIndexMap,
-    multiframe
-  } = _ref3;
+  let PerFrameFunctionalGroups = _ref3.PerFrameFunctionalGroups,
+    sequenceIndex = _ref3.sequenceIndex,
+    sopUIDImageIdIndexMap = _ref3.sopUIDImageIdIndexMap,
+    multiframe = _ref3.multiframe;
   const referencedSOPInstanceUid = PerFrameFunctionalGroups.DerivationImageSequence[0].SourceImageSequence[0].ReferencedSOPInstanceUID;
   const referencedImageId = sopUIDImageIdIndexMap[referencedSOPInstanceUid];
   const segmentIndex = getSegmentIndex(multiframe, sequenceIndex);
@@ -59,11 +47,12 @@ const extractInfoFromPerFrameFunctionalGroups = _ref3 => {
   };
 };
 async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer, metadataProvider, options) {
-  const {
-    tolerance = 1e-3,
-    TypedArrayConstructor = Uint8Array,
-    maxBytesPerChunk = 199000000
-  } = options;
+  const _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;
   const dicomData = DicomMessage.readFile(arrayBuffer);
   const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
   dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
@@ -98,9 +87,8 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
   }
   const orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, referencedImageIds.length], tolerance);
   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;
   }, {});
@@ -128,23 +116,22 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
     labelMapImages.push(labelMapImage);
   }
   const segmentsPixelIndices = new Map();
-  const {
-    hasOverlappingSegments,
-    arrayOfLabelMapImages
-  } = await insertFunction({
-    segmentsOnFrame,
-    labelMapImages,
-    pixelDataChunks,
-    multiframe,
-    referencedImageIds,
-    validOrientations,
-    metadataProvider,
-    tolerance,
-    segmentsPixelIndices,
-    sopUIDImageIdIndexMap,
-    imageIdMaps,
-    TypedArrayConstructor
-  });
+  const _await$insertFunction = await insertFunction({
+      segmentsOnFrame,
+      labelMapImages,
+      pixelDataChunks,
+      multiframe,
+      referencedImageIds,
+      validOrientations,
+      metadataProvider,
+      tolerance,
+      segmentsPixelIndices,
+      sopUIDImageIdIndexMap,
+      imageIdMaps,
+      TypedArrayConstructor
+    }),
+    hasOverlappingSegments = _await$insertFunction.hasOverlappingSegments,
+    arrayOfLabelMapImages = _await$insertFunction.arrayOfLabelMapImages;
   const centroidXYZ = new Map();
   segmentsPixelIndices.forEach((imageIdIndexBufferIndex, segmentIndex) => {
     const centroids = calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, referencedImageIds);
@@ -164,25 +151,21 @@ const throttledTriggerLoadProgressEvent = utilities$1.throttle(percentComplete =
   });
 }, 200);
 function insertPixelDataPlanar(_ref4) {
-  let {
-    segmentsOnFrame,
-    labelMapImages,
-    pixelDataChunks,
-    multiframe,
-    referencedImageIds,
-    validOrientations,
-    metadataProvider,
-    tolerance,
-    segmentsPixelIndices,
-    sopUIDImageIdIndexMap,
-    imageIdMaps
-  } = _ref4;
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  let segmentsOnFrame = _ref4.segmentsOnFrame,
+    labelMapImages = _ref4.labelMapImages,
+    pixelDataChunks = _ref4.pixelDataChunks,
+    multiframe = _ref4.multiframe,
+    referencedImageIds = _ref4.referencedImageIds,
+    validOrientations = _ref4.validOrientations,
+    metadataProvider = _ref4.metadataProvider,
+    tolerance = _ref4.tolerance,
+    segmentsPixelIndices = _ref4.segmentsPixelIndices,
+    sopUIDImageIdIndexMap = _ref4.sopUIDImageIdIndexMap,
+    imageIdMaps = _ref4.imageIdMaps;
+  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 groupsLen = PerFrameFunctionalGroupsSequence.length;
@@ -342,17 +325,15 @@ function insertPixelDataPlanar(_ref4) {
   });
 }
 const getAlignedPixelData = _ref5 => {
-  let {
-    sharedImageOrientationPatient,
-    PerFrameFunctionalGroups,
-    pixelDataChunks,
-    sequenceIndex,
-    sliceLength,
-    Rows,
-    Columns,
-    validOrientations,
-    tolerance
-  } = _ref5;
+  let sharedImageOrientationPatient = _ref5.sharedImageOrientationPatient,
+    PerFrameFunctionalGroups = _ref5.PerFrameFunctionalGroups,
+    pixelDataChunks = _ref5.pixelDataChunks,
+    sequenceIndex = _ref5.sequenceIndex,
+    sliceLength = _ref5.sliceLength,
+    Rows = _ref5.Rows,
+    Columns = _ref5.Columns,
+    validOrientations = _ref5.validOrientations,
+    tolerance = _ref5.tolerance;
   const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
   const view = readFromUnpackedChunks(pixelDataChunks, sequenceIndex * sliceLength, sliceLength);
   const pixelDataI2D = ndarray(view, [Rows, Columns]);
@@ -363,22 +344,18 @@ const getAlignedPixelData = _ref5 => {
   return alignedPixelDataI;
 };
 const checkImageDimensions = _ref6 => {
-  let {
-    metadataProvider,
-    imageId,
-    Rows,
-    Columns
-  } = _ref6;
+  let metadataProvider = _ref6.metadataProvider,
+    imageId = _ref6.imageId,
+    Rows = _ref6.Rows,
+    Columns = _ref6.Columns;
   const sourceImageMetadata = metadataProvider.get('instance', imageId);
   if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
     throw new Error('Individual SEG frames have different geometry dimensions (Rows and Columns) ' + 'respect to the source image reference frame. This is not yet supported. ' + 'Aborting segmentation loading. ');
   }
 };
 const getArrayOfLabelMapImagesWithSegmentData = _ref7 => {
-  let {
-    arrayOfSegmentData,
-    referencedImageIds
-  } = _ref7;
+  let arrayOfSegmentData = _ref7.arrayOfSegmentData,
+    referencedImageIds = _ref7.referencedImageIds;
   let largestArray = [];
   for (let i = 0; i < arrayOfSegmentData.length; i++) {
     const segmentData = arrayOfSegmentData[i];
@@ -402,25 +379,21 @@ const getArrayOfLabelMapImagesWithSegmentData = _ref7 => {
   });
 };
 function insertOverlappingPixelDataPlanar(_ref8) {
-  let {
-    segmentsOnFrame,
-    labelMapImages,
-    pixelDataChunks,
-    multiframe,
-    referencedImageIds,
-    validOrientations,
-    metadataProvider,
-    tolerance,
-    segmentsPixelIndices,
-    sopUIDImageIdIndexMap,
-    imageIdMaps
-  } = _ref8;
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  let segmentsOnFrame = _ref8.segmentsOnFrame,
+    labelMapImages = _ref8.labelMapImages,
+    pixelDataChunks = _ref8.pixelDataChunks,
+    multiframe = _ref8.multiframe,
+    referencedImageIds = _ref8.referencedImageIds,
+    validOrientations = _ref8.validOrientations,
+    metadataProvider = _ref8.metadataProvider,
+    tolerance = _ref8.tolerance,
+    segmentsPixelIndices = _ref8.segmentsPixelIndices,
+    sopUIDImageIdIndexMap = _ref8.sopUIDImageIdIndexMap,
+    imageIdMaps = _ref8.imageIdMaps;
+  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 arrayOfSegmentData = getArrayOfSegmentData({
@@ -450,23 +423,21 @@ function insertOverlappingPixelDataPlanar(_ref8) {
   };
 }
 const getArrayOfSegmentData = _ref9 => {
-  let {
-    sliceLength,
-    Rows,
-    Columns,
-    validOrientations,
-    metadataProvider,
-    imageIdMaps,
-    segmentsOnFrame,
-    tolerance,
-    pixelDataChunks,
-    PerFrameFunctionalGroupsSequence,
-    labelMapImages,
-    sopUIDImageIdIndexMap,
-    multiframe,
-    sharedImageOrientationPatient,
-    segmentsPixelIndices
-  } = _ref9;
+  let sliceLength = _ref9.sliceLength,
+    Rows = _ref9.Rows,
+    Columns = _ref9.Columns,
+    validOrientations = _ref9.validOrientations,
+    metadataProvider = _ref9.metadataProvider,
+    imageIdMaps = _ref9.imageIdMaps,
+    segmentsOnFrame = _ref9.segmentsOnFrame,
+    tolerance = _ref9.tolerance,
+    pixelDataChunks = _ref9.pixelDataChunks,
+    PerFrameFunctionalGroupsSequence = _ref9.PerFrameFunctionalGroupsSequence,
+    labelMapImages = _ref9.labelMapImages,
+    sopUIDImageIdIndexMap = _ref9.sopUIDImageIdIndexMap,
+    multiframe = _ref9.multiframe,
+    sharedImageOrientationPatient = _ref9.sharedImageOrientationPatient,
+    segmentsPixelIndices = _ref9.segmentsPixelIndices;
   const arrayOfSegmentData = [];
   const numberOfSegments = multiframe.SegmentSequence.length;
   for (let currentSegmentIndex = 1; currentSegmentIndex <= numberOfSegments; ++currentSegmentIndex) {
@@ -496,38 +467,35 @@ const getArrayOfSegmentData = _ref9 => {
   return arrayOfSegmentData;
 };
 const getSegmentData = _ref10 => {
-  let {
-    PerFrameFunctionalGroupsSequence,
-    labelMapImages,
-    sopUIDImageIdIndexMap,
-    multiframe,
-    segmentIndex,
-    sliceLength,
-    Rows,
-    Columns,
-    validOrientations,
-    tolerance,
-    pixelDataChunks,
-    sharedImageOrientationPatient,
-    metadataProvider,
-    imageIdMaps,
-    segmentsOnFrame,
-    segmentsPixelIndices
-  } = _ref10;
+  let PerFrameFunctionalGroupsSequence = _ref10.PerFrameFunctionalGroupsSequence,
+    labelMapImages = _ref10.labelMapImages,
+    sopUIDImageIdIndexMap = _ref10.sopUIDImageIdIndexMap,
+    multiframe = _ref10.multiframe,
+    segmentIndex = _ref10.segmentIndex,
+    sliceLength = _ref10.sliceLength,
+    Rows = _ref10.Rows,
+    Columns = _ref10.Columns,
+    validOrientations = _ref10.validOrientations,
+    tolerance = _ref10.tolerance,
+    pixelDataChunks = _ref10.pixelDataChunks,
+    sharedImageOrientationPatient = _ref10.sharedImageOrientationPatient,
+    metadataProvider = _ref10.metadataProvider,
+    imageIdMaps = _ref10.imageIdMaps,
+    segmentsOnFrame = _ref10.segmentsOnFrame,
+    segmentsPixelIndices = _ref10.segmentsPixelIndices;
   const segmentData = [];
   for (let currentLabelMapImageIndex = 0; currentLabelMapImageIndex < labelMapImages.length; currentLabelMapImageIndex++) {
     const currentLabelMapImage = labelMapImages[currentLabelMapImageIndex];
     const referencedImageId = currentLabelMapImage.referencedImageId;
     const PerFrameFunctionalGroupsIndex = PerFrameFunctionalGroupsSequence.findIndex((PerFrameFunctionalGroups, currentSequenceIndex) => {
-      const {
-        segmentIndex: groupsSegmentIndex,
-        referencedImageId: groupsReferenceImageId
-      } = extractInfoFromPerFrameFunctionalGroups({
-        PerFrameFunctionalGroups,
-        sequenceIndex: currentSequenceIndex,
-        sopUIDImageIdIndexMap,
-        multiframe
-      });
+      const _extractInfoFromPerFr = extractInfoFromPerFrameFunctionalGroups({
+          PerFrameFunctionalGroups,
+          sequenceIndex: currentSequenceIndex,
+          sopUIDImageIdIndexMap,
+          multiframe
+        }),
+        groupsSegmentIndex = _extractInfoFromPerFr.segmentIndex,
+        groupsReferenceImageId = _extractInfoFromPerFr.referencedImageId;
       const isCorrectPerFrameFunctionalGroup = groupsSegmentIndex === segmentIndex && groupsReferenceImageId === currentLabelMapImage.referencedImageId;
       return isCorrectPerFrameFunctionalGroup;
     });

package/dist/esm/adapters/Cornerstone3D/UltrasoundDirectional.js

@@ -7,19 +7,14 @@ import BaseAdapter3D from './BaseAdapter3D.js';
 var _UltrasoundDirectional;
 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 {
-  Length: TID300Length
-} = utilities.TID300;
-const {
-  worldToImageCoords
-} = utilities$1;
+const TID300Length = utilities.TID300.Length;
+const worldToImageCoords = utilities$1.worldToImageCoords;
 class UltrasoundDirectional extends BaseAdapter3D {
   static getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata) {
-    const {
-      state,
-      worldCoords,
-      ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType),
+      state = _MeasurementReport$ge.state,
+      worldCoords = _MeasurementReport$ge.worldCoords,
+      ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
     state.annotation.data = _objectSpread(_objectSpread({}, state.annotation.data), {}, {
       handles: _objectSpread(_objectSpread({}, state.annotation.data.handles), {}, {
         points: worldCoords
@@ -29,18 +24,12 @@ class UltrasoundDirectional extends BaseAdapter3D {
     return state;
   }
   static getTID300RepresentationArguments(tool, is3DMeasurement) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      handles
-    } = data;
-    const {
-      referencedImageId
-    } = metadata;
+    const data = tool.data,
+      finding = tool.finding,
+      findingSites = tool.findingSites,
+      metadata = tool.metadata;
+    const handles = data.handles;
+    const referencedImageId = metadata.referencedImageId;
     if (!referencedImageId) {
       throw new Error('UltrasoundDirectionalTool.getTID300RepresentationArguments: referencedImageId is not defined');
     }

package/dist/esm/adapters/Cornerstone3D/metricHandler.js

@@ -1,3 +1,5 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+
 function extractAllNUMGroups(MeasurementGroup, referencedSOPInstanceUID) {
   const numGroupsBySOPInstanceUID = {};
   if (MeasurementGroup.ContentSequence) {
@@ -40,15 +42,16 @@ function restoreAdditionalMetrics(numGroups) {
     radius: 'radiusUnit',
     width: 'widthUnit'
   };
-  for (const [codeMeaning, metricKey] of Object.entries(metricMapping)) {
+  for (const _ref of Object.entries(metricMapping)) {
+    var _ref2 = _slicedToArray(_ref, 2);
+    const codeMeaning = _ref2[0];
+    const metricKey = _ref2[1];
     const group = numGroups[codeMeaning];
     if (!group) {
       continue;
     }
-    const {
-      value,
-      unit
-    } = group;
+    const value = group.value,
+      unit = group.unit;
     if (value == null) {
       continue;
     }

package/dist/esm/adapters/VTKjs/Segmentation.js

@@ -1,9 +1,7 @@
 import { data } from 'dcmjs';
 
-const {
-  Colors,
-  BitArray
-} = data;
+const Colors = data.Colors,
+  BitArray = data.BitArray;
 
 // TODO: Is there a better name for this? RGBAInt?
 // Should we move it to Colors.js

package/dist/esm/adapters/helpers/checkOrientation.js

@@ -2,10 +2,8 @@ import checkIfPerpendicular from './checkIfPerpendicular.js';
 import { utilities } from '@cornerstonejs/core';
 
 function checkOrientation(multiframe, validOrientations, sourceDataDimensions, tolerance) {
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence
-  } = multiframe;
+  const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence;
   const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
   const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[0];
   const iop = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;

package/dist/esm/adapters/helpers/downloadDICOMData.js

@@ -1,8 +1,6 @@
 import { data } from 'dcmjs';
 
-const {
-  datasetToBlob
-} = data;
+const datasetToBlob = data.datasetToBlob;
 function downloadDICOMData(bufferOrDataset, filename) {
   let blob;
   if (bufferOrDataset instanceof ArrayBuffer) {

package/dist/esm/adapters/helpers/getDatasetsFromImages.js

@@ -1,12 +1,8 @@
 import { data, normalizers } from 'dcmjs';
 
-const {
-  DicomMessage,
-  DicomMetaDictionary
-} = data;
-const {
-  Normalizer
-} = normalizers;
+const DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
 function getDatasetsFromImages(images, isMultiframe, options) {
   const datasets = [];
   if (isMultiframe) {

package/dist/esm/adapters/helpers/scoordToWorld.js

@@ -1,26 +1,18 @@
 import { utilities } from '@cornerstonejs/core';
 
-const {
-  imageToWorldCoords
-} = utilities;
+const imageToWorldCoords = utilities.imageToWorldCoords;
 function scoordToWorld(_ref, scoord) {
-  let {
-    is3DMeasurement,
-    referencedImageId
-  } = _ref;
+  let is3DMeasurement = _ref.is3DMeasurement,
+    referencedImageId = _ref.referencedImageId;
   const worldCoords = [];
   if (is3DMeasurement) {
-    const {
-      GraphicData
-    } = scoord;
+    const GraphicData = scoord.GraphicData;
     for (let i = 0; i < GraphicData.length; i += 3) {
       const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
       worldCoords.push(point);
     }
   } else {
-    const {
-      GraphicData
-    } = scoord;
+    const GraphicData = scoord.GraphicData;
     for (let i = 0; i < GraphicData.length; i += 2) {
       const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
       worldCoords.push(point);

package/dist/esm/adapters/helpers/toPoint3.js

@@ -3,9 +3,7 @@ function toPoint3(flatPoints) {
   if (!(flatPoints !== null && flatPoints !== void 0 && flatPoints.length)) {
     return points;
   }
-  const {
-    length: n
-  } = flatPoints;
+  const n = flatPoints.length;
   if (n % 3 !== 0) {
     throw new Error("Points array should be divisible by 3 for SCOORD3D, but contents are: ".concat(JSON.stringify(flatPoints), " of length ").concat(n));
   }

package/dist/esm/adapters/helpers/toScoordType.js

@@ -1,14 +1,10 @@
 import { utilities } from '@cornerstonejs/core';
 
-const {
-  worldToImageCoords: globalWorldToImageCoords
-} = utilities;
+const globalWorldToImageCoords = utilities.worldToImageCoords;
 let useWorldToImageCoords = globalWorldToImageCoords;
 function toScoord(_ref, point) {
-  let {
-    is3DMeasurement,
-    referencedImageId
-  } = _ref;
+  let is3DMeasurement = _ref.is3DMeasurement,
+    referencedImageId = _ref.referencedImageId;
   if (is3DMeasurement) {
     return {
       x: point[0],

package/dist/esm/adapters/index.js

@@ -3,8 +3,9 @@ import { Cornerstone3DSR, Cornerstone3DSEG, Cornerstone3DPMAP, Cornerstone3DRT }
 export { NO_IMAGE_ID } from './Cornerstone3D/constants/index.js';
 import { VTKjsSEG } from './VTKjs/index.js';
 import './enums/Events.js';
-import 'dcmjs';
-import '@cornerstonejs/core';
+import './helpers/downloadDICOMData.js';
+import './helpers/toScoordType.js';
+import './helpers/scoordToWorld.js';
 
 const adaptersSR = {
   Cornerstone: CornerstoneSR,

package/dist/esm/utilities/createInstance.js

@@ -1,13 +1,15 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { Enums, metaData } from '@cornerstonejs/core';
 
-const {
-  MetadataModules
-} = Enums;
+const MetadataModules = Enums.MetadataModules;
 function assignDefined(dest, source, options) {
   if (!source) {
     return;
   }
-  for (const [key, value] of Object.entries(source)) {
+  for (const _ref of Object.entries(source)) {
+    var _ref2 = _slicedToArray(_ref, 2);
+    const key = _ref2[0];
+    const value = _ref2[1];
     if (value === undefined) {
       continue;
     }
@@ -18,10 +20,9 @@ function assignDefined(dest, source, options) {
   }
 }
 function createInstance(instanceKey, studyExemplarImageId, base, options) {
-  const {
-    metadataProvider = metaData,
-    predecessorImageId
-  } = options;
+  const _options$metadataProv = options.metadataProvider,
+    metadataProvider = _options$metadataProv === void 0 ? metaData : _options$metadataProv,
+    predecessorImageId = options.predecessorImageId;
   const result = {};
   const instanceBase = metadataProvider.get(instanceKey, studyExemplarImageId);
   Object.assign(result, instanceBase);

package/dist/esm/utilities/referencedMetadataProvider.js

@@ -1,16 +1,12 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { metaData, Enums } from '@cornerstonejs/core';
+import { Enums, metaData } from '@cornerstonejs/core';
 import dcmjs from 'dcmjs';
 import { metaRTSSContour, metaSRAnnotation } from '../adapters/Cornerstone3D/constants/index.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 {
-  DicomMetaDictionary
-} = dcmjs.data;
-const {
-  MetadataModules
-} = Enums;
+const DicomMetaDictionary = dcmjs.data.DicomMetaDictionary;
+const MetadataModules = Enums.MetadataModules;
 const STUDY_MODULES = [MetadataModules.GENERAL_STUDY, MetadataModules.PATIENT_STUDY, MetadataModules.PATIENT];
 const SERIES_MODULES = [MetadataModules.GENERAL_SERIES];
 const IMAGE_MODULES = [MetadataModules.GENERAL_IMAGE, MetadataModules.IMAGE_PLANE, MetadataModules.CINE, MetadataModules.VOI_LUT, MetadataModules.MODALITY_LUT, MetadataModules.SOP_COMMON];
@@ -21,12 +17,10 @@ const metadataProvider = {
   },
   [MetadataModules.IMAGE_SOP_INSTANCE_REFERENCE]: function (imageId) {
     const frameModule = metaData.get(MetadataModules.FRAME_MODULE, imageId);
-    const {
-      sopClassUID,
-      sopInstanceUID,
-      frameNumber,
-      numberOfFrames
-    } = frameModule;
+    const sopClassUID = frameModule.sopClassUID,
+      sopInstanceUID = frameModule.sopInstanceUID,
+      frameNumber = frameModule.frameNumber,
+      numberOfFrames = frameModule.numberOfFrames;
     if (numberOfFrames > 1) {
       return {
         ReferencedSOPClassUID: sopClassUID,