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

package/dist/esm/src/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/src/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/src/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/src/shared/getMinMax_test.d.ts

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

package/dist/esm/src/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/src/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/src/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/src/shared/isColorImage.d.ts

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

package/dist/esm/src/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/src/shared/scaling/bilinear.d.ts

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

package/dist/esm/src/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/src/shared/scaling/replicate.d.ts

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

package/dist/esm/src/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/src/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/src/shared/scaling/scaleArray.js

@@ -0,0 +1,15 @@
+export default function scaleArray(array, scalingParameters) {
+    const arrayLength = array.length;
+    const { rescaleSlope, rescaleIntercept, suvbw } = scalingParameters;
+    if (scalingParameters.modality === 'PT' && typeof suvbw === 'number') {
+        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/src/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/src/types/DICOMLoaderDataSetWithFetchMore.js

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

package/dist/esm/src/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/src/types/DICOMLoaderIImage.js

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

package/dist/esm/src/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/src/types/DICOMLoaderImageOptions.js

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

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

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

package/dist/esm/src/types/LoadRequestFunction.js

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

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

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

package/dist/esm/src/types/LoaderDecodeOptions.js

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

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

@@ -0,0 +1,18 @@
+import type { LoaderDecodeOptions } from './LoaderDecodeOptions';
+import type { LoaderXhrRequestError, LoaderXhrRequestParams } from './XHRRequest';
+export interface LoaderOptions {
+    cornerstone?: unknown;
+    dicomParser?: unknown;
+    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/src/types/LoaderOptions.js

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

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

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

package/dist/esm/src/types/LutType.js

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

package/dist/esm/src/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/src/types/WADORSMetaData.js

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

package/dist/esm/src/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/src/types/WebWorkerTypes.js

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

package/dist/esm/src/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/src/types/XHRRequest.js

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

package/dist/esm/src/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/src/types/index.js

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

package/dist/esm/src/version.d.ts

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

package/dist/esm/src/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/dicom-image-loader",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.21",
   "description": "Cornerstone Image Loader for DICOM WADO-URI and WADO-RS and Local file",
   "keywords": [
     "DICOM",
@@ -12,8 +12,9 @@
   "author": "@cornerstonejs (previously Chris Hafey)",
   "homepage": "https://github.com/cornerstonejs/cornerstone3D",
   "license": "MIT",
-  "main": "dist/cornerstoneDICOMImageLoader.bundle.min.js",
-  "module": "dist/cornerstoneDICOMImageLoader.bundle.min.js",
+  "main": "dist/esm/src/imageLoader/index.js",
+  "module": "dist/esm/src/imageLoader/index.js",
+  "types": "dist/esm/src/imageLoader/index.d.ts",
   "files": [
     "dist/"
   ],
@@ -24,21 +25,33 @@
   "publishConfig": {
     "access": "public"
   },
+  "exports": {
+    ".": {
+      "import": "./dist/esm/src/imageLoader/index.js"
+    },
+    "./dynamic-umd": {
+      "import": "./dist/dynamic-import/cornerstoneDICOMImageLoader.min.js"
+    }
+  },
   "scripts": {
+    "build:loader": "yarn run build:all && yarn run copy-dts",
+    "build:esm": "tsc --project ./tsconfig.esm.json",
+    "build:esm:watch": "tsc --project ./tsconfig.esm.json --watch",
     "build:umd:dynamic": "cross-env NODE_ENV=production webpack --config .webpack/webpack-dynamic-import.js",
     "build:umd:bundle": "cross-env NODE_ENV=production webpack --config .webpack/webpack-bundle.js",
-    "build:all": "yarn run build:umd:dynamic & yarn run build:umd:bundle",
+    "build:all": "yarn run build:umd:dynamic & yarn run build:umd:bundle && yarn run build:esm",
+    "build:update-api": "echo 'not implemented yet'",
     "copy-dts": "echo 'not implemented yet'",
-    "build": "yarn run build:all && yarn run copy-dts",
+    "clean": "shx rm -rf dist",
+    "clean:deep": "yarn run clean && shx rm -rf node_modules",
     "api-check": "echo 'not implemented yet'",
-    "build:update-api": "echo 'not implemented yet'",
     "cm": "npx git-cz",
-    "clean": "npm run clean:dist && npm run clean:coverage",
     "clean:dist": "shx rm -rf dist",
     "clean:docs": "shx rm -rf documentation",
     "clean:coverage": "shx rm -rf coverage",
     "doc": "npm run doc:generate && opn documentation/index.html",
     "doc:generate": "npm run clean:docs && jsdoc -c .jsdocrc",
+    "dev": "tsc --project ./tsconfig.esm.json --watch",
     "eslint": "eslint -c .eslintrc.js src",
     "eslint-quiet": "eslint -c .eslintrc.js --quiet src",
     "eslint-fix": "eslint -c .eslintrc.js --fix src",
@@ -52,30 +65,24 @@
     "test:firefox": "karma start config/karma/karma-firefox.js",
     "test:watch": "karma start config/karma/karma-watch.js",
     "watch": "npm run clean && shx mkdir dist && npm run webpack:watch",
-    "dev": "npm run webpack:dev",
     "webpack:dev": "webpack serve --progress --config .webpack/webpack-dev.js",
     "webpack:dynamic-import": "webpack --progress --config .webpack/webpack-dynamic-import",
     "webpack:bundle": "webpack --progress --config .webpack/webpack-bundle",
     "webpack:dynamic-import:watch": "webpack --progress --watch --config .webpack/webpack-dynamic-import",
     "webpack:dynamic-import:debug": "webpack --progress --watch --config .webpack/webpack-dynamic-import-debug",
     "webpack:watch": "webpack --progress --watch  --config .webpack",
-    "prepublishOnly": "yarn run build"
+    "prepublishOnly": "yarn run build:loader"
   },
   "dependencies": {
     "@cornerstonejs/codec-charls": "^1.2.3",
     "@cornerstonejs/codec-libjpeg-turbo-8bit": "^1.2.2",
     "@cornerstonejs/codec-openjpeg": "^1.2.2",
-    "@cornerstonejs/codec-openjph": "^2.4.2",
-    "@cornerstonejs/core": "^2.0.0-beta.2",
+    "@cornerstonejs/codec-openjph": "^2.4.5",
+    "comlink": "^4.4.1",
     "dicom-parser": "^1.8.9",
     "pako": "^2.0.4",
     "uuid": "^9.0.0"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
-  },
   "lint-staged": {
     "src/**/*.{js,jsx,json,css}": [
       "eslint --fix",
@@ -88,5 +95,5 @@
       "path": "./node_modules/cz-conventional-changelog"
     }
   },
-  "gitHead": "c154f7531c166db29a54fe41c76a22ecc7ac47c8"
+  "gitHead": "de2d08d4edbae4ca48831cc44a57737717b10b22"
 }