@cornerstonejs/dicom-image-loader 2.0.0-beta.7 → 2.0.0

package/dist/esm/shared/decoders/decodeJPEGLossless.d.ts

@@ -0,0 +1,6 @@
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+import type { WebWorkerDecodeConfig } from '../../types';
+export declare function initialize(decodeConfig?: WebWorkerDecodeConfig): Promise<void>;
+declare function decodeJPEGLossless(imageFrame: Types.IImageFrame, pixelData: ByteArray): Promise<Types.IImageFrame>;
+export default decodeJPEGLossless;

package/dist/esm/shared/decoders/decodeJPEGLossless.js

@@ -0,0 +1,39 @@
+const local = {
+    jpeg: undefined,
+    decodeConfig: {},
+};
+export function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.jpeg) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        import('../../codecs/jpegLossless').then((jpeg) => {
+            local.jpeg = jpeg;
+            resolve();
+        }, reject);
+    });
+}
+async function decodeJPEGLossless(imageFrame, pixelData) {
+    await initialize();
+    if (typeof local.jpeg === 'undefined' ||
+        typeof local.jpeg.lossless === 'undefined' ||
+        typeof local.jpeg.lossless.Decoder === 'undefined') {
+        throw new Error('No JPEG Lossless decoder loaded');
+    }
+    const byteOutput = imageFrame.bitsAllocated <= 8 ? 1 : 2;
+    const buffer = pixelData.buffer;
+    const decoder = new local.jpeg.lossless.Decoder();
+    const decompressedData = decoder.decode(buffer, pixelData.byteOffset, pixelData.length, byteOutput);
+    if (imageFrame.pixelRepresentation === 0) {
+        if (imageFrame.bitsAllocated === 16) {
+            imageFrame.pixelData = new Uint16Array(decompressedData.buffer);
+            return imageFrame;
+        }
+        imageFrame.pixelData = new Uint8Array(decompressedData.buffer);
+        return imageFrame;
+    }
+    imageFrame.pixelData = new Int16Array(decompressedData.buffer);
+    return imageFrame;
+}
+export default decodeJPEGLossless;

package/dist/esm/shared/decoders/decodeLittleEndian.d.ts

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

package/dist/esm/shared/decoders/decodeLittleEndian.js

@@ -0,0 +1,29 @@
+async function decodeLittleEndian(imageFrame, pixelData) {
+    let arrayBuffer = pixelData.buffer;
+    let offset = pixelData.byteOffset;
+    const length = pixelData.length;
+    if (imageFrame.bitsAllocated === 16) {
+        if (offset % 2) {
+            arrayBuffer = arrayBuffer.slice(offset);
+            offset = 0;
+        }
+        if (imageFrame.pixelRepresentation === 0) {
+            imageFrame.pixelData = new Uint16Array(arrayBuffer, offset, length / 2);
+        }
+        else {
+            imageFrame.pixelData = new Int16Array(arrayBuffer, offset, length / 2);
+        }
+    }
+    else if (imageFrame.bitsAllocated === 8 || imageFrame.bitsAllocated === 1) {
+        imageFrame.pixelData = pixelData;
+    }
+    else if (imageFrame.bitsAllocated === 32) {
+        if (offset % 2) {
+            arrayBuffer = arrayBuffer.slice(offset);
+            offset = 0;
+        }
+        imageFrame.pixelData = new Float32Array(arrayBuffer, offset, length / 4);
+    }
+    return imageFrame;
+}
+export default decodeLittleEndian;

package/dist/esm/shared/decoders/decodeRLE.d.ts

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

package/dist/esm/shared/decoders/decodeRLE.js

@@ -0,0 +1,128 @@
+async function decodeRLE(imageFrame, pixelData) {
+    if (imageFrame.bitsAllocated === 8) {
+        if (imageFrame.planarConfiguration) {
+            return decode8Planar(imageFrame, pixelData);
+        }
+        return decode8(imageFrame, pixelData);
+    }
+    else if (imageFrame.bitsAllocated === 16) {
+        return decode16(imageFrame, pixelData);
+    }
+    throw new Error('unsupported pixel format for RLE');
+}
+function decode8(imageFrame, pixelData) {
+    const frameData = pixelData;
+    const frameSize = imageFrame.rows * imageFrame.columns;
+    const outFrame = new ArrayBuffer(frameSize * imageFrame.samplesPerPixel);
+    const header = new DataView(frameData.buffer, frameData.byteOffset);
+    const data = new Int8Array(frameData.buffer, frameData.byteOffset);
+    const out = new Int8Array(outFrame);
+    let outIndex = 0;
+    const numSegments = header.getInt32(0, true);
+    for (let s = 0; s < numSegments; ++s) {
+        outIndex = s;
+        let inIndex = header.getInt32((s + 1) * 4, true);
+        let maxIndex = header.getInt32((s + 2) * 4, true);
+        if (maxIndex === 0) {
+            maxIndex = frameData.length;
+        }
+        const endOfSegment = frameSize * numSegments;
+        while (inIndex < maxIndex) {
+            const n = data[inIndex++];
+            if (n >= 0 && n <= 127) {
+                for (let i = 0; i < n + 1 && outIndex < endOfSegment; ++i) {
+                    out[outIndex] = data[inIndex++];
+                    outIndex += imageFrame.samplesPerPixel;
+                }
+            }
+            else if (n <= -1 && n >= -127) {
+                const value = data[inIndex++];
+                for (let j = 0; j < -n + 1 && outIndex < endOfSegment; ++j) {
+                    out[outIndex] = value;
+                    outIndex += imageFrame.samplesPerPixel;
+                }
+            }
+        }
+    }
+    imageFrame.pixelData = new Uint8Array(outFrame);
+    return imageFrame;
+}
+function decode8Planar(imageFrame, pixelData) {
+    const frameData = pixelData;
+    const frameSize = imageFrame.rows * imageFrame.columns;
+    const outFrame = new ArrayBuffer(frameSize * imageFrame.samplesPerPixel);
+    const header = new DataView(frameData.buffer, frameData.byteOffset);
+    const data = new Int8Array(frameData.buffer, frameData.byteOffset);
+    const out = new Int8Array(outFrame);
+    let outIndex = 0;
+    const numSegments = header.getInt32(0, true);
+    for (let s = 0; s < numSegments; ++s) {
+        outIndex = s * frameSize;
+        let inIndex = header.getInt32((s + 1) * 4, true);
+        let maxIndex = header.getInt32((s + 2) * 4, true);
+        if (maxIndex === 0) {
+            maxIndex = frameData.length;
+        }
+        const endOfSegment = frameSize * numSegments;
+        while (inIndex < maxIndex) {
+            const n = data[inIndex++];
+            if (n >= 0 && n <= 127) {
+                for (let i = 0; i < n + 1 && outIndex < endOfSegment; ++i) {
+                    out[outIndex] = data[inIndex++];
+                    outIndex++;
+                }
+            }
+            else if (n <= -1 && n >= -127) {
+                const value = data[inIndex++];
+                for (let j = 0; j < -n + 1 && outIndex < endOfSegment; ++j) {
+                    out[outIndex] = value;
+                    outIndex++;
+                }
+            }
+        }
+    }
+    imageFrame.pixelData = new Uint8Array(outFrame);
+    return imageFrame;
+}
+function decode16(imageFrame, pixelData) {
+    const frameData = pixelData;
+    const frameSize = imageFrame.rows * imageFrame.columns;
+    const outFrame = new ArrayBuffer(frameSize * imageFrame.samplesPerPixel * 2);
+    const header = new DataView(frameData.buffer, frameData.byteOffset);
+    const data = new Int8Array(frameData.buffer, frameData.byteOffset);
+    const out = new Int8Array(outFrame);
+    const numSegments = header.getInt32(0, true);
+    for (let s = 0; s < numSegments; ++s) {
+        let outIndex = 0;
+        const highByte = s === 0 ? 1 : 0;
+        let inIndex = header.getInt32((s + 1) * 4, true);
+        let maxIndex = header.getInt32((s + 2) * 4, true);
+        if (maxIndex === 0) {
+            maxIndex = frameData.length;
+        }
+        while (inIndex < maxIndex) {
+            const n = data[inIndex++];
+            if (n >= 0 && n <= 127) {
+                for (let i = 0; i < n + 1 && outIndex < frameSize; ++i) {
+                    out[outIndex * 2 + highByte] = data[inIndex++];
+                    outIndex++;
+                }
+            }
+            else if (n <= -1 && n >= -127) {
+                const value = data[inIndex++];
+                for (let j = 0; j < -n + 1 && outIndex < frameSize; ++j) {
+                    out[outIndex * 2 + highByte] = value;
+                    outIndex++;
+                }
+            }
+        }
+    }
+    if (imageFrame.pixelRepresentation === 0) {
+        imageFrame.pixelData = new Uint16Array(outFrame);
+    }
+    else {
+        imageFrame.pixelData = new Int16Array(outFrame);
+    }
+    return imageFrame;
+}
+export default decodeRLE;

package/dist/esm/shared/getMinMax.d.ts

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+declare function getMinMax(storedPixelData: Types.PixelDataTypedArray): {
+    min: number;
+    max: number;
+};
+export default getMinMax;

package/dist/esm/shared/getMinMax.js

@@ -0,0 +1,16 @@
+function getMinMax(storedPixelData) {
+    let min = storedPixelData[0];
+    let max = storedPixelData[0];
+    let storedPixel;
+    const numPixels = storedPixelData.length;
+    for (let index = 1; index < numPixels; index++) {
+        storedPixel = storedPixelData[index];
+        min = Math.min(min, storedPixel);
+        max = Math.max(max, storedPixel);
+    }
+    return {
+        min,
+        max,
+    };
+}
+export default getMinMax;

package/dist/esm/shared/getMinMax_test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/getMinMax_test.js

@@ -0,0 +1,9 @@
+import { expect } from 'chai';
+import getMinMax from './getMinMax';
+describe('#getMinMax', () => {
+    it('should return the right min and max values', () => {
+        const result = getMinMax([7, 3, 9, 6, 8, 1, 4, 5, 2]);
+        expect(result.min).to.be.equal(1);
+        expect(result.max).to.be.equal(9);
+    });
+});

package/dist/esm/shared/getPixelDataTypeFromMinMax.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function getPixelDataTypeFromMinMax(min: number, max: number): Types.PixelDataTypedArray;

package/dist/esm/shared/getPixelDataTypeFromMinMax.js

@@ -0,0 +1,22 @@
+export default function getPixelDataTypeFromMinMax(min, max) {
+    let pixelDataType;
+    if (Number.isInteger(min) && Number.isInteger(max)) {
+        if (min >= 0) {
+            if (max <= 255) {
+                pixelDataType = Uint8Array;
+            }
+            else if (max <= 65535) {
+                pixelDataType = Uint16Array;
+            }
+        }
+        else {
+            if (min >= -128 && max <= 127) {
+                pixelDataType = Int8Array;
+            }
+            else if (min >= -32768 && max <= 32767) {
+                pixelDataType = Int16Array;
+            }
+        }
+    }
+    return pixelDataType || Float32Array;
+}

package/dist/esm/shared/isColorImage.d.ts

@@ -0,0 +1 @@
+export default function (photoMetricInterpretation: string): boolean;

package/dist/esm/shared/isColorImage.js

@@ -0,0 +1,10 @@
+export default function (photoMetricInterpretation) {
+    return (photoMetricInterpretation === 'RGB' ||
+        photoMetricInterpretation === 'PALETTE COLOR' ||
+        photoMetricInterpretation === 'YBR_FULL' ||
+        photoMetricInterpretation === 'YBR_FULL_422' ||
+        photoMetricInterpretation === 'YBR_PARTIAL_422' ||
+        photoMetricInterpretation === 'YBR_PARTIAL_420' ||
+        photoMetricInterpretation === 'YBR_RCT' ||
+        photoMetricInterpretation === 'YBR_ICT');
+}

package/dist/esm/shared/scaling/bilinear.d.ts

@@ -0,0 +1 @@
+export default function bilinear(src: any, dest: any): any;

package/dist/esm/shared/scaling/bilinear.js

@@ -0,0 +1,32 @@
+export default function bilinear(src, dest) {
+    const { rows: srcRows, columns: srcColumns, data: srcData } = src;
+    const { rows, columns, data } = dest;
+    const xSrc1Off = [];
+    const xSrc2Off = [];
+    const xFrac = [];
+    for (let x = 0; x < columns; x++) {
+        const xSrc = (x * (srcColumns - 1)) / (columns - 1);
+        xSrc1Off[x] = Math.floor(xSrc);
+        xSrc2Off[x] = Math.min(xSrc1Off[x] + 1, srcColumns - 1);
+        xFrac[x] = xSrc - xSrc1Off[x];
+    }
+    for (let y = 0; y < rows; y++) {
+        const ySrc = (y * (srcRows - 1)) / (rows - 1);
+        const ySrc1Off = Math.floor(ySrc) * srcColumns;
+        const ySrc2Off = Math.min(ySrc1Off + srcColumns, (srcRows - 1) * srcColumns);
+        const yFrac = ySrc - Math.floor(ySrc);
+        const yFracInv = 1 - yFrac;
+        const yOff = y * columns;
+        for (let x = 0; x < columns; x++) {
+            const p00 = srcData[ySrc1Off + xSrc1Off[x]];
+            const p10 = srcData[ySrc1Off + xSrc2Off[x]];
+            const p01 = srcData[ySrc2Off + xSrc1Off[x]];
+            const p11 = srcData[ySrc2Off + xSrc2Off[x]];
+            const xFracInv = 1 - xFrac[x];
+            data[yOff + x] =
+                (p00 * xFracInv + p10 * xFrac[x]) * yFracInv +
+                    (p01 * xFracInv + p11 * xFrac[x]) * yFrac;
+        }
+    }
+    return data;
+}

package/dist/esm/shared/scaling/replicate.d.ts

@@ -0,0 +1 @@
+export default function replicate(src: any, dest: any): any;

package/dist/esm/shared/scaling/replicate.js

@@ -0,0 +1,20 @@
+export default function replicate(src, dest) {
+    const { rows: srcRows, columns: srcColumns, pixelData: srcData, samplesPerPixel = 1, } = src;
+    const { rows, columns, pixelData } = dest;
+    const xSrc1Off = [];
+    for (let x = 0; x < columns; x++) {
+        const xSrc = (x * (srcColumns - 1)) / (columns - 1);
+        xSrc1Off[x] = Math.floor(xSrc) * samplesPerPixel;
+    }
+    for (let y = 0; y < rows; y++) {
+        const ySrc = (y * (srcRows - 1)) / (rows - 1);
+        const ySrc1Off = Math.floor(ySrc) * srcColumns * samplesPerPixel;
+        const yOff = y * columns;
+        for (let x = 0; x < columns; x++) {
+            for (let sample = 0; sample < samplesPerPixel; sample++) {
+                pixelData[yOff + x + sample] = srcData[ySrc1Off + xSrc1Off[x] + sample];
+            }
+        }
+    }
+    return pixelData;
+}

package/dist/esm/shared/scaling/scaleArray.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function scaleArray(array: Types.PixelDataTypedArray, scalingParameters: any): boolean;

package/dist/esm/shared/scaling/scaleArray.js

@@ -0,0 +1,17 @@
+export default function scaleArray(array, scalingParameters) {
+    const arrayLength = array.length;
+    const { rescaleSlope, rescaleIntercept, suvbw } = scalingParameters;
+    if (scalingParameters.modality === 'PT' &&
+        typeof suvbw === 'number' &&
+        !isNaN(suvbw)) {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = suvbw * (array[i] * rescaleSlope + rescaleIntercept);
+        }
+    }
+    else {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = array[i] * rescaleSlope + rescaleIntercept;
+        }
+    }
+    return true;
+}

package/dist/esm/types/DICOMLoaderDataSetWithFetchMore.d.ts

@@ -0,0 +1,9 @@
+import type { DataSet } from 'dicom-parser';
+export interface DICOMLoaderDataSetWithFetchMore extends DataSet {
+    fetchMore?: (fetchOptions: {
+        uri: string;
+        imageId: string;
+        fetchedLength: number;
+        lengthToFetch: number;
+    }) => Promise<DICOMLoaderDataSetWithFetchMore>;
+}

package/dist/esm/types/DICOMLoaderIImage.d.ts

@@ -0,0 +1,12 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ByteArray, DataSet } from 'dicom-parser';
+export interface DICOMLoaderIImage extends Types.IImage {
+    decodeTimeInMS: number;
+    floatPixelData?: ByteArray | Float32Array;
+    loadTimeInMS?: number;
+    totalTimeInMS?: number;
+    data?: DataSet;
+    imageFrame?: Types.IImageFrame;
+    voiLUTFunction: string | undefined;
+    transferSyntaxUID?: string;
+}

package/dist/esm/types/DICOMLoaderImageOptions.d.ts

@@ -0,0 +1,23 @@
+import type { Types } from '@cornerstonejs/core';
+import type { LoadRequestFunction } from './LoadRequestFunction';
+import type { StreamingData } from '../imageLoader/wadors/loadImage';
+export interface DICOMLoaderImageOptions {
+    useRGBA?: boolean;
+    allowFloatRendering?: boolean;
+    preScale?: {
+        enabled: boolean;
+        scalingParameters?: Types.ScalingParameters;
+    };
+    targetBuffer?: {
+        type: Types.PixelDataTypedArrayString;
+        arrayBuffer: ArrayBufferLike;
+        length: number;
+        offset: number;
+        rows?: number;
+        columns?: number;
+    };
+    loader?: LoadRequestFunction;
+    decodeLevel?: number;
+    retrieveOptions?: Types.RetrieveOptions;
+    streamingData?: StreamingData;
+}

package/dist/esm/types/LoadRequestFunction.d.ts

@@ -0,0 +1 @@
+export type LoadRequestFunction = (url: string, imageId: string, ...args: unknown[]) => Promise<ArrayBuffer>;

package/dist/esm/types/LoaderDecodeOptions.d.ts

@@ -0,0 +1,2 @@
+export interface LoaderDecodeOptions {
+}

package/dist/esm/types/LoaderOptions.d.ts

@@ -0,0 +1,16 @@
+import type { LoaderDecodeOptions } from './LoaderDecodeOptions';
+import type { LoaderXhrRequestError, LoaderXhrRequestParams } from './XHRRequest';
+export interface LoaderOptions {
+    maxWebWorkers?: number;
+    open?: (xhr: XMLHttpRequest, url: string, defaultHeaders: Record<string, string>, params: LoaderXhrRequestParams) => void;
+    beforeSend?: (xhr: XMLHttpRequest, imageId: string, defaultHeaders: Record<string, string>, params: LoaderXhrRequestParams) => Record<string, string> | void;
+    beforeProcessing?: (xhr: XMLHttpRequest) => Promise<ArrayBuffer>;
+    imageCreated?: (imageObject: unknown) => void;
+    onloadstart?: (event: ProgressEvent<EventTarget>, params: unknown) => void;
+    onloadend?: (event: ProgressEvent<EventTarget>, params: unknown) => void;
+    onreadystatechange?: (event: Event, params: unknown) => void;
+    onprogress?: (event: ProgressEvent<EventTarget>, params: unknown) => void;
+    errorInterceptor?: (error: LoaderXhrRequestError) => void;
+    strict?: boolean;
+    decodeConfig?: LoaderDecodeOptions;
+}

package/dist/esm/types/LutType.d.ts

@@ -0,0 +1,6 @@
+export interface LutType {
+    id: string;
+    firstValueMapped: number;
+    numBitsPerEntry: number;
+    lut: number[];
+}

package/dist/esm/types/WADORSMetaData.d.ts

@@ -0,0 +1,4 @@
+export interface WADORSMetaDataElement<ValueType = string[] | number[] | boolean> {
+    Value: ValueType;
+}
+export type WADORSMetaData = Record<string, WADORSMetaDataElement>;

package/dist/esm/types/WebWorkerTypes.d.ts

@@ -0,0 +1,64 @@
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+import type { LoaderOptions } from './LoaderOptions';
+import type { LoaderDecodeOptions } from './LoaderDecodeOptions';
+export interface WebWorkerOptions {
+    maxWebWorkers?: number;
+    startWebWorkersOnDemand?: boolean;
+    webWorkerTaskPaths?: string[];
+    taskConfiguration?: WebWorkerTaskOptions;
+}
+export interface WebWorkerDecodeConfig {
+    initializeCodecsOnStartup: boolean;
+    strict?: boolean;
+}
+export interface WebWorkerTaskOptions {
+    decodeTask: WebWorkerDecodeConfig;
+}
+export interface WebWorkerDeferredObject<T = unknown> {
+    resolve: (arg: T | PromiseLike<T>) => void;
+    reject: (err: any) => void;
+}
+export type WorkerTaskTypes = 'decodeTask' | 'loadWebWorkerTask' | 'initialize';
+export interface WorkerTask {
+    taskId: number;
+    taskType: WorkerTaskTypes;
+    status: 'ready' | 'success' | 'failed';
+    added: number;
+    start?: number;
+    data: WebWorkerDecodeTaskData;
+    deferred: WebWorkerDeferredObject;
+    priority: number;
+    transferList: Transferable[];
+}
+export interface WebWorkerDecodeTaskData {
+    imageFrame: Types.IImageFrame;
+    transferSyntax: string;
+    pixelData: ByteArray;
+    options: LoaderOptions;
+    decodeConfig: LoaderDecodeOptions;
+}
+export interface WebWorkerDecodeData {
+    taskType: 'decodeTask';
+    workerIndex: number;
+    data: WebWorkerDecodeTaskData;
+}
+export interface WebWorkerLoadData {
+    taskType: 'loadWebWorkerTask';
+    workerIndex: number;
+    sourcePath: string;
+    config: WebWorkerOptions;
+}
+export interface WebWorkerInitializeData {
+    taskType: 'initialize';
+    workerIndex: number;
+    config: WebWorkerOptions;
+}
+export type WebWorkerData = WebWorkerDecodeData | WebWorkerLoadData | WebWorkerInitializeData;
+export interface WebWorkerResponse {
+    taskType: WorkerTaskTypes;
+    status: 'failed' | 'success';
+    workerIndex: number;
+    data?: Types.IImageFrame;
+    result: string | Types.IImageFrame;
+}

package/dist/esm/types/XHRRequest.d.ts

@@ -0,0 +1,16 @@
+export interface LoaderXhrRequestError extends Error {
+    request: XMLHttpRequest;
+    response: unknown;
+    status: number;
+}
+export interface LoaderXhrRequestParams {
+    url?: string;
+    deferred?: {
+        resolve: (value: ArrayBuffer | PromiseLike<ArrayBuffer>) => void;
+        reject: (reason: any) => void;
+    };
+    imageId?: string;
+}
+export interface LoaderXhrRequestPromise<T> extends Promise<T> {
+    xhr?: XMLHttpRequest;
+}

package/dist/esm/types/index.d.ts

@@ -0,0 +1,11 @@
+import type { LoaderXhrRequestError, LoaderXhrRequestParams, LoaderXhrRequestPromise } from './XHRRequest';
+import type { WADORSMetaData, WADORSMetaDataElement } from './WADORSMetaData';
+import type { LoaderOptions } from './LoaderOptions';
+import type { LoaderDecodeOptions } from './LoaderDecodeOptions';
+import type { DICOMLoaderIImage } from './DICOMLoaderIImage';
+import type { DICOMLoaderImageOptions } from './DICOMLoaderImageOptions';
+import type { LutType } from './LutType';
+import type { LoadRequestFunction } from './LoadRequestFunction';
+import type { DICOMLoaderDataSetWithFetchMore } from './DICOMLoaderDataSetWithFetchMore';
+import type { WebWorkerOptions, WebWorkerDecodeConfig, WebWorkerTaskOptions, WorkerTaskTypes, WorkerTask, WebWorkerDecodeTaskData, WebWorkerDecodeData, WebWorkerLoadData, WebWorkerInitializeData, WebWorkerData, WebWorkerResponse, WebWorkerDeferredObject } from './WebWorkerTypes';
+export type { LoaderDecodeOptions, LoaderOptions, WADORSMetaData, WADORSMetaDataElement, LoaderXhrRequestError, LoaderXhrRequestParams, LoaderXhrRequestPromise, DICOMLoaderIImage, DICOMLoaderImageOptions, LutType, WebWorkerOptions, WebWorkerDecodeConfig, WebWorkerTaskOptions, WorkerTaskTypes, WorkerTask, WebWorkerDecodeTaskData, WebWorkerDecodeData, WebWorkerLoadData, WebWorkerInitializeData, WebWorkerData, WebWorkerResponse, WebWorkerDeferredObject, LoadRequestFunction, DICOMLoaderDataSetWithFetchMore, };

package/dist/esm/version.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "0.0.1";
+export default _default;

package/dist/esm/version.js

@@ -0,0 +1 @@
+export default '0.0.1';