@ohif/app 3.8.0-beta.6 → 3.8.0-beta.60

package/dist/{342.bundle.e485b92bd6d91bb7cc04.js → 704.bundle.9ecbe7b05ea278ef6ba8.js}

@@ -1,7 +1,7 @@
 "use strict";
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[342],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[704],{
 
-/***/ 56342:
+/***/ 49704:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -30,11 +30,11 @@ __webpack_require__.d(utils_namespaceObject, {
 });
 
 // EXTERNAL MODULE: ../../../node_modules/dicomweb-client/build/dicomweb-client.es.js
-var dicomweb_client_es = __webpack_require__(97604);
-// EXTERNAL MODULE: ../../core/src/index.ts + 65 modules
-var src = __webpack_require__(71771);
+var dicomweb_client_es = __webpack_require__(36922);
+// EXTERNAL MODULE: ../../core/src/index.ts + 66 modules
+var src = __webpack_require__(14283);
 // EXTERNAL MODULE: ../../core/src/utils/sortStudy.ts
-var sortStudy = __webpack_require__(62971);
+var sortStudy = __webpack_require__(45476);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/qido.js
 /**
  * QIDO - Query based on ID for DICOM Objects
@@ -125,7 +125,7 @@ function processSeriesResults(qidoSeries) {
       description: getString(qidoSeries['0008103E'])
     }));
   }
-  (0,sortStudy/* sortStudySeries */.IO)(series);
+  (0,sortStudy/* sortStudySeries */.LM)(series);
   return series;
 }
 
@@ -179,8 +179,7 @@ function searchStudies(server, filter) {
  * @param serverSupportsQIDOIncludeField
  * @returns {string} The URL with encoded filter query data
  */
-function mapParams(params) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function mapParams(params, options = {}) {
   if (!params) {
     return;
   }
@@ -354,13 +353,12 @@ function buildInstanceWadoUrl(config, instance) {
  * @param thumbnail
  * @returns {string} The imageId to be used by Cornerstone
  */
-function getImageId(_ref) {
-  let {
-    instance,
-    frame,
-    config,
-    thumbnail = false
-  } = _ref;
+function getImageId({
+  instance,
+  frame,
+  config,
+  thumbnail = false
+}) {
   if (!instance) {
     return;
   }
@@ -380,7 +378,7 @@ function getImageId(_ref) {
   }
 }
 // EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
-var dcmjs_es = __webpack_require__(67540);
+var dcmjs_es = __webpack_require__(31426);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoader.js
 /**
  * Class to define inheritance of load retrieve strategy.
@@ -395,13 +393,11 @@ class RetrieveMetadataLoader {
    * @param {Object} client The dicomweb-client.
    * @param {Array} studyInstanceUID Study instance ui to be retrieved
    * @param {Object} [filters] - Object containing filters to be applied on retrieve metadata process
-   * @param {string} [filter.seriesInstanceUID] - series instance uid to filter results against
-   * @param {Function} [sortSeries] - Custom sort function for series
+   * @param {string} [filters.seriesInstanceUID] - series instance uid to filter results against
+   * @param {Object} [sortCriteria] - Custom sort criteria used for series
+   * @param {Function} [sortFunction] - Custom sort function for series
    */
-  constructor(client, studyInstanceUID) {
-    let filters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    let sortCriteria = arguments.length > 3 ? arguments[3] : undefined;
-    let sortFunction = arguments.length > 4 ? arguments[4] : undefined;
+  constructor(client, studyInstanceUID, filters = {}, sortCriteria = undefined, sortFunction = undefined) {
     this.client = client;
     this.studyInstanceUID = studyInstanceUID;
     this.filters = filters;
@@ -422,13 +418,9 @@ class RetrieveMetadataLoader {
   async runLoaders(loaders) {
     let result;
     for (const loader of loaders) {
-      try {
-        result = await loader();
-        if (result && result.length) {
-          break; // closes iterator in case data is retrieved successfully
-        }
-      } catch (e) {
-        throw e;
+      result = await loader();
+      if (result && result.length) {
+        break; // closes iterator in case data is retrieved successfully
       }
     }
     if (loaders.next().done && !result) {
@@ -511,11 +503,64 @@ class RetrieveMetadataLoaderSync extends RetrieveMetadataLoader {
 
 
 
+// Series Date, Series Time, Series Description and Series Number to be included
+// in the series metadata query result
+const includeField = ['00080021', '00080031', '0008103E', '00200011'].join(',');
+class DeferredPromise {
+  constructor() {
+    this.metadata = undefined;
+    this.processFunction = undefined;
+    this.internalPromise = undefined;
+    this.thenFunction = undefined;
+    this.rejectFunction = undefined;
+  }
+  setMetadata(metadata) {
+    this.metadata = metadata;
+  }
+  setProcessFunction(func) {
+    this.processFunction = func;
+  }
+  getPromise() {
+    return this.start();
+  }
+  start() {
+    if (this.internalPromise) {
+      return this.internalPromise;
+    }
+    this.internalPromise = this.processFunction();
+    // in case then and reject functions called before start
+    if (this.thenFunction) {
+      this.then(this.thenFunction);
+      this.thenFunction = undefined;
+    }
+    if (this.rejectFunction) {
+      this.reject(this.rejectFunction);
+      this.rejectFunction = undefined;
+    }
+    return this.internalPromise;
+  }
+  then(func) {
+    if (this.internalPromise) {
+      return this.internalPromise.then(func);
+    } else {
+      this.thenFunction = func;
+    }
+  }
+  reject(func) {
+    if (this.internalPromise) {
+      return this.internalPromise.reject(func);
+    } else {
+      this.rejectFunction = func;
+    }
+  }
+}
 /**
- * Creates an immutable series loader object which loads each series sequentially using the iterator interface
+ * Creates an immutable series loader object which loads each series sequentially using the iterator interface.
+ *
  * @param {DICOMWebClient} dicomWebClient The DICOMWebClient instance to be used for series load
  * @param {string} studyInstanceUID The Study Instance UID from which series will be loaded
  * @param {Array} seriesInstanceUIDList A list of Series Instance UIDs
+ *
  * @returns {Object} Returns an object which supports loading of instances from each of given Series Instance UID
  */
 function makeSeriesAsyncLoader(client, studyInstanceUID, seriesInstanceUIDList) {
@@ -523,12 +568,20 @@ function makeSeriesAsyncLoader(client, studyInstanceUID, seriesInstanceUIDList)
     hasNext() {
       return seriesInstanceUIDList.length > 0;
     },
-    async next() {
-      const seriesInstanceUID = seriesInstanceUIDList.shift();
-      return client.retrieveSeriesMetadata({
-        studyInstanceUID,
-        seriesInstanceUID
+    next() {
+      const {
+        seriesInstanceUID,
+        metadata
+      } = seriesInstanceUIDList.shift();
+      const promise = new DeferredPromise();
+      promise.setMetadata(metadata);
+      promise.setProcessFunction(() => {
+        return client.retrieveSeriesMetadata({
+          studyInstanceUID,
+          seriesInstanceUID
+        });
       });
+      return promise;
     }
   });
 }
@@ -552,19 +605,22 @@ class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader {
       } = {},
       client
     } = this;
+
+    // asking to include Series Date, Series Time, Series Description
+    // and Series Number in the series metadata returned to better sort series
+    // in preLoad function
+    let options = {
+      studyInstanceUID,
+      queryParams: {
+        includefield: includeField
+      }
+    };
     if (seriesInstanceUID) {
-      const options = {
-        studyInstanceUID,
-        queryParams: {
-          SeriesInstanceUID: seriesInstanceUID
-        }
-      };
+      options.queryParams.SeriesInstanceUID = seriesInstanceUID;
       preLoaders.push(client.searchForSeries.bind(client, options));
     }
     // Fallback preloader
-    preLoaders.push(client.searchForSeries.bind(client, {
-      studyInstanceUID
-    }));
+    preLoaders.push(client.searchForSeries.bind(client, options));
     yield* preLoaders;
   }
   async preLoad() {
@@ -574,31 +630,36 @@ class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader {
     const sortFunction = this.sortFunction;
     const {
       naturalizeDataset
-    } = dcmjs_es["default"].data.DicomMetaDictionary;
+    } = dcmjs_es/* default.data */.Ay.data.DicomMetaDictionary;
     const naturalized = result.map(naturalizeDataset);
-    return (0,sortStudy/* sortStudySeries */.IO)(naturalized, sortCriteria || sortStudy/* sortingCriteria */.S1.seriesSortCriteria.seriesInfoSortingCriteria, sortFunction);
+    return (0,sortStudy/* sortStudySeries */.LM)(naturalized, sortCriteria, sortFunction);
   }
   async load(preLoadData) {
     const {
       client,
       studyInstanceUID
     } = this;
-    const seriesInstanceUIDs = preLoadData.map(s => s.SeriesInstanceUID);
+    const seriesInstanceUIDs = preLoadData.map(seriesMetadata => {
+      return {
+        seriesInstanceUID: seriesMetadata.SeriesInstanceUID,
+        metadata: seriesMetadata
+      };
+    });
     const seriesAsyncLoader = makeSeriesAsyncLoader(client, studyInstanceUID, seriesInstanceUIDs);
     const promises = [];
     while (seriesAsyncLoader.hasNext()) {
-      promises.push(seriesAsyncLoader.next());
+      const promise = seriesAsyncLoader.next();
+      promises.push(promise);
     }
     return {
       preLoadData,
       promises
     };
   }
-  async posLoad(_ref) {
-    let {
-      preLoadData,
-      promises
-    } = _ref;
+  async posLoad({
+    preLoadData,
+    promises
+  }) {
     return {
       preLoadData,
       promises
@@ -613,40 +674,91 @@ class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader {
  * Retrieve Study metadata from a DICOM server. If the server is configured to use lazy load, only the first series
  * will be loaded and the property "studyLoader" will be set to let consumer load remaining series as needed.
  *
- * @param {Object} dicomWebClient The dicomweb-client.
- * @param {string} studyInstanceUid The Study Instance UID of the study which needs to be loaded
- * @param {Object} [filters] - Object containing filters to be applied on retrieve metadata process
- * @param {string} [filter.seriesInstanceUID] - series instance uid to filter results against
- * @returns {Object} A study descriptor object
+ * @param {*} dicomWebClient The DICOMWebClient instance to be used for series load
+ * @param {*} StudyInstanceUID The UID of the Study to be retrieved
+ * @param {*} enableStudyLazyLoad Whether the study metadata should be loaded asynchronously
+ * @param {object} filters Object containing filters to be applied on retrieve metadata process
+ * @param {string} [filters.seriesInstanceUID] Series instance uid to filter results against
+ * @param {array} [filters.SeriesInstanceUIDs] Series instance uids to filter results against
+ * @param {function} [sortCriteria] Sort criteria function
+ * @param {function} [sortFunction] Sort function
+ *
+ * @returns {Promise} A promises that resolves the study descriptor object
  */
-async function RetrieveMetadata(dicomWebClient, studyInstanceUid, enableStudyLazyLoad) {
-  let filters = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  let sortCriteria = arguments.length > 4 ? arguments[4] : undefined;
-  let sortFunction = arguments.length > 5 ? arguments[5] : undefined;
+async function RetrieveMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters = {}, sortCriteria, sortFunction) {
   const RetrieveMetadataLoader = enableStudyLazyLoad !== false ? RetrieveMetadataLoaderAsync : RetrieveMetadataLoaderSync;
-  const retrieveMetadataLoader = new RetrieveMetadataLoader(dicomWebClient, studyInstanceUid, filters, sortCriteria, sortFunction);
+  const retrieveMetadataLoader = new RetrieveMetadataLoader(dicomWebClient, StudyInstanceUID, filters, sortCriteria, sortFunction);
   const data = await retrieveMetadataLoader.execLoad();
   return data;
 }
 /* harmony default export */ const retrieveMetadata = (RetrieveMetadata);
+;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/utils/retrieveMetadataFiltered.js
+
+
+/**
+ * Retrieve metadata filtered.
+ *
+ * @param {*} dicomWebClient The DICOMWebClient instance to be used for series load
+ * @param {*} StudyInstanceUID The UID of the Study to be retrieved
+ * @param {*} enableStudyLazyLoad Whether the study metadata should be loaded asynchronously
+ * @param {object} filters Object containing filters to be applied on retrieve metadata process
+ * @param {string} [filters.seriesInstanceUID] Series instance uid to filter results against
+ * @param {array} [filters.SeriesInstanceUIDs] Series instance uids to filter results against
+ * @param {function} [sortCriteria] Sort criteria function
+ * @param {function} [sortFunction] Sort function
+ *
+ * @returns
+ */
+function retrieveMetadataFiltered(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction) {
+  const {
+    SeriesInstanceUIDs
+  } = filters;
+  return new Promise((resolve, reject) => {
+    const promises = SeriesInstanceUIDs.map(uid => {
+      const seriesSpecificFilters = Object.assign({}, filters, {
+        seriesInstanceUID: uid
+      });
+      return retrieveMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, seriesSpecificFilters, sortCriteria, sortFunction);
+    });
+    Promise.all(promises).then(results => {
+      const aggregatedResult = {
+        preLoadData: [],
+        promises: []
+      };
+      results.forEach(({
+        preLoadData,
+        promises
+      }) => {
+        aggregatedResult.preLoadData = aggregatedResult.preLoadData.concat(preLoadData);
+        aggregatedResult.promises = aggregatedResult.promises.concat(promises);
+      });
+      resolve(aggregatedResult);
+    }, reject);
+  });
+}
+/* harmony default export */ const utils_retrieveMetadataFiltered = (retrieveMetadataFiltered);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/retrieveStudyMetadata.js
 
+
 const moduleName = 'RetrieveStudyMetadata';
 // Cache for promises. Prevents unnecessary subsequent calls to the server
 const StudyMetaDataPromises = new Map();
 
 /**
- * Retrieves study metadata
+ * Retrieves study metadata.
  *
- * @param {Object} server Object with server configuration parameters
+ * @param {Object} dicomWebClient The DICOMWebClient instance to be used for series load
  * @param {string} StudyInstanceUID The UID of the Study to be retrieved
- * @param {boolean} enabledStudyLazyLoad Whether the study metadata should be loaded asynchronously.
- * @param {function} storeInstancesCallback A callback used to store the retrieved instance metadata.
- * @param {Object} [filters] - Object containing filters to be applied on retrieve metadata process
- * @param {string} [filter.seriesInstanceUID] - series instance uid to filter results against
+ * @param {boolean} enableStudyLazyLoad Whether the study metadata should be loaded asynchronously.
+ * @param {Object} [filters] Object containing filters to be applied on retrieve metadata process
+ * @param {string} [filters.seriesInstanceUID] Series instance uid to filter results against
+ * @param {array} [filters.SeriesInstanceUIDs] Series instance uids to filter results against
+ * @param {function} [sortCriteria] Sort criteria function
+ * @param {function} [sortFunction] Sort function
+ *
  * @returns {Promise} that will be resolved with the metadata or rejected with the error
  */
-function retrieveStudyMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction) {
+function retrieveStudyMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction, dicomWebConfig = {}) {
   // @TODO: Whenever a study metadata request has failed, its related promise will be rejected once and for all
   // and further requests for that metadata will always fail. On failure, we probably need to remove the
   // corresponding promise from the "StudyMetaDataPromises" map...
@@ -657,30 +769,34 @@ function retrieveStudyMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazy
   if (!StudyInstanceUID) {
     throw new Error(`${moduleName}: Required 'StudyInstanceUID' parameter not provided.`);
   }
+  const promiseId = `${dicomWebConfig.name}:${StudyInstanceUID}`;
 
   // Already waiting on result? Return cached promise
-  if (StudyMetaDataPromises.has(StudyInstanceUID)) {
-    return StudyMetaDataPromises.get(StudyInstanceUID);
+  if (StudyMetaDataPromises.has(promiseId)) {
+    return StudyMetaDataPromises.get(promiseId);
+  }
+  let promise;
+  if (filters && filters.SeriesInstanceUIDs) {
+    promise = utils_retrieveMetadataFiltered(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction);
+  } else {
+    // Create a promise to handle the data retrieval
+    promise = new Promise((resolve, reject) => {
+      retrieveMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction).then(function (data) {
+        resolve(data);
+      }, reject);
+    });
   }
-
-  // Create a promise to handle the data retrieval
-  const promise = new Promise((resolve, reject) => {
-    retrieveMetadata(dicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction).then(function (data) {
-      resolve(data);
-    }, reject);
-  });
 
   // Store the promise in cache
-  StudyMetaDataPromises.set(StudyInstanceUID, promise);
+  StudyMetaDataPromises.set(promiseId, promise);
   return promise;
 }
 
 /**
  * Delete the cached study metadata retrieval promise to ensure that the browser will
- * re-retrieve the study metadata when it is next requested
+ * re-retrieve the study metadata when it is next requested.
  *
  * @param {String} StudyInstanceUID The UID of the Study to be removed from cache
- *
  */
 function deleteStudyMetadataPromise(StudyInstanceUID) {
   if (StudyMetaDataPromises.has(StudyInstanceUID)) {
@@ -697,7 +813,8 @@ function deleteStudyMetadataPromise(StudyInstanceUID) {
  * performing searches doesn't work.  This version fixes the query issue
  * by manually implementing a query option.
  */
-class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
+
+class StaticWadoClient extends dicomweb_client_es/* api */.FH.DICOMwebClient {
   constructor(qidoConfig) {
     super(qidoConfig);
     this.staticWado = qidoConfig.staticWado;
@@ -841,8 +958,7 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
   /** Converts the query parameters to lower case query parameters */
   toLowerParams(queryParams) {
     const lowerParams = {};
-    Object.entries(queryParams).forEach(_ref => {
-      let [key, value] = _ref;
+    Object.entries(queryParams).forEach(([key, value]) => {
       lowerParams[key.toLowerCase()] = value;
     });
     return lowerParams;
@@ -904,7 +1020,11 @@ const getDirectURL = (config, params) => {
   }
   if (!singlepart || singlepart !== true && singlepart.indexOf(fetchPart) === -1) {
     if (value.retrieveBulkData) {
-      return value.retrieveBulkData().then(arr => {
+      // Try the specified retrieve type.
+      const options = {
+        mediaType: defaultType
+      };
+      return value.retrieveBulkData(options).then(arr => {
         value.DirectRetrieveURL = URL.createObjectURL(new Blob([arr], {
           type: defaultType
         }));
@@ -995,7 +1115,7 @@ function fixBulkDataURI(value, instance, dicomWebConfig) {
 const {
   DicomMetaDictionary,
   DicomDict
-} = dcmjs_es["default"].data;
+} = dcmjs_es/* default.data */.Ay.data;
 const {
   naturalizeDataset,
   denaturalizeDataset
@@ -1006,26 +1126,47 @@ const EXPLICIT_VR_LITTLE_ENDIAN = '1.2.840.10008.1.2.1';
 const metadataProvider = src.classes.MetadataProvider;
 
 /**
+ * Creates a DICOM Web API based on the provided configuration.
  *
- * @param {string} name - Data source name
- * @param {string} wadoUriRoot - Legacy? (potentially unused/replaced)
- * @param {string} qidoRoot - Base URL to use for QIDO requests
- * @param {string} wadoRoot - Base URL to use for WADO requests
- * @param {boolean} qidoSupportsIncludeField - Whether QIDO supports the "Include" option to request additional fields in response
- * @param {string} imageRengering - wadors | ? (unsure of where/how this is used)
- * @param {string} thumbnailRendering - wadors | ? (unsure of where/how this is used)
- * @param {bool} supportsReject - Whether the server supports reject calls (i.e. DCM4CHEE)
- * @param {bool} lazyLoadStudy - "enableStudyLazyLoad"; Request series meta async instead of blocking
- * @param {string|bool} singlepart - indicates of the retrieves can fetch singlepart.  Options are bulkdata, video, image or boolean true
+ * @param {object} dicomWebConfig - Configuration for the DICOM Web API
+ * @param {string} dicomWebConfig.name - Data source name
+ * @param {string} dicomWebConfig.wadoUriRoot - Legacy? (potentially unused/replaced)
+ * @param {string} dicomWebConfig.qidoRoot - Base URL to use for QIDO requests
+ * @param {string} dicomWebConfig.wadoRoot - Base URL to use for WADO requests
+ * @param {string} dicomWebConfig.wadoUri - Base URL to use for WADO URI requests
+ * @param {boolean} dicomWebConfig.qidoSupportsIncludeField - Whether QIDO supports the "Include" option to request additional fields in response
+ * @param {string} dicomWebConfig.imageRendering - wadors | ? (unsure of where/how this is used)
+ * @param {string} dicomWebConfig.thumbnailRendering - wadors | ? (unsure of where/how this is used)
+ * @param {boolean} dicomWebConfig.supportsReject - Whether the server supports reject calls (i.e. DCM4CHEE)
+ * @param {boolean} dicomWebConfig.lazyLoadStudy - "enableStudyLazyLoad"; Request series meta async instead of blocking
+ * @param {string|boolean} dicomWebConfig.singlepart - indicates if the retrieves can fetch singlepart. Options are bulkdata, video, image, or boolean true
+ * @param {string} dicomWebConfig.requestTransferSyntaxUID - Transfer syntax to request from the server
+ * @param {object} dicomWebConfig.acceptHeader - Accept header to use for requests
+ * @param {boolean} dicomWebConfig.omitQuotationForMultipartRequest - Whether to omit quotation marks for multipart requests
+ * @param {boolean} dicomWebConfig.supportsFuzzyMatching - Whether the server supports fuzzy matching
+ * @param {boolean} dicomWebConfig.supportsWildcard - Whether the server supports wildcard matching
+ * @param {boolean} dicomWebConfig.supportsNativeDICOMModel - Whether the server supports the native DICOM model
+ * @param {boolean} dicomWebConfig.enableStudyLazyLoad - Whether to enable study lazy loading
+ * @param {boolean} dicomWebConfig.enableRequestTag - Whether to enable request tag
+ * @param {boolean} dicomWebConfig.enableStudyLazyLoad - Whether to enable study lazy loading
+ * @param {boolean} dicomWebConfig.bulkDataURI - Whether to enable bulkDataURI
+ * @param {function} dicomWebConfig.onConfiguration - Function that is called after the configuration is initialized
+ * @param {boolean} dicomWebConfig.staticWado - Whether to use the static WADO client
+ * @param {object} userAuthenticationService - User authentication service
+ * @param {object} userAuthenticationService.getAuthorizationHeader - Function that returns the authorization header
+ * @returns {object} - DICOM Web API object
  */
-function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
+function createDicomWebApi(dicomWebConfig, servicesManager) {
+  const {
+    userAuthenticationService,
+    customizationService
+  } = servicesManager.services;
   let dicomWebConfigCopy, qidoConfig, wadoConfig, qidoDicomWebClient, wadoDicomWebClient, getAuthrorizationHeader, generateWadoHeader;
   const implementation = {
-    initialize: _ref => {
-      let {
-        params,
-        query
-      } = _ref;
+    initialize: ({
+      params,
+      query
+    }) => {
       if (dicomWebConfig.onConfiguration && typeof dicomWebConfig.onConfiguration === 'function') {
         dicomWebConfig = dicomWebConfig.onConfiguration(dicomWebConfig, {
           params,
@@ -1055,20 +1196,20 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         staticWado: dicomWebConfig.staticWado,
         singlepart: dicomWebConfig.singlepart,
         headers: userAuthenticationService.getAuthorizationHeader(),
-        errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
+        errorInterceptor: src/* errorHandler */.r_.getHTTPErrorHandler()
       };
       wadoConfig = {
         url: dicomWebConfig.wadoRoot,
         staticWado: dicomWebConfig.staticWado,
         singlepart: dicomWebConfig.singlepart,
         headers: userAuthenticationService.getAuthorizationHeader(),
-        errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
+        errorInterceptor: src/* errorHandler */.r_.getHTTPErrorHandler()
       };
 
       // TODO -> Two clients sucks, but its better than 1000.
       // TODO -> We'll need to merge auth later.
-      qidoDicomWebClient = dicomWebConfig.staticWado ? new StaticWadoClient(qidoConfig) : new dicomweb_client_es.api.DICOMwebClient(qidoConfig);
-      wadoDicomWebClient = dicomWebConfig.staticWado ? new StaticWadoClient(wadoConfig) : new dicomweb_client_es.api.DICOMwebClient(wadoConfig);
+      qidoDicomWebClient = dicomWebConfig.staticWado ? new StaticWadoClient(qidoConfig) : new dicomweb_client_es/* api */.FH.DICOMwebClient(qidoConfig);
+      wadoDicomWebClient = dicomWebConfig.staticWado ? new StaticWadoClient(wadoConfig) : new dicomweb_client_es/* api */.FH.DICOMwebClient(wadoConfig);
     },
     query: {
       studies: {
@@ -1097,11 +1238,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         }
         // processResults: processResults.bind(),
       },
-
       instances: {
         search: (studyInstanceUid, queryParameters) => {
           qidoDicomWebClient.headers = getAuthrorizationHeader();
-          search.call(undefined, qidoDicomWebClient, studyInstanceUid, null, queryParameters);
+          return search.call(undefined, qidoDicomWebClient, studyInstanceUid, null, queryParameters);
         }
       }
     },
@@ -1123,11 +1263,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
           singlepart: dicomWebConfig.singlepart
         }, params);
       },
-      bulkDataURI: async _ref2 => {
-        let {
-          StudyInstanceUID,
-          BulkDataURI
-        } = _ref2;
+      bulkDataURI: async ({
+        StudyInstanceUID,
+        BulkDataURI
+      }) => {
         qidoDicomWebClient.headers = getAuthrorizationHeader();
         const options = {
           multipart: false,
@@ -1140,26 +1279,26 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         });
       },
       series: {
-        metadata: async function () {
-          let {
-            StudyInstanceUID,
-            filters,
-            sortCriteria,
-            sortFunction,
-            madeInClient = false
-          } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        metadata: async ({
+          StudyInstanceUID,
+          filters,
+          sortCriteria,
+          sortFunction,
+          madeInClient = false,
+          returnPromises = false
+        } = {}) => {
           if (!StudyInstanceUID) {
             throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
           }
           if (dicomWebConfig.enableStudyLazyLoad) {
-            return implementation._retrieveSeriesMetadataAsync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient);
+            return implementation._retrieveSeriesMetadataAsync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient, returnPromises);
           }
           return implementation._retrieveSeriesMetadataSync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient);
         }
       }
     },
     store: {
-      dicom: async (dataset, request) => {
+      dicom: async (dataset, request, dicomDict) => {
         wadoDicomWebClient.headers = getAuthrorizationHeader();
         if (dataset instanceof ArrayBuffer) {
           const options = {
@@ -1168,18 +1307,22 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
           };
           await wadoDicomWebClient.storeInstances(options);
         } else {
-          const meta = {
-            FileMetaInformationVersion: dataset._meta?.FileMetaInformationVersion?.Value,
-            MediaStorageSOPClassUID: dataset.SOPClassUID,
-            MediaStorageSOPInstanceUID: dataset.SOPInstanceUID,
-            TransferSyntaxUID: EXPLICIT_VR_LITTLE_ENDIAN,
-            ImplementationClassUID,
-            ImplementationVersionName
-          };
-          const denaturalized = denaturalizeDataset(meta);
-          const dicomDict = new DicomDict(denaturalized);
-          dicomDict.dict = denaturalizeDataset(dataset);
-          const part10Buffer = dicomDict.write();
+          let effectiveDicomDict = dicomDict;
+          if (!dicomDict) {
+            const meta = {
+              FileMetaInformationVersion: dataset._meta?.FileMetaInformationVersion?.Value,
+              MediaStorageSOPClassUID: dataset.SOPClassUID,
+              MediaStorageSOPInstanceUID: dataset.SOPInstanceUID,
+              TransferSyntaxUID: EXPLICIT_VR_LITTLE_ENDIAN,
+              ImplementationClassUID,
+              ImplementationVersionName
+            };
+            const denaturalized = denaturalizeDataset(meta);
+            const defaultDicomDict = new DicomDict(denaturalized);
+            defaultDicomDict.dict = denaturalizeDataset(dataset);
+            effectiveDicomDict = defaultDicomDict;
+          }
+          const part10Buffer = effectiveDicomDict.write();
           const options = {
             datasets: [part10Buffer],
             request
@@ -1192,7 +1335,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
       const enableStudyLazyLoad = false;
       wadoDicomWebClient.headers = generateWadoHeader();
       // data is all SOPInstanceUIDs
-      const data = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction);
+      const data = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction, dicomWebConfig);
 
       // first naturalize the data
       const naturalizedInstancesMetadata = data.map(naturalizeDataset);
@@ -1233,16 +1376,16 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
       const seriesMetadata = Object.values(seriesSummaryMetadata);
       src.DicomMetadataStore.addSeriesMetadata(seriesMetadata, madeInClient);
       Object.keys(instancesPerSeries).forEach(seriesInstanceUID => src.DicomMetadataStore.addInstances(instancesPerSeries[seriesInstanceUID], madeInClient));
+      return seriesSummaryMetadata;
     },
-    _retrieveSeriesMetadataAsync: async function (StudyInstanceUID, filters, sortCriteria, sortFunction) {
-      let madeInClient = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+    _retrieveSeriesMetadataAsync: async (StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient = false, returnPromises = false) => {
       const enableStudyLazyLoad = true;
       wadoDicomWebClient.headers = generateWadoHeader();
       // Get Series
       const {
         preLoadData: seriesSummaryMetadata,
         promises: seriesPromises
-      } = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction);
+      } = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction, dicomWebConfig);
 
       /**
        * naturalizes the dataset, and adds a retrieve bulkdata method
@@ -1264,10 +1407,13 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
           // in which case it isn't necessary to re-read this.
           if (value && value.BulkDataURI && !value.Value) {
             // Provide a method to fetch bulkdata
-            value.retrieveBulkData = () => {
+            value.retrieveBulkData = (options = {}) => {
               // handle the scenarios where bulkDataURI is relative path
               fixBulkDataURI(value, naturalized, dicomWebConfig);
-              const options = {
+              const {
+                mediaType
+              } = options;
+              const useOptions = {
                 // The bulkdata fetches work with either multipart or
                 // singlepart, so set multipart to false to let the server
                 // decide which type to respond with.
@@ -1277,10 +1423,16 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
                 // is relative - that isn't disallowed by DICOMweb, but
                 // isn't well specified in the standard, but is needed in
                 // any implementation that stores static copies of the metadata
-                StudyInstanceUID: naturalized.StudyInstanceUID
+                StudyInstanceUID: naturalized.StudyInstanceUID,
+                mediaTypes: mediaType ? [{
+                  mediaType
+                }, {
+                  mediaType: 'application/octet-stream'
+                }] : undefined,
+                ...options
               };
               // Todo: this needs to be from wado dicom web client
-              return qidoDicomWebClient.retrieveBulkData(options).then(val => {
+              return qidoDicomWebClient.retrieveBulkData(useOptions).then(val => {
                 // There are DICOM PDF cases where the first ArrayBuffer in the array is
                 // the bulk data and DICOM video cases where the second ArrayBuffer is
                 // the bulk data. Here we play it safe and do a find.
@@ -1299,7 +1451,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         const naturalizedInstances = instances.map(addRetrieveBulkData);
 
         // Adding instanceMetadata to OHIF MetadataProvider
-        naturalizedInstances.forEach((instance, index) => {
+        naturalizedInstances.forEach(instance => {
           instance.wadoRoot = dicomWebConfig.wadoRoot;
           instance.wadoUri = dicomWebConfig.wadoUri;
           const imageId = implementation.getImageIdsForInstance({
@@ -1323,7 +1475,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         src.DicomMetadataStore.addInstances(naturalizedInstances, madeInClient);
       }
       function setSuccessFlag() {
-        const study = src.DicomMetadataStore.getStudy(StudyInstanceUID, madeInClient);
+        const study = src.DicomMetadataStore.getStudy(StudyInstanceUID);
+        if (!study) {
+          return;
+        }
         study.isLoaded = true;
       }
 
@@ -1333,11 +1488,22 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
         aSeries.StudyInstanceUID = StudyInstanceUID;
       });
       src.DicomMetadataStore.addSeriesMetadata(seriesSummaryMetadata, madeInClient);
-      const seriesDeliveredPromises = seriesPromises.map(promise => promise.then(instances => {
-        storeInstances(instances);
-      }));
-      await Promise.all(seriesDeliveredPromises);
-      setSuccessFlag();
+      const seriesDeliveredPromises = seriesPromises.map(promise => {
+        if (!returnPromises) {
+          promise?.start();
+        }
+        return promise.then(instances => {
+          storeInstances(instances);
+        });
+      });
+      if (returnPromises) {
+        Promise.all(seriesDeliveredPromises).then(() => setSuccessFlag());
+        return seriesPromises;
+      } else {
+        await Promise.all(seriesDeliveredPromises);
+        setSuccessFlag();
+      }
+      return seriesSummaryMetadata;
     },
     deleteStudyMetadataPromise: deleteStudyMetadataPromise,
     getImageIdsForDisplaySet(displaySet) {
@@ -1365,11 +1531,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
       });
       return imageIds;
     },
-    getImageIdsForInstance(_ref3) {
-      let {
-        instance,
-        frame
-      } = _ref3;
+    getImageIdsForInstance({
+      instance,
+      frame = undefined
+    }) {
       const imageIds = getImageId({
         instance,
         frame,
@@ -1380,11 +1545,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     getConfig() {
       return dicomWebConfigCopy;
     },
-    getStudyInstanceUIDs(_ref4) {
-      let {
-        params,
-        query
-      } = _ref4;
+    getStudyInstanceUIDs({
+      params,
+      query
+    }) {
       const {
         StudyInstanceUIDs: paramsStudyInstanceUIDs
       } = params;
@@ -1397,7 +1561,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
   if (dicomWebConfig.supportsReject) {
     implementation.reject = dcm4cheeReject(dicomWebConfig.wadoRoot);
   }
-  return src/* IWebApiDataSource */.Is.create(implementation);
+  return src/* IWebApiDataSource */.pt.create(implementation);
 }
 
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomJSONDataSource/index.js
@@ -1405,7 +1569,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
 
 
 
-const DicomJSONDataSource_metadataProvider = src["default"].classes.MetadataProvider;
+const DicomJSONDataSource_metadataProvider = src/* default.classes */.Ay.classes.MetadataProvider;
 const mappings = {
   studyInstanceUid: 'StudyInstanceUID',
   patientId: 'PatientID'
@@ -1423,7 +1587,20 @@ let _store = {
   // }
   // }
 };
-
+function wrapSequences(obj) {
+  return Object.keys(obj).reduce((acc, key) => {
+    if (typeof obj[key] === 'object' && obj[key] !== null) {
+      // Recursively wrap sequences for nested objects
+      acc[key] = wrapSequences(obj[key]);
+    } else {
+      acc[key] = obj[key];
+    }
+    if (key.endsWith('Sequence')) {
+      acc[key] = src/* default.utils */.Ay.utils.addAccessors(acc[key]);
+    }
+    return acc;
+  }, Array.isArray(obj) ? [] : {});
+}
 const getMetaDataByURL = url => {
   return _store.urls.find(metaData => metaData.url === url);
 };
@@ -1443,11 +1620,10 @@ function createDicomJSONApi(dicomJsonConfig) {
     wadoRoot
   } = dicomJsonConfig;
   const implementation = {
-    initialize: async _ref => {
-      let {
-        query,
-        url
-      } = _ref;
+    initialize: async ({
+      query,
+      url
+    }) => {
       if (!url) {
         url = query.get('url');
       }
@@ -1548,12 +1724,11 @@ function createDicomJSONApi(dicomJsonConfig) {
         return utils_getDirectURL(wadoRoot, params);
       },
       series: {
-        metadata: async function () {
-          let {
-            StudyInstanceUID,
-            madeInClient = false,
-            customSort
-          } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        metadata: async ({
+          StudyInstanceUID,
+          madeInClient = false,
+          customSort
+        } = {}) => {
           if (!StudyInstanceUID) {
             throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
           }
@@ -1585,8 +1760,13 @@ function createDicomJSONApi(dicomJsonConfig) {
           const numberOfSeries = series.length;
           series.forEach((series, index) => {
             const instances = series.instances.map(instance => {
+              // for instance.metadata if the key ends with sequence then
+              // we need to add a proxy to the first item in the sequence
+              // so that we can access the value of the sequence
+              // by using sequenceName.value
+              const modifiedMetadata = wrapSequences(instance.metadata);
               const obj = {
-                ...instance.metadata,
+                ...modifiedMetadata,
                 url: instance.url,
                 imageId: instance.url,
                 ...series,
@@ -1636,34 +1816,32 @@ function createDicomJSONApi(dicomJsonConfig) {
       });
       return imageIds;
     },
-    getImageIdsForInstance(_ref2) {
-      let {
-        instance,
-        frame
-      } = _ref2;
+    getImageIdsForInstance({
+      instance,
+      frame
+    }) {
       const imageIds = getImageId({
         instance,
         frame
       });
       return imageIds;
     },
-    getStudyInstanceUIDs: _ref3 => {
-      let {
-        params,
-        query
-      } = _ref3;
+    getStudyInstanceUIDs: ({
+      params,
+      query
+    }) => {
       const url = query.get('url');
       return _store.studyInstanceUIDMap.get(url);
     }
   };
-  return src/* IWebApiDataSource */.Is.create(implementation);
+  return src/* IWebApiDataSource */.pt.create(implementation);
 }
 
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomLocalDataSource/index.js
 
 
 
-const DicomLocalDataSource_metadataProvider = src["default"].classes.MetadataProvider;
+const DicomLocalDataSource_metadataProvider = src/* default.classes */.Ay.classes.MetadataProvider;
 const {
   EVENTS
 } = src.DicomMetadataStore;
@@ -1672,8 +1850,7 @@ const END_MODALITIES = {
   SEG: true,
   DOC: true
 };
-const compareValue = function (v1, v2) {
-  let def = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+const compareValue = (v1, v2, def = 0) => {
   if (v1 === v2) {
     return def;
   }
@@ -1705,12 +1882,10 @@ function createDicomLocalApi(dicomLocalConfig) {
     name
   } = dicomLocalConfig;
   const implementation = {
-    initialize: _ref => {
-      let {
-        params,
-        query
-      } = _ref;
-    },
+    initialize: ({
+      params,
+      query
+    }) => {},
     query: {
       studies: {
         mapParams: () => {},
@@ -1789,11 +1964,10 @@ function createDicomLocalApi(dicomLocalConfig) {
         }
       },
       series: {
-        metadata: async function () {
-          let {
-            StudyInstanceUID,
-            madeInClient = false
-          } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        metadata: async ({
+          StudyInstanceUID,
+          madeInClient = false
+        } = {}) => {
           if (!StudyInstanceUID) {
             throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
           }
@@ -1839,7 +2013,7 @@ function createDicomLocalApi(dicomLocalConfig) {
     },
     store: {
       dicom: naturalizedReport => {
-        const reportBlob = dcmjs_es["default"].data.datasetToBlob(naturalizedReport);
+        const reportBlob = dcmjs_es/* default.data */.Ay.data.datasetToBlob(naturalizedReport);
 
         //Create a URL for the binary.
         var objectUrl = URL.createObjectURL(reportBlob);
@@ -1872,11 +2046,10 @@ function createDicomLocalApi(dicomLocalConfig) {
       });
       return imageIds;
     },
-    getImageIdsForInstance(_ref2) {
-      let {
-        instance,
-        frame
-      } = _ref2;
+    getImageIdsForInstance({
+      instance,
+      frame
+    }) {
       const {
         StudyInstanceUID,
         SeriesInstanceUID,
@@ -1892,11 +2065,10 @@ function createDicomLocalApi(dicomLocalConfig) {
     deleteStudyMetadataPromise() {
       console.log('deleteStudyMetadataPromise not implemented');
     },
-    getStudyInstanceUIDs: _ref3 => {
-      let {
-        params,
-        query
-      } = _ref3;
+    getStudyInstanceUIDs: ({
+      params,
+      query
+    }) => {
       const {
         StudyInstanceUIDs: paramsStudyInstanceUIDs
       } = params;
@@ -1916,7 +2088,7 @@ function createDicomLocalApi(dicomLocalConfig) {
       return isStudyInCache ? StudyInstanceUIDsAsArray : [];
     }
   };
-  return src/* IWebApiDataSource */.Is.create(implementation);
+  return src/* IWebApiDataSource */.pt.create(implementation);
 }
 
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebProxyDataSource/index.js
@@ -1931,17 +2103,16 @@ function createDicomLocalApi(dicomLocalConfig) {
  * dicomWeb configuration array
  *
  */
-function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService) {
+function createDicomWebProxyApi(dicomWebProxyConfig, servicesManager) {
   const {
     name
   } = dicomWebProxyConfig;
   let dicomWebDelegate = undefined;
   const implementation = {
-    initialize: async _ref => {
-      let {
-        params,
-        query
-      } = _ref;
+    initialize: async ({
+      params,
+      query
+    }) => {
       const url = query.get('url');
       if (!url) {
         throw new Error(`No url for '${name}'`);
@@ -1951,7 +2122,7 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
         if (!data.servers?.dicomWeb?.[0]) {
           throw new Error('Invalid configuration returned by url');
         }
-        dicomWebDelegate = createDicomWebApi(data.servers.dicomWeb[0].configuration, UserAuthenticationService);
+        dicomWebDelegate = createDicomWebApi(data.servers.dicomWeb[0].configuration, servicesManager);
         dicomWebDelegate.initialize({
           params,
           query
@@ -1963,43 +2134,28 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
         search: params => dicomWebDelegate.query.studies.search(params)
       },
       series: {
-        search: function () {
-          return dicomWebDelegate.query.series.search(...arguments);
-        }
+        search: (...args) => dicomWebDelegate.query.series.search(...args)
       },
       instances: {
         search: (studyInstanceUid, queryParameters) => dicomWebDelegate.query.instances.search(studyInstanceUid, queryParameters)
       }
     },
     retrieve: {
-      directURL: function () {
-        return dicomWebDelegate.retrieve.directURL(...arguments);
-      },
+      directURL: (...args) => dicomWebDelegate.retrieve.directURL(...args),
       series: {
-        metadata: async function () {
-          return dicomWebDelegate.retrieve.series.metadata(...arguments);
-        }
+        metadata: async (...args) => dicomWebDelegate.retrieve.series.metadata(...args)
       }
     },
     store: {
-      dicom: function () {
-        return dicomWebDelegate.store(...arguments);
-      }
+      dicom: (...args) => dicomWebDelegate.store(...args)
     },
-    deleteStudyMetadataPromise: function () {
-      return dicomWebDelegate.deleteStudyMetadataPromise(...arguments);
-    },
-    getImageIdsForDisplaySet: function () {
-      return dicomWebDelegate.getImageIdsForDisplaySet(...arguments);
-    },
-    getImageIdsForInstance: function () {
-      return dicomWebDelegate.getImageIdsForInstance(...arguments);
-    },
-    getStudyInstanceUIDs(_ref2) {
-      let {
-        params,
-        query
-      } = _ref2;
+    deleteStudyMetadataPromise: (...args) => dicomWebDelegate.deleteStudyMetadataPromise(...args),
+    getImageIdsForDisplaySet: (...args) => dicomWebDelegate.getImageIdsForDisplaySet(...args),
+    getImageIdsForInstance: (...args) => dicomWebDelegate.getImageIdsForInstance(...args),
+    getStudyInstanceUIDs({
+      params,
+      query
+    }) {
       let studyInstanceUIDs = [];
 
       // there seem to be a couple of variations of the case for this parameter
@@ -2011,7 +2167,278 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
       return studyInstanceUIDs;
     }
   };
-  return src/* IWebApiDataSource */.Is.create(implementation);
+  return src/* IWebApiDataSource */.pt.create(implementation);
+}
+
+// EXTERNAL MODULE: ../../../node_modules/lodash/lodash.js
+var lodash = __webpack_require__(5517);
+;// CONCATENATED MODULE: ../../../extensions/default/src/MergeDataSource/index.ts
+
+
+const mergeMap = {
+  'query.studies.search': {
+    mergeKey: 'studyInstanceUid',
+    tagFunc: x => x
+  },
+  'query.series.search': {
+    mergeKey: 'seriesInstanceUid',
+    tagFunc: (series, sourceName) => {
+      series.forEach(series => {
+        series.RetrieveAETitle = sourceName;
+        src.DicomMetadataStore.updateSeriesMetadata(series);
+      });
+      return series;
+    }
+  }
+};
+
+/**
+ * Calls all data sources asynchronously and merges the results.
+ * @param {CallForAllDataSourcesAsyncOptions} options - The options for calling all data sources.
+ * @param {string} options.path - The path to the function to be called on each data source.
+ * @param {unknown[]} options.args - The arguments to be passed to the function.
+ * @param {ExtensionManager} options.extensionManager - The extension manager.
+ * @param {string[]} options.dataSourceNames - The names of the data sources to be called.
+ * @param {string} options.defaultDataSourceName - The name of the default data source.
+ * @returns {Promise<unknown[]>} - A promise that resolves to the merged data from all data sources.
+ */
+const callForAllDataSourcesAsync = async ({
+  mergeMap,
+  path,
+  args,
+  extensionManager,
+  dataSourceNames,
+  defaultDataSourceName
+}) => {
+  const {
+    mergeKey,
+    tagFunc
+  } = mergeMap[path] || {
+    tagFunc: x => x
+  };
+
+  /** Sort by default data source */
+  const defs = Object.values(extensionManager.dataSourceDefs);
+  const defaultDataSourceDef = defs.find(def => def.sourceName === defaultDataSourceName);
+  const dataSourceDefs = defs.filter(def => def.sourceName !== defaultDataSourceName);
+  if (defaultDataSourceDef) {
+    dataSourceDefs.unshift(defaultDataSourceDef);
+  }
+  const promises = [];
+  const sourceNames = [];
+  for (const dataSourceDef of dataSourceDefs) {
+    const {
+      configuration,
+      sourceName
+    } = dataSourceDef;
+    if (!!configuration && dataSourceNames.includes(sourceName)) {
+      const [dataSource] = extensionManager.getDataSources(sourceName);
+      const func = (0,lodash.get)(dataSource, path);
+      const promise = func.apply(dataSource, args);
+      promises.push(promise);
+      sourceNames.push(sourceName);
+    }
+  }
+  const data = await Promise.allSettled(promises);
+  const mergedData = data.map((data, i) => tagFunc(data.value, sourceNames[i]));
+  let results = [];
+  if (mergeKey) {
+    results = (0,lodash.uniqBy)(mergedData.flat(), obj => (0,lodash.get)(obj, mergeKey));
+  } else {
+    results = mergedData.flat();
+  }
+  return results;
+};
+
+/**
+ * Calls all data sources that match the provided names and merges their data.
+ * @param options - The options for calling all data sources.
+ * @param options.path - The path to the function to be called on each data source.
+ * @param options.args - The arguments to be passed to the function.
+ * @param options.extensionManager - The extension manager instance.
+ * @param options.dataSourceNames - The names of the data sources to be called.
+ * @param options.defaultDataSourceName - The name of the default data source.
+ * @returns The merged data from all the matching data sources.
+ */
+const callForAllDataSources = ({
+  path,
+  args,
+  extensionManager,
+  dataSourceNames,
+  defaultDataSourceName
+}) => {
+  /** Sort by default data source */
+  const defs = Object.values(extensionManager.dataSourceDefs);
+  const defaultDataSourceDef = defs.find(def => def.sourceName === defaultDataSourceName);
+  const dataSourceDefs = defs.filter(def => def.sourceName !== defaultDataSourceName);
+  if (defaultDataSourceDef) {
+    dataSourceDefs.unshift(defaultDataSourceDef);
+  }
+  const mergedData = [];
+  for (const dataSourceDef of dataSourceDefs) {
+    const {
+      configuration,
+      sourceName
+    } = dataSourceDef;
+    if (!!configuration && dataSourceNames.includes(sourceName)) {
+      const [dataSource] = extensionManager.getDataSources(sourceName);
+      const func = (0,lodash.get)(dataSource, path);
+      const data = func.apply(dataSource, args);
+      mergedData.push(data);
+    }
+  }
+  return mergedData.flat();
+};
+
+/**
+ * Calls the default data source function specified by the given path with the provided arguments.
+ * @param {CallForDefaultDataSourceOptions} options - The options for calling the default data source.
+ * @param {string} options.path - The path to the function within the default data source.
+ * @param {unknown[]} options.args - The arguments to pass to the function.
+ * @param {string} options.defaultDataSourceName - The name of the default data source.
+ * @param {ExtensionManager} options.extensionManager - The extension manager instance.
+ * @returns {unknown} - The result of calling the default data source function.
+ */
+const callForDefaultDataSource = ({
+  path,
+  args,
+  defaultDataSourceName,
+  extensionManager
+}) => {
+  const [dataSource] = extensionManager.getDataSources(defaultDataSourceName);
+  const func = (0,lodash.get)(dataSource, path);
+  return func.apply(dataSource, args);
+};
+
+/**
+ * Calls the data source specified by the RetrieveAETitle of the given display set.
+ * @typedef {Object} CallByRetrieveAETitleOptions
+ * @property {string} path - The path of the method to call on the data source.
+ * @property {any[]} args - The arguments to pass to the method.
+ * @property {string} defaultDataSourceName - The name of the default data source.
+ * @property {ExtensionManager} extensionManager - The extension manager.
+ */
+const callByRetrieveAETitle = ({
+  path,
+  args,
+  defaultDataSourceName,
+  extensionManager
+}) => {
+  const [displaySet] = args;
+  const seriesMetadata = src.DicomMetadataStore.getSeries(displaySet.StudyInstanceUID, displaySet.SeriesInstanceUID);
+  const [dataSource] = extensionManager.getDataSources(seriesMetadata.RetrieveAETitle || defaultDataSourceName);
+  return dataSource[path](...args);
+};
+function createMergeDataSourceApi(mergeConfig, servicesManager, extensionManager) {
+  const {
+    seriesMerge
+  } = mergeConfig;
+  const {
+    dataSourceNames,
+    defaultDataSourceName
+  } = seriesMerge;
+  const implementation = {
+    initialize: (...args) => callForAllDataSources({
+      path: 'initialize',
+      args,
+      extensionManager,
+      dataSourceNames,
+      defaultDataSourceName
+    }),
+    query: {
+      studies: {
+        search: (...args) => callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'query.studies.search',
+          args,
+          extensionManager,
+          dataSourceNames,
+          defaultDataSourceName
+        })
+      },
+      series: {
+        search: (...args) => callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'query.series.search',
+          args,
+          extensionManager,
+          dataSourceNames,
+          defaultDataSourceName
+        })
+      },
+      instances: {
+        search: (...args) => callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'query.instances.search',
+          args,
+          extensionManager,
+          dataSourceNames,
+          defaultDataSourceName
+        })
+      }
+    },
+    retrieve: {
+      bulkDataURI: (...args) => callForAllDataSourcesAsync({
+        mergeMap,
+        path: 'retrieve.bulkDataURI',
+        args,
+        extensionManager,
+        dataSourceNames,
+        defaultDataSourceName
+      }),
+      directURL: (...args) => callForDefaultDataSource({
+        path: 'retrieve.directURL',
+        args,
+        defaultDataSourceName,
+        extensionManager
+      }),
+      series: {
+        metadata: (...args) => callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'retrieve.series.metadata',
+          args,
+          extensionManager,
+          dataSourceNames,
+          defaultDataSourceName
+        })
+      }
+    },
+    store: {
+      dicom: (...args) => callForDefaultDataSource({
+        path: 'store.dicom',
+        args,
+        defaultDataSourceName,
+        extensionManager
+      })
+    },
+    deleteStudyMetadataPromise: (...args) => callForAllDataSources({
+      path: 'deleteStudyMetadataPromise',
+      args,
+      extensionManager,
+      dataSourceNames,
+      defaultDataSourceName
+    }),
+    getImageIdsForDisplaySet: (...args) => callByRetrieveAETitle({
+      path: 'getImageIdsForDisplaySet',
+      args,
+      defaultDataSourceName,
+      extensionManager
+    }),
+    getImageIdsForInstance: (...args) => callByRetrieveAETitle({
+      path: 'getImageIdsForDisplaySet',
+      args,
+      defaultDataSourceName,
+      extensionManager
+    }),
+    getStudyInstanceUIDs: (...args) => callForAllDataSources({
+      path: 'getStudyInstanceUIDs',
+      args,
+      extensionManager,
+      dataSourceNames,
+      defaultDataSourceName
+    })
+  };
+  return src/* IWebApiDataSource */.pt.create(implementation);
 }
 
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getDataSourcesModule.js
@@ -2024,6 +2451,7 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
 
 
 
+
 /**
  *
  */
@@ -2044,42 +2472,45 @@ function getDataSourcesModule() {
     name: 'dicomlocal',
     type: 'localApi',
     createDataSource: createDicomLocalApi
+  }, {
+    name: 'merge',
+    type: 'mergeApi',
+    createDataSource: createMergeDataSourceApi
   }];
 }
 /* harmony default export */ const src_getDataSourcesModule = (getDataSourcesModule);
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
-var react = __webpack_require__(43001);
+var react = __webpack_require__(41766);
 // EXTERNAL MODULE: ../../../node_modules/prop-types/index.js
-var prop_types = __webpack_require__(3827);
+var prop_types = __webpack_require__(11374);
 var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
-// EXTERNAL MODULE: ../../ui/src/index.js + 485 modules
-var ui_src = __webpack_require__(71783);
+// EXTERNAL MODULE: ../../ui/src/index.js + 487 modules
+var ui_src = __webpack_require__(55395);
 // EXTERNAL MODULE: ./state/index.js + 1 modules
-var state = __webpack_require__(62657);
+var state = __webpack_require__(15575);
 // EXTERNAL MODULE: ../node_modules/react-router-dom/dist/index.js
-var dist = __webpack_require__(62474);
+var dist = __webpack_require__(37396);
 // EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules
-var es = __webpack_require__(69190);
+var es = __webpack_require__(80619);
 // EXTERNAL MODULE: ../node_modules/react-router/dist/index.js
-var react_router_dist = __webpack_require__(85066);
-// EXTERNAL MODULE: ../../i18n/src/index.js + 134 modules
-var i18n_src = __webpack_require__(50376);
+var react_router_dist = __webpack_require__(10971);
+// EXTERNAL MODULE: ../../i18n/src/index.js + 148 modules
+var i18n_src = __webpack_require__(69536);
 // EXTERNAL MODULE: ../../../node_modules/classnames/index.js
-var classnames = __webpack_require__(44921);
+var classnames = __webpack_require__(61466);
 var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/Toolbar/Toolbar.tsx
 function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
 
 
-function Toolbar(_ref) {
-  let {
-    servicesManager
-  } = _ref;
+function Toolbar({
+  servicesManager
+}) {
   const {
     toolbarService
   } = servicesManager.services;
-  const [viewportGrid, viewportGridService] = (0,ui_src/* useViewportGrid */.O_)();
+  const [viewportGrid, viewportGridService] = (0,ui_src/* useViewportGrid */.ih)();
   const [toolbarButtons, setToolbarButtons] = (0,react.useState)([]);
   (0,react.useEffect)(() => {
     const updateToolbar = () => {
@@ -2131,16 +2562,15 @@ const {
   availableLanguages,
   defaultLanguage,
   currentLanguage
-} = i18n_src["default"];
-function ViewerHeader(_ref) {
-  let {
-    hotkeysManager,
-    extensionManager,
-    servicesManager
-  } = _ref;
-  const [appConfig] = (0,state/* useAppConfig */.M)();
-  const navigate = (0,dist/* useNavigate */.s0)();
-  const location = (0,react_router_dist/* useLocation */.TH)();
+} = i18n_src/* default */.A;
+function ViewerHeader({
+  hotkeysManager,
+  extensionManager,
+  servicesManager
+}) {
+  const [appConfig] = (0,state/* useAppConfig */.r)();
+  const navigate = (0,dist/* useNavigate */.Zp)();
+  const location = (0,react_router_dist/* useLocation */.zy)();
   const onClickReturnButton = () => {
     const {
       pathname
@@ -2164,23 +2594,23 @@ function ViewerHeader(_ref) {
   };
   const {
     t
-  } = (0,es/* useTranslation */.$G)();
+  } = (0,es/* useTranslation */.Bd)();
   const {
     show,
     hide
-  } = (0,ui_src/* useModal */.dd)();
+  } = (0,ui_src/* useModal */.hS)();
   const {
     hotkeyDefinitions,
     hotkeyDefaults
   } = hotkeysManager;
-  const versionNumber = "3.8.0-beta.6";
-  const commitHash = "dd6d9768bbca1d3cc472e8c1e6d85822500b96ef";
+  const versionNumber = "3.8.0-beta.60";
+  const commitHash = "f7fe91c5f6c4f05f3f3f5f640d3a119bd40a5870";
   const menuOptions = [{
     title: t('Header:About'),
     icon: 'info',
     onClick: () => show({
-      content: ui_src/* AboutModal */.tk,
-      title: 'About OHIF Viewer',
+      content: ui_src/* AboutModal */.VT,
+      title: t('AboutModal:About OHIF Viewer'),
       contentProps: {
         versionNumber,
         commitHash
@@ -2190,8 +2620,8 @@ function ViewerHeader(_ref) {
     title: t('Header:Preferences'),
     icon: 'settings',
     onClick: () => show({
-      title: t('UserPreferencesModal:User Preferences'),
-      content: ui_src/* UserPreferences */.i1,
+      title: t('UserPreferencesModal:User preferences'),
+      content: ui_src/* UserPreferences */.im,
       contentProps: {
         hotkeyDefaults: hotkeysManager.getValidHotkeyDefinitions(hotkeyDefaults),
         hotkeyDefinitions,
@@ -2199,23 +2629,22 @@ function ViewerHeader(_ref) {
         availableLanguages,
         defaultLanguage,
         onCancel: () => {
-          src/* hotkeys */.dD.stopRecord();
-          src/* hotkeys */.dD.unpause();
+          src/* hotkeys */.ot.stopRecord();
+          src/* hotkeys */.ot.unpause();
           hide();
         },
-        onSubmit: _ref2 => {
-          let {
-            hotkeyDefinitions,
-            language
-          } = _ref2;
+        onSubmit: ({
+          hotkeyDefinitions,
+          language
+        }) => {
           if (language.value !== currentLanguage().value) {
-            i18n_src["default"].changeLanguage(language.value);
+            i18n_src/* default */.A.changeLanguage(language.value);
           }
           hotkeysManager.setHotkeys(hotkeyDefinitions);
           hide();
         },
         onReset: () => hotkeysManager.restoreDefaultBindings(),
-        hotkeysModule: src/* hotkeys */.dD
+        hotkeysModule: src/* hotkeys */.ot
       }
     })
   }];
@@ -2228,12 +2657,12 @@ function ViewerHeader(_ref) {
       }
     });
   }
-  return /*#__PURE__*/react.createElement(ui_src/* Header */.h4, {
+  return /*#__PURE__*/react.createElement(ui_src/* Header */.Y9, {
     menuOptions: menuOptions,
     isReturnEnabled: !!appConfig.showStudyList,
     onClickReturnButton: onClickReturnButton,
     WhiteLabeling: appConfig.whiteLabeling
-  }, /*#__PURE__*/react.createElement(ui_src/* ErrorBoundary */.SV, {
+  }, /*#__PURE__*/react.createElement(ui_src/* ErrorBoundary */.tH, {
     context: "Primary Toolbar"
   }, /*#__PURE__*/react.createElement("div", {
     className: "relative flex justify-center"
@@ -2245,14 +2674,14 @@ function ViewerHeader(_ref) {
 ;// CONCATENATED MODULE: ../../../extensions/default/src/Components/SidePanelWithServices.tsx
 
 
-const SidePanelWithServices = _ref => {
-  let {
-    servicesManager,
-    side,
-    className,
-    activeTabIndex: activeTabIndexProp,
-    tabs
-  } = _ref;
+const SidePanelWithServices = ({
+  servicesManager,
+  side,
+  className,
+  activeTabIndex: activeTabIndexProp,
+  tabs,
+  expandedWidth
+}) => {
   const panelService = servicesManager?.services?.panelService;
 
   // Tracks whether this SidePanel has been opened at least once since this SidePanel was inserted into the DOM.
@@ -2274,14 +2703,15 @@ const SidePanelWithServices = _ref => {
       };
     }
   }, [tabs, hasBeenOpened, panelService]);
-  return /*#__PURE__*/react.createElement(ui_src/* SidePanel */.hs, {
+  return /*#__PURE__*/react.createElement(ui_src/* SidePanel */.wv, {
     side: side,
     className: className,
     activeTabIndex: activeTabIndex,
     tabs: tabs,
     onOpen: () => {
       setHasBeenOpened(true);
-    }
+    },
+    expandedWidth: expandedWidth
   });
 };
 /* harmony default export */ const Components_SidePanelWithServices = (SidePanelWithServices);
@@ -2293,22 +2723,21 @@ const SidePanelWithServices = _ref => {
 
 
 
-function ViewerLayout(_ref) {
-  let {
-    // From Extension Module Params
-    extensionManager,
-    servicesManager,
-    hotkeysManager,
-    commandsManager,
-    // From Modes
-    viewports,
-    ViewportGridComp,
-    leftPanels = [],
-    rightPanels = [],
-    leftPanelDefaultClosed = false,
-    rightPanelDefaultClosed = false
-  } = _ref;
-  const [appConfig] = (0,state/* useAppConfig */.M)();
+function ViewerLayout({
+  // From Extension Module Params
+  extensionManager,
+  servicesManager,
+  hotkeysManager,
+  commandsManager,
+  // From Modes
+  viewports,
+  ViewportGridComp,
+  leftPanels = [],
+  rightPanels = [],
+  leftPanelDefaultClosed = false,
+  rightPanelDefaultClosed = false
+}) {
+  const [appConfig] = (0,state/* useAppConfig */.r)();
   const {
     hangingProtocolService
   } = servicesManager.services;
@@ -2360,7 +2789,7 @@ function ViewerLayout(_ref) {
   (0,react.useEffect)(() => {
     const {
       unsubscribe
-    } = hangingProtocolService.subscribe(src/* HangingProtocolService */.hy.EVENTS.PROTOCOL_CHANGED,
+    } = hangingProtocolService.subscribe(src/* HangingProtocolService */.Qe.EVENTS.PROTOCOL_CHANGED,
     // Todo: right now to set the loading indicator to false, we need to wait for the
     // hangingProtocolService to finish applying the viewport matching to each viewport,
     // however, this might not be the only approach to set the loading indicator to false. we need to explore this further.
@@ -2392,9 +2821,9 @@ function ViewerLayout(_ref) {
     style: {
       height: 'calc(100vh - 52px'
     }
-  }, /*#__PURE__*/react.createElement(react.Fragment, null, showLoadingIndicator && /*#__PURE__*/react.createElement(ui_src/* LoadingIndicatorProgress */.LE, {
+  }, /*#__PURE__*/react.createElement(react.Fragment, null, showLoadingIndicator && /*#__PURE__*/react.createElement(ui_src/* LoadingIndicatorProgress */.Jx, {
     className: "h-full w-full bg-black"
-  }), leftPanelComponents.length ? /*#__PURE__*/react.createElement(ui_src/* ErrorBoundary */.SV, {
+  }), leftPanelComponents.length ? /*#__PURE__*/react.createElement(ui_src/* ErrorBoundary */.tH, {
     context: "Left Panel"
   }, /*#__PURE__*/react.createElement(Components_SidePanelWithServices, {
     side: "left",
@@ -2405,13 +2834,13 @@ function ViewerLayout(_ref) {
     className: "flex h-full flex-1 flex-col"
   }, /*#__PURE__*/react.createElement("div", {
     className: "relative flex h-full flex-1 items-center justify-center overflow-hidden bg-black"
-  }, /*#__PURE__*/react.createElement(ui_src/* ErrorBoundary */.SV, {
+  }, /*#__PURE__*/react.createElement(ui_src/* ErrorBoundary */.tH, {
     context: "Grid"
   }, /*#__PURE__*/react.createElement(ViewportGridComp, {
     servicesManager: servicesManager,
     viewportComponents: viewportComponents,
     commandsManager: commandsManager
-  })))), rightPanelComponents.length ? /*#__PURE__*/react.createElement(ui_src/* ErrorBoundary */.SV, {
+  })))), rightPanelComponents.length ? /*#__PURE__*/react.createElement(ui_src/* ErrorBoundary */.tH, {
     context: "Right Panel"
   }, /*#__PURE__*/react.createElement(Components_SidePanelWithServices, {
     side: "right",
@@ -2425,8 +2854,8 @@ ViewerLayout.propTypes = {
   extensionManager: prop_types_default().shape({
     getModuleEntry: (prop_types_default()).func.isRequired
   }).isRequired,
-  commandsManager: prop_types_default().instanceOf(src/* CommandsManager */.HQ),
-  servicesManager: prop_types_default().instanceOf(src/* ServicesManager */.Xw),
+  commandsManager: prop_types_default().instanceOf(src/* CommandsManager */.Sp),
+  servicesManager: prop_types_default().instanceOf(src/* ServicesManager */.CS),
   // From modes
   leftPanels: (prop_types_default()).array,
   rightPanels: (prop_types_default()).array,
@@ -2445,13 +2874,12 @@ ViewerLayout.propTypes = {
 - Init layout based on the displaySets and the objects.
 */
 
-/* harmony default export */ function getLayoutTemplateModule(_ref) {
-  let {
-    servicesManager,
-    extensionManager,
-    commandsManager,
-    hotkeysManager
-  } = _ref;
+/* harmony default export */ function getLayoutTemplateModule({
+  servicesManager,
+  extensionManager,
+  commandsManager,
+  hotkeysManager
+}) {
   function ViewerLayoutWithServices(props) {
     return src_ViewerLayout({
       servicesManager,
@@ -2485,31 +2913,30 @@ const {
  *
  * @param {*} param0
  */
-function PanelStudyBrowser(_ref) {
-  let {
-    servicesManager,
-    getImageSrc,
-    getStudiesForPatientByMRN,
-    requestDisplaySetCreationForStudy,
-    dataSource
-  } = _ref;
+function PanelStudyBrowser({
+  servicesManager,
+  getImageSrc,
+  getStudiesForPatientByMRN,
+  requestDisplaySetCreationForStudy,
+  dataSource
+}) {
   const {
     hangingProtocolService,
     displaySetService,
     uiNotificationService
   } = servicesManager.services;
-  const navigate = (0,dist/* useNavigate */.s0)();
+  const navigate = (0,dist/* useNavigate */.Zp)();
 
   // Normally you nest the components so the tree isn't so deep, and the data
   // doesn't have to have such an intense shape. This works well enough for now.
   // Tabs --> Studies --> DisplaySets --> Thumbnails
   const {
     StudyInstanceUIDs
-  } = (0,ui_src/* useImageViewer */.zG)();
+  } = (0,ui_src/* useImageViewer */.Bz)();
   const [{
     activeViewportId,
     viewports
-  }, viewportGridService] = (0,ui_src/* useViewportGrid */.O_)();
+  }, viewportGridService] = (0,ui_src/* useViewportGrid */.ih)();
   const [activeTabName, setActiveTabName] = (0,react.useState)('primary');
   const [expandedStudyInstanceUIDs, setExpandedStudyInstanceUIDs] = (0,react.useState)([...StudyInstanceUIDs]);
   const [studyDisplayList, setStudyDisplayList] = (0,react.useState)([]);
@@ -2675,7 +3102,7 @@ function PanelStudyBrowser(_ref) {
     }
   }
   const activeDisplaySetInstanceUIDs = viewports.get(activeViewportId)?.displaySetInstanceUIDs;
-  return /*#__PURE__*/react.createElement(ui_src/* StudyBrowser */.eX, {
+  return /*#__PURE__*/react.createElement(ui_src/* StudyBrowser */.M4, {
     tabs: tabs,
     servicesManager: servicesManager,
     activeTabName: activeTabName,
@@ -2745,7 +3172,6 @@ function _mapDisplaySets(displaySets, thumbnailImageSrcMap) {
         displaySetInstanceUID: ds.displaySetInstanceUID
         // .. Any other data to pass
       },
-
       isHydratedForDerivedDisplaySet: ds.isHydrated
     });
   });
@@ -2860,17 +3286,16 @@ function requestDisplaySetCreationForStudy(dataSource, displaySetService, StudyI
  * @param {object} commandsManager
  * @param {object} extensionManager
  */
-function WrappedPanelStudyBrowser(_ref) {
-  let {
-    commandsManager,
-    extensionManager,
-    servicesManager
-  } = _ref;
+function WrappedPanelStudyBrowser({
+  commandsManager,
+  extensionManager,
+  servicesManager
+}) {
   // TODO: This should be made available a different way; route should have
   // already determined our datasource
   const dataSource = extensionManager.getDataSources()[0];
   const _getStudiesForPatientByMRN = Panels_getStudiesForPatientByMRN.bind(null, dataSource);
-  const _getImageSrcFromImageId = _createGetImageSrcFromImageIdFn(extensionManager);
+  const _getImageSrcFromImageId = (0,react.useCallback)(_createGetImageSrcFromImageIdFn(extensionManager), []);
   const _requestDisplaySetCreationForStudy = Panels_requestDisplaySetCreationForStudy.bind(null, dataSource);
   return /*#__PURE__*/react.createElement(Panels_PanelStudyBrowser, {
     servicesManager: servicesManager,
@@ -2912,21 +3337,20 @@ WrappedPanelStudyBrowser.propTypes = {
 
 
 
-function ActionButtons(_ref) {
-  let {
-    onExportClick,
-    onCreateReportClick
-  } = _ref;
+function ActionButtons({
+  onExportClick,
+  onCreateReportClick
+}) {
   const {
     t
-  } = (0,es/* useTranslation */.$G)('MeasurementTable');
-  return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(ui_src/* LegacyButtonGroup */.HO, {
+  } = (0,es/* useTranslation */.Bd)('MeasurementTable');
+  return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(ui_src/* LegacyButtonGroup */.xA, {
     color: "black",
     size: "inherit"
-  }, /*#__PURE__*/react.createElement(ui_src/* LegacyButton */.mN, {
+  }, /*#__PURE__*/react.createElement(ui_src/* LegacyButton */._H, {
     className: "px-2 py-2 text-base",
     onClick: onExportClick
-  }, t('Export CSV')), /*#__PURE__*/react.createElement(ui_src/* LegacyButton */.mN, {
+  }, t('Export CSV')), /*#__PURE__*/react.createElement(ui_src/* LegacyButton */._H, {
     className: "px-2 py-2 text-base",
     onClick: onCreateReportClick
   }, t('Create Report'))));
@@ -2941,7 +3365,7 @@ ActionButtons.defaultProps = {
 };
 /* harmony default export */ const Panels_ActionButtons = (ActionButtons);
 // EXTERNAL MODULE: ../../../node_modules/lodash.debounce/index.js
-var lodash_debounce = __webpack_require__(8324);
+var lodash_debounce = __webpack_require__(14771);
 var lodash_debounce_default = /*#__PURE__*/__webpack_require__.n(lodash_debounce);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/Panels/createReportDialogPrompt.tsx
 
@@ -2950,10 +3374,9 @@ const CREATE_REPORT_DIALOG_RESPONSE = {
   CANCEL: 0,
   CREATE_REPORT: 1
 };
-function CreateReportDialogPrompt(uiDialogService, _ref) {
-  let {
-    extensionManager
-  } = _ref;
+function CreateReportDialogPrompt(uiDialogService, {
+  extensionManager
+}) {
   return new Promise(function (resolve, reject) {
     let dialogId = undefined;
     const _handleClose = () => {
@@ -2974,11 +3397,10 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
      * @param {string} param0.action - value of action performed
      * @param {string} param0.value - value from input field
      */
-    const _handleFormSubmit = _ref2 => {
-      let {
-        action,
-        value
-      } = _ref2;
+    const _handleFormSubmit = ({
+      action,
+      value
+    }) => {
       uiDialogService.dismiss({
         id: dialogId
       });
@@ -3013,7 +3435,7 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
     dialogId = uiDialogService.create({
       centralize: true,
       isDraggable: false,
-      content: ui_src/* Dialog */.Vq,
+      content: ui_src/* Dialog */.lG,
       useLastPosition: false,
       showOverlay: true,
       contentProps: {
@@ -3027,19 +3449,18 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
         actions: [{
           id: 'cancel',
           text: 'Cancel',
-          type: ui_src/* ButtonEnums.type */.LZ.dt.secondary
+          type: ui_src/* ButtonEnums.type */.Ny.NW.secondary
         }, {
           id: 'save',
           text: 'Save',
-          type: ui_src/* ButtonEnums.type */.LZ.dt.primary
+          type: ui_src/* ButtonEnums.type */.Ny.NW.primary
         }],
         // TODO: Should be on button press...
         onSubmit: _handleFormSubmit,
-        body: _ref3 => {
-          let {
-            value,
-            setValue
-          } = _ref3;
+        body: ({
+          value,
+          setValue
+        }) => {
           const onChangeHandler = event => {
             event.persist();
             setValue(value => ({
@@ -3060,7 +3481,7 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
           };
           return /*#__PURE__*/react.createElement(react.Fragment, null, dataSourcesOpts.length > 1 && window.config?.allowMultiSelectExport && /*#__PURE__*/react.createElement("div", null, /*#__PURE__*/react.createElement("label", {
             className: "text-[14px] leading-[1.2] text-white"
-          }, "Data Source"), /*#__PURE__*/react.createElement(ui_src/* Select */.Ph, {
+          }, "Data Source"), /*#__PURE__*/react.createElement(ui_src/* Select */.l6, {
             closeMenuOnSelect: true,
             className: "border-primary-main  mt-2 bg-black",
             options: dataSourcesOpts,
@@ -3075,7 +3496,7 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
             isClearable: false
           })), /*#__PURE__*/react.createElement("div", {
             className: "mt-3"
-          }, /*#__PURE__*/react.createElement(ui_src/* Input */.II, {
+          }, /*#__PURE__*/react.createElement(ui_src/* Input */.pd, {
             autoFocus: true,
             label: "Enter the report name",
             labelClassName: "text-white text-[14px] leading-[1.2]",
@@ -3099,12 +3520,11 @@ function CreateReportDialogPrompt(uiDialogService, _ref) {
  *
  * @param {*} servicesManager
  */
-async function createReportAsync(_ref) {
-  let {
-    servicesManager,
-    getReport,
-    reportType = 'measurement'
-  } = _ref;
+async function createReportAsync({
+  servicesManager,
+  getReport,
+  reportType = 'measurement'
+}) {
   const {
     displaySetService,
     uiNotificationService,
@@ -3215,16 +3635,19 @@ function findSRWithSameSeriesDescription(SeriesDescription, displaySetService) {
 
 
 
+
 const {
   downloadCSVReport
 } = src.utils;
-function PanelMeasurementTable(_ref) {
-  let {
-    servicesManager,
-    commandsManager,
-    extensionManager
-  } = _ref;
-  const [viewportGrid, viewportGridService] = (0,ui_src/* useViewportGrid */.O_)();
+function PanelMeasurementTable({
+  servicesManager,
+  commandsManager,
+  extensionManager
+}) {
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('MeasurementTable');
+  const [viewportGrid, viewportGridService] = (0,ui_src/* useViewportGrid */.ih)();
   const {
     activeViewportId,
     viewports
@@ -3310,31 +3733,28 @@ function PanelMeasurementTable(_ref) {
       });
     }
   }
-  const jumpToImage = _ref2 => {
-    let {
-      uid,
-      isActive
-    } = _ref2;
+  const jumpToImage = ({
+    uid,
+    isActive
+  }) => {
     measurementService.jumpToMeasurement(viewportGrid.activeViewportId, uid);
     onMeasurementItemClickHandler({
       uid,
       isActive
     });
   };
-  const onMeasurementItemEditHandler = _ref3 => {
-    let {
-      uid,
-      isActive
-    } = _ref3;
+  const onMeasurementItemEditHandler = ({
+    uid,
+    isActive
+  }) => {
     const measurement = measurementService.getMeasurement(uid);
     //Todo: why we are jumping to image?
     // jumpToImage({ id, isActive });
 
-    const onSubmitHandler = _ref4 => {
-      let {
-        action,
-        value
-      } = _ref4;
+    const onSubmitHandler = ({
+      action,
+      value
+    }) => {
       switch (action.id) {
         case 'save':
           {
@@ -3353,18 +3773,17 @@ function PanelMeasurementTable(_ref) {
       centralize: true,
       isDraggable: false,
       showOverlay: true,
-      content: ui_src/* Dialog */.Vq,
+      content: ui_src/* Dialog */.lG,
       contentProps: {
         title: 'Annotation',
         noCloseButton: true,
         value: {
           label: measurement.label || ''
         },
-        body: _ref5 => {
-          let {
-            value,
-            setValue
-          } = _ref5;
+        body: ({
+          value,
+          setValue
+        }) => {
           const onChangeHandler = event => {
             event.persist();
             setValue(value => ({
@@ -3382,7 +3801,7 @@ function PanelMeasurementTable(_ref) {
               });
             }
           };
-          return /*#__PURE__*/react.createElement(ui_src/* Input */.II, {
+          return /*#__PURE__*/react.createElement(ui_src/* Input */.pd, {
             label: "Enter your annotation",
             labelClassName: "text-white text-[14px] leading-[1.2]",
             autoFocus: true,
@@ -3397,21 +3816,20 @@ function PanelMeasurementTable(_ref) {
         actions: [{
           id: 'cancel',
           text: 'Cancel',
-          type: ui_src/* ButtonEnums.type */.LZ.dt.secondary
+          type: ui_src/* ButtonEnums.type */.Ny.NW.secondary
         }, {
           id: 'save',
           text: 'Save',
-          type: ui_src/* ButtonEnums.type */.LZ.dt.primary
+          type: ui_src/* ButtonEnums.type */.Ny.NW.primary
         }],
         onSubmit: onSubmitHandler
       }
     });
   };
-  const onMeasurementItemClickHandler = _ref6 => {
-    let {
-      uid,
-      isActive
-    } = _ref6;
+  const onMeasurementItemClickHandler = ({
+    uid,
+    isActive
+  }) => {
     if (!isActive) {
       const measurements = [...displayMeasurements];
       const measurement = measurements.find(m => m.uid === uid);
@@ -3423,8 +3841,8 @@ function PanelMeasurementTable(_ref) {
   return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("div", {
     className: "ohif-scrollbar overflow-y-auto overflow-x-hidden",
     "data-cy": 'measurements-panel'
-  }, /*#__PURE__*/react.createElement(ui_src/* MeasurementTable */.wt, {
-    title: "Measurements",
+  }, /*#__PURE__*/react.createElement(ui_src/* MeasurementTable */.V, {
+    title: t("Measurements"),
     servicesManager: servicesManager,
     data: displayMeasurements,
     onClick: jumpToImage,
@@ -3438,7 +3856,7 @@ function PanelMeasurementTable(_ref) {
   })));
 }
 PanelMeasurementTable.propTypes = {
-  servicesManager: prop_types_default().instanceOf(src/* ServicesManager */.Xw).isRequired
+  servicesManager: prop_types_default().instanceOf(src/* ServicesManager */.CS).isRequired
 };
 function _getMappedMeasurements(measurementService) {
   const measurements = measurementService.getMeasurements();
@@ -3495,21 +3913,23 @@ function _mapMeasurementToDisplay(measurement, index, types) {
 
 
 
+// EXTERNAL MODULE: ../../../node_modules/i18next/dist/esm/i18next.js
+var i18next = __webpack_require__(92344);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getPanelModule.tsx
 
 
 
+
 // TODO:
 // - No loading UI exists yet
 // - cancel promises when component is destroyed
 // - show errors in UI for thumbnails if promise fails
 
-function getPanelModule(_ref) {
-  let {
-    commandsManager,
-    extensionManager,
-    servicesManager
-  } = _ref;
+function getPanelModule({
+  commandsManager,
+  extensionManager,
+  servicesManager
+}) {
   const wrappedMeasurementPanel = () => {
     return /*#__PURE__*/react.createElement(PanelMeasurementTable, {
       commandsManager: commandsManager,
@@ -3521,7 +3941,7 @@ function getPanelModule(_ref) {
     name: 'seriesList',
     iconName: 'tab-studies',
     iconLabel: 'Studies',
-    label: 'Studies',
+    label: i18next/* default */.A.t('SidePanel:Studies'),
     component: Panels_WrappedPanelStudyBrowser.bind(null, {
       commandsManager,
       extensionManager,
@@ -3531,28 +3951,28 @@ function getPanelModule(_ref) {
     name: 'measure',
     iconName: 'tab-linear',
     iconLabel: 'Measure',
-    label: 'Measurements',
-    secondaryLabel: 'Measurements',
+    label: i18next/* default */.A.t('SidePanel:Measurements'),
+    secondaryLabel: i18next/* default */.A.t('SidePanel:Measurements'),
     component: wrappedMeasurementPanel
   }];
 }
 /* harmony default export */ const src_getPanelModule = (getPanelModule);
 // EXTERNAL MODULE: ../../core/src/utils/isImage.js
-var isImage = __webpack_require__(11835);
+var isImage = __webpack_require__(8094);
 // EXTERNAL MODULE: ../../core/src/utils/sopClassDictionary.js
-var sopClassDictionary = __webpack_require__(24369);
+var sopClassDictionary = __webpack_require__(48085);
 // EXTERNAL MODULE: ../../core/src/classes/ImageSet.ts
-var ImageSet = __webpack_require__(13950);
+var ImageSet = __webpack_require__(14169);
 // EXTERNAL MODULE: ../../core/src/utils/isDisplaySetReconstructable.js
-var isDisplaySetReconstructable = __webpack_require__(89359);
+var isDisplaySetReconstructable = __webpack_require__(13835);
 ;// CONCATENATED MODULE: ../../../extensions/default/package.json
-const package_namespaceObject = JSON.parse('{"u2":"@ohif/extension-default"}');
+const package_namespaceObject = /*#__PURE__*/JSON.parse('{"UU":"@ohif/extension-default"}');
 ;// CONCATENATED MODULE: ../../../extensions/default/src/id.js
 
-const id = package_namespaceObject.u2;
+const id = package_namespaceObject.UU;
 
 // EXTERNAL MODULE: ../../core/src/utils/sortInstancesByPosition.ts
-var sortInstancesByPosition = __webpack_require__(87425);
+var sortInstancesByPosition = __webpack_require__(44563);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/checkMultiframe.ts
 
 
@@ -3563,18 +3983,18 @@ var sortInstancesByPosition = __webpack_require__(87425);
  * @param {*} warnings
  */
 function checkMultiFrame(multiFrameInstance, messages) {
-  if (!(0,isDisplaySetReconstructable/* hasPixelMeasurements */.hu)(multiFrameInstance)) {
-    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MULTIFRAME_NO_PIXEL_MEASUREMENTS);
+  if (!(0,isDisplaySetReconstructable/* hasPixelMeasurements */.Yt)(multiFrameInstance)) {
+    messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.MULTIFRAME_NO_PIXEL_MEASUREMENTS);
   }
-  if (!(0,isDisplaySetReconstructable/* hasOrientation */.sb)(multiFrameInstance)) {
-    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MULTIFRAME_NO_ORIENTATION);
+  if (!(0,isDisplaySetReconstructable/* hasOrientation */.VX)(multiFrameInstance)) {
+    messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.MULTIFRAME_NO_ORIENTATION);
   }
-  if (!(0,isDisplaySetReconstructable/* hasPosition */.kN)(multiFrameInstance)) {
-    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MULTIFRAME_NO_POSITION_INFORMATION);
+  if (!(0,isDisplaySetReconstructable/* hasPosition */.sL)(multiFrameInstance)) {
+    messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.MULTIFRAME_NO_POSITION_INFORMATION);
   }
 }
 // EXTERNAL MODULE: ../../core/src/utils/toNumber.js
-var toNumber = __webpack_require__(94972);
+var toNumber = __webpack_require__(58099);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageDimensionsEqual.ts
 
 
@@ -3588,8 +4008,8 @@ function areAllImageDimensionsEqual(instances) {
     return false;
   }
   const firstImage = instances[0];
-  const firstImageRows = (0,toNumber/* default */.Z)(firstImage.Rows);
-  const firstImageColumns = (0,toNumber/* default */.Z)(firstImage.Columns);
+  const firstImageRows = (0,toNumber/* default */.A)(firstImage.Rows);
+  const firstImageColumns = (0,toNumber/* default */.A)(firstImage.Columns);
   for (let i = 1; i < instances.length; i++) {
     const instance = instances[i];
     const {
@@ -3615,7 +4035,7 @@ function areAllImageComponentsEqual(instances) {
     return false;
   }
   const firstImage = instances[0];
-  const firstImageSamplesPerPixel = (0,toNumber/* default */.Z)(firstImage.SamplesPerPixel);
+  const firstImageSamplesPerPixel = (0,toNumber/* default */.A)(firstImage.SamplesPerPixel);
   for (let i = 1; i < instances.length; i++) {
     const instance = instances[i];
     const {
@@ -3641,18 +4061,18 @@ function areAllImageOrientationsEqual(instances) {
     return false;
   }
   const firstImage = instances[0];
-  const firstImageOrientationPatient = (0,toNumber/* default */.Z)(firstImage.ImageOrientationPatient);
+  const firstImageOrientationPatient = (0,toNumber/* default */.A)(firstImage.ImageOrientationPatient);
   for (let i = 1; i < instances.length; i++) {
     const instance = instances[i];
-    const imageOrientationPatient = (0,toNumber/* default */.Z)(instance.ImageOrientationPatient);
-    if (!(0,isDisplaySetReconstructable/* _isSameOrientation */.NB)(imageOrientationPatient, firstImageOrientationPatient)) {
+    const imageOrientationPatient = (0,toNumber/* default */.A)(instance.ImageOrientationPatient);
+    if (!(0,isDisplaySetReconstructable/* _isSameOrientation */.sW)(imageOrientationPatient, firstImageOrientationPatient)) {
       return false;
     }
   }
   return true;
 }
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 10 modules
-var esm = __webpack_require__(45451);
+var esm = __webpack_require__(83636);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/utils/calculateScanAxisNormal.ts
 
 
@@ -3662,9 +4082,9 @@ var esm = __webpack_require__(45451);
  * @returns
  */
 function calculateScanAxisNormal(imageOrientation) {
-  const rowCosineVec = esm/* vec3.fromValues */.R3.fromValues(imageOrientation[0], imageOrientation[1], imageOrientation[2]);
-  const colCosineVec = esm/* vec3.fromValues */.R3.fromValues(imageOrientation[3], imageOrientation[4], imageOrientation[5]);
-  return esm/* vec3.cross */.R3.cross(esm/* vec3.create */.R3.create(), rowCosineVec, colCosineVec);
+  const rowCosineVec = esm/* vec3.fromValues */.eR.fromValues(imageOrientation[0], imageOrientation[1], imageOrientation[2]);
+  const colCosineVec = esm/* vec3.fromValues */.eR.fromValues(imageOrientation[3], imageOrientation[4], imageOrientation[5]);
+  return esm/* vec3.cross */.eR.cross(esm/* vec3.create */.eR.create(), rowCosineVec, colCosineVec);
 }
 ;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImagePositionsEqual.ts
 
@@ -3683,8 +4103,8 @@ function calculateScanAxisNormal(imageOrientation) {
 function _checkSeriesPositionShift(previousPosition, actualPosition, scanAxisNormal, averageSpacingBetweenFrames) {
   // predicted position should be the previous position added by the multiplication
   // of the scanAxisNormal and the average spacing between frames
-  const predictedPosition = esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(esm/* vec3.create */.R3.create(), previousPosition, scanAxisNormal, averageSpacingBetweenFrames);
-  return esm/* vec3.distance */.R3.distance(actualPosition, predictedPosition) > averageSpacingBetweenFrames;
+  const predictedPosition = esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(esm/* vec3.create */.eR.create(), previousPosition, scanAxisNormal, averageSpacingBetweenFrames);
+  return esm/* vec3.distance */.eR.distance(actualPosition, predictedPosition) > averageSpacingBetweenFrames;
 }
 
 /**
@@ -3696,18 +4116,18 @@ function areAllImagePositionsEqual(instances) {
   if (!instances?.length) {
     return false;
   }
-  const firstImageOrientationPatient = (0,toNumber/* default */.Z)(instances[0].ImageOrientationPatient);
+  const firstImageOrientationPatient = (0,toNumber/* default */.A)(instances[0].ImageOrientationPatient);
   if (!firstImageOrientationPatient) {
     return false;
   }
   const scanAxisNormal = calculateScanAxisNormal(firstImageOrientationPatient);
-  const firstImagePositionPatient = (0,toNumber/* default */.Z)(instances[0].ImagePositionPatient);
-  const lastIpp = (0,toNumber/* default */.Z)(instances[instances.length - 1].ImagePositionPatient);
-  const averageSpacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.Xn)(firstImagePositionPatient, lastIpp) / (instances.length - 1);
+  const firstImagePositionPatient = (0,toNumber/* default */.A)(instances[0].ImagePositionPatient);
+  const lastIpp = (0,toNumber/* default */.A)(instances[instances.length - 1].ImagePositionPatient);
+  const averageSpacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.jj)(firstImagePositionPatient, lastIpp) / (instances.length - 1);
   let previousImagePositionPatient = firstImagePositionPatient;
   for (let i = 1; i < instances.length; i++) {
     const instance = instances[i];
-    const imagePositionPatient = (0,toNumber/* default */.Z)(instance.ImagePositionPatient);
+    const imagePositionPatient = (0,toNumber/* default */.A)(instance.ImagePositionPatient);
     if (_checkSeriesPositionShift(previousImagePositionPatient, imagePositionPatient, scanAxisNormal, averageSpacingBetweenFrames)) {
       return false;
     }
@@ -3728,29 +4148,29 @@ function areAllImageSpacingEqual(instances, messages) {
   if (!instances?.length) {
     return;
   }
-  const firstImagePositionPatient = (0,toNumber/* default */.Z)(instances[0].ImagePositionPatient);
+  const firstImagePositionPatient = (0,toNumber/* default */.A)(instances[0].ImagePositionPatient);
   if (!firstImagePositionPatient) {
     return;
   }
-  const lastIpp = (0,toNumber/* default */.Z)(instances[instances.length - 1].ImagePositionPatient);
-  const averageSpacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.Xn)(firstImagePositionPatient, lastIpp) / (instances.length - 1);
+  const lastIpp = (0,toNumber/* default */.A)(instances[instances.length - 1].ImagePositionPatient);
+  const averageSpacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.jj)(firstImagePositionPatient, lastIpp) / (instances.length - 1);
   let previousImagePositionPatient = firstImagePositionPatient;
   const issuesFound = [];
   for (let i = 1; i < instances.length; i++) {
     const instance = instances[i];
-    const imagePositionPatient = (0,toNumber/* default */.Z)(instance.ImagePositionPatient);
-    const spacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.Xn)(imagePositionPatient, previousImagePositionPatient);
-    const spacingIssue = (0,isDisplaySetReconstructable/* _getSpacingIssue */.bg)(spacingBetweenFrames, averageSpacingBetweenFrames);
+    const imagePositionPatient = (0,toNumber/* default */.A)(instance.ImagePositionPatient);
+    const spacingBetweenFrames = (0,isDisplaySetReconstructable/* _getPerpendicularDistance */.jj)(imagePositionPatient, previousImagePositionPatient);
+    const spacingIssue = (0,isDisplaySetReconstructable/* _getSpacingIssue */.Op)(spacingBetweenFrames, averageSpacingBetweenFrames);
     if (spacingIssue) {
       const issue = spacingIssue.issue;
 
       // avoid multiple warning of the same thing
       if (!issuesFound.includes(issue)) {
         issuesFound.push(issue);
-        if (issue === isDisplaySetReconstructable/* reconstructionIssues */.e1.MISSING_FRAMES) {
-          messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MISSING_FRAMES);
-        } else if (issue === isDisplaySetReconstructable/* reconstructionIssues */.e1.IRREGULAR_SPACING) {
-          messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.IRREGULAR_SPACING);
+        if (issue === isDisplaySetReconstructable/* reconstructionIssues */.JG.MISSING_FRAMES) {
+          messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.MISSING_FRAMES);
+        } else if (issue === isDisplaySetReconstructable/* reconstructionIssues */.JG.IRREGULAR_SPACING) {
+          messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.IRREGULAR_SPACING);
         }
       }
       // we just want to find issues not how many
@@ -3777,16 +4197,16 @@ function areAllImageSpacingEqual(instances, messages) {
 function checkSingleFrames(instances, messages) {
   if (instances.length > 2) {
     if (!areAllImageDimensionsEqual(instances)) {
-      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_DIMENSIONS);
+      messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.INCONSISTENT_DIMENSIONS);
     }
     if (!areAllImageComponentsEqual(instances)) {
-      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_COMPONENTS);
+      messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.INCONSISTENT_COMPONENTS);
     }
     if (!areAllImageOrientationsEqual(instances)) {
-      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_ORIENTATIONS);
+      messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.INCONSISTENT_ORIENTATIONS);
     }
     if (!areAllImagePositionsEqual(instances)) {
-      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_POSITION_INFORMATION);
+      messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.INCONSISTENT_POSITION_INFORMATION);
     }
     areAllImageSpacingEqual(instances, messages);
   }
@@ -3803,9 +4223,9 @@ function checkSingleFrames(instances, messages) {
  * @param {Object[]} instances An array of `OHIFInstanceMetadata` objects.
  */
 function getDisplaySetMessages(instances, isReconstructable) {
-  const messages = new src/* DisplaySetMessageList */.iK();
+  const messages = new src/* DisplaySetMessageList */.WZ();
   if (!instances.length) {
-    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.NO_VALID_INSTANCES);
+    messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.NO_VALID_INSTANCES);
     return;
   }
   const firstInstance = instances[0];
@@ -3818,18 +4238,18 @@ function getDisplaySetMessages(instances, isReconstructable) {
   if (ImageType?.includes('LOCALIZER')) {
     return messages;
   }
-  if (!isDisplaySetReconstructable/* constructableModalities */.M6.includes(Modality)) {
+  if (!isDisplaySetReconstructable/* constructableModalities */.Hf.includes(Modality)) {
     return messages;
   }
   const isMultiframe = NumberOfFrames > 1;
   // Can't reconstruct if all instances don't have the ImagePositionPatient.
   if (!isMultiframe && !instances.every(instance => instance.ImagePositionPatient)) {
-    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.NO_POSITION_INFORMATION);
+    messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.NO_POSITION_INFORMATION);
   }
-  const sortedInstances = (0,sortInstancesByPosition/* default */.Z)(instances);
+  const sortedInstances = (0,sortInstancesByPosition/* default */.A)(instances);
   isMultiframe ? checkMultiFrame(sortedInstances[0], messages) : checkSingleFrames(sortedInstances, messages);
   if (!isReconstructable) {
-    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.NOT_RECONSTRUCTABLE);
+    messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.NOT_RECONSTRUCTABLE);
   }
   return messages;
 }
@@ -3840,9 +4260,9 @@ function getDisplaySetMessages(instances, isReconstructable) {
  * Default handler for a instance list with an unsupported sopClassUID
  */
 function getDisplaySetsFromUnsupportedSeries(instances) {
-  const imageSet = new ImageSet/* default */.Z(instances);
-  const messages = new src/* DisplaySetMessageList */.iK();
-  messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.UNSUPPORTED_DISPLAYSET);
+  const imageSet = new ImageSet/* default */.A(instances);
+  const messages = new src/* DisplaySetMessageList */.WZ();
+  messages.addMessage(src/* DisplaySetMessage */.Ob.CODES.UNSUPPORTED_DISPLAYSET);
   const instance = instances[0];
   imageSet.setAttributes({
     displaySetInstanceUID: imageSet.uid,
@@ -3878,11 +4298,11 @@ const isMultiFrame = instance => {
 };
 const makeDisplaySet = instances => {
   const instance = instances[0];
-  const imageSet = new ImageSet/* default */.Z(instances);
+  const imageSet = new ImageSet/* default */.A(instances);
   const {
     value: isReconstructable,
     averageSpacingBetweenFrames
-  } = (0,isDisplaySetReconstructable/* default */.ZP)(instances);
+  } = (0,isDisplaySetReconstructable/* default */.Ay)(instances);
   // set appropriate attributes to image set...
   const messages = getDisplaySetMessages(instances, isReconstructable);
   imageSet.setAttributes({
@@ -3967,7 +4387,7 @@ function getDisplaySetsFromSeries(instances) {
   const stackableInstances = [];
   instances.forEach(instance => {
     // All imaging modalities must have a valid value for sopClassUid (x00080016) or rows (x00280010)
-    if (!(0,isImage/* isImage */.O)(instance.SOPClassUID) && !instance.Rows) {
+    if (!(0,isImage/* isImage */.w)(instance.SOPClassUID) && !instance.Rows) {
       return;
     }
     let displaySet;
@@ -4003,7 +4423,7 @@ function getDisplaySetsFromSeries(instances) {
   }
   return displaySets;
 }
-const sopClassUids = [sopClassDictionary/* default */.Z.ComputedRadiographyImageStorage, sopClassDictionary/* default */.Z.DigitalXRayImageStorageForPresentation, sopClassDictionary/* default */.Z.DigitalXRayImageStorageForProcessing, sopClassDictionary/* default */.Z.DigitalMammographyXRayImageStorageForPresentation, sopClassDictionary/* default */.Z.DigitalMammographyXRayImageStorageForProcessing, sopClassDictionary/* default */.Z.DigitalIntraOralXRayImageStorageForPresentation, sopClassDictionary/* default */.Z.DigitalIntraOralXRayImageStorageForProcessing, sopClassDictionary/* default */.Z.CTImageStorage, sopClassDictionary/* default */.Z.EnhancedCTImageStorage, sopClassDictionary/* default */.Z.LegacyConvertedEnhancedCTImageStorage, sopClassDictionary/* default */.Z.UltrasoundMultiframeImageStorage, sopClassDictionary/* default */.Z.MRImageStorage, sopClassDictionary/* default */.Z.EnhancedMRImageStorage, sopClassDictionary/* default */.Z.EnhancedMRColorImageStorage, sopClassDictionary/* default */.Z.LegacyConvertedEnhancedMRImageStorage, sopClassDictionary/* default */.Z.UltrasoundImageStorage, sopClassDictionary/* default */.Z.UltrasoundImageStorageRET, sopClassDictionary/* default */.Z.SecondaryCaptureImageStorage, sopClassDictionary/* default */.Z.MultiframeSingleBitSecondaryCaptureImageStorage, sopClassDictionary/* default */.Z.MultiframeGrayscaleByteSecondaryCaptureImageStorage, sopClassDictionary/* default */.Z.MultiframeGrayscaleWordSecondaryCaptureImageStorage, sopClassDictionary/* default */.Z.MultiframeTrueColorSecondaryCaptureImageStorage, sopClassDictionary/* default */.Z.XRayAngiographicImageStorage, sopClassDictionary/* default */.Z.EnhancedXAImageStorage, sopClassDictionary/* default */.Z.XRayRadiofluoroscopicImageStorage, sopClassDictionary/* default */.Z.EnhancedXRFImageStorage, sopClassDictionary/* default */.Z.XRay3DAngiographicImageStorage, sopClassDictionary/* default */.Z.XRay3DCraniofacialImageStorage, sopClassDictionary/* default */.Z.BreastTomosynthesisImageStorage, sopClassDictionary/* default */.Z.BreastProjectionXRayImageStorageForPresentation, sopClassDictionary/* default */.Z.BreastProjectionXRayImageStorageForProcessing, sopClassDictionary/* default */.Z.IntravascularOpticalCoherenceTomographyImageStorageForPresentation, sopClassDictionary/* default */.Z.IntravascularOpticalCoherenceTomographyImageStorageForProcessing, sopClassDictionary/* default */.Z.NuclearMedicineImageStorage, sopClassDictionary/* default */.Z.VLEndoscopicImageStorage, sopClassDictionary/* default */.Z.VideoEndoscopicImageStorage, sopClassDictionary/* default */.Z.VLMicroscopicImageStorage, sopClassDictionary/* default */.Z.VideoMicroscopicImageStorage, sopClassDictionary/* default */.Z.VLSlideCoordinatesMicroscopicImageStorage, sopClassDictionary/* default */.Z.VLPhotographicImageStorage, sopClassDictionary/* default */.Z.VideoPhotographicImageStorage, sopClassDictionary/* default */.Z.OphthalmicPhotography8BitImageStorage, sopClassDictionary/* default */.Z.OphthalmicPhotography16BitImageStorage, sopClassDictionary/* default */.Z.OphthalmicTomographyImageStorage, sopClassDictionary/* default */.Z.VLWholeSlideMicroscopyImageStorage, sopClassDictionary/* default */.Z.PositronEmissionTomographyImageStorage, sopClassDictionary/* default */.Z.EnhancedPETImageStorage, sopClassDictionary/* default */.Z.LegacyConvertedEnhancedPETImageStorage, sopClassDictionary/* default */.Z.RTImageStorage, sopClassDictionary/* default */.Z.EnhancedUSVolumeStorage];
+const sopClassUids = [sopClassDictionary/* default */.A.ComputedRadiographyImageStorage, sopClassDictionary/* default */.A.DigitalXRayImageStorageForPresentation, sopClassDictionary/* default */.A.DigitalXRayImageStorageForProcessing, sopClassDictionary/* default */.A.DigitalMammographyXRayImageStorageForPresentation, sopClassDictionary/* default */.A.DigitalMammographyXRayImageStorageForProcessing, sopClassDictionary/* default */.A.DigitalIntraOralXRayImageStorageForPresentation, sopClassDictionary/* default */.A.DigitalIntraOralXRayImageStorageForProcessing, sopClassDictionary/* default */.A.CTImageStorage, sopClassDictionary/* default */.A.EnhancedCTImageStorage, sopClassDictionary/* default */.A.LegacyConvertedEnhancedCTImageStorage, sopClassDictionary/* default */.A.UltrasoundMultiframeImageStorage, sopClassDictionary/* default */.A.MRImageStorage, sopClassDictionary/* default */.A.EnhancedMRImageStorage, sopClassDictionary/* default */.A.EnhancedMRColorImageStorage, sopClassDictionary/* default */.A.LegacyConvertedEnhancedMRImageStorage, sopClassDictionary/* default */.A.UltrasoundImageStorage, sopClassDictionary/* default */.A.UltrasoundImageStorageRET, sopClassDictionary/* default */.A.SecondaryCaptureImageStorage, sopClassDictionary/* default */.A.MultiframeSingleBitSecondaryCaptureImageStorage, sopClassDictionary/* default */.A.MultiframeGrayscaleByteSecondaryCaptureImageStorage, sopClassDictionary/* default */.A.MultiframeGrayscaleWordSecondaryCaptureImageStorage, sopClassDictionary/* default */.A.MultiframeTrueColorSecondaryCaptureImageStorage, sopClassDictionary/* default */.A.XRayAngiographicImageStorage, sopClassDictionary/* default */.A.EnhancedXAImageStorage, sopClassDictionary/* default */.A.XRayRadiofluoroscopicImageStorage, sopClassDictionary/* default */.A.EnhancedXRFImageStorage, sopClassDictionary/* default */.A.XRay3DAngiographicImageStorage, sopClassDictionary/* default */.A.XRay3DCraniofacialImageStorage, sopClassDictionary/* default */.A.BreastTomosynthesisImageStorage, sopClassDictionary/* default */.A.BreastProjectionXRayImageStorageForPresentation, sopClassDictionary/* default */.A.BreastProjectionXRayImageStorageForProcessing, sopClassDictionary/* default */.A.IntravascularOpticalCoherenceTomographyImageStorageForPresentation, sopClassDictionary/* default */.A.IntravascularOpticalCoherenceTomographyImageStorageForProcessing, sopClassDictionary/* default */.A.NuclearMedicineImageStorage, sopClassDictionary/* default */.A.VLEndoscopicImageStorage, sopClassDictionary/* default */.A.VideoEndoscopicImageStorage, sopClassDictionary/* default */.A.VLMicroscopicImageStorage, sopClassDictionary/* default */.A.VideoMicroscopicImageStorage, sopClassDictionary/* default */.A.VLSlideCoordinatesMicroscopicImageStorage, sopClassDictionary/* default */.A.VLPhotographicImageStorage, sopClassDictionary/* default */.A.VideoPhotographicImageStorage, sopClassDictionary/* default */.A.OphthalmicPhotography8BitImageStorage, sopClassDictionary/* default */.A.OphthalmicPhotography16BitImageStorage, sopClassDictionary/* default */.A.OphthalmicTomographyImageStorage, sopClassDictionary/* default */.A.VLWholeSlideMicroscopyImageStorage, sopClassDictionary/* default */.A.PositronEmissionTomographyImageStorage, sopClassDictionary/* default */.A.EnhancedPETImageStorage, sopClassDictionary/* default */.A.LegacyConvertedEnhancedPETImageStorage, sopClassDictionary/* default */.A.RTImageStorage, sopClassDictionary/* default */.A.EnhancedUSVolumeStorage];
 function getSopClassHandlerModule() {
   return [{
     name: sopClassHandlerName,
@@ -4029,11 +4449,10 @@ function ToolbarLayoutSelector_extends() { ToolbarLayoutSelector_extends = Objec
 
 
 
-function ToolbarLayoutSelectorWithServices(_ref) {
-  let {
-    servicesManager,
-    ...props
-  } = _ref;
+function ToolbarLayoutSelectorWithServices({
+  servicesManager,
+  ...props
+}) {
   const {
     toolbarService
   } = servicesManager.services;
@@ -4053,14 +4472,13 @@ function ToolbarLayoutSelectorWithServices(_ref) {
     onSelection: onSelection
   }));
 }
-function LayoutSelector(_ref2) {
-  let {
-    rows,
-    columns,
-    className,
-    onSelection,
-    ...rest
-  } = _ref2;
+function LayoutSelector({
+  rows,
+  columns,
+  className,
+  onSelection,
+  ...rest
+}) {
   const [isOpen, setIsOpen] = (0,react.useState)(false);
   const closeOnOutsideClick = () => {
     if (isOpen) {
@@ -4074,8 +4492,8 @@ function LayoutSelector(_ref2) {
     };
   }, [isOpen]);
   const onInteractionHandler = () => setIsOpen(!isOpen);
-  const DropdownContent = isOpen ? ui_src/* LayoutSelector */.OF : null;
-  return /*#__PURE__*/react.createElement(ui_src/* ToolbarButton */.hA, {
+  const DropdownContent = isOpen ? ui_src/* LayoutSelector */.sG : null;
+  return /*#__PURE__*/react.createElement(ui_src/* ToolbarButton */.IB, {
     id: "Layout",
     label: "Grid Layout",
     icon: "tool-layout",
@@ -4095,7 +4513,7 @@ LayoutSelector.propTypes = {
   rows: (prop_types_default()).number,
   columns: (prop_types_default()).number,
   onLayoutChange: (prop_types_default()).func,
-  servicesManager: prop_types_default().instanceOf(src/* ServicesManager */.Xw)
+  servicesManager: prop_types_default().instanceOf(src/* ServicesManager */.CS)
 };
 LayoutSelector.defaultProps = {
   rows: 3,
@@ -4109,18 +4527,17 @@ function ToolbarSplitButtonWithServices_extends() { ToolbarSplitButtonWithServic
 
 
 
-function ToolbarSplitButtonWithServices(_ref) {
-  let {
-    isRadio,
-    isAction,
-    groupId,
-    primary,
-    secondary,
-    items,
-    renderer,
-    onInteraction,
-    servicesManager
-  } = _ref;
+function ToolbarSplitButtonWithServices({
+  isRadio,
+  isAction,
+  groupId,
+  primary,
+  secondary,
+  items,
+  renderer,
+  onInteraction,
+  servicesManager
+}) {
   const {
     toolbarService
   } = servicesManager?.services;
@@ -4168,7 +4585,7 @@ function ToolbarSplitButtonWithServices(_ref) {
   } = buttonsState;
   const isPrimaryToggle = state.primary.type === 'toggle';
   const isPrimaryActive = state.primary.type === 'tool' && primaryToolId === state.primary.id || isPrimaryToggle && toggles[state.primary.id] === true;
-  const PrimaryButtonComponent = toolbarService?.getButtonComponentForUIType(state.primary.uiType) ?? ui_src/* ToolbarButton */.hA;
+  const PrimaryButtonComponent = toolbarService?.getButtonComponentForUIType(state.primary.uiType) ?? ui_src/* ToolbarButton */.IB;
   (0,react.useEffect)(() => {
     const {
       unsubscribe
@@ -4193,20 +4610,19 @@ function ToolbarSplitButtonWithServices(_ref) {
       isActive
     };
   });
-  const DefaultListItemRenderer = _ref2 => {
-    let {
-      type,
-      icon,
-      label,
-      t,
-      id
-    } = _ref2;
+  const DefaultListItemRenderer = ({
+    type,
+    icon,
+    label,
+    t,
+    id
+  }) => {
     const isActive = type === 'toggle' && toggles[id] === true;
     return /*#__PURE__*/react.createElement("div", {
       className: classnames_default()('hover:bg-primary-dark flex h-8 w-full flex-row items-center p-3', 'whitespace-pre text-base', isActive && 'bg-primary-dark', isActive ? 'text-[#348CFD]' : 'text-common-bright hover:bg-primary-dark hover:text-primary-light')
     }, icon && /*#__PURE__*/react.createElement("span", {
       className: "mr-4"
-    }, /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+    }, /*#__PURE__*/react.createElement(ui_src/* Icon */.In, {
       name: icon,
       className: "h-5 w-5"
     })), /*#__PURE__*/react.createElement("span", {
@@ -4214,7 +4630,7 @@ function ToolbarSplitButtonWithServices(_ref) {
     }, t(label)));
   };
   const listItemRenderer = renderer || DefaultListItemRenderer;
-  return /*#__PURE__*/react.createElement(ui_src/* SplitButton */.aW, {
+  return /*#__PURE__*/react.createElement(ui_src/* SplitButton */.fk, {
     isRadio: isRadio,
     isAction: isAction,
     primary: state.primary,
@@ -4271,15 +4687,14 @@ function ToolbarButtonWithServices_extends() { ToolbarButtonWithServices_extends
 
 
 
-function ToolbarButtonWithServices(_ref) {
-  let {
-    id,
-    type,
-    commands,
-    onInteraction,
-    servicesManager,
-    ...props
-  } = _ref;
+function ToolbarButtonWithServices({
+  id,
+  type,
+  commands,
+  onInteraction,
+  servicesManager,
+  ...props
+}) {
   const {
     toolbarService
   } = servicesManager?.services || {};
@@ -4304,7 +4719,7 @@ function ToolbarButtonWithServices(_ref) {
       unsubscribe();
     };
   }, [toolbarService]);
-  return /*#__PURE__*/react.createElement(ui_src/* ToolbarButton */.hA, ToolbarButtonWithServices_extends({
+  return /*#__PURE__*/react.createElement(ui_src/* ToolbarButton */.IB, ToolbarButtonWithServices_extends({
     commands: commands,
     id: id,
     type: type,
@@ -4339,11 +4754,10 @@ ToolbarButtonWithServices.propTypes = {
 
 
 
-function getToolbarModule(_ref) {
-  let {
-    commandsManager,
-    servicesManager
-  } = _ref;
+function getToolbarModule({
+  commandsManager,
+  servicesManager
+}) {
   return [{
     name: 'ohif.divider',
     defaultComponent: ToolbarDivider,
@@ -4536,8 +4950,12 @@ function adaptItem(item, subProps) {
   return newItem;
 }
 // EXTERNAL MODULE: ../../ui/src/components/ContextMenu/ContextMenu.tsx
-var ContextMenu = __webpack_require__(5638);
+var ContextMenu = __webpack_require__(59852);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js + 14 modules
+var dist_esm = __webpack_require__(72980);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/CustomizableContextMenu/ContextMenuController.tsx
+var _class;
+
 
 
 /**
@@ -4584,6 +5002,16 @@ class ContextMenuController {
       menus,
       selectorProps
     } = contextMenuProps;
+    const annotationManager = dist_esm.annotation.state.getAnnotationManager();
+    const {
+      locking
+    } = dist_esm.annotation;
+    const targetAnnotationId = selectorProps?.nearbyToolData?.annotationUID;
+    const isLocked = locking.isAnnotationLocked(annotationManager.getAnnotation(targetAnnotationId));
+    if (isLocked) {
+      console.warn('Annotation is locked.');
+      return;
+    }
     console.log('Getting items from', menus);
     const items = getMenuItems(selectorProps || contextMenuProps, event, menus, menuId);
     this.services.uiDialogService.dismiss({
@@ -4596,7 +5024,7 @@ class ContextMenuController {
       preventCutOf: true,
       defaultPosition: ContextMenuController._getDefaultPosition(defaultPointsPosition, event?.detail, viewportElement),
       event,
-      content: ContextMenu/* default */.Z,
+      content: ContextMenu/* default */.A,
       // This naming is part of the uiDialogService convention
       // Clicking outside simply closes the dialog box.
       onClickOutside: () => this.services.uiDialogService.dismiss({
@@ -4642,6 +5070,7 @@ class ContextMenuController {
     });
   }
 }
+_class = ContextMenuController;
 ContextMenuController.getDefaultPosition = () => {
   return {
     x: 0,
@@ -4665,16 +5094,14 @@ ContextMenuController._getElementDefaultPosition = element => {
     y: undefined
   };
 };
-ContextMenuController._getCanvasPointsPosition = function () {
-  let points = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  let element = arguments.length > 1 ? arguments[1] : undefined;
-  const viewerPos = ContextMenuController._getElementDefaultPosition(element);
+ContextMenuController._getCanvasPointsPosition = (points = [], element) => {
+  const viewerPos = _class._getElementDefaultPosition(element);
   for (let pointIndex = 0; pointIndex < points.length; pointIndex++) {
     const point = {
       x: points[pointIndex][0] || points[pointIndex]['x'],
       y: points[pointIndex][1] || points[pointIndex]['y']
     };
-    if (ContextMenuController._isValidPosition(point) && ContextMenuController._isValidPosition(viewerPos)) {
+    if (_class._isValidPosition(point) && _class._isValidPosition(viewerPos)) {
       return {
         x: point.x + viewerPos.x,
         y: point.y + viewerPos.y
@@ -4690,17 +5117,17 @@ ContextMenuController._isValidPosition = source => {
  */
 ContextMenuController._getDefaultPosition = (canvasPoints, eventDetail, viewerElement) => {
   function* getPositionIterator() {
-    yield ContextMenuController._getCanvasPointsPosition(canvasPoints, viewerElement);
-    yield ContextMenuController._getEventDefaultPosition(eventDetail);
-    yield ContextMenuController._getElementDefaultPosition(viewerElement);
-    yield ContextMenuController.getDefaultPosition();
+    yield _class._getCanvasPointsPosition(canvasPoints, viewerElement);
+    yield _class._getEventDefaultPosition(eventDetail);
+    yield _class._getElementDefaultPosition(viewerElement);
+    yield _class.getDefaultPosition();
   }
   const positionIterator = getPositionIterator();
   let current = positionIterator.next();
   let position = current.value;
   while (!current.done) {
     position = current.value;
-    if (ContextMenuController._isValidPosition(position)) {
+    if (_class._isValidPosition(position)) {
       positionIterator.return();
     }
     current = positionIterator.next();
@@ -4715,12 +5142,9 @@ const defaultContextMenu = {
   // Get the items from the UI Customization for the menu name (and have a custom name)
   {
     id: 'forExistingMeasurement',
-    selector: _ref => {
-      let {
-        nearbyToolData
-      } = _ref;
-      return !!nearbyToolData;
-    },
+    selector: ({
+      nearbyToolData
+    }) => !!nearbyToolData,
     items: [{
       label: 'Delete measurement',
       commands: [{
@@ -4745,10 +5169,10 @@ const defaultContextMenu = {
 
 
 // EXTERNAL MODULE: ../../../node_modules/moment/moment.js
-var moment = __webpack_require__(71271);
+var moment = __webpack_require__(8291);
 var moment_default = /*#__PURE__*/__webpack_require__.n(moment);
 // EXTERNAL MODULE: ../../../node_modules/react-window/dist/index.esm.js
-var index_esm = __webpack_require__(94614);
+var index_esm = __webpack_require__(6943);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomTagBrowser/DicomTagTable.tsx
 
 
@@ -4765,13 +5189,12 @@ const rowStyle = {
   borderBottomWidth: `${rowBottomBorderPx}px`,
   ...rowVerticalPaddingStyle
 };
-function ColumnHeaders(_ref) {
-  let {
-    tagRef,
-    vrRef,
-    keywordRef,
-    valueRef
-  } = _ref;
+function ColumnHeaders({
+  tagRef,
+  vrRef,
+  keywordRef,
+  valueRef
+}) {
   return /*#__PURE__*/react.createElement("div", {
     className: classnames_default()('bg-secondary-dark ohif-scrollbar flex w-full flex-row overflow-y-scroll'),
     style: rowVerticalPaddingStyle
@@ -4805,10 +5228,9 @@ function ColumnHeaders(_ref) {
     className: "flex flex-row items-center focus:outline-none"
   }, "Value"))));
 }
-function DicomTagTable(_ref2) {
-  let {
-    rows
-  } = _ref2;
+function DicomTagTable({
+  rows
+}) {
   const listRef = (0,react.useRef)();
   const canvasRef = (0,react.useRef)();
   const [tagHeaderElem, setTagHeaderElem] = (0,react.useState)(null);
@@ -4862,11 +5284,10 @@ function DicomTagTable(_ref2) {
       window.removeEventListener('resize', debouncedResize);
     };
   }, []);
-  const Row = (0,react.useCallback)(_ref3 => {
-    let {
-      index,
-      style
-    } = _ref3;
+  const Row = (0,react.useCallback)(({
+    index,
+    style
+  }) => {
     const row = rows[index];
     return /*#__PURE__*/react.createElement("div", {
       style: {
@@ -4924,7 +5345,7 @@ function DicomTagTable(_ref2) {
     style: {
       height: '32rem'
     }
-  }, isHeaderRendered() && /*#__PURE__*/react.createElement(index_esm/* VariableSizeList */.S_, {
+  }, isHeaderRendered() && /*#__PURE__*/react.createElement(index_esm/* VariableSizeList */._m, {
     ref: listRef,
     height: 500,
     itemCount: rows.length,
@@ -4951,15 +5372,14 @@ const {
 } = src.classes;
 const {
   DicomMetaDictionary: DicomTagBrowser_DicomMetaDictionary
-} = dcmjs_es["default"].data;
+} = dcmjs_es/* default.data */.Ay.data;
 const {
   nameMap
 } = DicomTagBrowser_DicomMetaDictionary;
-const DicomTagBrowser = _ref => {
-  let {
-    displaySets,
-    displaySetInstanceUID
-  } = _ref;
+const DicomTagBrowser = ({
+  displaySets,
+  displaySetInstanceUID
+}) => {
   // The column indices that are to be excluded during a filter of the table.
   // At present the column indices are:
   // 0: DICOM tag
@@ -5042,12 +5462,12 @@ const DicomTagBrowser = _ref => {
     className: "mb-6 flex flex-row items-center pl-1"
   }, /*#__PURE__*/react.createElement("div", {
     className: "flex w-1/2 flex-row items-center"
-  }, /*#__PURE__*/react.createElement(ui_src/* Typography */.ZT, {
+  }, /*#__PURE__*/react.createElement(ui_src/* Typography */.o5, {
     variant: "subtitle",
     className: "mr-4"
   }, "Series"), /*#__PURE__*/react.createElement("div", {
     className: "mr-8 grow"
-  }, /*#__PURE__*/react.createElement(ui_src/* Select */.Ph, {
+  }, /*#__PURE__*/react.createElement(ui_src/* Select */.l6, {
     id: "display-set-selector",
     isClearable: false,
     onChange: onSelectChange,
@@ -5056,12 +5476,12 @@ const DicomTagBrowser = _ref => {
     className: "text-white"
   }))), /*#__PURE__*/react.createElement("div", {
     className: "flex w-1/2 flex-row items-center"
-  }, showInstanceList && /*#__PURE__*/react.createElement(ui_src/* Typography */.ZT, {
+  }, showInstanceList && /*#__PURE__*/react.createElement(ui_src/* Typography */.o5, {
     variant: "subtitle",
     className: "mr-4"
   }, "Instance Number"), showInstanceList && /*#__PURE__*/react.createElement("div", {
     className: "grow"
-  }, /*#__PURE__*/react.createElement(ui_src/* InputRange */.OX, {
+  }, /*#__PURE__*/react.createElement(ui_src/* InputRange */.Qr, {
     value: instanceNumber,
     key: selectedDisplaySetInstanceUID,
     onChange: value => {
@@ -5077,7 +5497,7 @@ const DicomTagBrowser = _ref => {
     className: "h-1 w-full bg-black"
   }), /*#__PURE__*/react.createElement("div", {
     className: "my-3 flex w-1/2 flex-row"
-  }, /*#__PURE__*/react.createElement(ui_src/* InputFilterText */.Xe, {
+  }, /*#__PURE__*/react.createElement(ui_src/* InputFilterText */.Cv, {
     className: "mr-8 block w-full",
     placeholder: "Search metadata...",
     onDebounceChange: setFilterValue
@@ -5101,7 +5521,7 @@ function getFormattedRowsFromTags(tags, metadata) {
     } else {
       if (tagInfo.vr === 'xs') {
         try {
-          const tag = dcmjs_es["default"].data.Tag.fromPString(tagInfo.tag).toCleanString();
+          const tag = dcmjs_es/* default.data */.Ay.data.Tag.fromPString(tagInfo.tag).toCleanString();
           const originalTagInfo = metadata[tag];
           tagInfo.vr = originalTagInfo.vr;
         } catch (error) {
@@ -5120,8 +5540,7 @@ function getSortedTags(metadata) {
   _sortTagList(tagList);
   return tagList;
 }
-function getRows(metadata) {
-  let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+function getRows(metadata, depth = 0) {
   // Tag, Type, Value, Keyword
 
   const keywords = Object.keys(metadata);
@@ -5132,7 +5551,6 @@ function getRows(metadata) {
   if (depth > 0) {
     tagIndent += ' '; // If indented, add a space after the indents.
   }
-
   const rows = [];
   for (let i = 0; i < keywords.length; i++) {
     let keyword = keywords[i];
@@ -5373,11 +5791,10 @@ const findViewportsByPosition_findOrCreateViewport = (hangingProtocolService, vi
  * @returns Set of states that can be applied to the state sync to remember
  *   the current view state.
  */
-const findViewportsByPosition = (state, _ref, syncService) => {
-  let {
-    numRows,
-    numCols
-  } = _ref;
+const findViewportsByPosition = (state, {
+  numRows,
+  numCols
+}, syncService) => {
   const {
     viewports
   } = state;
@@ -5415,7 +5832,7 @@ const findViewportsByPosition = (state, _ref, syncService) => {
 };
 /* harmony default export */ const src_findViewportsByPosition = (findViewportsByPosition);
 // EXTERNAL MODULE: ./index.js + 33 modules
-var index = __webpack_require__(59754);
+var index = __webpack_require__(45573);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/commandsModule.ts
 
 
@@ -5432,11 +5849,10 @@ const {
  * commands module, but if others get added elsewhere this may need enhancing.
  */
 const isHangingProtocolCommand = command => command && (command.commandName === 'setHangingProtocol' || command.commandName === 'toggleHangingProtocol');
-const commandsModule = _ref => {
-  let {
-    servicesManager,
-    commandsManager
-  } = _ref;
+const commandsModule = ({
+  servicesManager,
+  commandsManager
+}) => {
   const {
     customizationService,
     measurementService,
@@ -5491,12 +5907,11 @@ const commandsModule = _ref => {
     closeContextMenu: () => {
       contextMenuController.closeContextMenu();
     },
-    displayNotification: _ref2 => {
-      let {
-        text,
-        title,
-        type
-      } = _ref2;
+    displayNotification: ({
+      text,
+      title,
+      type
+    }) => {
       uiNotificationService.show({
         title: title,
         message: text,
@@ -5522,8 +5937,12 @@ const commandsModule = _ref => {
         }
         const {
           commands,
-          items
+          items,
+          primary
         } = button.props || button;
+        if (primary) {
+          enableListener(primary);
+        }
         if (items) {
           items.forEach(enableListener);
         }
@@ -5565,14 +5984,13 @@ const commandsModule = _ref => {
      * @param options.stageIndex - the index of the stage to go to.
      * @param options.reset - flag to indicate if the HP should be reset to its original and not restored to a previous state
      */
-    setHangingProtocol: _ref3 => {
-      let {
-        activeStudyUID = '',
-        protocolId,
-        stageId,
-        stageIndex,
-        reset = false
-      } = _ref3;
+    setHangingProtocol: ({
+      activeStudyUID = '',
+      protocolId,
+      stageId,
+      stageIndex,
+      reset = false
+    }) => {
       const primaryToolBeforeHPChange = toolbarService.getActivePrimaryTool();
       try {
         // Stores in the state the display set selector id to displaySetUID mapping
@@ -5633,9 +6051,6 @@ const commandsModule = _ref => {
         delete displaySetSelectorMap[`${activeStudyUID || hpInfo.activeStudyUID}:activeDisplaySet:0`];
         stateSyncService.store(stateSyncReduce);
         // This is a default action applied
-        const {
-          protocol
-        } = hangingProtocolService.getActiveProtocol();
         actions.toggleHpTools();
 
         // try to use the same tool in the new hanging protocol stage
@@ -5656,17 +6071,6 @@ const commandsModule = _ref => {
             });
           }
         }
-
-        // Send the notification about updating the state
-        if (protocolId !== hpInfo.protocolId) {
-          // The old protocol callbacks are used for turning off things
-          // like crosshairs when moving to the new HP
-          commandsManager.run(oldProtocol.callbacks?.onProtocolExit);
-          // The new protocol callback is used for things like
-          // activating modes etc.
-        }
-
-        commandsManager.run(protocol.callbacks?.onProtocolEnter);
         return true;
       } catch (e) {
         console.error(e);
@@ -5680,11 +6084,10 @@ const commandsModule = _ref => {
         return false;
       }
     },
-    toggleHangingProtocol: _ref4 => {
-      let {
-        protocolId,
-        stageIndex
-      } = _ref4;
+    toggleHangingProtocol: ({
+      protocolId,
+      stageIndex
+    }) => {
       const {
         protocol,
         stageIndex: desiredStageIndex,
@@ -5717,10 +6120,9 @@ const commandsModule = _ref => {
         });
       }
     },
-    deltaStage: _ref5 => {
-      let {
-        direction
-      } = _ref5;
+    deltaStage: ({
+      direction
+    }) => {
       const {
         protocolId,
         stageIndex: oldStageIndex
@@ -5746,11 +6148,10 @@ const commandsModule = _ref => {
     /**
      * Changes the viewport grid layout in terms of the MxN layout.
      */
-    setViewportGridLayout: _ref6 => {
-      let {
-        numRows,
-        numCols
-      } = _ref6;
+    setViewportGridLayout: ({
+      numRows,
+      numCols
+    }) => {
       const {
         protocol
       } = hangingProtocolService.getActiveProtocol();
@@ -5897,7 +6298,7 @@ const commandsModule = _ref => {
      *                      for `replace` is false
      */
     navigateHistory(historyArgs) {
-      index/* history */.m.navigate(historyArgs.to, historyArgs.options);
+      index/* history */.b.navigate(historyArgs.to, historyArgs.options);
     },
     openDICOMTagViewer() {
       const {
@@ -5960,11 +6361,10 @@ const commandsModule = _ref => {
         behavior: 'smooth'
       });
     },
-    updateViewportDisplaySet: _ref7 => {
-      let {
-        direction,
-        excludeNonImageModalities
-      } = _ref7;
+    updateViewportDisplaySet: ({
+      direction,
+      excludeNonImageModalities
+    }) => {
       const nonImageModalities = ['SR', 'SEG', 'SM', 'RTSTRUCT', 'RTPLAN', 'RTDOSE'];
 
       // Sort the display sets as per the hanging protocol service viewport/display set scoring system.
@@ -6480,6 +6880,9 @@ const defaultProtocol = {
   editableBy: {},
   protocolMatchingRules: [],
   toolGroupIds: ['default'],
+  hpInitiationCriteria: {
+    minSeriesLoaded: 1
+  },
   // -1 would be used to indicate active only, whereas other values are
   // the number of required priors referenced - so 0 means active with
   // 0 or more priors.
@@ -6524,7 +6927,6 @@ const defaultProtocol = {
       // studyMatchingRules: [],
     }
   },
-
   stages: [{
     name: 'default',
     viewportStructure: {
@@ -6550,7 +6952,6 @@ const defaultProtocol = {
         //   preset: 'middle', // 'first', 'last', 'middle'
         // },
       },
-
       displaySets: [{
         id: 'defaultDisplaySetId'
       }]
@@ -6582,8 +6983,8 @@ function getHangingProtocolModule() {
 
 
 function DataSourceSelector() {
-  const [appConfig] = (0,state/* useAppConfig */.M)();
-  const navigate = (0,dist/* useNavigate */.s0)();
+  const [appConfig] = (0,state/* useAppConfig */.r)();
+  const navigate = (0,dist/* useNavigate */.Zp)();
 
   // This is frowned upon, but the raw config is needed here to provide
   // the selector
@@ -6607,8 +7008,8 @@ function DataSourceSelector() {
     key: ds.sourceName
   }, /*#__PURE__*/react.createElement("h1", {
     className: "text-white"
-  }, ds.configuration?.friendlyName || ds.friendlyName), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
-    type: ui_src/* ButtonEnums.type */.LZ.dt.primary,
+  }, ds.configuration?.friendlyName || ds.friendlyName), /*#__PURE__*/react.createElement(ui_src/* Button */.$n, {
+    type: ui_src/* ButtonEnums.type */.Ny.NW.primary,
     className: classnames_default()('ml-2'),
     onClick: () => {
       navigate({
@@ -6624,15 +7025,14 @@ function DataSourceSelector() {
 
 
 
-function ItemListComponent(_ref) {
-  let {
-    itemLabel,
-    itemList,
-    onItemClicked
-  } = _ref;
+function ItemListComponent({
+  itemLabel,
+  itemList,
+  onItemClicked
+}) {
   const {
     t
-  } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
+  } = (0,es/* useTranslation */.Bd)('DataSourceConfiguration');
   const [filterValue, setFilterValue] = (0,react.useState)('');
   (0,react.useEffect)(() => {
     setFilterValue('');
@@ -6643,18 +7043,18 @@ function ItemListComponent(_ref) {
     className: "flex items-center justify-between"
   }, /*#__PURE__*/react.createElement("div", {
     className: "text-primary-light text-[20px]"
-  }, t(`Select ${itemLabel}`)), /*#__PURE__*/react.createElement(ui_src/* InputFilterText */.Xe, {
+  }, t(`Select ${itemLabel}`)), /*#__PURE__*/react.createElement(ui_src/* InputFilterText */.Cv, {
     className: "max-w-[40%] grow",
     value: filterValue,
     onDebounceChange: setFilterValue,
     placeholder: t(`Search ${itemLabel} list`)
   })), /*#__PURE__*/react.createElement("div", {
     className: "relative flex min-h-[1px] grow flex-col bg-black text-[14px]"
-  }, itemList == null ? /*#__PURE__*/react.createElement(ui_src/* LoadingIndicatorProgress */.LE, {
+  }, itemList == null ? /*#__PURE__*/react.createElement(ui_src/* LoadingIndicatorProgress */.Jx, {
     className: 'h-full w-full'
   }) : itemList.length === 0 ? /*#__PURE__*/react.createElement("div", {
     className: "text-primary-light flex h-full flex-col items-center justify-center px-6 py-4"
-  }, /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+  }, /*#__PURE__*/react.createElement(ui_src/* Icon */.In, {
     name: "magnifier",
     className: "mb-4"
   }), /*#__PURE__*/react.createElement("span", null, t(`No ${itemLabel} available`))) : /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("div", {
@@ -6666,10 +7066,10 @@ function ItemListComponent(_ref) {
     return /*#__PURE__*/react.createElement("div", {
       className: classnames_default()('hover:text-primary-light hover:bg-primary-dark group mx-2 flex items-center justify-between px-6 py-2', border),
       key: item.id
-    }, /*#__PURE__*/react.createElement("div", null, item.name), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
+    }, /*#__PURE__*/react.createElement("div", null, item.name), /*#__PURE__*/react.createElement(ui_src/* Button */.$n, {
       onClick: () => onItemClicked(item),
       className: "invisible group-hover:visible",
-      endIcon: /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+      endIcon: /*#__PURE__*/react.createElement(ui_src/* Icon */.In, {
         name: "arrow-left"
       })
     }, t('Select')));
@@ -6683,15 +7083,14 @@ function ItemListComponent(_ref) {
 
 
 const NO_WRAP_ELLIPSIS_CLASS_NAMES = 'text-ellipsis whitespace-nowrap overflow-hidden';
-function DataSourceConfigurationModalComponent(_ref) {
-  let {
-    configurationAPI,
-    configuredItems,
-    onHide
-  } = _ref;
+function DataSourceConfigurationModalComponent({
+  configurationAPI,
+  configuredItems,
+  onHide
+}) {
   const {
     t
-  } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
+  } = (0,es/* useTranslation */.Bd)('DataSourceConfiguration');
   const [itemList, setItemList] = (0,react.useState)();
   const [selectedItems, setSelectedItems] = (0,react.useState)(configuredItems);
   const [errorMessage, setErrorMessage] = (0,react.useState)();
@@ -6765,9 +7164,9 @@ function DataSourceConfigurationModalComponent(_ref) {
         } : undefined
       }, /*#__PURE__*/react.createElement("div", {
         className: "text- flex items-center gap-2"
-      }, itemLabelIndex < selectedItems.length ? /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+      }, itemLabelIndex < selectedItems.length ? /*#__PURE__*/react.createElement(ui_src/* Icon */.In, {
         name: "status-tracked"
-      }) : /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+      }) : /*#__PURE__*/react.createElement(ui_src/* Icon */.In, {
         name: "status-untracked"
       }), /*#__PURE__*/react.createElement("div", {
         className: classnames_default()(NO_WRAP_ELLIPSIS_CLASS_NAMES)
@@ -6795,18 +7194,17 @@ function DataSourceConfigurationModalComponent(_ref) {
 
 
 
-function DataSourceConfigurationComponent(_ref) {
-  let {
-    servicesManager,
-    extensionManager
-  } = _ref;
+function DataSourceConfigurationComponent({
+  servicesManager,
+  extensionManager
+}) {
   const {
     t
-  } = (0,es/* useTranslation */.$G)('DataSourceConfiguration');
+  } = (0,es/* useTranslation */.Bd)('DataSourceConfiguration');
   const {
     show,
     hide
-  } = (0,ui_src/* useModal */.dd)();
+  } = (0,ui_src/* useModal */.hS)();
   const {
     customizationService
   } = servicesManager.services;
@@ -6865,7 +7263,7 @@ function DataSourceConfigurationComponent(_ref) {
   }, [configurationAPI, configuredItems, showConfigurationModal]);
   return configuredItems ? /*#__PURE__*/react.createElement("div", {
     className: "text-aqua-pale flex items-center overflow-hidden"
-  }, /*#__PURE__*/react.createElement(ui_src/* Icon */.JO, {
+  }, /*#__PURE__*/react.createElement(ui_src/* Icon */.In, {
     name: "settings",
     className: "mr-2.5 h-3.5 w-3.5 shrink-0 cursor-pointer",
     onClick: showConfigurationModal
@@ -7017,9 +7415,7 @@ class GoogleCloudDataSourceConfigurationAPI {
    * @param fetchSearchParams any search query params; currently only used for paging results
    * @returns an array of items of the specified type
    */
-  static async _doFetch(urlStr, fetchItemType) {
-    let fetchOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    let fetchSearchParams = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  static async _doFetch(urlStr, fetchItemType, fetchOptions = {}, fetchSearchParams = {}) {
     try {
       const url = new URL(urlStr);
       url.search = new URLSearchParams(fetchSearchParams).toString();
@@ -7064,11 +7460,10 @@ class GoogleCloudDataSourceConfigurationAPI {
  * custom page for the user to view their profile, or to add a custom
  * page for login etc.
  */
-function getCustomizationModule(_ref) {
-  let {
-    servicesManager,
-    extensionManager
-  } = _ref;
+function getCustomizationModule({
+  servicesManager,
+  extensionManager
+}) {
   return [{
     name: 'helloPage',
     value: {
@@ -7197,10 +7592,10 @@ function getCustomizationModule(_ref) {
   }];
 }
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/calculate-suv/dist/calculate-suv.esm.js
-var calculate_suv_esm = __webpack_require__(15747);
+var calculate_suv_esm = __webpack_require__(79717);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getPTImageIdInstanceMetadata.ts
 
-const getPTImageIdInstanceMetadata_metadataProvider = src["default"].classes.MetadataProvider;
+const getPTImageIdInstanceMetadata_metadataProvider = src/* default.classes */.Ay.classes.MetadataProvider;
 function getPTImageIdInstanceMetadata(imageId) {
   const dicomMetaData = getPTImageIdInstanceMetadata_metadataProvider.get('instance', imageId);
   if (!dicomMetaData) {
@@ -7276,11 +7671,10 @@ const init_metadataProvider = src.classes.MetadataProvider;
  * @param {Object} servicesManager
  * @param {Object} configuration
  */
-function init(_ref) {
-  let {
-    servicesManager,
-    configuration = {}
-  } = _ref;
+function init({
+  servicesManager,
+  configuration = {}
+}) {
   const {
     stateSyncService
   } = servicesManager.services;
@@ -7327,43 +7721,41 @@ function init(_ref) {
     clearOnModeExit: true
   });
 }
-const handlePETImageMetadata = _ref2 => {
-  let {
-    SeriesInstanceUID,
-    StudyInstanceUID
-  } = _ref2;
+const handlePETImageMetadata = ({
+  SeriesInstanceUID,
+  StudyInstanceUID
+}) => {
   const {
     instances
   } = src.DicomMetadataStore.getSeries(StudyInstanceUID, SeriesInstanceUID);
+  if (!instances?.length) {
+    return;
+  }
   const modality = instances[0].Modality;
-  if (modality !== 'PT') {
+  if (!modality || modality !== 'PT') {
     return;
   }
   const imageIds = instances.map(instance => instance.imageId);
   const instanceMetadataArray = [];
-  imageIds.forEach(imageId => {
-    const instanceMetadata = getPTImageIdInstanceMetadata(imageId);
-    if (instanceMetadata) {
-      instanceMetadataArray.push(instanceMetadata);
-    }
-  });
-  if (!instanceMetadataArray.length) {
-    return;
-  }
 
   // try except block to prevent errors when the metadata is not correct
-  let suvScalingFactors;
   try {
-    suvScalingFactors = (0,calculate_suv_esm/* calculateSUVScalingFactors */.d)(instanceMetadataArray);
+    imageIds.forEach(imageId => {
+      const instanceMetadata = getPTImageIdInstanceMetadata(imageId);
+      if (instanceMetadata) {
+        instanceMetadataArray.push(instanceMetadata);
+      }
+    });
+    if (!instanceMetadataArray.length) {
+      return;
+    }
+    const suvScalingFactors = (0,calculate_suv_esm/* calculateSUVScalingFactors */.C)(instanceMetadataArray);
+    instanceMetadataArray.forEach((instanceMetadata, index) => {
+      init_metadataProvider.addCustomMetadata(imageIds[index], 'scalingModule', suvScalingFactors[index]);
+    });
   } catch (error) {
     console.log(error);
   }
-  if (!suvScalingFactors) {
-    return;
-  }
-  instanceMetadataArray.forEach((instanceMetadata, index) => {
-    init_metadataProvider.addCustomMetadata(imageIds[index], 'scalingModule', suvScalingFactors[index]);
-  });
 };
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/utils/index.ts
 
@@ -7397,10 +7789,9 @@ const defaultExtension = {
   getSopClassHandlerModule: src_getSopClassHandlerModule,
   getToolbarModule: getToolbarModule,
   getCommandsModule: src_commandsModule,
-  getUtilityModule(_ref) {
-    let {
-      servicesManager
-    } = _ref;
+  getUtilityModule({
+    servicesManager
+  }) {
     return [{
       name: 'common',
       exports: {