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

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

@@ -0,0 +1,57 @@
+import { loadedDataSets } from './dataSetCacheManager';
+function _get(uri) {
+    if (!loadedDataSets[uri]) {
+        return;
+    }
+    return loadedDataSets[uri];
+}
+function isMultiframeDataset(uri) {
+    const dataSet = _get(uri);
+    return _isMultiframeDataset(dataSet);
+}
+function _isMultiframeDataset(dataSet) {
+    if (!dataSet) {
+        return false;
+    }
+    const numberOfFrames = dataSet.intString('x00280008');
+    return numberOfFrames && numberOfFrames > 1;
+}
+function retrieveFrameParameterIndex(uri) {
+    return uri.indexOf('&frame=');
+}
+function retrieveMultiframeDataset(uri) {
+    const frameParameterIndex = retrieveFrameParameterIndex(uri);
+    const multiframeURI = frameParameterIndex === -1 ? uri : uri.slice(0, frameParameterIndex);
+    const frame = parseInt(uri.slice(frameParameterIndex + 7), 10) || 1;
+    let dataSet;
+    if (loadedDataSets[multiframeURI]) {
+        dataSet = loadedDataSets[multiframeURI].dataSet;
+    }
+    else {
+        dataSet = undefined;
+    }
+    return {
+        dataSet,
+        frame,
+    };
+}
+function generateMultiframeWADOURIs(uri) {
+    const listWADOURIs = [];
+    const dataSet = _get(uri);
+    if (_isMultiframeDataset(dataSet)) {
+        const numberOfFrames = dataSet.intString('x00280008');
+        for (let i = 1; i <= numberOfFrames; i++) {
+            listWADOURIs.push(`${uri}&frame=${i}`);
+        }
+    }
+    else {
+        listWADOURIs.push(uri);
+    }
+    return listWADOURIs;
+}
+export default {
+    _get,
+    generateMultiframeWADOURIs,
+    retrieveMultiframeDataset,
+    isMultiframeDataset,
+};

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

@@ -0,0 +1,3 @@
+import type { ByteArray } from 'dicom-parser';
+declare function unpackBinaryFrame(byteArray: ByteArray, frameOffset: number, pixelsPerFrame: number): Uint8Array;
+export default unpackBinaryFrame;

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

@@ -0,0 +1,14 @@
+function isBitSet(byte, bitPos) {
+    return byte & (1 << bitPos);
+}
+function unpackBinaryFrame(byteArray, frameOffset, pixelsPerFrame) {
+    const pixelData = new Uint8Array(pixelsPerFrame);
+    for (let i = 0; i < pixelsPerFrame; i++) {
+        const bytePos = Math.floor(i / 8);
+        const byte = byteArray[bytePos + frameOffset];
+        const bitPos = i % 8;
+        pixelData[i] = isBitSet(byte, bitPos) ? 1 : 0;
+    }
+    return pixelData;
+}
+export default unpackBinaryFrame;

package/dist/esm/src/shared/decoders/decodeBigEndian.d.ts

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

package/dist/esm/src/shared/decoders/decodeBigEndian.js

@@ -0,0 +1,28 @@
+function swap16(val) {
+    return ((val & 0xff) << 8) | ((val >> 8) & 0xff);
+}
+async function decodeBigEndian(imageFrame, pixelData) {
+    if (imageFrame.bitsAllocated === 16) {
+        let arrayBuffer = pixelData.buffer;
+        let offset = pixelData.byteOffset;
+        const length = pixelData.length;
+        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);
+        }
+        for (let i = 0; i < imageFrame.pixelData.length; i++) {
+            imageFrame.pixelData[i] = swap16(imageFrame.pixelData[i]);
+        }
+    }
+    else if (imageFrame.bitsAllocated === 8) {
+        imageFrame.pixelData = pixelData;
+    }
+    return imageFrame;
+}
+export default decodeBigEndian;

package/dist/esm/src/shared/decoders/decodeHTJ2K.d.ts

@@ -0,0 +1,5 @@
+import type { ByteArray } from 'dicom-parser';
+import type { LoaderDecodeOptions } from '../../types';
+export declare function initialize(decodeConfig?: LoaderDecodeOptions): Promise<void>;
+declare function decodeAsync(compressedImageFrame: ByteArray, imageInfo: any): Promise<any>;
+export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeHTJ2K.js

@@ -0,0 +1,109 @@
+import openJphFactory from '@cornerstonejs/codec-openjph/wasmjs';
+const openjphWasm = new URL('@cornerstonejs/codec-openjph/wasm', import.meta.url);
+const local = {
+    codec: undefined,
+    decoder: undefined,
+    decodeConfig: {},
+};
+function calculateSizeAtDecompositionLevel(decompositionLevel, frameWidth, frameHeight) {
+    const result = { width: frameWidth, height: frameHeight };
+    while (decompositionLevel > 0) {
+        result.width = Math.ceil(result.width / 2);
+        result.height = Math.ceil(result.height / 2);
+        decompositionLevel--;
+    }
+    return result;
+}
+export function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.codec) {
+        return Promise.resolve();
+    }
+    const openJphModule = openJphFactory({
+        locateFile: (f) => {
+            if (f.endsWith('.wasm')) {
+                return openjphWasm;
+            }
+            return f;
+        },
+    });
+    return new Promise((resolve, reject) => {
+        openJphModule.then((instance) => {
+            local.codec = instance;
+            local.decoder = new instance.HTJ2KDecoder();
+            resolve();
+        }, reject);
+    });
+}
+async function decodeAsync(compressedImageFrame, imageInfo) {
+    await initialize();
+    const decoder = new local.codec.HTJ2KDecoder();
+    const encodedBufferInWASM = decoder.getEncodedBuffer(compressedImageFrame.length);
+    encodedBufferInWASM.set(compressedImageFrame);
+    const decodeLevel = imageInfo.decodeLevel || 0;
+    decoder.decodeSubResolution(decodeLevel);
+    const frameInfo = decoder.getFrameInfo();
+    if (imageInfo.decodeLevel > 0) {
+        const { width, height } = calculateSizeAtDecompositionLevel(imageInfo.decodeLevel, frameInfo.width, frameInfo.height);
+        frameInfo.width = width;
+        frameInfo.height = height;
+    }
+    const decodedBufferInWASM = decoder.getDecodedBuffer();
+    const imageFrame = new Uint8Array(decodedBufferInWASM.length);
+    imageFrame.set(decodedBufferInWASM);
+    const imageOffset = `x: ${decoder.getImageOffset().x}, y: ${decoder.getImageOffset().y}`;
+    const numDecompositions = decoder.getNumDecompositions();
+    const numLayers = decoder.getNumLayers();
+    const progessionOrder = ['unknown', 'LRCP', 'RLCP', 'RPCL', 'PCRL', 'CPRL'][decoder.getProgressionOrder() + 1];
+    const reversible = decoder.getIsReversible();
+    const blockDimensions = `${decoder.getBlockDimensions().width} x ${decoder.getBlockDimensions().height}`;
+    const tileSize = `${decoder.getTileSize().width} x ${decoder.getTileSize().height}`;
+    const tileOffset = `${decoder.getTileOffset().x}, ${decoder.getTileOffset().y}`;
+    const decodedSize = `${decodedBufferInWASM.length.toLocaleString()} bytes`;
+    const compressionRatio = `${(decodedBufferInWASM.length / encodedBufferInWASM.length).toFixed(2)}:1`;
+    const encodedImageInfo = {
+        columns: frameInfo.width,
+        rows: frameInfo.height,
+        bitsPerPixel: frameInfo.bitsPerSample,
+        signed: frameInfo.isSigned,
+        bytesPerPixel: imageInfo.bytesPerPixel,
+        componentsPerPixel: frameInfo.componentCount,
+    };
+    let pixelData = getPixelData(frameInfo, decodedBufferInWASM);
+    const { buffer: b, byteOffset, byteLength } = pixelData;
+    const pixelDataArrayBuffer = b.slice(byteOffset, byteOffset + byteLength);
+    pixelData = new pixelData.constructor(pixelDataArrayBuffer);
+    const encodeOptions = {
+        imageOffset,
+        numDecompositions,
+        numLayers,
+        progessionOrder,
+        reversible,
+        blockDimensions,
+        tileSize,
+        tileOffset,
+        decodedSize,
+        compressionRatio,
+    };
+    return {
+        ...imageInfo,
+        pixelData,
+        imageInfo: encodedImageInfo,
+        encodeOptions,
+        ...encodeOptions,
+        ...encodedImageInfo,
+    };
+}
+function getPixelData(frameInfo, decodedBuffer) {
+    if (frameInfo.bitsPerSample > 8) {
+        if (frameInfo.isSigned) {
+            return new Int16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
+        }
+        return new Uint16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
+    }
+    if (frameInfo.isSigned) {
+        return new Int8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+    }
+    return new Uint8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+}
+export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEG2000.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core/src';
+import type { WebWorkerDecodeConfig } from '../../types';
+export declare function initialize(decodeConfig?: WebWorkerDecodeConfig): Promise<void>;
+declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<Types.IImageFrame>;
+export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEG2000.js

@@ -0,0 +1,93 @@
+import openJpegFactory from '@cornerstonejs/codec-openjpeg/decodewasmjs';
+const openjpegWasm = new URL('@cornerstonejs/codec-openjpeg/decodewasm', import.meta.url);
+const local = {
+    codec: undefined,
+    decoder: undefined,
+    decodeConfig: {},
+};
+export function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.codec) {
+        return Promise.resolve();
+    }
+    const openJpegModule = openJpegFactory({
+        locateFile: (f) => {
+            if (f.endsWith('.wasm')) {
+                return openjpegWasm.toString();
+            }
+            return f;
+        },
+    });
+    return new Promise((resolve, reject) => {
+        openJpegModule.then((instance) => {
+            local.codec = instance;
+            local.decoder = new instance.J2KDecoder();
+            resolve();
+        }, reject);
+    });
+}
+async function decodeAsync(compressedImageFrame, imageInfo) {
+    await initialize();
+    const decoder = local.decoder;
+    const encodedBufferInWASM = decoder.getEncodedBuffer(compressedImageFrame.length);
+    encodedBufferInWASM.set(compressedImageFrame);
+    decoder.decode();
+    const frameInfo = decoder.getFrameInfo();
+    const decodedBufferInWASM = decoder.getDecodedBuffer();
+    const imageFrame = new Uint8Array(decodedBufferInWASM.length);
+    imageFrame.set(decodedBufferInWASM);
+    const imageOffset = `x: ${decoder.getImageOffset().x}, y: ${decoder.getImageOffset().y}`;
+    const numDecompositions = decoder.getNumDecompositions();
+    const numLayers = decoder.getNumLayers();
+    const progessionOrder = ['unknown', 'LRCP', 'RLCP', 'RPCL', 'PCRL', 'CPRL'][decoder.getProgressionOrder() + 1];
+    const reversible = decoder.getIsReversible();
+    const blockDimensions = `${decoder.getBlockDimensions().width} x ${decoder.getBlockDimensions().height}`;
+    const tileSize = `${decoder.getTileSize().width} x ${decoder.getTileSize().height}`;
+    const tileOffset = `${decoder.getTileOffset().x}, ${decoder.getTileOffset().y}`;
+    const colorTransform = decoder.getColorSpace();
+    const decodedSize = `${decodedBufferInWASM.length.toLocaleString()} bytes`;
+    const compressionRatio = `${(decodedBufferInWASM.length / encodedBufferInWASM.length).toFixed(2)}:1`;
+    const encodedImageInfo = {
+        columns: frameInfo.width,
+        rows: frameInfo.height,
+        bitsPerPixel: frameInfo.bitsPerSample,
+        signed: frameInfo.isSigned,
+        bytesPerPixel: imageInfo.bytesPerPixel,
+        componentsPerPixel: frameInfo.componentCount,
+    };
+    const pixelData = getPixelData(frameInfo, decodedBufferInWASM);
+    const encodeOptions = {
+        imageOffset,
+        numDecompositions,
+        numLayers,
+        progessionOrder,
+        reversible,
+        blockDimensions,
+        tileSize,
+        tileOffset,
+        colorTransform,
+        decodedSize,
+        compressionRatio,
+    };
+    return {
+        ...imageInfo,
+        pixelData,
+        imageInfo: encodedImageInfo,
+        encodeOptions,
+        ...encodeOptions,
+        ...encodedImageInfo,
+    };
+}
+function getPixelData(frameInfo, decodedBuffer) {
+    if (frameInfo.bitsPerSample > 8) {
+        if (frameInfo.isSigned) {
+            return new Int16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
+        }
+        return new Uint16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
+    }
+    if (frameInfo.isSigned) {
+        return new Int8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+    }
+    return new Uint8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+}
+export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEGBaseline12Bit-js.d.ts

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

package/dist/esm/src/shared/decoders/decodeJPEGBaseline12Bit-js.js

@@ -0,0 +1,34 @@
+const local = {
+    JpegImage: undefined,
+    decodeConfig: {},
+};
+export function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.JpegImage) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        import('../../../codecs/jpeg').then(({ JpegImage }) => {
+            local.JpegImage = JpegImage;
+            resolve();
+        }, reject);
+    });
+}
+async function decodeJPEGBaseline12BitAsync(imageFrame, pixelData) {
+    await initialize();
+    if (typeof local.JpegImage === 'undefined') {
+        throw new Error('No JPEG Baseline decoder loaded');
+    }
+    const jpeg = new local.JpegImage();
+    jpeg.parse(pixelData);
+    jpeg.colorTransform = false;
+    if (imageFrame.bitsAllocated === 8) {
+        imageFrame.pixelData = jpeg.getData(imageFrame.columns, imageFrame.rows);
+        return imageFrame;
+    }
+    else if (imageFrame.bitsAllocated === 16) {
+        imageFrame.pixelData = jpeg.getData16(imageFrame.columns, imageFrame.rows);
+        return imageFrame;
+    }
+}
+export default decodeJPEGBaseline12BitAsync;

package/dist/esm/src/shared/decoders/decodeJPEGBaseline12Bit-wasm-not-yet-working.d.ts

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

package/dist/esm/src/shared/decoders/decodeJPEGBaseline12Bit-wasm-not-yet-working.js

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

package/dist/esm/src/shared/decoders/decodeJPEGBaseline8Bit.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core/src';
+declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<Types.IImageFrame>;
+export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEGBaseline8Bit.js

@@ -0,0 +1,62 @@
+import libjpegTurboFactory from '@cornerstonejs/codec-libjpeg-turbo-8bit/decodewasmjs';
+const libjpegTurboWasm = new URL('@cornerstonejs/codec-libjpeg-turbo-8bit/decodewasm', import.meta.url);
+const local = {
+    codec: undefined,
+    decoder: undefined,
+};
+function initLibjpegTurbo() {
+    if (local.codec) {
+        return Promise.resolve();
+    }
+    const libjpegTurboModule = libjpegTurboFactory({
+        locateFile: (f) => {
+            if (f.endsWith('.wasm')) {
+                return libjpegTurboWasm.toString();
+            }
+            return f;
+        },
+    });
+    return new Promise((resolve, reject) => {
+        libjpegTurboModule.then((instance) => {
+            local.codec = instance;
+            local.decoder = new instance.JPEGDecoder();
+            resolve();
+        }, reject);
+    });
+}
+async function decodeAsync(compressedImageFrame, imageInfo) {
+    await initLibjpegTurbo();
+    const decoder = local.decoder;
+    const encodedBufferInWASM = decoder.getEncodedBuffer(compressedImageFrame.length);
+    encodedBufferInWASM.set(compressedImageFrame);
+    decoder.decode();
+    const frameInfo = decoder.getFrameInfo();
+    const decodedPixelsInWASM = decoder.getDecodedBuffer();
+    const encodedImageInfo = {
+        columns: frameInfo.width,
+        rows: frameInfo.height,
+        bitsPerPixel: frameInfo.bitsPerSample,
+        signed: imageInfo.signed,
+        bytesPerPixel: imageInfo.bytesPerPixel,
+        componentsPerPixel: frameInfo.componentCount,
+    };
+    const pixelData = getPixelData(frameInfo, decodedPixelsInWASM);
+    const encodeOptions = {
+        frameInfo,
+    };
+    return {
+        ...imageInfo,
+        pixelData,
+        imageInfo: encodedImageInfo,
+        encodeOptions,
+        ...encodeOptions,
+        ...encodedImageInfo,
+    };
+}
+function getPixelData(frameInfo, decodedBuffer) {
+    if (frameInfo.isSigned) {
+        return new Int8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+    }
+    return new Uint8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+}
+export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEGLS.d.ts

@@ -0,0 +1,5 @@
+import type { WebWorkerDecodeConfig } from '../../types';
+import type { Types } from '@cornerstonejs/core/src';
+export declare function initialize(decodeConfig?: WebWorkerDecodeConfig): Promise<void>;
+declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<Types.IImageFrame>;
+export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEGLS.js

@@ -0,0 +1,84 @@
+import charlsFactory from '@cornerstonejs/codec-charls/decodewasmjs';
+const charlsWasm = new URL('@cornerstonejs/codec-charls/decodewasm', import.meta.url);
+const local = {
+    codec: undefined,
+    decoder: undefined,
+    decodeConfig: {},
+};
+function getExceptionMessage(exception) {
+    return typeof exception === 'number'
+        ? local.codec.getExceptionMessage(exception)
+        : exception;
+}
+export function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.codec) {
+        return Promise.resolve();
+    }
+    const charlsModule = charlsFactory({
+        locateFile: (f) => {
+            if (f.endsWith('.wasm')) {
+                return charlsWasm.toString();
+            }
+            return f;
+        },
+    });
+    return new Promise((resolve, reject) => {
+        charlsModule.then((instance) => {
+            local.codec = instance;
+            local.decoder = new instance.JpegLSDecoder();
+            resolve();
+        }, reject);
+    });
+}
+async function decodeAsync(compressedImageFrame, imageInfo) {
+    try {
+        await initialize();
+        const decoder = local.decoder;
+        const encodedBufferInWASM = decoder.getEncodedBuffer(compressedImageFrame.length);
+        encodedBufferInWASM.set(compressedImageFrame);
+        decoder.decode();
+        const frameInfo = decoder.getFrameInfo();
+        const interleaveMode = decoder.getInterleaveMode();
+        const nearLossless = decoder.getNearLossless();
+        const decodedPixelsInWASM = decoder.getDecodedBuffer();
+        const encodedImageInfo = {
+            columns: frameInfo.width,
+            rows: frameInfo.height,
+            bitsPerPixel: frameInfo.bitsPerSample,
+            signed: imageInfo.signed,
+            bytesPerPixel: imageInfo.bytesPerPixel,
+            componentsPerPixel: frameInfo.componentCount,
+        };
+        const pixelData = getPixelData(frameInfo, decodedPixelsInWASM, imageInfo.signed);
+        const encodeOptions = {
+            nearLossless,
+            interleaveMode,
+            frameInfo,
+        };
+        return {
+            ...imageInfo,
+            pixelData,
+            imageInfo: encodedImageInfo,
+            encodeOptions,
+            ...encodeOptions,
+            ...encodedImageInfo,
+        };
+    }
+    catch (error) {
+        throw getExceptionMessage(error);
+    }
+}
+function getPixelData(frameInfo, decodedBuffer, signed) {
+    if (frameInfo.bitsPerSample > 8) {
+        if (signed) {
+            return new Int16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
+        }
+        return new Uint16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
+    }
+    if (signed) {
+        return new Int8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+    }
+    return new Uint8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+}
+export default decodeAsync;

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

@@ -0,0 +1,6 @@
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core/src';
+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/src/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/src/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/src/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/src/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;