@ohif/app 3.7.0-beta.5 → 3.7.0-beta.50

package/dist/{82.bundle.0456c9e58fa89b131f14.js → 789.bundle.aad9b29b476ea70e1350.js}

@@ -1,7 +1,7 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[82],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[789],{
 
-/***/ 96082:
+/***/ 1789:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -28,11 +28,11 @@ __webpack_require__.d(utils_namespaceObject, {
 });
 
 // EXTERNAL MODULE: ../../../node_modules/dicomweb-client/build/dicomweb-client.es.js
-var dicomweb_client_es = __webpack_require__(75935);
-// EXTERNAL MODULE: ../../core/src/index.ts + 101 modules
-var src = __webpack_require__(48501);
+var dicomweb_client_es = __webpack_require__(97604);
+// EXTERNAL MODULE: ../../core/src/index.ts + 104 modules
+var src = __webpack_require__(24966);
 // EXTERNAL MODULE: ../../core/src/utils/sortStudy.ts
-var sortStudy = __webpack_require__(87853);
+var sortStudy = __webpack_require__(62971);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/qido.js
 /**
  * QIDO - Query based on ID for DICOM Objects
@@ -378,7 +378,7 @@ function getImageId(_ref) {
   }
 }
 // EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
-var dcmjs_es = __webpack_require__(22737);
+var dcmjs_es = __webpack_require__(67540);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoader.js
 /**
  * Class to define inheritance of load retrieve strategy.
@@ -708,12 +708,16 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
    * @returns
    */
   async searchForStudies(options) {
-    if (!this.staticWado) return super.searchForStudies(options);
+    if (!this.staticWado) {
+      return super.searchForStudies(options);
+    }
     const searchResult = await super.searchForStudies(options);
     const {
       queryParams
     } = options;
-    if (!queryParams) return searchResult;
+    if (!queryParams) {
+      return searchResult;
+    }
     const lowerParams = this.toLowerParams(queryParams);
     const filtered = searchResult.filter(study => {
       for (const key of Object.keys(StaticWadoClient.studyFilterKeys)) {
@@ -726,12 +730,16 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
     return filtered;
   }
   async searchForSeries(options) {
-    if (!this.staticWado) return super.searchForSeries(options);
+    if (!this.staticWado) {
+      return super.searchForSeries(options);
+    }
     const searchResult = await super.searchForSeries(options);
     const {
       queryParams
     } = options;
-    if (!queryParams) return searchResult;
+    if (!queryParams) {
+      return searchResult;
+    }
     const lowerParams = this.toLowerParams(queryParams);
     const filtered = searchResult.filter(series => {
       for (const key of Object.keys(StaticWadoClient.seriesFilterKeys)) {
@@ -767,8 +775,12 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
       actual = actual.Alphabetic;
     }
     if (typeof actual == 'string') {
-      if (actual.length === 0) return true;
-      if (desired.length === 0 || desired === '*') return true;
+      if (actual.length === 0) {
+        return true;
+      }
+      if (desired.length === 0 || desired === '*') {
+        return true;
+      }
       if (desired[0] === '*' && desired[desired.length - 1] === '*') {
         // console.log(`Comparing ${actual} to ${desired.substring(1, desired.length - 1)}`)
         return actual.indexOf(desired.substring(1, desired.length - 1)) != -1;
@@ -783,9 +795,13 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
 
   /** Compares a pair of dates to see if the value is within the range */
   compareDateRange(range, value) {
-    if (!value) return true;
+    if (!value) {
+      return true;
+    }
     const dash = range.indexOf('-');
-    if (dash === -1) return this.compareValues(range, value);
+    if (dash === -1) {
+      return this.compareValues(range, value);
+    }
     const start = range.substring(0, dash);
     const end = range.substring(dash + 1);
     return (!start || value >= start) && (!end || value <= end);
@@ -802,11 +818,17 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
    */
   filterItem(key, queryParams, study, sourceFilterMap) {
     const altKey = sourceFilterMap[key] || key;
-    if (!queryParams) return true;
+    if (!queryParams) {
+      return true;
+    }
     const testValue = queryParams[key] || queryParams[altKey];
-    if (!testValue) return true;
+    if (!testValue) {
+      return true;
+    }
     const valueElem = study[key] || study[altKey];
-    if (!valueElem) return false;
+    if (!valueElem) {
+      return false;
+    }
     if (valueElem.vr == 'DA') {
       return this.compareDateRange(testValue, valueElem.Value[0]);
     }
@@ -867,8 +889,12 @@ const getDirectURL = (config, params) => {
     singlepart: fetchPart = 'video'
   } = params;
   const value = instance[tag];
-  if (!value) return undefined;
-  if (value.DirectRetrieveURL) return value.DirectRetrieveURL;
+  if (!value) {
+    return undefined;
+  }
+  if (value.DirectRetrieveURL) {
+    return value.DirectRetrieveURL;
+  }
   if (value.InlineBinary) {
     const blob = src.utils.b64toBlob(value.InlineBinary, defaultType);
     value.DirectRetrieveURL = URL.createObjectURL(blob);
@@ -991,65 +1017,69 @@ const metadataProvider = src.classes.MetadataProvider;
  * @param {string|bool} singlepart - indicates of the retrieves can fetch singlepart.  Options are bulkdata, video, image or boolean true
  */
 function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
-  const {
-    qidoRoot,
-    wadoRoot,
-    enableStudyLazyLoad,
-    supportsFuzzyMatching,
-    supportsWildcard,
-    supportsReject,
-    staticWado,
-    singlepart
-  } = dicomWebConfig;
-  const dicomWebConfigCopy = JSON.parse(JSON.stringify(dicomWebConfig));
-  const qidoConfig = {
-    url: qidoRoot,
-    staticWado,
-    singlepart,
-    headers: userAuthenticationService.getAuthorizationHeader(),
-    errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
-  };
-  const wadoConfig = {
-    url: wadoRoot,
-    staticWado,
-    singlepart,
-    headers: userAuthenticationService.getAuthorizationHeader(),
-    errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
-  };
-
-  // TODO -> Two clients sucks, but its better than 1000.
-  // TODO -> We'll need to merge auth later.
-  const qidoDicomWebClient = staticWado ? new StaticWadoClient(qidoConfig) : new dicomweb_client_es.api.DICOMwebClient(qidoConfig);
-  const wadoDicomWebClient = staticWado ? new StaticWadoClient(wadoConfig) : new dicomweb_client_es.api.DICOMwebClient(wadoConfig);
+  let dicomWebConfigCopy, qidoConfig, wadoConfig, qidoDicomWebClient, wadoDicomWebClient, getAuthrorizationHeader, generateWadoHeader;
   const implementation = {
     initialize: _ref => {
       let {
         params,
         query
       } = _ref;
-      const {
-        StudyInstanceUIDs: paramsStudyInstanceUIDs
-      } = params;
-      const queryStudyInstanceUIDs = src.utils.splitComma(query.getAll('StudyInstanceUIDs'));
-      const StudyInstanceUIDs = queryStudyInstanceUIDs.length && queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
-      const StudyInstanceUIDsAsArray = StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs) ? StudyInstanceUIDs : [StudyInstanceUIDs];
-      return StudyInstanceUIDsAsArray;
+      if (dicomWebConfig.onConfiguration && typeof dicomWebConfig.onConfiguration === 'function') {
+        dicomWebConfig = dicomWebConfig.onConfiguration(dicomWebConfig, {
+          params,
+          query
+        });
+      }
+      dicomWebConfigCopy = JSON.parse(JSON.stringify(dicomWebConfig));
+      getAuthrorizationHeader = () => {
+        const xhrRequestHeaders = {};
+        const authHeaders = userAuthenticationService.getAuthorizationHeader();
+        if (authHeaders && authHeaders.Authorization) {
+          xhrRequestHeaders.Authorization = authHeaders.Authorization;
+        }
+        return xhrRequestHeaders;
+      };
+      generateWadoHeader = () => {
+        let authorizationHeader = getAuthrorizationHeader();
+        //Generate accept header depending on config params
+        let formattedAcceptHeader = src.utils.generateAcceptHeader(dicomWebConfig.acceptHeader, dicomWebConfig.requestTransferSyntaxUID, dicomWebConfig.omitQuotationForMultipartRequest);
+        return {
+          ...authorizationHeader,
+          Accept: formattedAcceptHeader
+        };
+      };
+      qidoConfig = {
+        url: dicomWebConfig.qidoRoot,
+        staticWado: dicomWebConfig.staticWado,
+        singlepart: dicomWebConfig.singlepart,
+        headers: userAuthenticationService.getAuthorizationHeader(),
+        errorInterceptor: src/* errorHandler */.Po.getHTTPErrorHandler()
+      };
+      wadoConfig = {
+        url: dicomWebConfig.wadoRoot,
+        staticWado: dicomWebConfig.staticWado,
+        singlepart: dicomWebConfig.singlepart,
+        headers: userAuthenticationService.getAuthorizationHeader(),
+        errorInterceptor: src/* errorHandler */.Po.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);
     },
     query: {
       studies: {
         mapParams: mapParams.bind(),
         search: async function (origParams) {
-          const headers = userAuthenticationService.getAuthorizationHeader();
-          if (headers) {
-            qidoDicomWebClient.headers = headers;
-          }
+          qidoDicomWebClient.headers = getAuthrorizationHeader();
           const {
             studyInstanceUid,
             seriesInstanceUid,
             ...mappedParams
           } = mapParams(origParams, {
-            supportsFuzzyMatching,
-            supportsWildcard
+            supportsFuzzyMatching: dicomWebConfig.supportsFuzzyMatching,
+            supportsWildcard: dicomWebConfig.supportsWildcard
           }) || {};
           const results = await search(qidoDicomWebClient, undefined, undefined, mappedParams);
           return processResults(results);
@@ -1059,10 +1089,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
       series: {
         // mapParams: mapParams.bind(),
         search: async function (studyInstanceUid) {
-          const headers = userAuthenticationService.getAuthorizationHeader();
-          if (headers) {
-            qidoDicomWebClient.headers = headers;
-          }
+          qidoDicomWebClient.headers = getAuthrorizationHeader();
           const results = await seriesInStudy(qidoDicomWebClient, studyInstanceUid);
           return processSeriesResults(results);
         }
@@ -1071,10 +1098,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
 
       instances: {
         search: (studyInstanceUid, queryParameters) => {
-          const headers = userAuthenticationService.getAuthorizationHeader();
-          if (headers) {
-            qidoDicomWebClient.headers = headers;
-          }
+          qidoDicomWebClient.headers = getAuthrorizationHeader();
           search.call(undefined, qidoDicomWebClient, studyInstanceUid, null, queryParameters);
         }
       }
@@ -1093,8 +1117,8 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
        */
       directURL: params => {
         return utils_getDirectURL({
-          wadoRoot,
-          singlepart
+          wadoRoot: dicomWebConfig.wadoRoot,
+          singlepart: dicomWebConfig.singlepart
         }, params);
       },
       bulkDataURI: async _ref2 => {
@@ -1102,6 +1126,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
           StudyInstanceUID,
           BulkDataURI
         } = _ref2;
+        qidoDicomWebClient.headers = getAuthrorizationHeader();
         const options = {
           multipart: false,
           BulkDataURI,
@@ -1121,14 +1146,10 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
             sortFunction,
             madeInClient = false
           } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-          const headers = userAuthenticationService.getAuthorizationHeader();
-          if (headers) {
-            wadoDicomWebClient.headers = headers;
-          }
           if (!StudyInstanceUID) {
             throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
           }
-          if (enableStudyLazyLoad) {
+          if (dicomWebConfig.enableStudyLazyLoad) {
             return implementation._retrieveSeriesMetadataAsync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient);
           }
           return implementation._retrieveSeriesMetadataSync(StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient);
@@ -1137,10 +1158,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     },
     store: {
       dicom: async (dataset, request) => {
-        const headers = userAuthenticationService.getAuthorizationHeader();
-        if (headers) {
-          wadoDicomWebClient.headers = headers;
-        }
+        wadoDicomWebClient.headers = getAuthrorizationHeader();
         if (dataset instanceof ArrayBuffer) {
           const options = {
             datasets: [dataset],
@@ -1170,7 +1188,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     },
     _retrieveSeriesMetadataSync: async (StudyInstanceUID, filters, sortCriteria, sortFunction, madeInClient) => {
       const enableStudyLazyLoad = false;
-
+      wadoDicomWebClient.headers = generateWadoHeader();
       // data is all SOPInstanceUIDs
       const data = await retrieveStudyMetadata(wadoDicomWebClient, StudyInstanceUID, enableStudyLazyLoad, filters, sortCriteria, sortFunction);
 
@@ -1215,6 +1233,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     _retrieveSeriesMetadataAsync: async function (StudyInstanceUID, filters, sortCriteria, sortFunction) {
       let madeInClient = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
       const enableStudyLazyLoad = true;
+      wadoDicomWebClient.headers = generateWadoHeader();
       // Get Series
       const {
         preLoadData: seriesSummaryMetadata,
@@ -1356,10 +1375,23 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
     },
     getConfig() {
       return dicomWebConfigCopy;
+    },
+    getStudyInstanceUIDs(_ref4) {
+      let {
+        params,
+        query
+      } = _ref4;
+      const {
+        StudyInstanceUIDs: paramsStudyInstanceUIDs
+      } = params;
+      const queryStudyInstanceUIDs = src.utils.splitComma(query.getAll('StudyInstanceUIDs'));
+      const StudyInstanceUIDs = queryStudyInstanceUIDs.length && queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
+      const StudyInstanceUIDsAsArray = StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs) ? StudyInstanceUIDs : [StudyInstanceUIDs];
+      return StudyInstanceUIDsAsArray;
     }
   };
-  if (supportsReject) {
-    implementation.reject = dcm4cheeReject(wadoRoot);
+  if (dicomWebConfig.supportsReject) {
+    implementation.reject = dcm4cheeReject(dicomWebConfig.wadoRoot);
   }
   return src/* IWebApiDataSource */.Is.create(implementation);
 }
@@ -1375,7 +1407,8 @@ const mappings = {
   patientId: 'PatientID'
 };
 let _store = {
-  urls: []
+  urls: [],
+  studyInstanceUIDMap: new Map() // map of urls to array of study instance UIDs
   // {
   //   url: url1
   //   studies: [Study1, Study2], // if multiple studies
@@ -1403,17 +1436,17 @@ const findStudies = (key, value) => {
 };
 function createDicomJSONApi(dicomJsonConfig) {
   const {
-    name,
     wadoRoot
   } = dicomJsonConfig;
   const implementation = {
     initialize: async _ref => {
       let {
-        params,
         query,
         url
       } = _ref;
-      if (!url) url = query.get('url');
+      if (!url) {
+        url = query.get('url');
+      }
       let metaData = getMetaDataByURL(url);
 
       // if we have already cached the data from this specific url
@@ -1425,8 +1458,7 @@ function createDicomJSONApi(dicomJsonConfig) {
         });
       }
       const response = await fetch(url);
-      let data = await response.json();
-      const studyInstanceUIDs = data.studies.map(study => study.StudyInstanceUID);
+      const data = await response.json();
       let StudyInstanceUID;
       let SeriesInstanceUID;
       data.studies.forEach(study => {
@@ -1452,7 +1484,7 @@ function createDicomJSONApi(dicomJsonConfig) {
         url,
         studies: [...data.studies]
       });
-      return studyInstanceUIDs;
+      _store.studyInstanceUIDMap.set(url, data.studies.map(study => study.StudyInstanceUID));
     },
     query: {
       studies: {
@@ -1561,7 +1593,9 @@ function createDicomJSONApi(dicomJsonConfig) {
               return obj;
             });
             storeInstances(instances);
-            if (index === numberOfSeries - 1) setSuccessFlag();
+            if (index === numberOfSeries - 1) {
+              setSuccessFlag();
+            }
           });
         }
       }
@@ -1608,6 +1642,14 @@ function createDicomJSONApi(dicomJsonConfig) {
         frame
       });
       return imageIds;
+    },
+    getStudyInstanceUIDs: _ref3 => {
+      let {
+        params,
+        query
+      } = _ref3;
+      const url = query.get('url');
+      return _store.studyInstanceUIDMap.get(url);
     }
   };
   return src/* IWebApiDataSource */.Is.create(implementation);
@@ -1628,8 +1670,12 @@ const END_MODALITIES = {
 };
 const compareValue = function (v1, v2) {
   let def = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  if (v1 === v2) return def;
-  if (v1 < v2) return -1;
+  if (v1 === v2) {
+    return def;
+  }
+  if (v1 < v2) {
+    return -1;
+  }
   return 1;
 };
 
@@ -1660,19 +1706,6 @@ function createDicomLocalApi(dicomLocalConfig) {
         params,
         query
       } = _ref;
-      const {
-        StudyInstanceUIDs: paramsStudyInstanceUIDs
-      } = params;
-      const queryStudyInstanceUIDs = query.getAll('StudyInstanceUIDs');
-      const StudyInstanceUIDs = queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
-      const StudyInstanceUIDsAsArray = StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs) ? StudyInstanceUIDs : [StudyInstanceUIDs];
-
-      // Put SRs at the end of series list to make sure images are loaded first
-      StudyInstanceUIDsAsArray.forEach(StudyInstanceUID => {
-        const study = src.DicomMetadataStore.getStudy(StudyInstanceUID);
-        study.series = study.series.sort(customSort);
-      });
-      return StudyInstanceUIDsAsArray;
     },
     query: {
       studies: {
@@ -1854,6 +1887,29 @@ function createDicomLocalApi(dicomLocalConfig) {
     },
     deleteStudyMetadataPromise() {
       console.log('deleteStudyMetadataPromise not implemented');
+    },
+    getStudyInstanceUIDs: _ref3 => {
+      let {
+        params,
+        query
+      } = _ref3;
+      const {
+        StudyInstanceUIDs: paramsStudyInstanceUIDs
+      } = params;
+      const queryStudyInstanceUIDs = query.getAll('StudyInstanceUIDs');
+      const StudyInstanceUIDs = queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
+      const StudyInstanceUIDsAsArray = StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs) ? StudyInstanceUIDs : [StudyInstanceUIDs];
+
+      // Put SRs at the end of series list to make sure images are loaded first
+      let isStudyInCache = false;
+      StudyInstanceUIDsAsArray.forEach(StudyInstanceUID => {
+        const study = src.DicomMetadataStore.getStudy(StudyInstanceUID);
+        if (study) {
+          study.series = study.series.sort(customSort);
+          isStudyInCache = true;
+        }
+      });
+      return isStudyInCache ? StudyInstanceUIDsAsArray : [];
     }
   };
   return src/* IWebApiDataSource */.Is.create(implementation);
@@ -1882,13 +1938,6 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
         params,
         query
       } = _ref;
-      let studyInstanceUIDs = [];
-
-      // there seem to be a couple of variations of the case for this parameter
-      const queryStudyInstanceUIDs = query.get('studyInstanceUIDs') || query.get('studyInstanceUids');
-      if (!queryStudyInstanceUIDs) {
-        throw new Error(`No studyInstanceUids in request for '${name}'`);
-      }
       const url = query.get('url');
       if (!url) {
         throw new Error(`No url for '${name}'`);
@@ -1898,10 +1947,12 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
         if (!data.servers?.dicomWeb?.[0]) {
           throw new Error('Invalid configuration returned by url');
         }
-        dicomWebDelegate = createDicomWebApi(data.servers.dicomWeb[0], UserAuthenticationService);
-        studyInstanceUIDs = queryStudyInstanceUIDs.split(';');
+        dicomWebDelegate = createDicomWebApi(data.servers.dicomWeb[0].configuration, UserAuthenticationService);
+        dicomWebDelegate.initialize({
+          params,
+          query
+        });
       }
-      return studyInstanceUIDs;
     },
     query: {
       studies: {
@@ -1939,6 +1990,21 @@ function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService)
     },
     getImageIdsForInstance: function () {
       return dicomWebDelegate.getImageIdsForInstance(...arguments);
+    },
+    getStudyInstanceUIDs(_ref2) {
+      let {
+        params,
+        query
+      } = _ref2;
+      let studyInstanceUIDs = [];
+
+      // there seem to be a couple of variations of the case for this parameter
+      const queryStudyInstanceUIDs = query.get('studyInstanceUIDs') || query.get('studyInstanceUids');
+      if (!queryStudyInstanceUIDs) {
+        throw new Error(`No studyInstanceUids in request for '${name}'`);
+      }
+      studyInstanceUIDs = queryStudyInstanceUIDs.split(';');
+      return studyInstanceUIDs;
     }
   };
   return src/* IWebApiDataSource */.Is.create(implementation);
@@ -1978,24 +2044,24 @@ function getDataSourcesModule() {
 }
 /* harmony default export */ const src_getDataSourcesModule = (getDataSourcesModule);
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
-var react = __webpack_require__(32735);
+var react = __webpack_require__(43001);
 // EXTERNAL MODULE: ../../../node_modules/prop-types/index.js
-var prop_types = __webpack_require__(60216);
+var prop_types = __webpack_require__(3827);
 var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
 // EXTERNAL MODULE: ../node_modules/react-router-dom/dist/index.js
-var dist = __webpack_require__(65783);
+var dist = __webpack_require__(62474);
 // EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules
-var es = __webpack_require__(21572);
+var es = __webpack_require__(69190);
 // EXTERNAL MODULE: ../node_modules/react-router/dist/index.js
-var react_router_dist = __webpack_require__(14935);
-// EXTERNAL MODULE: ../../ui/src/index.js + 452 modules
-var ui_src = __webpack_require__(28619);
-// EXTERNAL MODULE: ../../i18n/src/index.js + 95 modules
-var i18n_src = __webpack_require__(93058);
+var react_router_dist = __webpack_require__(85066);
+// EXTERNAL MODULE: ../../ui/src/index.js + 456 modules
+var ui_src = __webpack_require__(60082);
+// EXTERNAL MODULE: ../../i18n/src/index.js + 97 modules
+var i18n_src = __webpack_require__(24908);
 // EXTERNAL MODULE: ./state/index.js + 1 modules
-var state = __webpack_require__(22896);
+var state = __webpack_require__(62657);
 // EXTERNAL MODULE: ../../../node_modules/classnames/index.js
-var classnames = __webpack_require__(40841);
+var classnames = __webpack_require__(44921);
 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); }
@@ -2030,7 +2096,7 @@ function Toolbar(_ref) {
       unsub2();
     };
   }, [toolbarService]);
-  return /*#__PURE__*/react.createElement(react.Fragment, null, toolbarButtons.map((toolDef, index) => {
+  return /*#__PURE__*/react.createElement(react.Fragment, null, toolbarButtons.map(toolDef => {
     const {
       id,
       Component,
@@ -2116,8 +2182,10 @@ function ViewerLayout(_ref) {
     // Todo: Handle parameters in a better way.
     const query = new URLSearchParams(window.location.search);
     const configUrl = query.get('configUrl');
+    const dataSourceName = pathname.substring(dataSourceIdx + 1);
+    const existingDataSource = extensionManager.getDataSources(dataSourceName);
     const searchQuery = new URLSearchParams();
-    if (dataSourceIdx !== -1) {
+    if (dataSourceIdx !== -1 && existingDataSource) {
       searchQuery.append('datasources', pathname.substring(dataSourceIdx + 1));
     }
     if (configUrl) {
@@ -2143,8 +2211,8 @@ function ViewerLayout(_ref) {
     hotkeyDefinitions,
     hotkeyDefaults
   } = hotkeysManager;
-  const versionNumber = "3.7.0-beta.5";
-  const commitHash = "cc73f15c8ce3bf562081611e7a54ff4c3b9ef4f5";
+  const versionNumber = "3.7.0-beta.50";
+  const commitHash = "19408c987fa705aa8782a30820c0c012d0f3132f";
   const menuOptions = [{
     title: t('Header:About'),
     icon: 'info',
@@ -2364,6 +2432,7 @@ ViewerLayout.propTypes = {
 
 
 
+
 const {
   sortStudyInstances,
   formatDate
@@ -2386,6 +2455,8 @@ function PanelStudyBrowser(_ref) {
     displaySetService,
     uiNotificationService
   } = servicesManager.services;
+  const navigate = (0,dist/* useNavigate */.s0)();
+
   // 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
@@ -2427,6 +2498,10 @@ function PanelStudyBrowser(_ref) {
       const qidoForStudyUID = await dataSource.query.studies.search({
         studyInstanceUid: StudyInstanceUID
       });
+      if (!qidoForStudyUID?.length) {
+        navigate('/notfoundstudy', '_self');
+        throw new Error('Invalid study URL');
+      }
       let qidoStudiesForPatient = qidoForStudyUID;
 
       // try to fetch the prior studies based on the patientID if the
@@ -2617,6 +2692,7 @@ function _mapDisplaySets(displaySets, thumbnailImageSrcMap) {
       numInstances: ds.numImageFrames,
       countIcon: ds.countIcon,
       StudyInstanceUID: ds.StudyInstanceUID,
+      messages: ds.messages,
       componentType,
       imageSrc,
       dragData: {
@@ -2819,7 +2895,7 @@ ActionButtons.defaultProps = {
 };
 /* harmony default export */ const Panels_ActionButtons = (ActionButtons);
 // EXTERNAL MODULE: ../../../node_modules/lodash.debounce/index.js
-var lodash_debounce = __webpack_require__(40001);
+var lodash_debounce = __webpack_require__(8324);
 var lodash_debounce_default = /*#__PURE__*/__webpack_require__.n(lodash_debounce);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/Panels/createReportDialogPrompt.tsx
 /* eslint-disable react/display-name */
@@ -3336,7 +3412,9 @@ function _mapMeasurementToDisplay(measurement, index, types) {
   if (findingSites) {
     const siteText = [];
     findingSites.forEach(site => {
-      if (site?.text !== label) siteText.push(site.text);
+      if (site?.text !== label) {
+        siteText.push(site.text);
+      }
     });
     displayText = [...siteText, ...displayText];
   }
@@ -3403,25 +3481,297 @@ function getPanelModule(_ref) {
 }
 /* harmony default export */ const src_getPanelModule = (getPanelModule);
 // EXTERNAL MODULE: ../../core/src/utils/isImage.js
-var isImage = __webpack_require__(81596);
+var isImage = __webpack_require__(11835);
 // EXTERNAL MODULE: ../../core/src/utils/sopClassDictionary.js
-var sopClassDictionary = __webpack_require__(32746);
+var sopClassDictionary = __webpack_require__(24369);
 // EXTERNAL MODULE: ../../core/src/classes/ImageSet.ts
-var ImageSet = __webpack_require__(4797);
+var ImageSet = __webpack_require__(13950);
 // EXTERNAL MODULE: ../../core/src/utils/isDisplaySetReconstructable.js
-var isDisplaySetReconstructable = __webpack_require__(51227);
+var isDisplaySetReconstructable = __webpack_require__(89359);
 ;// CONCATENATED MODULE: ../../../extensions/default/package.json
 const package_namespaceObject = JSON.parse('{"u2":"@ohif/extension-default"}');
 ;// CONCATENATED MODULE: ../../../extensions/default/src/id.js
 
 const id = package_namespaceObject.u2;
 
+// EXTERNAL MODULE: ../../core/src/utils/sortInstancesByPosition.ts
+var sortInstancesByPosition = __webpack_require__(87425);
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/checkMultiframe.ts
+
+
+
+/**
+ * Check various multi frame issues. It calls OHIF core functions
+ * @param {*} multiFrameInstance
+ * @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/* hasOrientation */.sb)(multiFrameInstance)) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MULTIFRAME_NO_ORIENTATION);
+  }
+  if (!(0,isDisplaySetReconstructable/* hasPosition */.kN)(multiFrameInstance)) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.MULTIFRAME_NO_POSITION_INFORMATION);
+  }
+}
+// EXTERNAL MODULE: ../../core/src/utils/toNumber.js
+var toNumber = __webpack_require__(94972);
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageDimensionsEqual.ts
+
+
+/**
+ * Check if the frames in a series has different dimensions
+ * @param {*} instances
+ * @returns
+ */
+function areAllImageDimensionsEqual(instances) {
+  if (!instances?.length) {
+    return false;
+  }
+  const firstImage = instances[0];
+  const firstImageRows = (0,toNumber/* default */.Z)(firstImage.Rows);
+  const firstImageColumns = (0,toNumber/* default */.Z)(firstImage.Columns);
+  for (let i = 1; i < instances.length; i++) {
+    const instance = instances[i];
+    const {
+      Rows,
+      Columns
+    } = instance;
+    if (Rows !== firstImageRows || Columns !== firstImageColumns) {
+      return false;
+    }
+  }
+  return true;
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageComponentsEqual.ts
+
+
+/**
+ * Check if all voxels in series images has same number of components (samplesPerPixel)
+ * @param {*} instances
+ * @returns
+ */
+function areAllImageComponentsEqual(instances) {
+  if (!instances?.length) {
+    return false;
+  }
+  const firstImage = instances[0];
+  const firstImageSamplesPerPixel = (0,toNumber/* default */.Z)(firstImage.SamplesPerPixel);
+  for (let i = 1; i < instances.length; i++) {
+    const instance = instances[i];
+    const {
+      SamplesPerPixel
+    } = instance;
+    if (SamplesPerPixel !== firstImageSamplesPerPixel) {
+      return false;
+    }
+  }
+  return true;
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageOrientationsEqual.ts
+
+
+
+/**
+ * Check is the series has frames with different orientations
+ * @param {*} instances
+ * @returns
+ */
+function areAllImageOrientationsEqual(instances) {
+  if (!instances?.length) {
+    return false;
+  }
+  const firstImage = instances[0];
+  const firstImageOrientationPatient = (0,toNumber/* default */.Z)(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)) {
+      return false;
+    }
+  }
+  return true;
+}
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 10 modules
+var esm = __webpack_require__(45451);
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/calculateScanAxisNormal.ts
+
+
+/**
+ * Calculates the scanAxisNormal based on a image orientation vector extract from a frame
+ * @param {*} imageOrientation
+ * @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);
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImagePositionsEqual.ts
+
+
+
+
+
+/**
+ * Checks if there is a position shift between consecutive frames
+ * @param {*} previousPosition
+ * @param {*} actualPosition
+ * @param {*} scanAxisNormal
+ * @param {*} averageSpacingBetweenFrames
+ * @returns
+ */
+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;
+}
+
+/**
+ * Checks if a series has position shifts between consecutive frames
+ * @param {*} instances
+ * @returns
+ */
+function areAllImagePositionsEqual(instances) {
+  if (!instances?.length) {
+    return false;
+  }
+  const firstImageOrientationPatient = (0,toNumber/* default */.Z)(instances[0].ImageOrientationPatient);
+  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);
+  let previousImagePositionPatient = firstImagePositionPatient;
+  for (let i = 1; i < instances.length; i++) {
+    const instance = instances[i];
+    const imagePositionPatient = (0,toNumber/* default */.Z)(instance.ImagePositionPatient);
+    if (_checkSeriesPositionShift(previousImagePositionPatient, imagePositionPatient, scanAxisNormal, averageSpacingBetweenFrames)) {
+      return false;
+    }
+    previousImagePositionPatient = imagePositionPatient;
+  }
+  return true;
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/areAllImageSpacingEqual.ts
+
+
+
+/**
+ * Checks if series has spacing issues
+ * @param {*} instances
+ * @param {*} warnings
+ */
+function areAllImageSpacingEqual(instances, messages) {
+  if (!instances?.length) {
+    return;
+  }
+  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);
+  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);
+    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);
+        }
+      }
+      // we just want to find issues not how many
+      if (issuesFound.length > 1) {
+        break;
+      }
+    }
+    previousImagePositionPatient = imagePositionPatient;
+  }
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/utils/validations/checkSingleFrames.ts
+
+
+
+
+
+
+
+/**
+ * Runs various checks in a single frame series
+ * @param {*} instances
+ * @param {*} warnings
+ */
+function checkSingleFrames(instances, messages) {
+  if (instances.length > 2) {
+    if (!areAllImageDimensionsEqual(instances)) {
+      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_DIMENSIONS);
+    }
+    if (!areAllImageComponentsEqual(instances)) {
+      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_COMPONENTS);
+    }
+    if (!areAllImageOrientationsEqual(instances)) {
+      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_ORIENTATIONS);
+    }
+    if (!areAllImagePositionsEqual(instances)) {
+      messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.INCONSISTENT_POSITION_INFORMATION);
+    }
+    areAllImageSpacingEqual(instances, messages);
+  }
+}
+;// CONCATENATED MODULE: ../../../extensions/default/src/getDisplaySetMessages.ts
+
+
+
+
+
+/**
+ * Checks if a series is reconstructable to a 3D volume.
+ *
+ * @param {Object[]} instances An array of `OHIFInstanceMetadata` objects.
+ */
+function getDisplaySetMessages(instances, isReconstructable) {
+  const messages = new src/* DisplaySetMessageList */.iK();
+  if (!instances.length) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.NO_VALID_INSTANCES);
+  }
+  const firstInstance = instances[0];
+  // Due to current requirements, LOCALIZER series doesn't have any messages
+  if (firstInstance.ImageType.includes('LOCALIZER')) {
+    return messages;
+  }
+  const Modality = firstInstance.Modality;
+  if (!isDisplaySetReconstructable/* constructableModalities */.M6.includes(Modality)) {
+    return messages;
+  }
+  const isMultiframe = firstInstance.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);
+  }
+  const sortedInstances = (0,sortInstancesByPosition/* default */.Z)(instances);
+  isMultiframe ? checkMultiFrame(sortedInstances[0], messages) : checkSingleFrames(sortedInstances, messages);
+  if (!isReconstructable) {
+    messages.addMessage(src/* DisplaySetMessage */.Lt.CODES.NOT_RECONSTRUCTABLE);
+  }
+  return messages;
+}
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getSopClassHandlerModule.js
 
 
 
 
 
+
 const sopClassHandlerName = 'stack';
 const isMultiFrame = instance => {
   return instance.NumberOfFrames > 1;
@@ -3432,9 +3782,9 @@ const makeDisplaySet = instances => {
   const {
     value: isReconstructable,
     averageSpacingBetweenFrames
-  } = (0,isDisplaySetReconstructable/* default */.Z)(instances);
-
+  } = (0,isDisplaySetReconstructable/* default */.ZP)(instances);
   // set appropriate attributes to image set...
+  const messages = getDisplaySetMessages(instances, isReconstructable);
   imageSet.setAttributes({
     displaySetInstanceUID: imageSet.uid,
     // create a local alias for the imageSet UID
@@ -3452,6 +3802,7 @@ const makeDisplaySet = instances => {
     numImageFrames: instances.length,
     SOPClassHandlerId: `${id}.sopClassHandlerModule.${sopClassHandlerName}`,
     isReconstructable,
+    messages,
     averageSpacingBetweenFrames: averageSpacingBetweenFrames || null
   });
 
@@ -3856,7 +4207,7 @@ function adaptItem(item, subProps) {
   return newItem;
 }
 // EXTERNAL MODULE: ../../ui/src/components/ContextMenu/ContextMenu.tsx
-var ContextMenu = __webpack_require__(63021);
+var ContextMenu = __webpack_require__(5638);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/CustomizableContextMenu/ContextMenuController.tsx
 
 
@@ -4065,10 +4416,10 @@ const defaultContextMenu = {
 
 
 // EXTERNAL MODULE: ../../../node_modules/moment/moment.js
-var moment = __webpack_require__(53806);
+var moment = __webpack_require__(71271);
 var moment_default = /*#__PURE__*/__webpack_require__.n(moment);
 // EXTERNAL MODULE: ../../../node_modules/react-window/dist/index.esm.js
-var index_esm = __webpack_require__(21767);
+var index_esm = __webpack_require__(94614);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/DicomTagBrowser/DicomTagTable.tsx
 
 
@@ -4637,10 +4988,14 @@ const reuseCachedLayout = (state, hangingProtocolService, syncService) => {
       displaySetOptions,
       displaySetInstanceUIDs
     } = viewport;
-    if (!displaySetOptions) continue;
+    if (!displaySetOptions) {
+      continue;
+    }
     for (let i = 0; i < displaySetOptions.length; i++) {
       const displaySetUID = displaySetInstanceUIDs[i];
-      if (!displaySetUID) continue;
+      if (!displaySetUID) {
+        continue;
+      }
       if (idx === activeViewportIndex && i === 0) {
         displaySetSelectorMap[`${activeStudyUID}:activeDisplaySet:0`] = displaySetUID;
       }
@@ -4673,9 +5028,11 @@ const reuseCachedLayout = (state, hangingProtocolService, syncService) => {
  */
 const findViewportsByPosition_findOrCreateViewport = (hangingProtocolService, viewportsByPosition, viewportIndex, positionId, options) => {
   const byPositionViewport = viewportsByPosition?.[positionId];
-  if (byPositionViewport) return {
-    ...byPositionViewport
-  };
+  if (byPositionViewport) {
+    return {
+      ...byPositionViewport
+    };
+  }
   const {
     protocolId,
     stageIndex
@@ -4756,8 +5113,8 @@ const findViewportsByPosition = (state, _ref, syncService) => {
   };
 };
 /* harmony default export */ const src_findViewportsByPosition = (findViewportsByPosition);
-// EXTERNAL MODULE: ./index.js + 32 modules
-var index = __webpack_require__(97837);
+// EXTERNAL MODULE: ./index.js + 33 modules
+var index = __webpack_require__(59754);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/commandsModule.ts
 
 
@@ -4859,7 +5216,9 @@ const commandsModule = _ref => {
         stage
       } = hangingProtocolService.getActiveProtocol();
       const enableListener = button => {
-        if (!button.id) return;
+        if (!button.id) {
+          return;
+        }
         const {
           commands,
           items
@@ -4868,7 +5227,9 @@ const commandsModule = _ref => {
           items.forEach(enableListener);
         }
         const hpCommand = commands?.find?.(isHangingProtocolCommand);
-        if (!hpCommand) return;
+        if (!hpCommand) {
+          return;
+        }
         const {
           protocolId,
           stageIndex,
@@ -5743,7 +6104,7 @@ function DataSourceSelector() {
     key: ds.sourceName
   }, /*#__PURE__*/react.createElement("h1", {
     className: "text-white"
-  }, ds.friendlyName), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
+  }, ds.configuration?.friendlyName || ds.friendlyName), /*#__PURE__*/react.createElement(ui_src/* Button */.zx, {
     type: ui_src/* ButtonEnums.type */.LZ.U.primary,
     className: classnames_default()('ml-2'),
     onClick: () => {
@@ -5835,12 +6196,16 @@ function getCustomizationModule() {
     {
       id: 'ohif.overlayItem',
       content: function (props) {
-        if (this.condition && !this.condition(props)) return null;
+        if (this.condition && !this.condition(props)) {
+          return null;
+        }
         const {
           instance
         } = props;
         const value = instance && this.attribute ? instance[this.attribute] : this.contentF && typeof this.contentF === 'function' ? this.contentF(props) : null;
-        if (!value) return null;
+        if (!value) {
+          return null;
+        }
         return /*#__PURE__*/react.createElement("span", {
           className: "overlay-item flex flex-row",
           style: {
@@ -5882,7 +6247,7 @@ function getCustomizationModule() {
   }];
 }
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/calculate-suv/dist/calculate-suv.esm.js
-var calculate_suv_esm = __webpack_require__(71251);
+var calculate_suv_esm = __webpack_require__(15747);
 ;// CONCATENATED MODULE: ../../../extensions/default/src/getPTImageIdInstanceMetadata.ts
 
 const getPTImageIdInstanceMetadata_metadataProvider = src["default"].classes.MetadataProvider;