@ohif/app 3.8.0-beta.27 → 3.8.0-beta.29

package/dist/{420.bundle.208f94f15dcc2be09dc0.js → 456.bundle.475e0e878872ad61e39e.js}

@@ -1,7 +1,7 @@
 "use strict";
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[420],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[456],{
 
-/***/ 41420:
+/***/ 86456:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -35,10 +35,10 @@ __webpack_require__.r(types_namespaceObject);
 
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
 var react = __webpack_require__(43001);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 363 modules
-var esm = __webpack_require__(56959);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js + 413 modules
-var dist_esm = __webpack_require__(1026);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 364 modules
+var esm = __webpack_require__(27968);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js + 424 modules
+var dist_esm = __webpack_require__(74566);
 // EXTERNAL MODULE: ../../core/src/index.ts + 65 modules
 var src = __webpack_require__(71771);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/index.js + 13 modules
@@ -137,9 +137,7 @@ var ui_src = __webpack_require__(22582);
  * @param {string?} dialogConfig.dialogTitle - title of the input dialog
  * @param {string?} dialogConfig.inputLabel - show label above the input
  */
-function callInputDialog(uiDialogService, data, callback) {
-  let isArrowAnnotateInputDialog = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
-  let dialogConfig = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+function callInputDialog(uiDialogService, data, callback, isArrowAnnotateInputDialog = true, dialogConfig = {}) {
   const dialogId = 'dialog-enter-annotation';
   const label = data ? isArrowAnnotateInputDialog ? data.text : data.label : '';
   const {
@@ -147,11 +145,10 @@ function callInputDialog(uiDialogService, data, callback) {
     inputLabel = 'Enter your annotation',
     validateFunc = value => true
   } = dialogConfig;
-  const onSubmitHandler = _ref => {
-    let {
-      action,
-      value
-    } = _ref;
+  const onSubmitHandler = ({
+    action,
+    value
+  }) => {
     switch (action.id) {
       case 'save':
         if (typeof validateFunc === 'function' && !validateFunc(value.label)) {
@@ -193,11 +190,10 @@ function callInputDialog(uiDialogService, data, callback) {
           type: ui_src/* ButtonEnums.type */.LZ.dt.primary
         }],
         onSubmit: onSubmitHandler,
-        body: _ref2 => {
-          let {
-            value,
-            setValue
-          } = _ref2;
+        body: ({
+          value,
+          setValue
+        }) => {
           return /*#__PURE__*/react.createElement(ui_src/* Input */.II, {
             autoFocus: true,
             className: "border-primary-main bg-black",
@@ -257,8 +253,8 @@ const {
  * Calibration Line tool works almost the same as the
  */
 class CalibrationLineTool extends dist_esm.LengthTool {
-  constructor() {
-    super(...arguments);
+  constructor(...args) {
+    super(...args);
     this._renderingViewport = void 0;
     this._lengthToolRenderAnnotation = this.renderAnnotation;
     this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
@@ -407,14 +403,12 @@ esm.metaData.addProvider(OverlayPlaneModuleProvider.get, 10_000);
  * toolGroup.setToolEnabled() and toolGroup.setToolDisabled()
  */
 class ImageOverlayViewerTool extends dist_esm.AnnotationDisplayTool {
-  constructor() {
-    let toolProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let defaultToolProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      supportedInteractionTypes: [],
-      configuration: {
-        fillColor: [255, 127, 127, 255]
-      }
-    };
+  constructor(toolProps = {}, defaultToolProps = {
+    supportedInteractionTypes: [],
+    configuration: {
+      fillColor: [255, 127, 127, 255]
+    }
+  }) {
     super(toolProps, defaultToolProps);
     this.onSetToolDisabled = () => {};
     this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
@@ -567,11 +561,10 @@ class ImageOverlayViewerTool extends dist_esm.AnnotationDisplayTool {
    * @param color
    * @returns
    */
-  _renderOverlayToDataUrl(_ref, color, pixelDataRaw) {
-    let {
-      width,
-      height
-    } = _ref;
+  _renderOverlayToDataUrl({
+    width,
+    height
+  }, color, pixelDataRaw) {
     const pixelDataView = new DataView(pixelDataRaw);
     const totalBits = width * height;
     const canvas = document.createElement('canvas');
@@ -613,8 +606,7 @@ ImageOverlayViewerTool.addOverlayPlaneModule = tools_OverlayPlaneModuleProvider.
 
 
 
-function initCornerstoneTools() {
-  let configuration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function initCornerstoneTools(configuration = {}) {
   dist_esm.CrosshairsTool.isAnnotation = false;
   dist_esm.ReferenceLinesTool.isAnnotation = false;
   (0,dist_esm.init)(configuration);
@@ -2684,10 +2676,9 @@ const connectMeasurementServiceToTools = (measurementService, cornerstoneViewpor
     RAW_MEASUREMENT_ADDED
   } = measurementService.EVENTS;
   const csTools3DVer1MeasurementSource = measurementService.getSource(CORNERSTONE_3D_TOOLS_SOURCE_NAME, CORNERSTONE_3D_TOOLS_SOURCE_VERSION);
-  measurementService.subscribe(MEASUREMENTS_CLEARED, _ref => {
-    let {
-      measurements
-    } = _ref;
+  measurementService.subscribe(MEASUREMENTS_CLEARED, ({
+    measurements
+  }) => {
     if (!Object.keys(measurements).length) {
       return;
     }
@@ -2702,12 +2693,11 @@ const connectMeasurementServiceToTools = (measurementService, cornerstoneViewpor
       removeAnnotation(uid);
     }
   });
-  measurementService.subscribe(MEASUREMENT_UPDATED, _ref2 => {
-    let {
-      source,
-      measurement,
-      notYetUpdatedAtSource
-    } = _ref2;
+  measurementService.subscribe(MEASUREMENT_UPDATED, ({
+    source,
+    measurement,
+    notYetUpdatedAtSource
+  }) => {
     if (source.name !== CORNERSTONE_3D_TOOLS_SOURCE_NAME) {
       return;
     }
@@ -2737,14 +2727,12 @@ const connectMeasurementServiceToTools = (measurementService, cornerstoneViewpor
 
     // Todo: trigger render for annotation
   });
-
-  measurementService.subscribe(RAW_MEASUREMENT_ADDED, _ref3 => {
-    let {
-      source,
-      measurement,
-      data,
-      dataSource
-    } = _ref3;
+  measurementService.subscribe(RAW_MEASUREMENT_ADDED, ({
+    source,
+    measurement,
+    data,
+    dataSource
+  }) => {
     if (source.name !== CORNERSTONE_3D_TOOLS_SOURCE_NAME) {
       return;
     }
@@ -2788,11 +2776,10 @@ const connectMeasurementServiceToTools = (measurementService, cornerstoneViewpor
       }
     });
   });
-  measurementService.subscribe(MEASUREMENT_REMOVED, _ref4 => {
-    let {
-      source,
-      measurement: removedMeasurementId
-    } = _ref4;
+  measurementService.subscribe(MEASUREMENT_REMOVED, ({
+    source,
+    measurement: removedMeasurementId
+  }) => {
     if (source?.name && source.name !== CORNERSTONE_3D_TOOLS_SOURCE_NAME) {
       return;
     }
@@ -2889,15 +2876,14 @@ const viewportIdVolumeInputArrayMap = new Map();
  * @param {Object} props image loading properties from Cornerstone ViewportService
  * @returns
  */
-function interleaveCenterLoader(_ref) {
-  let {
-    data: {
-      viewportId,
-      volumeInputArray
-    },
-    displaySetsMatchDetails,
-    viewportMatchDetails: matchDetails
-  } = _ref;
+function interleaveCenterLoader({
+  data: {
+    viewportId,
+    volumeInputArray
+  },
+  displaySetsMatchDetails,
+  viewportMatchDetails: matchDetails
+}) {
   viewportIdVolumeInputArrayMap.set(viewportId, volumeInputArray);
 
   // Based on the volumeInputs store the volumeIds and SeriesInstanceIds
@@ -2966,10 +2952,9 @@ function interleaveCenterLoader(_ref) {
       return request.imageId;
     });
     const imageIds = getInterleavedFrames(requestImageIds);
-    const reOrderedRequests = imageIds.map(_ref2 => {
-      let {
-        imageId
-      } = _ref2;
+    const reOrderedRequests = imageIds.map(({
+      imageId
+    }) => {
       const request = requests.find(req => req.imageId === imageId);
       return request;
     });
@@ -2995,14 +2980,13 @@ function interleaveCenterLoader(_ref) {
   });
   const requestType = esm.Enums.RequestType.Prefetch;
   const priority = 0;
-  finalRequests.forEach(_ref3 => {
-    let {
-      callLoadImage,
-      additionalDetails,
-      imageId,
-      imageIdIndex,
-      options
-    } = _ref3;
+  finalRequests.forEach(({
+    callLoadImage,
+    additionalDetails,
+    imageId,
+    imageIdIndex,
+    options
+  }) => {
     const callLoadImageBound = callLoadImage.bind(null, imageId, imageIdIndex, options);
     esm.imageLoadPoolManager.addRequest(callLoadImageBound, requestType, additionalDetails, priority);
   });
@@ -3100,14 +3084,13 @@ const nthLoader_viewportIdVolumeInputArrayMap = new Map();
  * visually much better.
  * @param {Object} props image loading properties from Cornerstone ViewportService
  */
-function interleaveNthLoader(_ref) {
-  let {
-    data: {
-      viewportId,
-      volumeInputArray
-    },
-    displaySetsMatchDetails
-  } = _ref;
+function interleaveNthLoader({
+  data: {
+    viewportId,
+    volumeInputArray
+  },
+  displaySetsMatchDetails
+}) {
   nthLoader_viewportIdVolumeInputArrayMap.set(viewportId, volumeInputArray);
 
   // Based on the volumeInputs store the volumeIds and SeriesInstanceIds
@@ -3145,14 +3128,13 @@ function interleaveNthLoader(_ref) {
   const finalRequests = interleave(orderedRequests);
   const requestType = esm.Enums.RequestType.Prefetch;
   const priority = 0;
-  finalRequests.forEach(_ref2 => {
-    let {
-      callLoadImage,
-      additionalDetails,
-      imageId,
-      imageIdIndex,
-      options
-    } = _ref2;
+  finalRequests.forEach(({
+    callLoadImage,
+    additionalDetails,
+    imageId,
+    imageIdIndex,
+    options
+  }) => {
     const callLoadImageBound = callLoadImage.bind(null, imageId, imageIdIndex, options);
     esm.imageLoadPoolManager.addRequest(callLoadImageBound, requestType, additionalDetails, priority);
   });
@@ -3183,15 +3165,14 @@ const interleaveTopToBottom_viewportIdVolumeInputArrayMap = new Map();
  * @param {Object} {viewportData, displaySetMatchDetails}
  * @returns
  */
-function interleaveTopToBottom(_ref) {
-  let {
-    data: {
-      viewportId,
-      volumeInputArray
-    },
-    displaySetsMatchDetails,
-    viewportMatchDetails: matchDetails
-  } = _ref;
+function interleaveTopToBottom({
+  data: {
+    viewportId,
+    volumeInputArray
+  },
+  displaySetsMatchDetails,
+  viewportMatchDetails: matchDetails
+}) {
   interleaveTopToBottom_viewportIdVolumeInputArrayMap.set(viewportId, volumeInputArray);
 
   // Based on the volumeInputs store the volumeIds and SeriesInstanceIds
@@ -3280,14 +3261,13 @@ function interleaveTopToBottom(_ref) {
   });
   const requestType = esm.Enums.RequestType.Prefetch;
   const priority = 0;
-  finalRequests.forEach(_ref2 => {
-    let {
-      callLoadImage,
-      additionalDetails,
-      imageId,
-      imageIdIndex,
-      options
-    } = _ref2;
+  finalRequests.forEach(({
+    callLoadImage,
+    additionalDetails,
+    imageId,
+    imageIdIndex,
+    options
+  }) => {
     const callLoadImageBound = callLoadImage.bind(null, imageId, imageIdIndex, options);
     esm.imageLoadPoolManager.addRequest(callLoadImageBound, requestType, additionalDetails, priority);
   });
@@ -3369,12 +3349,11 @@ function getEventName(evt) {
   nameArr.push(button);
   return nameArr.join('');
 }
-function initContextMenu(_ref) {
-  let {
-    cornerstoneViewportService,
-    customizationService,
-    commandsManager
-  } = _ref;
+function initContextMenu({
+  cornerstoneViewportService,
+  customizationService,
+  commandsManager
+}) {
   /*
    * Run the commands associated with the given button press,
    * defaults on button1 and button2
@@ -3458,11 +3437,10 @@ function getDoubleClickEventName(evt) {
   nameArr.push('doubleClick');
   return nameArr.join('');
 }
-function initDoubleClick(_ref) {
-  let {
-    customizationService,
-    commandsManager
-  } = _ref;
+function initDoubleClick({
+  customizationService,
+  commandsManager
+}) {
   const cornerstoneViewportHandleDoubleClick = evt => {
     // Do not allow double click on a tool.
     const nearbyToolData = findNearbyToolData(commandsManager, evt);
@@ -3515,10 +3493,9 @@ const imageTiming = {
  *
  */
 
-function initViewTiming(_ref) {
-  let {
-    element
-  } = _ref;
+function initViewTiming({
+  element
+}) {
   if (!IMAGE_TIMING_KEYS.find(key => src/* log */.cM.timingKeys[key])) {
     return;
   }
@@ -3563,14 +3540,13 @@ window.cornerstoneTools = dist_esm;
 /**
  *
  */
-async function init(_ref) {
-  let {
-    servicesManager,
-    commandsManager,
-    extensionManager,
-    configuration,
-    appConfig
-  } = _ref;
+async function init({
+  servicesManager,
+  commandsManager,
+  extensionManager,
+  configuration,
+  appConfig
+}) {
   // Note: this should run first before initializing the cornerstone
   // DO NOT CHANGE THE ORDER
   const value = appConfig.useSharedArrayBuffer;
@@ -3760,10 +3736,9 @@ async function init(_ref) {
    * Runs error handler for failed requests.
    * @param event 
    */
-  const imageLoadFailedHandler = _ref2 => {
-    let {
-      detail
-    } = _ref2;
+  const imageLoadFailedHandler = ({
+    detail
+  }) => {
     const handler = src/* errorHandler */.Po.getHTTPErrorHandler();
     handler(detail.error);
   };
@@ -3819,7 +3794,6 @@ async function init(_ref) {
     //   newStackCallback
     // );
   }
-
   esm.eventTarget.addEventListener(esm.EVENTS.ELEMENT_ENABLED, elementEnabledHandler.bind(null));
   esm.eventTarget.addEventListener(esm.EVENTS.ELEMENT_DISABLED, elementDisabledHandler.bind(null));
   viewportGridService.subscribe(viewportGridService.EVENTS.ACTIVE_VIEWPORT_ID_CHANGED, activeViewportEventListener);
@@ -4015,10 +3989,9 @@ class DicomFileUploader extends src/* PubSubService */.hC {
 
 
 // eslint-disable-next-line react/display-name
-const DicomUploadProgressItem = /*#__PURE__*/(0,react.memo)(_ref => {
-  let {
-    dicomFileUploader
-  } = _ref;
+const DicomUploadProgressItem = /*#__PURE__*/(0,react.memo)(({
+  dicomFileUploader
+}) => {
   const [percentComplete, setPercentComplete] = (0,react.useState)(dicomFileUploader.getPercentComplete());
   const [failedReason, setFailedReason] = (0,react.useState)('');
   const [status, setStatus] = (0,react.useState)(dicomFileUploader.getStatus());
@@ -4114,11 +4087,10 @@ const BASE_INTERVAL_TIME = 15000;
 // calculate the upload rate.
 const UPLOAD_RATE_THRESHOLD = 75;
 const NO_WRAP_ELLIPSIS_CLASS_NAMES = 'text-ellipsis whitespace-nowrap overflow-hidden';
-function DicomUploadProgress(_ref) {
-  let {
-    dicomFileUploaderArr,
-    onComplete
-  } = _ref;
+function DicomUploadProgress({
+  dicomFileUploaderArr,
+  onComplete
+}) {
   const [totalUploadSize] = (0,react.useState)(dicomFileUploaderArr.reduce((acc, fileUploader) => acc + fileUploader.getFileSize(), 0));
   const currentUploadSizeRef = (0,react.useRef)(0);
   const uploadRateRef = (0,react.useRef)(0);
@@ -4383,12 +4355,11 @@ function _extends() { _extends = Object.assign ? Object.assign.bind() : function
 
 
 
-function DicomUpload(_ref) {
-  let {
-    dataSource,
-    onComplete,
-    onStarted
-  } = _ref;
+function DicomUpload({
+  dataSource,
+  onComplete,
+  onStarted
+}) {
   const baseClassNames = 'min-h-[480px] flex flex-col bg-black select-none';
   const [dicomFileUploaderArr, setDicomFileUploaderArr] = (0,react.useState)([]);
   const onDrop = (0,react.useCallback)(async acceptedFiles => {
@@ -4401,48 +4372,39 @@ function DicomUpload(_ref) {
         onDrop(acceptedFiles);
       },
       noClick: true
-    }, _ref2 => {
-      let {
-        getRootProps
-      } = _ref2;
-      return /*#__PURE__*/react.createElement("div", _extends({}, getRootProps(), {
-        className: "dicom-upload-drop-area-border-dash m-5 flex h-full flex-col items-center justify-center"
-      }), /*#__PURE__*/react.createElement("div", {
-        className: "flex gap-3"
-      }, /*#__PURE__*/react.createElement(es/* default */.Z, {
-        onDrop: onDrop,
-        noDrag: true
-      }, _ref3 => {
-        let {
-          getRootProps,
-          getInputProps
-        } = _ref3;
-        return /*#__PURE__*/react.createElement("div", getRootProps(), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
-          disabled: false,
-          onClick: () => {}
-        }, 'Add files', /*#__PURE__*/react.createElement("input", getInputProps())));
-      }), /*#__PURE__*/react.createElement(es/* default */.Z, {
-        onDrop: onDrop,
-        noDrag: true
-      }, _ref4 => {
-        let {
-          getRootProps,
-          getInputProps
-        } = _ref4;
-        return /*#__PURE__*/react.createElement("div", getRootProps(), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
-          type: ui_src/* ButtonEnums.type */.LZ.dt.secondary,
-          disabled: false,
-          onClick: () => {}
-        }, 'Add folder', /*#__PURE__*/react.createElement("input", _extends({}, getInputProps(), {
-          webkitdirectory: "true",
-          mozdirectory: "true"
-        }))));
-      })), /*#__PURE__*/react.createElement("div", {
-        className: "pt-5"
-      }, "or drag images or folders here"), /*#__PURE__*/react.createElement("div", {
-        className: "text-aqua-pale pt-3 text-lg"
-      }, "(DICOM files supported)"));
-    });
+    }, ({
+      getRootProps
+    }) => /*#__PURE__*/react.createElement("div", _extends({}, getRootProps(), {
+      className: "dicom-upload-drop-area-border-dash m-5 flex h-full flex-col items-center justify-center"
+    }), /*#__PURE__*/react.createElement("div", {
+      className: "flex gap-3"
+    }, /*#__PURE__*/react.createElement(es/* default */.Z, {
+      onDrop: onDrop,
+      noDrag: true
+    }, ({
+      getRootProps,
+      getInputProps
+    }) => /*#__PURE__*/react.createElement("div", getRootProps(), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
+      disabled: false,
+      onClick: () => {}
+    }, 'Add files', /*#__PURE__*/react.createElement("input", getInputProps())))), /*#__PURE__*/react.createElement(es/* default */.Z, {
+      onDrop: onDrop,
+      noDrag: true
+    }, ({
+      getRootProps,
+      getInputProps
+    }) => /*#__PURE__*/react.createElement("div", getRootProps(), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
+      type: ui_src/* ButtonEnums.type */.LZ.dt.secondary,
+      disabled: false,
+      onClick: () => {}
+    }, 'Add folder', /*#__PURE__*/react.createElement("input", _extends({}, getInputProps(), {
+      webkitdirectory: "true",
+      mozdirectory: "true"
+    })))))), /*#__PURE__*/react.createElement("div", {
+      className: "pt-5"
+    }, "or drag images or folders here"), /*#__PURE__*/react.createElement("div", {
+      className: "text-aqua-pale pt-3 text-lg"
+    }, "(DICOM files supported)")));
   };
   return /*#__PURE__*/react.createElement(react.Fragment, null, dicomFileUploaderArr.length ? /*#__PURE__*/react.createElement("div", {
     className: classnames_default()('h-[calc(100vh-300px)]', baseClassNames)
@@ -4519,12 +4481,11 @@ const MINIMUM_SIZE = 100;
 const DEFAULT_SIZE = 512;
 const MAX_TEXTURE_SIZE = 10000;
 const VIEWPORT_ID = 'cornerstone-viewport-download-form';
-const CornerstoneViewportDownloadForm = _ref => {
-  let {
-    onClose,
-    activeViewportId: activeViewportIdProp,
-    cornerstoneViewportService
-  } = _ref;
+const CornerstoneViewportDownloadForm = ({
+  onClose,
+  activeViewportId: activeViewportIdProp,
+  cornerstoneViewportService
+}) => {
   const enabledElement = (0,state/* getEnabledElement */.K8)(activeViewportIdProp);
   const activeViewportElement = enabledElement?.element;
   const activeViewportEnabledElement = (0,esm.getEnabledElement)(activeViewportElement);
@@ -4737,12 +4698,11 @@ CornerstoneViewportDownloadForm.propTypes = {
 /* harmony default export */ const utils_CornerstoneViewportDownloadForm = (CornerstoneViewportDownloadForm);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/utils/stackSync/toggleStackImageSync.ts
 const STACK_SYNC_NAME = 'stackImageSync';
-function toggleStackImageSync(_ref) {
-  let {
-    toggledState,
-    servicesManager,
-    viewports: providedViewports
-  } = _ref;
+function toggleStackImageSync({
+  toggledState,
+  servicesManager,
+  viewports: providedViewports
+}) {
   if (!toggledState) {
     return disableSync(STACK_SYNC_NAME, servicesManager);
   }
@@ -4829,11 +4789,10 @@ function getReconstructableStackViewports(viewportGridService, displaySetService
 
 
 
-function commandsModule(_ref) {
-  let {
-    servicesManager,
-    commandsManager
-  } = _ref;
+function commandsModule({
+  servicesManager,
+  commandsManager
+}) {
   const {
     viewportGridService,
     toolGroupService,
@@ -4897,19 +4856,17 @@ function commandsModule(_ref) {
       };
       commandsManager.run(options, optionsToUse);
     },
-    getNearbyToolData(_ref2) {
-      let {
-        nearbyToolData,
-        element,
-        canvasCoordinates
-      } = _ref2;
+    getNearbyToolData({
+      nearbyToolData,
+      element,
+      canvasCoordinates
+    }) {
       return nearbyToolData ?? dist_esm.utilities.getAnnotationNearPoint(element, canvasCoordinates);
     },
-    getNearbyAnnotation(_ref3) {
-      let {
-        element,
-        canvasCoordinates
-      } = _ref3;
+    getNearbyAnnotation({
+      element,
+      canvasCoordinates
+    }) {
       const nearbyToolData = actions.getNearbyToolData({
         nearbyToolData: null,
         element,
@@ -4933,10 +4890,9 @@ function commandsModule(_ref) {
     // Measurement tool commands:
 
     /** Delete the given measurement */
-    deleteMeasurement: _ref4 => {
-      let {
-        uid
-      } = _ref4;
+    deleteMeasurement: ({
+      uid
+    }) => {
       if (uid) {
         measurementServiceSource.remove(uid);
       }
@@ -4945,10 +4901,9 @@ function commandsModule(_ref) {
      * Show the measurement labelling input dialog and update the label
      * on the measurement with a response if not cancelled.
      */
-    setMeasurementLabel: _ref5 => {
-      let {
-        uid
-      } = _ref5;
+    setMeasurementLabel: ({
+      uid
+    }) => {
       const measurement = measurementService.getMeasurement(uid);
       utils_callInputDialog(uiDialogService, measurement, (label, actionId) => {
         if (actionId === 'cancel') {
@@ -5023,10 +4978,9 @@ function commandsModule(_ref) {
     },
     // Retrieve value commands
     getActiveViewportEnabledElement: _getActiveViewportEnabledElement,
-    setViewportActive: _ref6 => {
-      let {
-        viewportId
-      } = _ref6;
+    setViewportActive: ({
+      viewportId
+    }) => {
       const viewportInfo = cornerstoneViewportService.getViewportInfo(viewportId);
       if (!viewportInfo) {
         console.warn('No viewport found for viewportId:', viewportId);
@@ -5034,11 +4988,10 @@ function commandsModule(_ref) {
       }
       viewportGridService.setActiveViewportId(viewportId);
     },
-    arrowTextCallback: _ref7 => {
-      let {
-        callback,
-        data
-      } = _ref7;
+    arrowTextCallback: ({
+      callback,
+      data
+    }) => {
       utils_callInputDialog(uiDialogService, data, callback);
     },
     cleanUpCrosshairs: () => {
@@ -5075,12 +5028,11 @@ function commandsModule(_ref) {
         isPlaying: false
       }));
     },
-    setWindowLevel(_ref8) {
-      let {
-        window,
-        level,
-        toolGroupId
-      } = _ref8;
+    setWindowLevel({
+      window,
+      level,
+      toolGroupId
+    }) {
       // convert to numbers
       const windowWidthNum = Number(window);
       const windowCenterNum = Number(level);
@@ -5118,12 +5070,11 @@ function commandsModule(_ref) {
     setToolbarToggled: props => {
       toolbarService.setToggled(props.toolId, props.isActive ?? true);
     },
-    setToolActive: _ref9 => {
-      let {
-        toolName,
-        toolGroupId = null,
-        toggledState
-      } = _ref9;
+    setToolActive: ({
+      toolName,
+      toolGroupId = null,
+      toggledState
+    }) => {
       if (toolName === 'Crosshairs') {
         const activeViewportToolGroup = toolGroupService.getToolGroup(null);
         if (!activeViewportToolGroup._toolInstances.Crosshairs) {
@@ -5208,10 +5159,9 @@ function commandsModule(_ref) {
         });
       }
     },
-    rotateViewport: _ref10 => {
-      let {
-        rotation
-      } = _ref10;
+    rotateViewport: ({
+      rotation
+    }) => {
       const enabledElement = _getActiveViewportEnabledElement();
       if (!enabledElement) {
         return;
@@ -5274,10 +5224,9 @@ function commandsModule(_ref) {
         viewport.render();
       }
     },
-    invertViewport: _ref11 => {
-      let {
-        element
-      } = _ref11;
+    invertViewport: ({
+      element
+    }) => {
       let enabledElement;
       if (element === undefined) {
         enabledElement = _getActiveViewportEnabledElement();
@@ -5310,10 +5259,9 @@ function commandsModule(_ref) {
       viewport.resetCamera();
       viewport.render();
     },
-    scaleViewport: _ref12 => {
-      let {
-        direction
-      } = _ref12;
+    scaleViewport: ({
+      direction
+    }) => {
       const enabledElement = _getActiveViewportEnabledElement();
       const scaleFactor = direction > 0 ? 0.9 : 1.1;
       if (!enabledElement) {
@@ -5338,11 +5286,10 @@ function commandsModule(_ref) {
       }
     },
     /** Jumps the active viewport or the specified one to the given slice index */
-    jumpToImage: _ref13 => {
-      let {
-        imageIndex,
-        viewport: gridViewport
-      } = _ref13;
+    jumpToImage: ({
+      imageIndex,
+      viewport: gridViewport
+    }) => {
       // Get current active viewport (return if none active)
       let viewport;
       if (!gridViewport) {
@@ -5376,10 +5323,9 @@ function commandsModule(_ref) {
       };
       dist_esm.utilities.jumpToSlice(viewport.element, options);
     },
-    scroll: _ref14 => {
-      let {
-        direction
-      } = _ref14;
+    scroll: ({
+      direction
+    }) => {
       const enabledElement = _getActiveViewportEnabledElement();
       if (!enabledElement) {
         return;
@@ -5392,13 +5338,12 @@ function commandsModule(_ref) {
       };
       dist_esm.utilities.scroll(viewport, options);
     },
-    setViewportColormap: _ref15 => {
-      let {
-        viewportId,
-        displaySetInstanceUID,
-        colormap,
-        immediate = false
-      } = _ref15;
+    setViewportColormap: ({
+      viewportId,
+      displaySetInstanceUID,
+      colormap,
+      immediate = false
+    }) => {
       const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
       const actorEntries = viewport.getActors();
       const actorEntry = actorEntries.find(actorEntry => {
@@ -5416,10 +5361,9 @@ function commandsModule(_ref) {
         viewport.render();
       }
     },
-    changeActiveViewport: _ref16 => {
-      let {
-        direction = 1
-      } = _ref16;
+    changeActiveViewport: ({
+      direction = 1
+    }) => {
       const {
         activeViewportId,
         viewports
@@ -5429,20 +5373,18 @@ function commandsModule(_ref) {
       const nextViewportIndex = (currentIndex + direction + viewportIds.length) % viewportIds.length;
       viewportGridService.setActiveViewportId(viewportIds[nextViewportIndex]);
     },
-    toggleStackImageSync: _ref17 => {
-      let {
-        toggledState
-      } = _ref17;
+    toggleStackImageSync: ({
+      toggledState
+    }) => {
       toggleStackImageSync({
         servicesManager,
         toggledState
       });
     },
-    setSourceViewportForReferenceLinesTool: _ref18 => {
-      let {
-        toggledState,
-        viewportId
-      } = _ref18;
+    setSourceViewportForReferenceLinesTool: ({
+      toggledState,
+      viewportId
+    }) => {
       if (!viewportId) {
         const {
           activeViewportId
@@ -5455,20 +5397,17 @@ function commandsModule(_ref) {
       }, true // overwrite
       );
     },
-
-    storePresentation: _ref19 => {
-      let {
-        viewportId
-      } = _ref19;
+    storePresentation: ({
+      viewportId
+    }) => {
       cornerstoneViewportService.storePresentation({
         viewportId
       });
     },
-    attachProtocolViewportDataListener: _ref20 => {
-      let {
-        protocol,
-        stageIndex
-      } = _ref20;
+    attachProtocolViewportDataListener: ({
+      protocol,
+      stageIndex
+    }) => {
       const EVENT = cornerstoneViewportService.EVENTS.VIEWPORT_DATA_CHANGED;
       const command = protocol.callbacks.onViewportDataInitialized;
       const numPanes = protocol.stages?.[stageIndex]?.viewports.length ?? 1;
@@ -5644,35 +5583,19 @@ function commandsModule(_ref) {
   };
 }
 /* harmony default export */ const src_commandsModule = (commandsModule);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/getHangingProtocolModule.ts
-const mpr = {
-  id: 'mpr',
-  name: 'Multi-Planar Reconstruction',
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/hps/fourUp.ts
+const fourUp = {
+  id: 'fourUp',
   locked: true,
-  createdDate: '2021-02-23',
-  modifiedDate: '2023-08-15',
+  name: 'fourUp',
+  createdDate: '2023-03-15T10:29:44.894Z',
+  modifiedDate: '2023-03-15T10:29:44.894Z',
   availableTo: {},
   editableBy: {},
-  // Unknown number of priors referenced - so just match any study
-  numberOfPriorsReferenced: 0,
   protocolMatchingRules: [],
-  imageLoadStrategy: 'nth',
-  callbacks: {
-    // Switches out of MPR mode when the layout change button is used
-    onLayoutChange: [{
-      commandName: 'toggleHangingProtocol',
-      commandOptions: {
-        protocolId: 'mpr'
-      },
-      context: 'DEFAULT'
-    }],
-    // Turns off crosshairs when switching out of MPR mode
-    onProtocolExit: [{
-      commandName: 'cleanUpCrosshairs'
-    }]
-  },
+  imageLoadStrategy: 'interleaveCenter',
   displaySetSelectors: {
-    activeDisplaySet: {
+    mprDisplaySet: {
       seriesMatchingRules: [{
         weight: 1,
         attribute: 'isReconstructable',
@@ -5686,33 +5609,17 @@ const mpr = {
     }
   },
   stages: [{
-    name: 'MPR 1x3',
+    id: 'fourUpStage',
+    name: 'fourUp',
     viewportStructure: {
       layoutType: 'grid',
       properties: {
-        rows: 1,
-        columns: 3,
-        layoutOptions: [{
-          x: 0,
-          y: 0,
-          width: 1 / 3,
-          height: 1
-        }, {
-          x: 1 / 3,
-          y: 0,
-          width: 1 / 3,
-          height: 1
-        }, {
-          x: 2 / 3,
-          y: 0,
-          width: 1 / 3,
-          height: 1
-        }]
+        rows: 2,
+        columns: 2
       }
     },
     viewports: [{
       viewportOptions: {
-        viewportId: 'mpr-axial',
         toolGroupId: 'mpr',
         viewportType: 'volume',
         orientation: 'axial',
@@ -5727,14 +5634,29 @@ const mpr = {
         }]
       },
       displaySets: [{
-        id: 'activeDisplaySet'
+        id: 'mprDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'volume3d',
+        viewportType: 'volume3d',
+        orientation: 'coronal',
+        customViewportProps: {
+          hideOverlays: true
+        }
+      },
+      displaySets: [{
+        id: 'mprDisplaySet',
+        options: {
+          // ToDo: choose appropriate preset
+          displayPreset: 'CT-Bone'
+        }
       }]
     }, {
       viewportOptions: {
-        viewportId: 'mpr-sagittal',
         toolGroupId: 'mpr',
         viewportType: 'volume',
-        orientation: 'sagittal',
+        orientation: 'coronal',
         initialImageOptions: {
           preset: 'middle'
         },
@@ -5746,14 +5668,13 @@ const mpr = {
         }]
       },
       displaySets: [{
-        id: 'activeDisplaySet'
+        id: 'mprDisplaySet'
       }]
     }, {
       viewportOptions: {
-        viewportId: 'mpr-coronal',
         toolGroupId: 'mpr',
         viewportType: 'volume',
-        orientation: 'coronal',
+        orientation: 'sagittal',
         initialImageOptions: {
           preset: 'middle'
         },
@@ -5765,15 +5686,16 @@ const mpr = {
         }]
       },
       displaySets: [{
-        id: 'activeDisplaySet'
+        id: 'mprDisplaySet'
       }]
     }]
   }]
 };
-const mprAnd3DVolumeViewport = {
-  id: 'mprAnd3DVolumeViewport',
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/hps/main3D.ts
+const main3D = {
+  id: 'main3D',
   locked: true,
-  name: 'mpr',
+  name: 'main3D',
   createdDate: '2023-03-15T10:29:44.894Z',
   modifiedDate: '2023-03-15T10:29:44.894Z',
   availableTo: {},
@@ -5791,28 +5713,57 @@ const mprAnd3DVolumeViewport = {
           }
         },
         required: true
-      }, {
-        attribute: 'Modality',
-        constraint: {
-          equals: {
-            value: 'CT'
-          }
-        },
-        required: true
       }]
     }
   },
   stages: [{
-    id: 'mpr3Stage',
-    name: 'mpr',
+    id: 'main3DStage',
+    name: 'main3D',
     viewportStructure: {
       layoutType: 'grid',
       properties: {
         rows: 2,
-        columns: 2
+        columns: 3,
+        layoutOptions: [{
+          x: 0,
+          y: 0,
+          width: 1,
+          height: 1 / 2
+        }, {
+          x: 0,
+          y: 1 / 2,
+          width: 1 / 3,
+          height: 1 / 2
+        }, {
+          x: 1 / 3,
+          y: 1 / 2,
+          width: 1 / 3,
+          height: 1 / 2
+        }, {
+          x: 2 / 3,
+          y: 1 / 2,
+          width: 1 / 3,
+          height: 1 / 2
+        }]
       }
     },
     viewports: [{
+      viewportOptions: {
+        toolGroupId: 'volume3d',
+        viewportType: 'volume3d',
+        orientation: 'coronal',
+        customViewportProps: {
+          hideOverlays: true
+        }
+      },
+      displaySets: [{
+        id: 'mprDisplaySet',
+        options: {
+          // ToDo: choose appropriate preset
+          displayPreset: 'CT-Bone'
+        }
+      }]
+    }, {
       viewportOptions: {
         toolGroupId: 'mpr',
         viewportType: 'volume',
@@ -5830,21 +5781,6 @@ const mprAnd3DVolumeViewport = {
       displaySets: [{
         id: 'mprDisplaySet'
       }]
-    }, {
-      viewportOptions: {
-        toolGroupId: 'volume3d',
-        viewportType: 'volume3d',
-        orientation: 'coronal',
-        customViewportProps: {
-          hideOverlays: true
-        }
-      },
-      displaySets: [{
-        id: 'mprDisplaySet',
-        options: {
-          displayPreset: 'CT-Bone'
-        }
-      }]
     }, {
       viewportOptions: {
         toolGroupId: 'mpr',
@@ -5884,55 +5820,611 @@ const mprAnd3DVolumeViewport = {
     }]
   }]
 };
-function getHangingProtocolModule() {
-  return [{
-    name: mpr.id,
-    protocol: mpr
-  }, {
-    name: mprAnd3DVolumeViewport.id,
-    protocol: mprAnd3DVolumeViewport
-  }];
-}
-/* harmony default export */ const src_getHangingProtocolModule = (getHangingProtocolModule);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ToolGroupService/ToolGroupService.ts
-
-
-
-const ToolGroupService_EVENTS = {
-  VIEWPORT_ADDED: 'event::cornerstone::toolgroupservice:viewportadded',
-  TOOLGROUP_CREATED: 'event::cornerstone::toolgroupservice:toolgroupcreated'
-};
-class ToolGroupService {
-  constructor(serviceManager) {
-    this.serviceManager = void 0;
-    this.toolGroupIds = new Set();
-    /**
-     * Service-specific
-     */
-    this.listeners = void 0;
-    this.EVENTS = void 0;
-    const {
-      cornerstoneViewportService,
-      viewportGridService
-    } = serviceManager.services;
-    this.cornerstoneViewportService = cornerstoneViewportService;
-    this.viewportGridService = viewportGridService;
-    this.listeners = {};
-    this.EVENTS = ToolGroupService_EVENTS;
-    Object.assign(this, src/* pubSubServiceInterface */.KZ);
-  }
-  onModeExit() {
-    this.destroy();
-  }
-
-  /**
-   * Retrieves a tool group from the ToolGroupManager by tool group ID.
-   * If no tool group ID is provided, it retrieves the tool group of the active viewport.
-   * @param toolGroupId - Optional ID of the tool group to retrieve.
-   * @returns The tool group or undefined if it is not found.
-   */
-  getToolGroup(toolGroupId) {
-    let toolGroupIdToUse = toolGroupId;
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/hps/mpr.ts
+const mpr = {
+  id: 'mpr',
+  name: 'Multi-Planar Reconstruction',
+  locked: true,
+  createdDate: '2021-02-23',
+  modifiedDate: '2023-08-15',
+  availableTo: {},
+  editableBy: {},
+  // Unknown number of priors referenced - so just match any study
+  numberOfPriorsReferenced: 0,
+  protocolMatchingRules: [],
+  imageLoadStrategy: 'nth',
+  callbacks: {
+    // Switches out of MPR mode when the layout change button is used
+    onLayoutChange: [{
+      commandName: 'toggleHangingProtocol',
+      commandOptions: {
+        protocolId: 'mpr'
+      },
+      context: 'DEFAULT'
+    }],
+    // Turns off crosshairs when switching out of MPR mode
+    onProtocolExit: [{
+      commandName: 'cleanUpCrosshairs'
+    }]
+  },
+  displaySetSelectors: {
+    activeDisplaySet: {
+      seriesMatchingRules: [{
+        weight: 1,
+        attribute: 'isReconstructable',
+        constraint: {
+          equals: {
+            value: true
+          }
+        },
+        required: true
+      }]
+    }
+  },
+  stages: [{
+    name: 'MPR 1x3',
+    viewportStructure: {
+      layoutType: 'grid',
+      properties: {
+        rows: 1,
+        columns: 3,
+        layoutOptions: [{
+          x: 0,
+          y: 0,
+          width: 1 / 3,
+          height: 1
+        }, {
+          x: 1 / 3,
+          y: 0,
+          width: 1 / 3,
+          height: 1
+        }, {
+          x: 2 / 3,
+          y: 0,
+          width: 1 / 3,
+          height: 1
+        }]
+      }
+    },
+    viewports: [{
+      viewportOptions: {
+        viewportId: 'mpr-axial',
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'axial',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'activeDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        viewportId: 'mpr-sagittal',
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'sagittal',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'activeDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        viewportId: 'mpr-coronal',
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'coronal',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'activeDisplaySet'
+      }]
+    }]
+  }]
+};
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/hps/mprAnd3DVolumeViewport.ts
+const mprAnd3DVolumeViewport = {
+  id: 'mprAnd3DVolumeViewport',
+  locked: true,
+  name: 'mpr',
+  createdDate: '2023-03-15T10:29:44.894Z',
+  modifiedDate: '2023-03-15T10:29:44.894Z',
+  availableTo: {},
+  editableBy: {},
+  protocolMatchingRules: [],
+  imageLoadStrategy: 'interleaveCenter',
+  displaySetSelectors: {
+    mprDisplaySet: {
+      seriesMatchingRules: [{
+        weight: 1,
+        attribute: 'isReconstructable',
+        constraint: {
+          equals: {
+            value: true
+          }
+        },
+        required: true
+      }, {
+        attribute: 'Modality',
+        constraint: {
+          equals: {
+            value: 'CT'
+          }
+        },
+        required: true
+      }]
+    }
+  },
+  stages: [{
+    id: 'mpr3Stage',
+    name: 'mpr',
+    viewportStructure: {
+      layoutType: 'grid',
+      properties: {
+        rows: 2,
+        columns: 2
+      }
+    },
+    viewports: [{
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'axial',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'volume3d',
+        viewportType: 'volume3d',
+        orientation: 'coronal',
+        customViewportProps: {
+          hideOverlays: true
+        }
+      },
+      displaySets: [{
+        id: 'mprDisplaySet',
+        options: {
+          displayPreset: 'CT-Bone'
+        }
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'coronal',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'sagittal',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }]
+  }]
+};
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/hps/only3D.ts
+const only3D = {
+  id: 'only3D',
+  locked: true,
+  name: 'only3D',
+  createdDate: '2023-03-15T10:29:44.894Z',
+  modifiedDate: '2023-03-15T10:29:44.894Z',
+  availableTo: {},
+  editableBy: {},
+  protocolMatchingRules: [],
+  imageLoadStrategy: 'interleaveCenter',
+  displaySetSelectors: {
+    mprDisplaySet: {
+      seriesMatchingRules: [{
+        weight: 1,
+        attribute: 'isReconstructable',
+        constraint: {
+          equals: {
+            value: true
+          }
+        },
+        required: true
+      }]
+    }
+  },
+  stages: [{
+    id: 'only3DStage',
+    name: 'only3D',
+    viewportStructure: {
+      layoutType: 'grid',
+      properties: {
+        rows: 1,
+        columns: 1
+      }
+    },
+    viewports: [{
+      viewportOptions: {
+        toolGroupId: 'volume3d',
+        viewportType: 'volume3d',
+        orientation: 'coronal',
+        customViewportProps: {
+          hideOverlays: true
+        }
+      },
+      displaySets: [{
+        id: 'mprDisplaySet',
+        options: {
+          // ToDo: choose appropriate preset
+          displayPreset: 'CT-Bone'
+        }
+      }]
+    }]
+  }]
+};
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/hps/primary3D.ts
+const primary3D = {
+  id: 'primary3D',
+  locked: true,
+  name: 'primary3D',
+  createdDate: '2023-03-15T10:29:44.894Z',
+  modifiedDate: '2023-03-15T10:29:44.894Z',
+  availableTo: {},
+  editableBy: {},
+  protocolMatchingRules: [],
+  imageLoadStrategy: 'interleaveCenter',
+  displaySetSelectors: {
+    mprDisplaySet: {
+      seriesMatchingRules: [{
+        weight: 1,
+        attribute: 'isReconstructable',
+        constraint: {
+          equals: {
+            value: true
+          }
+        },
+        required: true
+      }]
+    }
+  },
+  stages: [{
+    id: 'primary3DStage',
+    name: 'primary3D',
+    viewportStructure: {
+      layoutType: 'grid',
+      properties: {
+        rows: 3,
+        columns: 3,
+        layoutOptions: [{
+          x: 0,
+          y: 0,
+          width: 2 / 3,
+          height: 1
+        }, {
+          x: 2 / 3,
+          y: 0,
+          width: 1 / 3,
+          height: 1 / 3
+        }, {
+          x: 2 / 3,
+          y: 1 / 3,
+          width: 1 / 3,
+          height: 1 / 3
+        }, {
+          x: 2 / 3,
+          y: 2 / 3,
+          width: 1 / 3,
+          height: 1 / 3
+        }]
+      }
+    },
+    viewports: [{
+      viewportOptions: {
+        toolGroupId: 'volume3d',
+        viewportType: 'volume3d',
+        orientation: 'coronal',
+        customViewportProps: {
+          hideOverlays: true
+        }
+      },
+      displaySets: [{
+        id: 'mprDisplaySet',
+        options: {
+          // ToDo: choose appropriate preset
+          displayPreset: 'CT-Bone'
+        }
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'axial',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'coronal',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'sagittal',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }]
+  }]
+};
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/hps/primaryAxial.ts
+const primaryAxial = {
+  id: 'primaryAxial',
+  locked: true,
+  name: 'primaryAxial',
+  createdDate: '2023-03-15T10:29:44.894Z',
+  modifiedDate: '2023-03-15T10:29:44.894Z',
+  availableTo: {},
+  editableBy: {},
+  protocolMatchingRules: [],
+  imageLoadStrategy: 'interleaveCenter',
+  displaySetSelectors: {
+    mprDisplaySet: {
+      seriesMatchingRules: [{
+        weight: 1,
+        attribute: 'isReconstructable',
+        constraint: {
+          equals: {
+            value: true
+          }
+        },
+        required: true
+      }]
+    }
+  },
+  stages: [{
+    id: 'primaryAxialStage',
+    name: 'primaryAxial',
+    viewportStructure: {
+      layoutType: 'grid',
+      properties: {
+        rows: 2,
+        columns: 3,
+        layoutOptions: [{
+          x: 0,
+          y: 0,
+          width: 2 / 3,
+          height: 1
+        }, {
+          x: 2 / 3,
+          y: 0,
+          width: 1 / 3,
+          height: 1 / 2
+        }, {
+          x: 2 / 3,
+          y: 1 / 2,
+          width: 1 / 3,
+          height: 1 / 2
+        }]
+      }
+    },
+    viewports: [{
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'axial',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'sagittal',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }, {
+      viewportOptions: {
+        toolGroupId: 'mpr',
+        viewportType: 'volume',
+        orientation: 'coronal',
+        initialImageOptions: {
+          preset: 'middle'
+        },
+        syncGroups: [{
+          type: 'voi',
+          id: 'mpr',
+          source: true,
+          target: true
+        }]
+      },
+      displaySets: [{
+        id: 'mprDisplaySet'
+      }]
+    }]
+  }]
+};
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/getHangingProtocolModule.ts
+
+
+
+
+
+
+
+function getHangingProtocolModule() {
+  return [{
+    name: mpr.id,
+    protocol: mpr
+  }, {
+    name: mprAnd3DVolumeViewport.id,
+    protocol: mprAnd3DVolumeViewport
+  }, {
+    name: fourUp.id,
+    protocol: fourUp
+  }, {
+    name: main3D.id,
+    protocol: main3D
+  }, {
+    name: primaryAxial.id,
+    protocol: primaryAxial
+  }, {
+    name: only3D.id,
+    protocol: only3D
+  }, {
+    name: primary3D.id,
+    protocol: primary3D
+  }];
+}
+/* harmony default export */ const src_getHangingProtocolModule = (getHangingProtocolModule);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ToolGroupService/ToolGroupService.ts
+var _class;
+
+
+
+const ToolGroupService_EVENTS = {
+  VIEWPORT_ADDED: 'event::cornerstone::toolgroupservice:viewportadded',
+  TOOLGROUP_CREATED: 'event::cornerstone::toolgroupservice:toolgroupcreated'
+};
+class ToolGroupService {
+  constructor(serviceManager) {
+    this.serviceManager = void 0;
+    this.toolGroupIds = new Set();
+    /**
+     * Service-specific
+     */
+    this.listeners = void 0;
+    this.EVENTS = void 0;
+    const {
+      cornerstoneViewportService,
+      viewportGridService
+    } = serviceManager.services;
+    this.cornerstoneViewportService = cornerstoneViewportService;
+    this.viewportGridService = viewportGridService;
+    this.listeners = {};
+    this.EVENTS = ToolGroupService_EVENTS;
+    Object.assign(this, src/* pubSubServiceInterface */.KZ);
+  }
+  onModeExit() {
+    this.destroy();
+  }
+
+  /**
+   * Retrieves a tool group from the ToolGroupManager by tool group ID.
+   * If no tool group ID is provided, it retrieves the tool group of the active viewport.
+   * @param toolGroupId - Optional ID of the tool group to retrieve.
+   * @returns The tool group or undefined if it is not found.
+   */
+  getToolGroup(toolGroupId) {
+    let toolGroupIdToUse = toolGroupId;
     if (!toolGroupIdToUse) {
       // Use the active viewport's tool group if no tool group id is provided
       const enabledElement = getActiveViewportEnabledElement(this.viewportGridService);
@@ -6018,8 +6510,7 @@ class ToolGroupService {
     });
     return toolGroup;
   }
-  addToolsToToolGroup(toolGroupId, tools) {
-    let configs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  addToolsToToolGroup(toolGroupId, tools, configs = {}) {
     const toolGroup = dist_esm.ToolGroupManager.getToolGroup(toolGroupId);
     // this.changeConfigurationIfNecessary(toolGroup, volumeId);
     this._addTools(toolGroup, tools, configs);
@@ -6081,49 +6572,44 @@ class ToolGroupService {
       disabled
     } = tools;
     if (active) {
-      active.forEach(_ref => {
-        let {
-          toolName,
-          bindings
-        } = _ref;
+      active.forEach(({
+        toolName,
+        bindings
+      }) => {
         toolGroup.setToolActive(toolName, {
           bindings
         });
       });
     }
     if (passive) {
-      passive.forEach(_ref2 => {
-        let {
-          toolName
-        } = _ref2;
+      passive.forEach(({
+        toolName
+      }) => {
         toolGroup.setToolPassive(toolName);
       });
     }
     if (enabled) {
-      enabled.forEach(_ref3 => {
-        let {
-          toolName
-        } = _ref3;
+      enabled.forEach(({
+        toolName
+      }) => {
         toolGroup.setToolEnabled(toolName);
       });
     }
     if (disabled) {
-      disabled.forEach(_ref4 => {
-        let {
-          toolName
-        } = _ref4;
+      disabled.forEach(({
+        toolName
+      }) => {
         toolGroup.setToolDisabled(toolName);
       });
     }
   }
   _addTools(toolGroup, tools) {
     const addTools = tools => {
-      tools.forEach(_ref5 => {
-        let {
-          toolName,
-          parentTool,
-          configuration
-        } = _ref5;
+      tools.forEach(({
+        toolName,
+        parentTool,
+        configuration
+      }) => {
         if (parentTool) {
           toolGroup.addToolInstance(toolName, parentTool, {
             ...configuration
@@ -6149,20 +6635,21 @@ class ToolGroupService {
     }
   }
 }
+_class = ToolGroupService;
 ToolGroupService.REGISTRATION = {
   name: 'toolGroupService',
   altName: 'ToolGroupService',
-  create: _ref6 => {
-    let {
-      servicesManager
-    } = _ref6;
-    return new ToolGroupService(servicesManager);
+  create: ({
+    servicesManager
+  }) => {
+    return new _class(servicesManager);
   }
 };
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ToolGroupService/index.js
 
 /* harmony default export */ const services_ToolGroupService = (ToolGroupService);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/SyncGroupService/SyncGroupService.ts
+var SyncGroupService_class;
 
 
 const SyncGroupService_EVENTS = {
@@ -6276,14 +6763,14 @@ class SyncGroupService {
     });
   }
 }
+SyncGroupService_class = SyncGroupService;
 SyncGroupService.REGISTRATION = {
   name: 'syncGroupService',
   altName: 'SyncGroupService',
-  create: _ref => {
-    let {
-      servicesManager
-    } = _ref;
-    return new SyncGroupService(servicesManager);
+  create: ({
+    servicesManager
+  }) => {
+    return new SyncGroupService_class(servicesManager);
   }
 };
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/SyncGroupService/index.js
@@ -6343,24 +6830,21 @@ function reverseEaseInOutBell(x, baseline) {
  * and geometry Id
  */
 function mapROIContoursToRTStructData(structureSet, rtDisplaySetUID) {
-  return structureSet.ROIContours.map(_ref => {
-    let {
-      contourPoints,
-      ROINumber,
-      ROIName,
-      colorArray
-    } = _ref;
-    const data = contourPoints.map(_ref2 => {
-      let {
-        points,
-        ...rest
-      } = _ref2;
-      const newPoints = points.map(_ref3 => {
-        let {
-          x,
-          y,
-          z
-        } = _ref3;
+  return structureSet.ROIContours.map(({
+    contourPoints,
+    ROINumber,
+    ROIName,
+    colorArray
+  }) => {
+    const data = contourPoints.map(({
+      points,
+      ...rest
+    }) => {
+      const newPoints = points.map(({
+        x,
+        y,
+        z
+      }) => {
         return [x, y, z];
       });
       return {
@@ -6379,6 +6863,7 @@ function mapROIContoursToRTStructData(structureSet, rtDisplaySetUID) {
   });
 }
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
+var SegmentationService_class;
 
 
 
@@ -6415,13 +6900,10 @@ const SEGMENT_CONSTANT = {
 };
 const VOLUME_LOADER_SCHEME = 'cornerstoneStreamingImageVolume';
 class SegmentationService extends src/* PubSubService */.hC {
-  constructor(_ref) {
-    var _this;
-    let {
-      servicesManager
-    } = _ref;
+  constructor({
+    servicesManager
+  }) {
     super(SegmentationService_EVENTS);
-    _this = this;
     this.segmentations = void 0;
     this.servicesManager = void 0;
     this.highlightIntervalId = null;
@@ -6562,7 +7044,6 @@ class SegmentationService extends src/* PubSubService */.hC {
           }
         }
       };
-
       this.addOrUpdateSegmentation(segmentation);
       return segmentationId;
     };
@@ -6575,11 +7056,8 @@ class SegmentationService extends src/* PubSubService */.hC {
     this.toggleSegmentationVisibility = segmentationId => {
       this._toggleSegmentationVisibility(segmentationId, false);
     };
-    this.addSegmentationRepresentationToToolGroup = async function (toolGroupId, segmentationId) {
-      let hydrateSegmentation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      let representationType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : dist_esm.Enums.SegmentationRepresentations.Labelmap;
-      let suppressEvents = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-      const segmentation = _this.getSegmentation(segmentationId);
+    this.addSegmentationRepresentationToToolGroup = async (toolGroupId, segmentationId, hydrateSegmentation = false, representationType = dist_esm.Enums.SegmentationRepresentations.Labelmap, suppressEvents = false) => {
+      const segmentation = this.getSegmentation(segmentationId);
       if (!segmentation) {
         throw new Error(`Segmentation with segmentationId ${segmentationId} not found.`);
       }
@@ -6598,7 +7076,7 @@ class SegmentationService extends src/* PubSubService */.hC {
       }]);
 
       // set the latest segmentation representation as active one
-      _this._setActiveSegmentationForToolGroup(segmentationId, toolGroupId, segmentationRepresentationUIDs[0]);
+      this._setActiveSegmentationForToolGroup(segmentationId, toolGroupId, segmentationRepresentationUIDs[0]);
       dist_esm.segmentation.config.color.setColorLUT(toolGroupId, segmentationRepresentationUIDs[0], colorLUTIndex);
 
       // add the segmentation segments properly
@@ -6615,20 +7093,20 @@ class SegmentationService extends src/* PubSubService */.hC {
         } = segment;
         const suppressEvents = true;
         if (color !== undefined) {
-          _this._setSegmentColor(segmentationId, segmentIndex, color, toolGroupId, suppressEvents);
+          this._setSegmentColor(segmentationId, segmentIndex, color, toolGroupId, suppressEvents);
         }
         if (opacity !== undefined) {
-          _this._setSegmentOpacity(segmentationId, segmentIndex, opacity, toolGroupId, suppressEvents);
+          this._setSegmentOpacity(segmentationId, segmentIndex, opacity, toolGroupId, suppressEvents);
         }
         if (visibility !== undefined) {
-          _this._setSegmentVisibility(segmentationId, segmentIndex, visibility, toolGroupId, suppressEvents);
+          this._setSegmentVisibility(segmentationId, segmentIndex, visibility, toolGroupId, suppressEvents);
         }
         if (isLocked) {
-          _this._setSegmentLocked(segmentationId, segmentIndex, isLocked, suppressEvents);
+          this._setSegmentLocked(segmentationId, segmentIndex, isLocked, suppressEvents);
         }
       }
       if (!suppressEvents) {
-        _this._broadcastEvent(_this.EVENTS.SEGMENTATION_UPDATED, {
+        this._broadcastEvent(this.EVENTS.SEGMENTATION_UPDATED, {
           segmentation
         });
       }
@@ -6652,18 +7130,17 @@ class SegmentationService extends src/* PubSubService */.hC {
       const toolGroupIds = dist_esm.segmentation.state.getToolGroupIdsWithSegmentation(segmentationId);
       return toolGroupIds;
     };
-    this.hydrateSegmentation = function (segmentationId) {
-      let suppressEvents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      const segmentation = _this.getSegmentation(segmentationId);
+    this.hydrateSegmentation = (segmentationId, suppressEvents = false) => {
+      const segmentation = this.getSegmentation(segmentationId);
       if (!segmentation) {
         throw new Error(`Segmentation with segmentationId ${segmentationId} not found.`);
       }
       segmentation.hydrated = true;
 
       // Not all segmentations have dipslaysets, some of them are derived in the client
-      _this._setDisplaySetIsHydrated(segmentationId, true);
+      this._setDisplaySetIsHydrated(segmentationId, true);
       if (!suppressEvents) {
-        _this._broadcastEvent(_this.EVENTS.SEGMENTATION_UPDATED, {
+        this._broadcastEvent(this.EVENTS.SEGMENTATION_UPDATED, {
           segmentation
         });
       }
@@ -6721,11 +7198,10 @@ class SegmentationService extends src/* PubSubService */.hC {
         renderInactiveSegmentations,
         renderOutline
       } = configuration;
-      const setConfigValueIfDefined = function (key, value) {
-        let transformFn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      const setConfigValueIfDefined = (key, value, transformFn = null) => {
         if (value !== undefined) {
           const transformedValue = transformFn ? transformFn(value) : value;
-          _this._setSegmentationConfig(key, transformedValue);
+          this._setSegmentationConfig(key, transformedValue);
         }
       };
       setConfigValueIfDefined('renderOutline', renderOutline);
@@ -6772,32 +7248,30 @@ class SegmentationService extends src/* PubSubService */.hC {
     this.getSegmentationRepresentationsForToolGroup = toolGroupId => {
       return dist_esm.segmentation.state.getSegmentationRepresentations(toolGroupId);
     };
-    this._toggleSegmentationVisibility = function (segmentationId) {
-      let suppressEvents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      const segmentation = _this.segmentations[segmentationId];
+    this._toggleSegmentationVisibility = (segmentationId, suppressEvents = false) => {
+      const segmentation = this.segmentations[segmentationId];
       if (!segmentation) {
         throw new Error(`Segmentation with segmentationId ${segmentationId} not found.`);
       }
       segmentation.isVisible = !segmentation.isVisible;
-      _this._updateCornerstoneSegmentationVisibility(segmentationId);
+      this._updateCornerstoneSegmentationVisibility(segmentationId);
       if (suppressEvents === false) {
-        _this._broadcastEvent(_this.EVENTS.SEGMENTATION_UPDATED, {
+        this._broadcastEvent(this.EVENTS.SEGMENTATION_UPDATED, {
           segmentation
         });
       }
     };
-    this._setSegmentColor = function (segmentationId, segmentIndex, color, toolGroupId) {
-      let suppressEvents = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-      const segmentation = _this.getSegmentation(segmentationId);
+    this._setSegmentColor = (segmentationId, segmentIndex, color, toolGroupId, suppressEvents = false) => {
+      const segmentation = this.getSegmentation(segmentationId);
       if (segmentation === undefined) {
         throw new Error(`no segmentation for segmentationId: ${segmentationId}`);
       }
-      const segmentInfo = _this._getSegmentInfo(segmentation, segmentIndex);
+      const segmentInfo = this._getSegmentInfo(segmentation, segmentIndex);
       if (segmentInfo === undefined) {
         throw new Error(`Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`);
       }
-      toolGroupId = toolGroupId ?? _this._getApplicableToolGroupId();
-      const segmentationRepresentation = _this._getSegmentationRepresentation(segmentationId, toolGroupId);
+      toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
+      const segmentationRepresentation = this._getSegmentationRepresentation(segmentationId, toolGroupId);
       if (!segmentationRepresentation) {
         throw new Error('Must add representation to toolgroup before setting segments');
       }
@@ -6808,23 +7282,22 @@ class SegmentationService extends src/* PubSubService */.hC {
       dist_esm.segmentation.config.color.setColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex, [...color, rgbaColor[3]]);
       segmentInfo.color = color;
       if (suppressEvents === false) {
-        _this._broadcastEvent(_this.EVENTS.SEGMENTATION_UPDATED, {
+        this._broadcastEvent(this.EVENTS.SEGMENTATION_UPDATED, {
           segmentation
         });
       }
     };
-    this._setSegmentOpacity = function (segmentationId, segmentIndex, opacity, toolGroupId) {
-      let suppressEvents = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-      const segmentation = _this.getSegmentation(segmentationId);
+    this._setSegmentOpacity = (segmentationId, segmentIndex, opacity, toolGroupId, suppressEvents = false) => {
+      const segmentation = this.getSegmentation(segmentationId);
       if (segmentation === undefined) {
         throw new Error(`no segmentation for segmentationId: ${segmentationId}`);
       }
-      const segmentInfo = _this._getSegmentInfo(segmentation, segmentIndex);
+      const segmentInfo = this._getSegmentInfo(segmentation, segmentIndex);
       if (segmentInfo === undefined) {
         throw new Error(`Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`);
       }
-      toolGroupId = toolGroupId ?? _this._getApplicableToolGroupId();
-      const segmentationRepresentation = _this._getSegmentationRepresentation(segmentationId, toolGroupId);
+      toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
+      const segmentationRepresentation = this._getSegmentationRepresentation(segmentationId, toolGroupId);
       if (!segmentationRepresentation) {
         throw new Error('Must add representation to toolgroup before setting segments');
       }
@@ -6835,7 +7308,7 @@ class SegmentationService extends src/* PubSubService */.hC {
       dist_esm.segmentation.config.color.setColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex, [rgbaColor[0], rgbaColor[1], rgbaColor[2], opacity]);
       segmentInfo.opacity = opacity;
       if (suppressEvents === false) {
-        _this._broadcastEvent(_this.EVENTS.SEGMENTATION_UPDATED, {
+        this._broadcastEvent(this.EVENTS.SEGMENTATION_UPDATED, {
           segmentation
         });
       }
@@ -6995,8 +7468,7 @@ class SegmentationService extends src/* PubSubService */.hC {
    *     - isLocked: (optional) Whether the new segment should be locked for editing. If not provided, the segment will not be locked by default.
    *     - active: (optional) Whether the new segment should be the active segment to be edited. If not provided, the segment will not be active by default.
    */
-  addSegment(segmentationId) {
-    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  addSegment(segmentationId, config = {}) {
     if (config?.segmentIndex === 0) {
       throw new Error('Segment index 0 is reserved for "no label"');
     }
@@ -7110,8 +7582,7 @@ class SegmentationService extends src/* PubSubService */.hC {
       segmentation
     });
   }
-  setSegmentVisibility(segmentationId, segmentIndex, isVisible, toolGroupId) {
-    let suppressEvents = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  setSegmentVisibility(segmentationId, segmentIndex, isVisible, toolGroupId, suppressEvents = false) {
     this._setSegmentVisibility(segmentationId, segmentIndex, isVisible, toolGroupId, suppressEvents);
   }
   setSegmentLocked(segmentationId, segmentIndex, isLocked) {
@@ -7156,8 +7627,7 @@ class SegmentationService extends src/* PubSubService */.hC {
    *
     * @return Array of segmentations
    */
-  getSegmentations() {
-    let filterNonHydratedSegmentations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  getSegmentations(filterNonHydratedSegmentations = true) {
     const segmentations = this._getSegmentations();
     return segmentations && segmentations.filter(segmentation => {
       return !filterNonHydratedSegmentations || segmentation.hydrated;
@@ -7192,9 +7662,7 @@ class SegmentationService extends src/* PubSubService */.hC {
   getSegmentation(segmentationId) {
     return this.segmentations[segmentationId];
   }
-  addOrUpdateSegmentation(segmentation) {
-    let suppressEvents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    let notYetUpdatedAtSource = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  addOrUpdateSegmentation(segmentation, suppressEvents = false, notYetUpdatedAtSource = false) {
     const {
       id: segmentationId
     } = segmentation;
@@ -7255,8 +7723,7 @@ class SegmentationService extends src/* PubSubService */.hC {
     }
     return cachedSegmentation.id;
   }
-  async createSegmentationForSEGDisplaySet(segDisplaySet, segmentationId) {
-    let suppressEvents = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  async createSegmentationForSEGDisplaySet(segDisplaySet, segmentationId, suppressEvents = false) {
     // Todo: we only support creating labelmap for SEG displaySets for now
     const representationType = LABELMAP;
     segmentationId = segmentationId ?? segDisplaySet.displaySetInstanceUID;
@@ -7362,8 +7829,7 @@ class SegmentationService extends src/* PubSubService */.hC {
     });
     return this.addOrUpdateSegmentation(segmentation, suppressEvents);
   }
-  async createSegmentationForRTDisplaySet(rtDisplaySet, segmentationId) {
-    let suppressEvents = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  async createSegmentationForRTDisplaySet(rtDisplaySet, segmentationId, suppressEvents = false) {
     // Todo: we currently only have support for contour representation for initial
     // RT display
     const representationType = CONTOUR;
@@ -7380,12 +7846,9 @@ class SegmentationService extends src/* PubSubService */.hC {
 
     // sort by segmentIndex
     allRTStructData.sort((a, b) => a.segmentIndex - b.segmentIndex);
-    const geometryIds = allRTStructData.map(_ref2 => {
-      let {
-        geometryId
-      } = _ref2;
-      return geometryId;
-    });
+    const geometryIds = allRTStructData.map(({
+      geometryId
+    }) => geometryId);
     const segmentation = {
       ...defaultScheme,
       id: segmentationId,
@@ -7438,7 +7901,6 @@ class SegmentationService extends src/* PubSubService */.hC {
           },
           modifiedTime: rtDisplaySet.SeriesDate // we use the SeriesDate as the modifiedTime since this is the first time we are creating the segmentation
         };
-
         segmentation.segments[segmentIndex] = {
           label: id,
           segmentIndex,
@@ -7486,12 +7948,8 @@ class SegmentationService extends src/* PubSubService */.hC {
     });
     return this.addOrUpdateSegmentation(segmentation, suppressEvents);
   }
-  jumpToSegmentCenter(segmentationId, segmentIndex, toolGroupId) {
-    let highlightAlpha = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.9;
-    let highlightSegment = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
-    let animationLength = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 750;
-    let highlightHideOthers = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
-    let highlightFunctionType = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 'ease-in-out';
+  jumpToSegmentCenter(segmentationId, segmentIndex, toolGroupId, highlightAlpha = 0.9, highlightSegment = true, animationLength = 750, highlightHideOthers = false, highlightFunctionType = 'ease-in-out' // todo: make animation functions configurable from outside
+  ) {
     const {
       toolGroupService
     } = this.servicesManager.services;
@@ -7531,11 +7989,7 @@ class SegmentationService extends src/* PubSubService */.hC {
       }
     });
   }
-  highlightSegment(segmentationId, segmentIndex, toolGroupId) {
-    let alpha = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.9;
-    let animationLength = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 750;
-    let hideOthers = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
-    let highlightFunctionType = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 'ease-in-out';
+  highlightSegment(segmentationId, segmentIndex, toolGroupId, alpha = 0.9, animationLength = 750, hideOthers = true, highlightFunctionType = 'ease-in-out') {
     if (this.highlightIntervalId) {
       clearInterval(this.highlightIntervalId);
     }
@@ -7681,8 +8135,7 @@ class SegmentationService extends src/* PubSubService */.hC {
   setSegmentLabel(segmentationId, segmentIndex, label) {
     this._setSegmentLabel(segmentationId, segmentIndex, label);
   }
-  _setSegmentLabel(segmentationId, segmentIndex, label) {
-    let suppressEvents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  _setSegmentLabel(segmentationId, segmentIndex, label, suppressEvents = false) {
     const segmentation = this.getSegmentation(segmentationId);
     if (segmentation === undefined) {
       throw new Error(`no segmentation for segmentationId: ${segmentationId}`);
@@ -7738,8 +8191,7 @@ class SegmentationService extends src/* PubSubService */.hC {
       colorLUTIndex: 0
     };
   }
-  _setActiveSegmentationForToolGroup(segmentationId, toolGroupId) {
-    let suppressEvents = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  _setActiveSegmentationForToolGroup(segmentationId, toolGroupId, suppressEvents = false) {
     const segmentations = this._getSegmentations();
     const targetSegmentation = this.getSegmentation(segmentationId);
     if (targetSegmentation === undefined) {
@@ -7756,8 +8208,7 @@ class SegmentationService extends src/* PubSubService */.hC {
       });
     }
   }
-  _setActiveSegment(segmentationId, segmentIndex) {
-    let suppressEvents = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  _setActiveSegment(segmentationId, segmentIndex, suppressEvents = false) {
     const segmentation = this.getSegmentation(segmentationId);
     if (segmentation === undefined) {
       throw new Error(`no segmentation for segmentationId: ${segmentationId}`);
@@ -7805,8 +8256,7 @@ class SegmentationService extends src/* PubSubService */.hC {
     } = segmentCenter[segmentIndex];
     return center;
   }
-  _setSegmentLocked(segmentationId, segmentIndex, isLocked) {
-    let suppressEvents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  _setSegmentLocked(segmentationId, segmentIndex, isLocked, suppressEvents = false) {
     const segmentation = this.getSegmentation(segmentationId);
     if (segmentation === undefined) {
       throw new Error(`no segmentation for segmentationId: ${segmentationId}`);
@@ -7823,8 +8273,7 @@ class SegmentationService extends src/* PubSubService */.hC {
       });
     }
   }
-  _setSegmentVisibility(segmentationId, segmentIndex, isVisible, toolGroupId) {
-    let suppressEvents = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  _setSegmentVisibility(segmentationId, segmentIndex, isVisible, toolGroupId, suppressEvents = false) {
     toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
     const {
       segmentationRepresentationUID,
@@ -7850,8 +8299,7 @@ class SegmentationService extends src/* PubSubService */.hC {
       });
     }
   }
-  _setSegmentLabel(segmentationId, segmentIndex, segmentLabel) {
-    let suppressEvents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  _setSegmentLabel(segmentationId, segmentIndex, segmentLabel, suppressEvents = false) {
     const segmentation = this.getSegmentation(segmentationId);
     if (segmentation === undefined) {
       throw new Error(`no segmentation for segmentationId: ${segmentationId}`);
@@ -7929,11 +8377,10 @@ class SegmentationService extends src/* PubSubService */.hC {
       esm.cache.removeVolumeLoadObject(segmentationId);
     }
   }
-  _updateCornerstoneSegmentations(_ref3) {
-    let {
-      segmentationId,
-      notYetUpdatedAtSource
-    } = _ref3;
+  _updateCornerstoneSegmentations({
+    segmentationId,
+    notYetUpdatedAtSource
+  }) {
     if (notYetUpdatedAtSource === false) {
       return;
     }
@@ -7975,14 +8422,14 @@ class SegmentationService extends src/* PubSubService */.hC {
     return newColorLUT;
   }
 }
+SegmentationService_class = SegmentationService;
 SegmentationService.REGISTRATION = {
   name: 'segmentationService',
   altName: 'SegmentationService',
-  create: _ref4 => {
-    let {
-      servicesManager
-    } = _ref4;
-    return new SegmentationService({
+  create: ({
+    servicesManager
+  }) => {
+    return new SegmentationService_class({
       servicesManager
     });
   }
@@ -8012,6 +8459,7 @@ function getCornerstoneViewportType(viewportType) {
   throw new Error(`Invalid viewport type: ${viewportType}. Valid types are: stack, volume`);
 }
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/CornerstoneCacheService/CornerstoneCacheService.ts
+var CornerstoneCacheService_class;
 
 
 const CornerstoneCacheService_VOLUME_LOADER_SCHEME = 'cornerstoneStreamingImageVolume';
@@ -8065,12 +8513,9 @@ class CornerstoneCacheService {
       esm.cache.removeVolumeLoadObject(volumeId);
       this.volumeImageIds.delete(volumeId);
     }
-    const displaySets = viewportData.data.map(_ref => {
-      let {
-        displaySetInstanceUID
-      } = _ref;
-      return displaySetService.getDisplaySetByUID(displaySetInstanceUID);
-    });
+    const displaySets = viewportData.data.map(({
+      displaySetInstanceUID
+    }) => displaySetService.getDisplaySetByUID(displaySetInstanceUID));
     const newViewportData = await this._getVolumeViewportData(dataSource, displaySets, viewportData.viewportType);
     return newViewportData;
   }
@@ -8157,12 +8602,9 @@ class CornerstoneCacheService {
       segmentationService,
       displaySetService
     } = this.servicesManager.services;
-    const viewportDisplaySetInstanceUIDs = displaySets.map(_ref2 => {
-      let {
-        displaySetInstanceUID
-      } = _ref2;
-      return displaySetInstanceUID;
-    });
+    const viewportDisplaySetInstanceUIDs = displaySets.map(({
+      displaySetInstanceUID
+    }) => displaySetInstanceUID);
 
     // check inside segmentations if any of them are referencing the displaySets
     // that are about to be displayed
@@ -8185,14 +8627,14 @@ class CornerstoneCacheService {
     return stackImageIds;
   }
 }
+CornerstoneCacheService_class = CornerstoneCacheService;
 CornerstoneCacheService.REGISTRATION = {
   name: 'cornerstoneCacheService',
   altName: 'CornerstoneCacheService',
-  create: _ref3 => {
-    let {
-      servicesManager
-    } = _ref3;
-    return new CornerstoneCacheService(servicesManager);
+  create: ({
+    servicesManager
+  }) => {
+    return new CornerstoneCacheService_class(servicesManager);
   }
 };
 /* harmony default export */ const CornerstoneCacheService_CornerstoneCacheService = (CornerstoneCacheService);
@@ -8322,12 +8764,9 @@ class ViewportInfo {
     let viewportData = this.getViewportData();
     if (viewportData.viewportType === esm.Enums.ViewportType.ORTHOGRAPHIC || viewportData.viewportType === esm.Enums.ViewportType.VOLUME_3D) {
       viewportData = viewportData;
-      return viewportData.data.some(_ref => {
-        let {
-          displaySetInstanceUID: dsUID
-        } = _ref;
-        return dsUID === displaySetInstanceUID;
-      });
+      return viewportData.data.some(({
+        displaySetInstanceUID: dsUID
+      }) => dsUID === displaySetInstanceUID);
     }
     viewportData = viewportData;
     return viewportData.data.displaySetInstanceUID === displaySetInstanceUID;
@@ -8399,8 +8838,7 @@ class ViewportInfo {
 
   // Handle incoming public display set options or a display set select
   // with a contained options.
-  mapDisplaySetOptions() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [{}];
+  mapDisplaySetOptions(options = [{}]) {
     const displaySetOptions = [];
     options.forEach(item => {
       let option = item?.options || item;
@@ -8440,6 +8878,7 @@ var JumpPresets = /*#__PURE__*/function (JumpPresets) {
 }(JumpPresets || {});
 /* harmony default export */ const utils_JumpPresets = (JumpPresets);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts
+var CornerstoneViewportService_class;
 
 
 
@@ -8583,10 +9022,9 @@ class CornerstoneViewportService extends src/* PubSubService */.hC {
       camera
     };
   }
-  storePresentation(_ref) {
-    let {
-      viewportId
-    } = _ref;
+  storePresentation({
+    viewportId
+  }) {
     const stateSyncService = this.servicesManager.services.stateSyncService;
     let presentation;
     try {
@@ -8910,11 +9348,10 @@ class CornerstoneViewportService extends src/* PubSubService */.hC {
       };
     });
     await viewport.setVolumes(volumeInputArray);
-    volumesProperties.forEach(_ref2 => {
-      let {
-        properties,
-        volumeId
-      } = _ref2;
+    volumesProperties.forEach(({
+      properties,
+      volumeId
+    }) => {
       viewport.setProperties(properties, volumeId);
     });
     this.setPresentations(viewport, presentations);
@@ -9014,8 +9451,7 @@ class CornerstoneViewportService extends src/* PubSubService */.hC {
 
   // Todo: keepCamera is an interim solution until we have a better solution for
   // keeping the camera position when the viewport data is changed
-  updateViewport(viewportId, viewportData) {
-    let keepCamera = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  updateViewport(viewportId, viewportData, keepCamera = false) {
     const viewportInfo = this.getViewportInfo(viewportId);
     const viewport = this.getCornerstoneViewport(viewportId);
     const viewportCamera = viewport.getCamera();
@@ -9038,8 +9474,7 @@ class CornerstoneViewportService extends src/* PubSubService */.hC {
       });
     });
   }
-  _setDisplaySets(viewport, viewportData, viewportInfo) {
-    let presentations = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  _setDisplaySets(viewport, viewportData, viewportInfo, presentations = {}) {
     if (viewport instanceof esm.StackViewport) {
       return this._setStackViewport(viewport, viewportData, viewportInfo, presentations);
     } else if (viewport instanceof esm.VolumeViewport || viewport instanceof esm.VolumeViewport3D) {
@@ -9131,14 +9566,14 @@ class CornerstoneViewportService extends src/* PubSubService */.hC {
     return [...this.viewportsById.values()].find(viewportInfo => viewportInfo.contains(displaySetInstanceUID, referencedImageId))?.viewportId ?? null;
   }
 }
+CornerstoneViewportService_class = CornerstoneViewportService;
 CornerstoneViewportService.REGISTRATION = {
   name: 'cornerstoneViewportService',
   altName: 'CornerstoneViewportService',
-  create: _ref3 => {
-    let {
-      servicesManager
-    } = _ref3;
-    return new CornerstoneViewportService(servicesManager);
+  create: ({
+    servicesManager
+  }) => {
+    return new CornerstoneViewportService_class(servicesManager);
   }
 };
 /* harmony default export */ const ViewportService_CornerstoneViewportService = (CornerstoneViewportService);
@@ -9187,8 +9622,7 @@ const getNonImageInstance = dataset => {
 const getImageInstanceId = imageInstance => {
   return getImageId(imageInstance);
 };
-const fetchIt = function (url) {
-  let headers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : src.DICOMWeb.getAuthorizationHeader();
+const fetchIt = (url, headers = src.DICOMWeb.getAuthorizationHeader()) => {
   return fetch(url, headers).then(response => response.arrayBuffer());
 };
 const cornerstoneRetriever = imageId => {
@@ -9196,9 +9630,7 @@ const cornerstoneRetriever = imageId => {
     return image && image.data && image.data.byteArray.buffer;
   });
 };
-const wadorsRetriever = function (url, studyInstanceUID, seriesInstanceUID, sopInstanceUID) {
-  let headers = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : src.DICOMWeb.getAuthorizationHeader();
-  let errorInterceptor = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : src/* errorHandler */.Po.getHTTPErrorHandler();
+const wadorsRetriever = (url, studyInstanceUID, seriesInstanceUID, sopInstanceUID, headers = src.DICOMWeb.getAuthorizationHeader(), errorInterceptor = src/* errorHandler */.Po.getHTTPErrorHandler()) => {
   const config = {
     url,
     headers,
@@ -9395,11 +9827,10 @@ const cornerstoneExtension = {
     return init.call(this, props);
   },
   getHangingProtocolModule: src_getHangingProtocolModule,
-  getViewportModule(_ref) {
-    let {
-      servicesManager,
-      commandsManager
-    } = _ref;
+  getViewportModule({
+    servicesManager,
+    commandsManager
+  }) {
     const ExtendedOHIFCornerstoneViewport = props => {
       // const onNewImageHandler = jumpData => {
       //   commandsManager.runCommand('jumpToImage', jumpData);
@@ -9420,10 +9851,9 @@ const cornerstoneExtension = {
   },
   getCommandsModule: src_commandsModule,
   getCustomizationModule: src_getCustomizationModule,
-  getUtilityModule(_ref2) {
-    let {
-      servicesManager
-    } = _ref2;
+  getUtilityModule({
+    servicesManager
+  }) {
     return [{
       name: 'common',
       exports: {
@@ -9503,7 +9933,7 @@ const reset = () => {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Z: () => (/* binding */ getSOPInstanceAttributes)
 /* harmony export */ });
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(56959);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27968);
 
 
 /**
@@ -9520,7 +9950,6 @@ function getSOPInstanceAttributes(imageId) {
 
   // Todo: implement for volume viewports and use the referencedSeriesInstanceUID
 }
-
 function _getUIDFromImageID(imageId) {
   const instance = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.metaData.get('instance', imageId);
   return {