@cornerstonejs/dicom-image-loader 2.0.0-beta.20 → 2.0.0-beta.21

package/dist/esm/codecs/jpeg.d.ts

@@ -1,10 +1 @@
-declare namespace ColorSpace {
-    let Unkown: number;
-    let Grayscale: number;
-    let AdobeRGB: number;
-    let RGB: number;
-    let CYMK: number;
-}
-declare var JpegImage: {
-    new (): {};
-};
+export {};

package/dist/esm/codecs/jpeg.js

@@ -1,4 +1,3 @@
-"use strict";
 var ColorSpace = { Unkown: 0, Grayscale: 1, AdobeRGB: 2, RGB: 3, CYMK: 4 };
 var JpegImage = (function jpegImage() {
     'use strict';
@@ -888,3 +887,4 @@ var JpegImage = (function jpegImage() {
     });
     return JpegImage;
 })();
+export {};

package/dist/esm/codecs/jpegLossless.js

@@ -1,4 +1,3 @@
-"use strict";
 (function (f) {
     if (typeof exports === 'object' && typeof module !== 'undefined') {
         module.exports = f();
@@ -1217,3 +1216,4 @@
         ],
     }, {}, [6])(6);
 });
+export {};

package/dist/esm/src/decodeImageFrameWorker.js

@@ -100,7 +100,6 @@ async function decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeCon
     return postProcessed;
 }
 function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
-    const { use16BitDataType } = decodeConfig || {};
     const shouldShift = imageFrame.pixelRepresentation !== undefined &&
         imageFrame.pixelRepresentation === 1;
     const shift = shouldShift && imageFrame.bitsStored !== undefined
@@ -116,8 +115,8 @@ function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
     const { min: minBeforeScale, max: maxBeforeScale } = getMinMax(imageFrame.pixelData);
     const typedArrayConstructors = {
         Uint8Array,
-        Uint16Array: use16BitDataType ? Uint16Array : undefined,
-        Int16Array: use16BitDataType ? Int16Array : undefined,
+        Uint16Array,
+        Int16Array,
         Float32Array,
     };
     const type = options.targetBuffer?.type;
@@ -169,12 +168,9 @@ function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
         minAfterScale = minBeforeScale;
         maxAfterScale = maxBeforeScale;
     }
-    const hasTargetBuffer = options.targetBuffer !== undefined;
-    if (!hasTargetBuffer || !options.isSharedArrayBuffer) {
-        imageFrame.pixelData = pixelDataArray;
-    }
-    imageFrame.minAfterScale = minAfterScale;
-    imageFrame.maxAfterScale = maxAfterScale;
+    imageFrame.pixelData = pixelDataArray;
+    imageFrame.smallestPixelValue = minAfterScale;
+    imageFrame.largestPixelValue = maxAfterScale;
     const end = new Date().getTime();
     imageFrame.decodeTimeInMS = end - start;
     return imageFrame;
@@ -183,7 +179,7 @@ function _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelD
     const { arrayBuffer, type, offset: rawOffset = 0, length: rawLength, rows, } = options.targetBuffer;
     const TypedArrayConstructor = typedArrayConstructors[type];
     if (!TypedArrayConstructor) {
-        throw new Error(`target array ${type} is not supported, you need to set use16BitDataType to true if you want to use Uint16Array or Int16Array.`);
+        throw new Error(`target array ${type} is not supported, or doesn't exist.`);
     }
     if (rows && rows != imageFrame.rows) {
         scaleImageFrame(imageFrame, options.targetBuffer, TypedArrayConstructor);

package/dist/esm/src/imageLoader/colorSpaceConverters/convertPALETTECOLOR.d.ts

@@ -1,3 +1,3 @@
-import { ByteArray } from 'dicom-parser';
-import { ImageFrame } from '../../types';
-export default function (imageFrame: ImageFrame, colorBuffer: ByteArray, useRGBA: boolean): void;
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+export default function (imageFrame: Types.IImageFrame, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertRGBColorByPixel.d.ts

@@ -1,2 +1,2 @@
-import { ByteArray } from 'dicom-parser';
+import type { ByteArray } from 'dicom-parser';
 export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertRGBColorByPlane.d.ts

@@ -1,2 +1,2 @@
-import { ByteArray } from 'dicom-parser';
+import type { ByteArray } from 'dicom-parser';
 export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertYBRFull422ByPixel.d.ts

@@ -1,2 +1,2 @@
-import { ByteArray } from 'dicom-parser';
+import type { ByteArray } from 'dicom-parser';
 export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertYBRFullByPixel.d.ts

@@ -1,2 +1,2 @@
-import { ByteArray } from 'dicom-parser';
+import type { ByteArray } from 'dicom-parser';
 export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/colorSpaceConverters/convertYBRFullByPlane.d.ts

@@ -1,2 +1,2 @@
-import { ByteArray } from 'dicom-parser';
+import type { ByteArray } from 'dicom-parser';
 export default function (imageFrame: ByteArray, colorBuffer: ByteArray, useRGBA: boolean): void;

package/dist/esm/src/imageLoader/configure.d.ts

@@ -1,3 +1,3 @@
-import { LoaderOptions } from '../types';
+import type { LoaderOptions } from '../types';
 declare function configure(options: LoaderOptions): void;
 export default configure;

package/dist/esm/src/imageLoader/createImage.d.ts

@@ -1,4 +1,5 @@
-import { ByteArray } from 'dicom-parser';
-import { DICOMLoaderImageOptions, DICOMLoaderIImage, ImageFrame } from '../types';
-declare function createImage(imageId: string, pixelData: ByteArray, transferSyntax: string, options?: DICOMLoaderImageOptions): Promise<DICOMLoaderIImage | ImageFrame>;
+import type { ByteArray } from 'dicom-parser';
+import type { DICOMLoaderImageOptions, DICOMLoaderIImage } from '../types';
+import type { Types } from '@cornerstonejs/core/src';
+declare function createImage(imageId: string, pixelData: ByteArray, transferSyntax: string, options?: DICOMLoaderImageOptions): Promise<DICOMLoaderIImage | Types.IImageFrame>;
 export default createImage;

package/dist/esm/src/imageLoader/createImage.js

@@ -58,19 +58,11 @@ function createImage(imageId, pixelData, transferSyntax, options = {}) {
         if (scalingParameters) {
             options.preScale = {
                 ...options.preScale,
-                scalingParameters,
+                scalingParameters: scalingParameters,
             };
         }
     }
-    options.isSharedArrayBuffer =
-        options.targetBuffer?.arrayBuffer &&
-            options.targetBuffer.arrayBuffer instanceof SharedArrayBuffer;
     const { decodeConfig } = getOptions();
-    decodeConfig.use16BitDataType =
-        (options && options.targetBuffer?.type === 'Uint16Array') ||
-            options.targetBuffer?.type === 'Int16Array'
-            ? true
-            : options.useNativeDataType || decodeConfig.use16BitDataType;
     Object.keys(imageFrame).forEach((key) => {
         if (typeof imageFrame[key] === 'function' ||
             imageFrame[key] instanceof Promise) {
@@ -78,15 +70,13 @@ function createImage(imageId, pixelData, transferSyntax, options = {}) {
         }
     });
     const decodePromise = decodeImageFrame(imageFrame, transferSyntax, pixelData, canvas, options, decodeConfig);
-    const { use16BitDataType } = decodeConfig;
     const isColorImage = isColorImageFn(imageFrame.photometricInterpretation);
     return new Promise((resolve, reject) => {
         decodePromise.then(function (imageFrame) {
-            if (options.skipCreateImage) {
-                return resolve(imageFrame);
-            }
             let alreadyTyped = false;
-            if (options.targetBuffer && options.targetBuffer.type && !isColorImage) {
+            if (options.targetBuffer &&
+                options.targetBuffer.type &&
+                !isColorImage) {
                 const { arrayBuffer, type, offset: rawOffset = 0, length: rawLength, } = options.targetBuffer;
                 const imageFrameLength = imageFrame.pixelDataLength;
                 const offset = rawOffset;
@@ -95,8 +85,8 @@ function createImage(imageId, pixelData, transferSyntax, options = {}) {
                     : imageFrameLength - offset;
                 const typedArrayConstructors = {
                     Uint8Array,
-                    Uint16Array: use16BitDataType ? Uint16Array : undefined,
-                    Int16Array: use16BitDataType ? Int16Array : undefined,
+                    Uint16Array,
+                    Int16Array,
                     Float32Array,
                 };
                 if (length !== imageFrame.pixelDataLength) {
@@ -152,6 +142,8 @@ function createImage(imageId, pixelData, transferSyntax, options = {}) {
             }
             const image = {
                 imageId,
+                dataType: imageFrame.pixelData.constructor
+                    .name,
                 color: isColorImage,
                 calibration: calibrationModule,
                 columnPixelSpacing: imagePlaneModule.columnPixelSpacing,
@@ -186,7 +178,7 @@ function createImage(imageId, pixelData, transferSyntax, options = {}) {
                 rgba: isColorImage && useRGBA,
                 getPixelData: () => imageFrame.pixelData,
                 getCanvas: undefined,
-                numComps: undefined,
+                numberOfComponents: imageFrame.samplesPerPixel,
             };
             if (image.color) {
                 image.getCanvas = function () {
@@ -235,9 +227,10 @@ function createImage(imageId, pixelData, transferSyntax, options = {}) {
                 image.windowWidth = 256;
                 image.windowCenter = 128;
             }
-            if (image.windowCenter === undefined || image.windowWidth === undefined) {
-                const minVoi = image.imageFrame.minAfterScale;
-                const maxVoi = image.imageFrame.maxAfterScale;
+            if (image.windowCenter === undefined ||
+                image.windowWidth === undefined) {
+                const minVoi = image.imageFrame.smallestPixelValue;
+                const maxVoi = image.imageFrame.largestPixelValue;
                 image.windowWidth = maxVoi - minVoi;
                 image.windowCenter = (maxVoi + minVoi) / 2;
             }

package/dist/esm/src/imageLoader/decodeImageFrame.d.ts

@@ -1,3 +1,3 @@
-import { ImageFrame } from '../types';
-declare function decodeImageFrame(imageFrame: any, transferSyntax: any, pixelData: any, canvas: any, options: {}, decodeConfig: any): Promise<ImageFrame>;
+import type { Types } from '@cornerstonejs/core';
+declare function decodeImageFrame(imageFrame: any, transferSyntax: any, pixelData: any, canvas: any, options: {}, decodeConfig: any): Promise<Types.IImageFrame>;
 export default decodeImageFrame;

package/dist/esm/src/imageLoader/decodeJPEGBaseline8BitColor.d.ts

@@ -1,4 +1,4 @@
-import { ByteArray } from 'dicom-parser';
-import { ImageFrame } from '../types';
-declare function decodeJPEGBaseline8BitColor(imageFrame: ImageFrame, pixelData: ByteArray, canvas: HTMLCanvasElement): Promise<ImageFrame>;
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+declare function decodeJPEGBaseline8BitColor(imageFrame: Types.IImageFrame, pixelData: ByteArray, canvas: HTMLCanvasElement): Promise<Types.IImageFrame>;
 export default decodeJPEGBaseline8BitColor;

package/dist/esm/src/imageLoader/getImageFrame.d.ts

@@ -1,3 +1,3 @@
-import { ImageFrame } from '../types';
-declare function getImageFrame(imageId: string): ImageFrame;
+import type { Types } from '@cornerstonejs/core';
+declare function getImageFrame(imageId: string): Types.IImageFrame;
 export default getImageFrame;

package/dist/esm/src/imageLoader/getInstanceModule.d.ts

@@ -1,3 +1,3 @@
-declare function getInstanceModule(imageId: string, metaDataProvider: any, types: string[]): object;
+declare function getInstanceModule(imageId: any, metaDataProvider: any, types: any): {};
 declare const instanceModuleNames: string[];
 export { getInstanceModule, instanceModuleNames };

package/dist/esm/src/imageLoader/getScalingParameters.js

@@ -1,6 +1,7 @@
 export default function getScalingParameters(metaData, imageId) {
     const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-    const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+    const generalSeriesModule = (metaData.get('generalSeriesModule', imageId) ||
+        {});
     const { modality } = generalSeriesModule;
     const scalingParameters = {
         rescaleSlope: modalityLutModule.rescaleSlope,

package/dist/esm/src/imageLoader/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="dicom-parser" />
 import { convertRGBColorByPixel, convertRGBColorByPlane, convertYBRFullByPixel, convertYBRFullByPlane, convertPALETTECOLOR } from './colorSpaceConverters/index';
 import { default as wadouri } from './wadouri/index';
 import { default as wadors } from './wadors/index';
@@ -82,6 +81,7 @@ declare const cornerstoneDICOMImageLoader: {
     isJPEGBaseline8BitColor: typeof isJPEGBaseline8BitColor;
     internal: {
         xhrRequest: typeof import("./internal/xhrRequest").default;
+        streamRequest: typeof import("./internal/streamRequest").default;
         setOptions: typeof import("./internal/options").setOptions;
         getOptions: typeof import("./internal/options").getOptions;
     };

package/dist/esm/src/imageLoader/internal/index.d.ts

@@ -1,8 +1,10 @@
 import { default as xhrRequest } from './xhrRequest';
+import { default as streamRequest } from './streamRequest';
 import { setOptions, getOptions } from './options';
 declare const internal: {
     xhrRequest: typeof xhrRequest;
+    streamRequest: typeof streamRequest;
     setOptions: typeof setOptions;
     getOptions: typeof getOptions;
 };
-export { setOptions, getOptions, xhrRequest, internal };
+export { setOptions, getOptions, xhrRequest, internal, streamRequest };

package/dist/esm/src/imageLoader/internal/index.js

@@ -1,8 +1,10 @@
 import { default as xhrRequest } from './xhrRequest';
+import { default as streamRequest } from './streamRequest';
 import { setOptions, getOptions } from './options';
 const internal = {
     xhrRequest,
+    streamRequest,
     setOptions,
     getOptions,
 };
-export { setOptions, getOptions, xhrRequest, internal };
+export { setOptions, getOptions, xhrRequest, internal, streamRequest };

package/dist/esm/src/imageLoader/internal/options.d.ts

@@ -1,3 +1,3 @@
-import { LoaderOptions } from '../../types';
+import type { LoaderOptions } from '../../types';
 export declare function setOptions(newOptions: LoaderOptions): void;
 export declare function getOptions(): LoaderOptions;

package/dist/esm/src/imageLoader/internal/options.js

@@ -10,10 +10,6 @@ let options = {
     imageCreated() {
     },
     strict: false,
-    decodeConfig: {
-        convertFloatPixelDataToInt: true,
-        use16BitDataType: false,
-    },
 };
 export function setOptions(newOptions) {
     options = Object.assign(options, newOptions);

package/dist/esm/src/imageLoader/internal/rangeRequest.d.ts

@@ -1,6 +1,6 @@
-import { Enums } from '@cornerstonejs/core';
-import { LoaderXhrRequestPromise } from '../../types';
-import { CornerstoneWadoRsLoaderOptions } from '../wadors/loadImage';
+import type { Enums } from '@cornerstonejs/core';
+import type { LoaderXhrRequestPromise } from '../../types';
+import type { CornerstoneWadoRsLoaderOptions } from '../wadors/loadImage';
 export default function rangeRequest(url: string, imageId: string, defaultHeaders?: Record<string, string>, options?: CornerstoneWadoRsLoaderOptions): LoaderXhrRequestPromise<{
     contentType: string;
     pixelData: Uint8Array;

package/dist/esm/src/imageLoader/internal/streamRequest.d.ts

@@ -1,2 +1,2 @@
-import { CornerstoneWadoRsLoaderOptions } from '../wadors/loadImage';
+import type { CornerstoneWadoRsLoaderOptions } from '../wadors/loadImage';
 export default function streamRequest(url: string, imageId: string, defaultHeaders?: Record<string, string>, options?: CornerstoneWadoRsLoaderOptions): import("packages/core/dist/esm/utilities/ProgressiveIterator").PromiseIterator<unknown>;

package/dist/esm/src/imageLoader/internal/xhrRequest.d.ts

@@ -1,3 +1,3 @@
-import { LoaderXhrRequestParams, LoaderXhrRequestPromise } from '../../types';
+import type { LoaderXhrRequestParams, LoaderXhrRequestPromise } from '../../types';
 declare function xhrRequest(url: string, imageId: string, defaultHeaders?: Record<string, string>, params?: LoaderXhrRequestParams): LoaderXhrRequestPromise<ArrayBuffer>;
 export default xhrRequest;

package/dist/esm/src/imageLoader/isJPEGBaseline8BitColor.d.ts

@@ -1,3 +1,3 @@
-import { ImageFrame } from '../types';
-declare function isJPEGBaseline8BitColor(imageFrame: ImageFrame, transferSyntax: string): boolean;
+import type { Types } from '@cornerstonejs/core';
+declare function isJPEGBaseline8BitColor(imageFrame: Types.IImageFrame, transferSyntax: string): boolean;
 export default isJPEGBaseline8BitColor;

package/dist/esm/src/imageLoader/wadors/getImageQualityStatus.d.ts

@@ -1,2 +1,3 @@
-import { Types, Enums } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import { Enums } from '@cornerstonejs/core';
 export declare function getImageQualityStatus(retrieveOptions: Types.RetrieveOptions, done?: boolean): Enums.ImageQualityStatus;

package/dist/esm/src/imageLoader/wadors/getPixelData.d.ts

@@ -1,4 +1,4 @@
-import { CornerstoneWadoRsLoaderOptions } from './loadImage';
+import type { CornerstoneWadoRsLoaderOptions } from './loadImage';
 declare function getPixelData(uri: string, imageId: string, mediaType?: string, options?: CornerstoneWadoRsLoaderOptions): import("packages/core/dist/esm/utilities/ProgressiveIterator").PromiseIterator<unknown> | import("../../types").LoaderXhrRequestPromise<{
     contentType: string;
     pixelData: Uint8Array;

package/dist/esm/src/imageLoader/wadors/loadImage.d.ts

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { DICOMLoaderImageOptions } from '../../types';
+import type { DICOMLoaderImageOptions } from '../../types';
 export declare function getTransferSyntaxForContentType(contentType: string): string;
 export interface StreamingData {
     url: string;

package/dist/esm/src/imageLoader/wadors/metaData/getFirstNumberValue.d.ts

@@ -1,2 +1,2 @@
-declare function getFirstNumberValue(sequence: any, key: string): number | null;
+declare function getFirstNumberValue(sequence: unknown, key: string): number | null;
 export { getFirstNumberValue };

package/dist/esm/src/imageLoader/wadors/metaData/getNumberString.d.ts

@@ -1,3 +1,3 @@
-import { WADORSMetaDataElement } from '../../../types';
+import type { WADORSMetaDataElement } from '../../../types';
 declare function getNumberString(element: WADORSMetaDataElement, index: number, defaultValue: number): number;
 export default getNumberString;

package/dist/esm/src/imageLoader/wadors/metaData/getNumberString.js

@@ -4,6 +4,6 @@ function getNumberString(element, index, defaultValue) {
     if (value === undefined) {
         return;
     }
-    return parseFloat(value);
+    return parseFloat(String(value));
 }
 export default getNumberString;

package/dist/esm/src/imageLoader/wadors/metaData/getNumberValue.d.ts

@@ -1,3 +1,3 @@
-import { WADORSMetaDataElement } from '../../../types';
+import type { WADORSMetaDataElement } from '../../../types';
 declare function getNumberValue(element: WADORSMetaDataElement, index?: number): number;
 export default getNumberValue;

package/dist/esm/src/imageLoader/wadors/metaData/getNumberValues.d.ts

@@ -1,3 +1,3 @@
-import { WADORSMetaDataElement } from '../../../types';
+import type { WADORSMetaDataElement } from '../../../types';
 declare function getNumberValues(element: WADORSMetaDataElement, minimumLength?: number): number[];
 export default getNumberValues;

package/dist/esm/src/imageLoader/wadors/metaData/getOverlayPlaneModule.d.ts

@@ -1,4 +1,4 @@
-import { WADORSMetaData } from '../../../types';
+import type { WADORSMetaData } from '../../../types';
 export default function getOverlayPlaneModule(metaData: WADORSMetaData): {
     overlays: any[];
 };

package/dist/esm/src/imageLoader/wadors/metaData/getSequenceItems.d.ts

@@ -1,3 +1,3 @@
-import { WADORSMetaDataElement } from '../../../types';
+import type { WADORSMetaDataElement } from '../../../types';
 declare function getSequenceItems(element: any): WADORSMetaDataElement[];
 export default getSequenceItems;

package/dist/esm/src/imageLoader/wadors/metaData/getValue.d.ts

@@ -1,3 +1,3 @@
-import { WADORSMetaDataElement } from '../../../types';
+import type { WADORSMetaDataElement } from '../../../types';
 declare function getValue<ReturnType = unknown>(element: WADORSMetaDataElement, index?: number, defaultValue?: ReturnType): ReturnType;
 export default getValue;

package/dist/esm/src/imageLoader/wadors/metaData/getValue.js

@@ -6,7 +6,7 @@ function getValue(element, index, defaultValue) {
     if (!element.Value) {
         return defaultValue;
     }
-    if (element.Value.length <= index) {
+    if (Array.isArray(element.Value) && element.Value.length <= index) {
         return defaultValue;
     }
     return element.Value[index];

package/dist/esm/src/imageLoader/wadors/metaData/metaDataProvider.d.ts

@@ -1,4 +1,4 @@
-declare function metaDataProvider(type: any, imageId: any): object;
+declare function metaDataProvider(type: any, imageId: any): {};
 export declare function getImageUrlModule(imageId: any, metaData: any): {
     isVideo: any;
     rendered: any;

package/dist/esm/src/imageLoader/wadors/metaDataManager.d.ts

@@ -1,4 +1,4 @@
-import { WADORSMetaData } from '../../types';
+import type { WADORSMetaData } from '../../types';
 declare let metadataByImageURI: any[];
 declare function add(imageId: string, metadata: WADORSMetaData): void;
 declare function get(imageId: string): WADORSMetaData;

package/dist/esm/src/imageLoader/wadors/metaDataManager.js

@@ -5,7 +5,10 @@ let metadataByImageURI = [];
 let multiframeMetadataByImageURI = {};
 function add(imageId, metadata) {
     const imageURI = imageIdToURI(imageId);
-    metadata.isMultiframe = multiframeMetadata.isMultiframe(metadata);
+    Object.defineProperty(metadata, 'isMultiframe', {
+        value: multiframeMetadata.isMultiframe(metadata),
+        enumerable: false,
+    });
     metadataByImageURI[imageURI] = metadata;
 }
 function get(imageId) {

package/dist/esm/src/imageLoader/wadouri/combineFrameInstanceDataset.js

@@ -19,11 +19,13 @@ function getFrameInformation(PerFrameFunctionalGroupsSequence, SharedFunctionalG
     const shared = {};
     (SharedFunctionalGroupsSequence
         ? Object.values(SharedFunctionalGroupsSequence.items[0].dataSet.elements)
-        : []).map((it) => (shared[it.tag] = it));
+        : [])
+        .map((it) => (shared[it.tag] = it));
     const perFrame = {};
     (PerFrameFunctionalGroupsSequence
         ? Object.values(PerFrameFunctionalGroupsSequence.items[frameNumber - 1].dataSet.elements)
-        : []).map((it) => (perFrame[it.tag] = it));
+        : [])
+        .map((it) => (perFrame[it.tag] = it));
     return {
         shared,
         perFrame,

package/dist/esm/src/imageLoader/wadouri/dataSetCacheManager.d.ts

@@ -1,5 +1,5 @@
-import { DataSet } from 'dicom-parser';
-import { LoadRequestFunction, DICOMLoaderDataSetWithFetchMore } from '../../types';
+import type { DataSet } from 'dicom-parser';
+import type { LoadRequestFunction, DICOMLoaderDataSetWithFetchMore } from '../../types';
 export interface CornerstoneWadoLoaderCacheManagerInfoResponse {
     cacheSizeInBytes: number;
     numberOfDataSetsCached: number;

package/dist/esm/src/imageLoader/wadouri/dataset-from-partial-content.d.ts

@@ -1,4 +1,4 @@
-import { LoadRequestFunction, DICOMLoaderDataSetWithFetchMore } from '../../types';
+import type { LoadRequestFunction, DICOMLoaderDataSetWithFetchMore } from '../../types';
 export default function dataSetFromPartialContent(byteArray: Uint8Array, loadRequest: LoadRequestFunction, metadata: {
     uri: string;
     imageId: string;

package/dist/esm/src/imageLoader/wadouri/getEncapsulatedImageFrame.d.ts

@@ -1,2 +1,2 @@
-import { ByteArray, DataSet } from 'dicom-parser';
+import type { ByteArray, DataSet } from 'dicom-parser';
 export default function getEncapsulatedImageFrame(dataSet: DataSet, frameIndex: number): ByteArray;

package/dist/esm/src/imageLoader/wadouri/getPixelData.d.ts

@@ -1,3 +1,3 @@
-import { ByteArray, DataSet } from 'dicom-parser';
+import type { ByteArray, DataSet } from 'dicom-parser';
 declare function getPixelData(dataSet: DataSet, frameIndex?: number): ByteArray;
 export default getPixelData;

package/dist/esm/src/imageLoader/wadouri/getUncompressedImageFrame.d.ts

@@ -1,3 +1,3 @@
-import { DataSet } from 'dicom-parser';
+import type { DataSet } from 'dicom-parser';
 declare function getUncompressedImageFrame(dataSet: DataSet, frameIndex: number): Uint8Array;
 export default getUncompressedImageFrame;

package/dist/esm/src/imageLoader/wadouri/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="dicom-parser" />
 import { getImagePixelModule, getLUTs, getModalityLUTOutputPixelRepresentation, getNumberValues, metaDataProvider } from './metaData/index';
 import getEncapsulatedImageFrame from './getEncapsulatedImageFrame';
 import getUncompressedImageFrame from './getUncompressedImageFrame';

package/dist/esm/src/imageLoader/wadouri/loadImage.d.ts

@@ -1,6 +1,6 @@
-import { DataSet } from 'dicom-parser';
-import { Types } from '@cornerstonejs/core';
-import { LoadRequestFunction, DICOMLoaderIImage, DICOMLoaderImageOptions } from '../../types';
+import type { DataSet } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+import type { LoadRequestFunction, DICOMLoaderIImage, DICOMLoaderImageOptions } from '../../types';
 declare function loadImageFromPromise(dataSetPromise: Promise<DataSet>, imageId: string, frame: number, sharedCacheKey: string, options: DICOMLoaderImageOptions, callbacks?: {
     imageDoneCallback: (image: DICOMLoaderIImage) => void;
 }): Types.IImageLoadObject;

package/dist/esm/src/imageLoader/wadouri/metaData/USHelpers.d.ts

@@ -0,0 +1,2 @@
+declare function getUSEnhancedRegions(metadata: any): any;
+export { getUSEnhancedRegions };

package/dist/esm/src/imageLoader/wadouri/metaData/USHelpers.js

@@ -0,0 +1,44 @@
+function getUSEnhancedRegions(metadata) {
+    const sequence = metadata.elements['x00186011'];
+    if (!sequence || !sequence.items) {
+        return [];
+    }
+    const regions = sequence.items.map((item) => {
+        const physicalDeltaX = item.dataSet.double('x0018602c');
+        const physicalDeltaY = item.dataSet.double('x0018602e');
+        const physicalUnitsXDirection = item.dataSet.uint16('x00186024');
+        const physicalUnitsYDirection = item.dataSet.uint16('x00186026');
+        const regionLocationMinY0 = item.dataSet.uint16('x0018601a');
+        const regionLocationMaxY1 = item.dataSet.uint16('x0018601e');
+        const regionLocationMinX0 = item.dataSet.uint16('x00186018');
+        const regionLocationMaxX1 = item.dataSet.uint16('x0018601c');
+        const referencePixelX0 = item.dataSet.int32('x00186020') || null;
+        const referencePixelY0 = item.dataSet.int32('x00186022') || null;
+        const referencePhysicalPixelValueY = item.dataSet.uint16('x0018602a');
+        const referencePhysicalPixelValueX = item.dataSet.uint16('x00186028');
+        const regionSpatialFormat = item.dataSet.uint16('x00186012');
+        const regionDataType = item.dataSet.uint16('x00186014');
+        const regionFlags = item.dataSet.uint16('x00186016');
+        const transducerFrequency = item.dataSet.uint16('x00186030');
+        return {
+            regionLocationMinY0,
+            regionLocationMaxY1,
+            regionLocationMinX0,
+            regionLocationMaxX1,
+            referencePixelX0,
+            referencePixelY0,
+            physicalDeltaX,
+            physicalDeltaY,
+            physicalUnitsXDirection,
+            physicalUnitsYDirection,
+            referencePhysicalPixelValueY,
+            referencePhysicalPixelValueX,
+            regionSpatialFormat,
+            regionDataType,
+            regionFlags,
+            transducerFrequency,
+        };
+    });
+    return regions;
+}
+export { getUSEnhancedRegions };

package/dist/esm/src/imageLoader/wadouri/metaData/getImagePixelModule.d.ts

@@ -1,4 +1,4 @@
-import { MetadataImagePixelModule } from '../../../types';
-import { DataSet } from 'dicom-parser';
-declare function getImagePixelModule(dataSet: DataSet): MetadataImagePixelModule;
+import type { Types } from '@cornerstonejs/core';
+import type { DataSet } from 'dicom-parser';
+declare function getImagePixelModule(dataSet: DataSet): Types.ImagePixelModuleMetadata;
 export default getImagePixelModule;

package/dist/esm/src/imageLoader/wadouri/metaData/getLUTs.d.ts

@@ -1,4 +1,4 @@
-import { Element } from 'dicom-parser';
-import { LutType } from '../../../types';
+import type { Element } from 'dicom-parser';
+import type { LutType } from '../../../types';
 declare function getLUTs(pixelRepresentation: number, lutSequence: Element): LutType[];
 export default getLUTs;

package/dist/esm/src/imageLoader/wadouri/metaData/getModalityLUTOutputPixelRepresentation.d.ts

@@ -1,3 +1,3 @@
-import { DataSet } from 'dicom-parser';
+import type { DataSet } from 'dicom-parser';
 declare function getModalityLUTOutputPixelRepresentation(dataSet: DataSet): number;
 export default getModalityLUTOutputPixelRepresentation;

package/dist/esm/src/imageLoader/wadouri/metaData/getNumberValues.d.ts

@@ -1,3 +1,3 @@
-import { DataSet } from 'dicom-parser';
+import type { DataSet } from 'dicom-parser';
 declare function getNumberValues(dataSet: DataSet, tag: string, minimumLength: number): number[];
 export default getNumberValues;

package/dist/esm/src/imageLoader/wadouri/metaData/getOverlayPlaneModule.d.ts

@@ -1,4 +1,4 @@
-import { DataSet } from 'dicom-parser';
+import type { DataSet } from 'dicom-parser';
 export default function getOverlayPlaneModule(dataSet: DataSet): {
     overlays: any[];
 };

package/dist/esm/src/imageLoader/wadouri/metaData/metaDataProvider.d.ts

@@ -1,2 +1,2 @@
-declare function metaDataProvider(type: any, imageId: any): object;
+declare function metaDataProvider(type: any, imageId: any): any;
 export default metaDataProvider;