@ohif/app 3.12.0-beta.80 → 3.12.0-beta.81

package/dist/{3353.bundle.a52e42421b9407ad28ce.js → 5858.bundle.99a6b9de04c621694ffd.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[3353],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[5858],{
 
 /***/ 93720:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
@@ -3681,7 +3681,7 @@ else {}
 
 /***/ }),
 
-/***/ 83353:
+/***/ 15858:
 /***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -3746,480 +3746,454 @@ function replicate(src, dest) {
 
 // EXTERNAL MODULE: ../../../node_modules/comlink/dist/esm/comlink.mjs
 var comlink = __webpack_require__(99178);
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeLittleEndian.js
-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);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeLittleEndian.js
+var decodeLittleEndian = __webpack_require__(67927);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeBigEndian.js
+var decodeBigEndian = __webpack_require__(45155);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeRLE.js
+var decodeRLE = __webpack_require__(40115);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEGBaseline8Bit.js
+var decodeJPEGBaseline8Bit = __webpack_require__(89178);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEGBaseline12Bit-js.js
+var decodeJPEGBaseline12Bit_js = __webpack_require__(63991);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEGLossless.js
+var decodeJPEGLossless = __webpack_require__(32856);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEGLS.js
+var decodeJPEGLS = __webpack_require__(93119);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEG2000.js
+var decodeJPEG2000 = __webpack_require__(90612);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeHTJ2K.js
+var decodeHTJ2K = __webpack_require__(53383);
+;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/scaling/scaleArray.js
+function scaleArray(array, scalingParameters) {
+    const arrayLength = array.length;
+    const { rescaleSlope, rescaleIntercept, suvbw, doseGridScaling } = 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 if (imageFrame.bitsAllocated === 8 || imageFrame.bitsAllocated === 1) {
-        imageFrame.pixelData = pixelData;
-    }
-    else if (imageFrame.bitsAllocated === 32) {
-        if (offset % 2) {
-            arrayBuffer = arrayBuffer.slice(offset);
-            offset = 0;
-        }
-        if (imageFrame.floatPixelData || imageFrame.doubleFloatPixelData) {
-            throw new Error('Float pixel data is not supported for parsing into ImageFrame');
-        }
-        if (imageFrame.pixelRepresentation === 0) {
-            imageFrame.pixelData = new Uint32Array(arrayBuffer, offset, length / 4);
-        }
-        else if (imageFrame.pixelRepresentation === 1) {
-            imageFrame.pixelData = new Int32Array(arrayBuffer, offset, length / 4);
+    else if (scalingParameters.modality === 'RTDOSE' &&
+        typeof doseGridScaling === 'number' &&
+        !isNaN(doseGridScaling)) {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = array[i] * doseGridScaling;
         }
-        else {
-            imageFrame.pixelData = new Float32Array(arrayBuffer, offset, length / 4);
+    }
+    else {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = array[i] * rescaleSlope + rescaleIntercept;
         }
     }
-    return imageFrame;
+    return true;
 }
-/* harmony default export */ const decoders_decodeLittleEndian = (decodeLittleEndian);
 
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeBigEndian.js
-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);
-        }
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/getMinMax.js
+var getMinMax = __webpack_require__(52842);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/getPixelDataTypeFromMinMax.js
+var getPixelDataTypeFromMinMax = __webpack_require__(69952);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/isColorImage.js
+var isColorImage = __webpack_require__(30922);
+;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/decodeImageFrameWorker.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const imageUtils = {
+    bilinear: bilinear,
+    replicate: replicate,
+};
+const typedArrayConstructors = {
+    Uint8Array,
+    Uint16Array,
+    Int16Array,
+    Float32Array,
+    Uint32Array,
+};
+function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
+    const shouldShift = imageFrame.pixelRepresentation !== undefined &&
+        imageFrame.pixelRepresentation === 1;
+    const shift = shouldShift && imageFrame.bitsStored !== undefined
+        ? 32 - imageFrame.bitsStored
+        : undefined;
+    if (shouldShift && shift !== undefined) {
         for (let i = 0; i < imageFrame.pixelData.length; i++) {
-            imageFrame.pixelData[i] = swap16(imageFrame.pixelData[i]);
+            imageFrame.pixelData[i] = (imageFrame.pixelData[i] << shift) >> shift;
         }
     }
-    else if (imageFrame.bitsAllocated === 8) {
-        imageFrame.pixelData = pixelData;
+    let pixelDataArray = imageFrame.pixelData;
+    imageFrame.pixelDataLength = imageFrame.pixelData.length;
+    const { min: minBeforeScale, max: maxBeforeScale } = (0,getMinMax/* default */.A)(imageFrame.pixelData);
+    const canRenderFloat = typeof options.allowFloatRendering !== 'undefined'
+        ? options.allowFloatRendering
+        : true;
+    let invalidType = (0,isColorImage/* default */.A)(imageFrame.photometricInterpretation) &&
+        options.targetBuffer?.offset === undefined;
+    const willScale = options.preScale?.enabled;
+    const hasFloatRescale = willScale &&
+        Object.values(options.preScale.scalingParameters).some((v) => typeof v === 'number' && !Number.isInteger(v));
+    const disableScale = !options.preScale.enabled || (!canRenderFloat && hasFloatRescale);
+    const type = options.targetBuffer?.type;
+    if (type && options.preScale.enabled && !disableScale) {
+        const scalingParameters = options.preScale.scalingParameters;
+        const scaledValues = _calculateScaledMinMax(minBeforeScale, maxBeforeScale, scalingParameters);
+        invalidType = !(0,getPixelDataTypeFromMinMax/* validatePixelDataType */.r)(scaledValues.min, scaledValues.max, typedArrayConstructors[type]);
     }
-    return imageFrame;
-}
-/* harmony default export */ const decoders_decodeBigEndian = (decodeBigEndian);
-
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeRLE.js
-async function decodeRLE(imageFrame, pixelData) {
-    if (imageFrame.bitsAllocated === 8) {
-        if (imageFrame.planarConfiguration) {
-            return decode8Planar(imageFrame, pixelData);
-        }
-        return decode8(imageFrame, pixelData);
+    if (type && !invalidType) {
+        pixelDataArray = _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelDataArray);
     }
-    else if (imageFrame.bitsAllocated === 16) {
-        return decode16(imageFrame, pixelData);
+    else if (options.preScale.enabled && !disableScale) {
+        pixelDataArray = _handlePreScaleSetup(options, minBeforeScale, maxBeforeScale, imageFrame);
     }
-    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;
-                }
-            }
-        }
+    else {
+        pixelDataArray = _getDefaultPixelDataArray(minBeforeScale, maxBeforeScale, imageFrame);
     }
-    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++;
-                }
-            }
+    let minAfterScale = minBeforeScale;
+    let maxAfterScale = maxBeforeScale;
+    if (options.preScale.enabled && !disableScale) {
+        const scalingParameters = options.preScale.scalingParameters;
+        _validateScalingParameters(scalingParameters);
+        const isRequiredScaling = _isRequiredScaling(scalingParameters);
+        if (isRequiredScaling) {
+            scaleArray(pixelDataArray, scalingParameters);
+            imageFrame.preScale = {
+                ...options.preScale,
+                scaled: true,
+            };
+            const scaledValues = _calculateScaledMinMax(minBeforeScale, maxBeforeScale, scalingParameters);
+            minAfterScale = scaledValues.min;
+            maxAfterScale = scaledValues.max;
         }
     }
-    imageFrame.pixelData = new Uint8Array(outFrame);
+    else if (disableScale) {
+        imageFrame.preScale = {
+            enabled: true,
+            scaled: false,
+        };
+        minAfterScale = minBeforeScale;
+        maxAfterScale = maxBeforeScale;
+    }
+    imageFrame.pixelData = pixelDataArray;
+    imageFrame.smallestPixelValue = minAfterScale;
+    imageFrame.largestPixelValue = maxAfterScale;
+    const end = new Date().getTime();
+    imageFrame.decodeTimeInMS = end - start;
     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);
+function _isRequiredScaling(scalingParameters) {
+    const { rescaleSlope, rescaleIntercept, modality, doseGridScaling, suvbw } = scalingParameters;
+    const hasRescaleValues = typeof rescaleSlope === 'number' && typeof rescaleIntercept === 'number';
+    const isRTDOSEWithScaling = modality === 'RTDOSE' && typeof doseGridScaling === 'number';
+    const isPTWithSUV = modality === 'PT' && typeof suvbw === 'number';
+    return hasRescaleValues || isRTDOSEWithScaling || isPTWithSUV;
+}
+function _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelDataArray) {
+    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, or doesn't exist.`);
     }
-    else {
-        imageFrame.pixelData = new Int16Array(outFrame);
+    if (rows && rows != imageFrame.rows) {
+        scaleImageFrame(imageFrame, options.targetBuffer, TypedArrayConstructor);
     }
-    return imageFrame;
-}
-/* harmony default export */ const decoders_decodeRLE = (decodeRLE);
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/codec-libjpeg-turbo-8bit/dist/libjpegturbowasm_decode.js
-var libjpegturbowasm_decode = __webpack_require__(36317);
-var libjpegturbowasm_decode_default = /*#__PURE__*/__webpack_require__.n(libjpegturbowasm_decode);
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEGBaseline8Bit.js
-
-const libjpegTurboWasm = new URL(/* asset import */ __webpack_require__(99441), __webpack_require__.b);
-const local = {
-    codec: undefined,
-    decoder: undefined,
-};
-function initLibjpegTurbo() {
-    if (local.codec) {
-        return Promise.resolve();
+    const imageFrameLength = imageFrame.pixelDataLength;
+    const offset = rawOffset;
+    const length = rawLength !== null && rawLength !== undefined
+        ? rawLength
+        : imageFrameLength - offset;
+    const imageFramePixelData = imageFrame.pixelData;
+    if (length !== imageFramePixelData.length) {
+        throw new Error(`target array for image does not have the same length (${length}) as the decoded image length (${imageFramePixelData.length}).`);
     }
-    const libjpegTurboModule = libjpegturbowasm_decode_default()({
-        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,
-    };
+    const typedArray = arrayBuffer
+        ? new TypedArrayConstructor(arrayBuffer, offset, length)
+        : new TypedArrayConstructor(length);
+    typedArray.set(imageFramePixelData, 0);
+    pixelDataArray = typedArray;
+    return pixelDataArray;
 }
-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);
+function _handlePreScaleSetup(options, minBeforeScale, maxBeforeScale, imageFrame) {
+    const scalingParameters = options.preScale.scalingParameters;
+    _validateScalingParameters(scalingParameters);
+    const scaledValues = _calculateScaledMinMax(minBeforeScale, maxBeforeScale, scalingParameters);
+    return _getDefaultPixelDataArray(scaledValues.min, scaledValues.max, imageFrame);
 }
-/* harmony default export */ const decodeJPEGBaseline8Bit = (decodeAsync);
-
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEGBaseline12Bit-js.js
-const decodeJPEGBaseline12Bit_js_local = {
-    JpegImage: undefined,
-    decodeConfig: {},
-};
-function initialize(decodeConfig) {
-    decodeJPEGBaseline12Bit_js_local.decodeConfig = decodeConfig;
-    if (decodeJPEGBaseline12Bit_js_local.JpegImage) {
-        return Promise.resolve();
-    }
-    return new Promise((resolve, reject) => {
-        __webpack_require__.e(/* import() */ 8094).then(__webpack_require__.bind(__webpack_require__, 8094))
-            .then((module) => {
-            decodeJPEGBaseline12Bit_js_local.JpegImage = module.default;
-            resolve();
-        })
-            .catch(reject);
-    });
+function _getDefaultPixelDataArray(min, max, imageFrame) {
+    const TypedArrayConstructor = (0,getPixelDataTypeFromMinMax/* default */.A)(min, max);
+    const typedArray = new TypedArrayConstructor(imageFrame.pixelData.length);
+    typedArray.set(imageFrame.pixelData, 0);
+    return typedArray;
 }
-async function decodeJPEGBaseline12BitAsync(imageFrame, pixelData) {
-    await initialize();
-    if (typeof decodeJPEGBaseline12Bit_js_local.JpegImage === 'undefined') {
-        throw new Error('No JPEG Baseline decoder loaded');
+function _calculateScaledMinMax(minValue, maxValue, scalingParameters) {
+    const { rescaleSlope, rescaleIntercept, modality, doseGridScaling, suvbw } = scalingParameters;
+    if (modality === 'PT' && typeof suvbw === 'number' && !isNaN(suvbw)) {
+        return {
+            min: suvbw * (minValue * rescaleSlope + rescaleIntercept),
+            max: suvbw * (maxValue * rescaleSlope + rescaleIntercept),
+        };
     }
-    const jpeg = new decodeJPEGBaseline12Bit_js_local.JpegImage();
-    jpeg.parse(pixelData);
-    jpeg.colorTransform = false;
-    if (imageFrame.bitsAllocated === 8) {
-        imageFrame.pixelData = jpeg.getData(imageFrame.columns, imageFrame.rows);
-        return imageFrame;
+    else if (modality === 'RTDOSE' &&
+        typeof doseGridScaling === 'number' &&
+        !isNaN(doseGridScaling)) {
+        return {
+            min: minValue * doseGridScaling,
+            max: maxValue * doseGridScaling,
+        };
     }
-    else if (imageFrame.bitsAllocated === 16) {
-        imageFrame.pixelData = jpeg.getData16(imageFrame.columns, imageFrame.rows);
-        return imageFrame;
+    else if (typeof rescaleSlope === 'number' &&
+        typeof rescaleIntercept === 'number') {
+        return {
+            min: rescaleSlope * minValue + rescaleIntercept,
+            max: rescaleSlope * maxValue + rescaleIntercept,
+        };
     }
-}
-/* harmony default export */ const decodeJPEGBaseline12Bit_js = (decodeJPEGBaseline12BitAsync);
-
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEGLossless.js
-const decodeJPEGLossless_local = {
-    DecoderClass: undefined,
-    decodeConfig: {},
-};
-function decodeJPEGLossless_initialize(decodeConfig) {
-    decodeJPEGLossless_local.decodeConfig = decodeConfig;
-    if (decodeJPEGLossless_local.DecoderClass) {
-        return Promise.resolve();
+    else {
+        return {
+            min: minValue,
+            max: maxValue,
+        };
     }
-    return new Promise((resolve, reject) => {
-        __webpack_require__.e(/* import() */ 732).then(__webpack_require__.bind(__webpack_require__, 10732)).then(({ Decoder }) => {
-            decodeJPEGLossless_local.DecoderClass = Decoder;
-            resolve();
-        }, reject);
-    });
 }
-async function decodeJPEGLossless(imageFrame, pixelData) {
-    await decodeJPEGLossless_initialize();
-    if (typeof decodeJPEGLossless_local.DecoderClass === 'undefined') {
-        throw new Error('No JPEG Lossless decoder loaded');
-    }
-    const decoder = new decodeJPEGLossless_local.DecoderClass();
-    const byteOutput = imageFrame.bitsAllocated <= 8 ? 1 : 2;
-    const buffer = pixelData.buffer;
-    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;
+function _validateScalingParameters(scalingParameters) {
+    if (!scalingParameters) {
+        throw new Error('options.preScale.scalingParameters must be defined if preScale.enabled is true, and scalingParameters cannot be derived from the metadata providers.');
     }
-    imageFrame.pixelData = new Int16Array(decompressedData.buffer);
-    return imageFrame;
-}
-/* harmony default export */ const decoders_decodeJPEGLossless = (decodeJPEGLossless);
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/codec-charls/dist/charlswasm_decode.js
-var charlswasm_decode = __webpack_require__(93720);
-var charlswasm_decode_default = /*#__PURE__*/__webpack_require__.n(charlswasm_decode);
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEGLS.js
-
-const charlsWasm = new URL(/* asset import */ __webpack_require__(46920), __webpack_require__.b);
-const decodeJPEGLS_local = {
-    codec: undefined,
-    decoder: undefined,
-    decodeConfig: {},
-};
-function getExceptionMessage(exception) {
-    return typeof exception === 'number'
-        ? decodeJPEGLS_local.codec.getExceptionMessage(exception)
-        : exception;
 }
-function decodeJPEGLS_initialize(decodeConfig) {
-    decodeJPEGLS_local.decodeConfig = decodeConfig;
-    if (decodeJPEGLS_local.codec) {
-        return Promise.resolve();
-    }
-    const charlsModule = charlswasm_decode_default()({
-        locateFile: (f) => {
-            if (f.endsWith('.wasm')) {
-                return charlsWasm.toString();
-            }
-            return f;
+function createDestinationImage(imageFrame, targetBuffer, TypedArrayConstructor) {
+    const { samplesPerPixel } = imageFrame;
+    const { rows, columns } = targetBuffer;
+    const typedLength = rows * columns * samplesPerPixel;
+    const pixelData = new TypedArrayConstructor(typedLength);
+    const bytesPerPixel = pixelData.byteLength / typedLength;
+    return {
+        pixelData,
+        rows,
+        columns,
+        frameInfo: {
+            ...imageFrame.frameInfo,
+            rows,
+            columns,
         },
-    });
-    return new Promise((resolve, reject) => {
-        charlsModule.then((instance) => {
-            decodeJPEGLS_local.codec = instance;
-            decodeJPEGLS_local.decoder = new instance.JpegLSDecoder();
-            resolve();
-        }, reject);
-    });
+        imageInfo: {
+            ...imageFrame.imageInfo,
+            rows,
+            columns,
+            bytesPerPixel,
+        },
+    };
 }
-async function decodeJPEGLS_decodeAsync(compressedImageFrame, imageInfo) {
-    try {
-        await decodeJPEGLS_initialize();
-        const decoder = decodeJPEGLS_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 = decodeJPEGLS_getPixelData(frameInfo, decodedPixelsInWASM, imageInfo.signed);
-        const encodeOptions = {
-            nearLossless,
-            interleaveMode,
-            frameInfo,
-        };
-        return {
-            ...imageInfo,
-            pixelData,
-            imageInfo: encodedImageInfo,
-            encodeOptions,
-            ...encodeOptions,
-            ...encodedImageInfo,
-        };
+function scaleImageFrame(imageFrame, targetBuffer, TypedArrayConstructor) {
+    const dest = createDestinationImage(imageFrame, targetBuffer, TypedArrayConstructor);
+    const { scalingType = 'replicate' } = targetBuffer;
+    imageUtils[scalingType](imageFrame, dest);
+    Object.assign(imageFrame, dest);
+    imageFrame.pixelDataLength = imageFrame.pixelData.length;
+    return imageFrame;
+}
+async function decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn) {
+    const start = new Date().getTime();
+    let decodePromise = null;
+    let opts;
+    switch (transferSyntax) {
+        case '1.2.840.10008.1.2':
+        case '1.2.840.10008.1.2.1':
+            decodePromise = (0,decodeLittleEndian/* default */.A)(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.2':
+            decodePromise = (0,decodeBigEndian/* default */.A)(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.1.99':
+            decodePromise = (0,decodeLittleEndian/* default */.A)(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.5':
+            decodePromise = (0,decodeRLE/* default */.A)(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.50':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = (0,decodeJPEGBaseline8Bit/* default */.A)(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.51':
+            decodePromise = (0,decodeJPEGBaseline12Bit_js/* default */.A)(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.57':
+            decodePromise = (0,decodeJPEGLossless/* default */.A)(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.70':
+            decodePromise = (0,decodeJPEGLossless/* default */.A)(imageFrame, pixelData);
+            break;
+        case '1.2.840.10008.1.2.4.80':
+            opts = {
+                signed: imageFrame.pixelRepresentation === 1,
+                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
+                ...imageFrame,
+            };
+            decodePromise = (0,decodeJPEGLS/* default */.A)(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.81':
+            opts = {
+                signed: imageFrame.pixelRepresentation === 1,
+                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
+                ...imageFrame,
+            };
+            decodePromise = (0,decodeJPEGLS/* default */.A)(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.90':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = (0,decodeJPEG2000/* default */.A)(pixelData, opts);
+            break;
+        case '1.2.840.10008.1.2.4.91':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = (0,decodeJPEG2000/* default */.A)(pixelData, opts);
+            break;
+        case '3.2.840.10008.1.2.4.96':
+        case '1.2.840.10008.1.2.4.201':
+        case '1.2.840.10008.1.2.4.202':
+        case '1.2.840.10008.1.2.4.203':
+            opts = {
+                ...imageFrame,
+            };
+            decodePromise = (0,decodeHTJ2K/* default */.A)(pixelData, opts);
+            break;
+        default:
+            throw new Error(`no decoder for transfer syntax ${transferSyntax}`);
     }
-    catch (error) {
-        throw getExceptionMessage(error);
+    if (!decodePromise) {
+        throw new Error('decodePromise not defined');
     }
+    const decodedFrame = await decodePromise;
+    const postProcessed = postProcessDecodedPixels(decodedFrame, options, start, decodeConfig);
+    callbackFn?.(postProcessed);
+    return postProcessed;
 }
-function decodeJPEGLS_getPixelData(frameInfo, decodedBuffer, signed) {
-    if (frameInfo.bitsPerSample > 8) {
-        if (signed) {
-            return new Int16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
+const obj = {
+    decodeTask({ imageFrame, transferSyntax, decodeConfig, options, pixelData, callbackFn, }) {
+        return decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn);
+    },
+};
+(0,comlink/* expose */.p)(obj);
+
+
+/***/ }),
+
+/***/ 45155:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+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]);
         }
-        return new Uint16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
     }
-    if (signed) {
-        return new Int8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+    else if (imageFrame.bitsAllocated === 8) {
+        imageFrame.pixelData = pixelData;
     }
-    return new Uint8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
+    return imageFrame;
 }
-/* harmony default export */ const decodeJPEGLS = (decodeJPEGLS_decodeAsync);
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeBigEndian);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/codec-openjpeg/dist/openjpegwasm_decode.js
-var openjpegwasm_decode = __webpack_require__(53488);
-var openjpegwasm_decode_default = /*#__PURE__*/__webpack_require__.n(openjpegwasm_decode);
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeJPEG2000.js
 
-const openjpegWasm = new URL(/* asset import */ __webpack_require__(87840), __webpack_require__.b);
-const decodeJPEG2000_local = {
+/***/ }),
+
+/***/ 53383:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* unused harmony export initialize */
+/* harmony import */ var _cornerstonejs_codec_openjph_wasmjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(68112);
+/* harmony import */ var _cornerstonejs_codec_openjph_wasmjs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_cornerstonejs_codec_openjph_wasmjs__WEBPACK_IMPORTED_MODULE_0__);
+
+const openjphWasm = new URL(/* asset import */ __webpack_require__(12342), __webpack_require__.b);
+const local = {
     codec: undefined,
     decoder: undefined,
     decodeConfig: {},
 };
-function decodeJPEG2000_initialize(decodeConfig) {
-    decodeJPEG2000_local.decodeConfig = decodeConfig;
-    if (decodeJPEG2000_local.codec) {
+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;
+}
+function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.codec) {
         return Promise.resolve();
     }
-    const openJpegModule = openjpegwasm_decode_default()({
+    const openJphModule = _cornerstonejs_codec_openjph_wasmjs__WEBPACK_IMPORTED_MODULE_0___default()({
         locateFile: (f) => {
             if (f.endsWith('.wasm')) {
-                return openjpegWasm.toString();
+                return openjphWasm.toString();
             }
             return f;
         },
     });
     return new Promise((resolve, reject) => {
-        openJpegModule.then((instance) => {
-            decodeJPEG2000_local.codec = instance;
-            decodeJPEG2000_local.decoder = new instance.J2KDecoder();
+        openJphModule.then((instance) => {
+            local.codec = instance;
+            local.decoder = new instance.HTJ2KDecoder();
             resolve();
         }, reject);
     });
 }
-async function decodeJPEG2000_decodeAsync(compressedImageFrame, imageInfo) {
-    await decodeJPEG2000_initialize();
-    const decoder = decodeJPEG2000_local.decoder;
+async function decodeAsync(compressedImageFrame, imageInfo) {
+    await initialize();
+    const decoder = new local.codec.HTJ2KDecoder();
     const encodedBufferInWASM = decoder.getEncodedBuffer(compressedImageFrame.length);
     encodedBufferInWASM.set(compressedImageFrame);
-    decoder.decode();
+    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);
@@ -4231,7 +4205,6 @@ async function decodeJPEG2000_decodeAsync(compressedImageFrame, imageInfo) {
     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 = {
@@ -4242,7 +4215,10 @@ async function decodeJPEG2000_decodeAsync(compressedImageFrame, imageInfo) {
         bytesPerPixel: imageInfo.bytesPerPixel,
         componentsPerPixel: frameInfo.componentCount,
     };
-    const pixelData = decodeJPEG2000_getPixelData(frameInfo, decodedBufferInWASM);
+    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,
@@ -4252,7 +4228,6 @@ async function decodeJPEG2000_decodeAsync(compressedImageFrame, imageInfo) {
         blockDimensions,
         tileSize,
         tileOffset,
-        colorTransform,
         decodedSize,
         compressionRatio,
     };
@@ -4265,7 +4240,7 @@ async function decodeJPEG2000_decodeAsync(compressedImageFrame, imageInfo) {
         ...encodedImageInfo,
     };
 }
-function decodeJPEG2000_getPixelData(frameInfo, decodedBuffer) {
+function getPixelData(frameInfo, decodedBuffer) {
     if (frameInfo.bitsPerSample > 8) {
         if (frameInfo.isSigned) {
             return new Int16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
@@ -4277,62 +4252,56 @@ function decodeJPEG2000_getPixelData(frameInfo, decodedBuffer) {
     }
     return new Uint8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
 }
-/* harmony default export */ const decodeJPEG2000 = (decodeJPEG2000_decodeAsync);
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeAsync);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/codec-openjph/dist/openjphjs.js
-var openjphjs = __webpack_require__(68112);
-var openjphjs_default = /*#__PURE__*/__webpack_require__.n(openjphjs);
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/decoders/decodeHTJ2K.js
 
-const openjphWasm = new URL(/* asset import */ __webpack_require__(12342), __webpack_require__.b);
-const decodeHTJ2K_local = {
+/***/ }),
+
+/***/ 90612:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* unused harmony export initialize */
+/* harmony import */ var _cornerstonejs_codec_openjpeg_decodewasmjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(53488);
+/* harmony import */ var _cornerstonejs_codec_openjpeg_decodewasmjs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_cornerstonejs_codec_openjpeg_decodewasmjs__WEBPACK_IMPORTED_MODULE_0__);
+
+const openjpegWasm = new URL(/* asset import */ __webpack_require__(87840), __webpack_require__.b);
+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;
-}
-function decodeHTJ2K_initialize(decodeConfig) {
-    decodeHTJ2K_local.decodeConfig = decodeConfig;
-    if (decodeHTJ2K_local.codec) {
+function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.codec) {
         return Promise.resolve();
     }
-    const openJphModule = openjphjs_default()({
+    const openJpegModule = _cornerstonejs_codec_openjpeg_decodewasmjs__WEBPACK_IMPORTED_MODULE_0___default()({
         locateFile: (f) => {
             if (f.endsWith('.wasm')) {
-                return openjphWasm.toString();
+                return openjpegWasm.toString();
             }
             return f;
         },
     });
     return new Promise((resolve, reject) => {
-        openJphModule.then((instance) => {
-            decodeHTJ2K_local.codec = instance;
-            decodeHTJ2K_local.decoder = new instance.HTJ2KDecoder();
+        openJpegModule.then((instance) => {
+            local.codec = instance;
+            local.decoder = new instance.J2KDecoder();
             resolve();
         }, reject);
     });
 }
-async function decodeHTJ2K_decodeAsync(compressedImageFrame, imageInfo) {
-    await decodeHTJ2K_initialize();
-    const decoder = new decodeHTJ2K_local.codec.HTJ2KDecoder();
+async function decodeAsync(compressedImageFrame, imageInfo) {
+    await initialize();
+    const decoder = local.decoder;
     const encodedBufferInWASM = decoder.getEncodedBuffer(compressedImageFrame.length);
     encodedBufferInWASM.set(compressedImageFrame);
-    const decodeLevel = imageInfo.decodeLevel || 0;
-    decoder.decodeSubResolution(decodeLevel);
+    decoder.decode();
     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);
@@ -4344,6 +4313,7 @@ async function decodeHTJ2K_decodeAsync(compressedImageFrame, imageInfo) {
     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 = {
@@ -4354,10 +4324,7 @@ async function decodeHTJ2K_decodeAsync(compressedImageFrame, imageInfo) {
         bytesPerPixel: imageInfo.bytesPerPixel,
         componentsPerPixel: frameInfo.componentCount,
     };
-    let pixelData = decodeHTJ2K_getPixelData(frameInfo, decodedBufferInWASM);
-    const { buffer: b, byteOffset, byteLength } = pixelData;
-    const pixelDataArrayBuffer = b.slice(byteOffset, byteOffset + byteLength);
-    pixelData = new pixelData.constructor(pixelDataArrayBuffer);
+    const pixelData = getPixelData(frameInfo, decodedBufferInWASM);
     const encodeOptions = {
         imageOffset,
         numDecompositions,
@@ -4367,6 +4334,7 @@ async function decodeHTJ2K_decodeAsync(compressedImageFrame, imageInfo) {
         blockDimensions,
         tileSize,
         tileOffset,
+        colorTransform,
         decodedSize,
         compressionRatio,
     };
@@ -4379,7 +4347,7 @@ async function decodeHTJ2K_decodeAsync(compressedImageFrame, imageInfo) {
         ...encodedImageInfo,
     };
 }
-function decodeHTJ2K_getPixelData(frameInfo, decodedBuffer) {
+function getPixelData(frameInfo, decodedBuffer) {
     if (frameInfo.bitsPerSample > 8) {
         if (frameInfo.isSigned) {
             return new Int16Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength / 2);
@@ -4391,335 +4359,470 @@ function decodeHTJ2K_getPixelData(frameInfo, decodedBuffer) {
     }
     return new Uint8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
 }
-/* harmony default export */ const decodeHTJ2K = (decodeHTJ2K_decodeAsync);
-
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/scaling/scaleArray.js
-function scaleArray(array, scalingParameters) {
-    const arrayLength = array.length;
-    const { rescaleSlope, rescaleIntercept, suvbw, doseGridScaling } = 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 if (scalingParameters.modality === 'RTDOSE' &&
-        typeof doseGridScaling === 'number' &&
-        !isNaN(doseGridScaling)) {
-        for (let i = 0; i < arrayLength; i++) {
-            array[i] = array[i] * doseGridScaling;
-        }
-    }
-    else {
-        for (let i = 0; i < arrayLength; i++) {
-            array[i] = array[i] * rescaleSlope + rescaleIntercept;
-        }
-    }
-    return true;
-}
-
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/getMinMax.js
-var getMinMax = __webpack_require__(52842);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/getPixelDataTypeFromMinMax.js
-var getPixelDataTypeFromMinMax = __webpack_require__(69952);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/shared/isColorImage.js
-var isColorImage = __webpack_require__(30922);
-;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/decodeImageFrameWorker.js
-
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeAsync);
 
 
+/***/ }),
 
+/***/ 63991:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* unused harmony export initialize */
+const local = {
+    JpegImage: undefined,
+    decodeConfig: {},
+};
+function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.JpegImage) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        __webpack_require__.e(/* import() */ 8094).then(__webpack_require__.bind(__webpack_require__, 8094))
+            .then((module) => {
+            local.JpegImage = module.default;
+            resolve();
+        })
+            .catch(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;
+    }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeJPEGBaseline12BitAsync);
 
 
+/***/ }),
 
+/***/ 89178:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* unused harmony export initialize */
+/* harmony import */ var _cornerstonejs_codec_libjpeg_turbo_8bit_decodewasmjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36317);
+/* harmony import */ var _cornerstonejs_codec_libjpeg_turbo_8bit_decodewasmjs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_cornerstonejs_codec_libjpeg_turbo_8bit_decodewasmjs__WEBPACK_IMPORTED_MODULE_0__);
 
+const libjpegTurboWasm = new URL(/* asset import */ __webpack_require__(99441), __webpack_require__.b);
+const local = {
+    codec: undefined,
+    decoder: undefined,
+};
+function initLibjpegTurbo() {
+    if (local.codec) {
+        return Promise.resolve();
+    }
+    const libjpegTurboModule = _cornerstonejs_codec_libjpeg_turbo_8bit_decodewasmjs__WEBPACK_IMPORTED_MODULE_0___default()({
+        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);
+}
+const initialize = (/* unused pure expression or super */ null && (initLibjpegTurbo));
 
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeAsync);
 
 
+/***/ }),
 
+/***/ 93119:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* unused harmony export initialize */
+/* harmony import */ var _cornerstonejs_codec_charls_decodewasmjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(93720);
+/* harmony import */ var _cornerstonejs_codec_charls_decodewasmjs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_cornerstonejs_codec_charls_decodewasmjs__WEBPACK_IMPORTED_MODULE_0__);
 
-const imageUtils = {
-    bilinear: bilinear,
-    replicate: replicate,
-};
-const typedArrayConstructors = {
-    Uint8Array,
-    Uint16Array,
-    Int16Array,
-    Float32Array,
-    Uint32Array,
+const charlsWasm = new URL(/* asset import */ __webpack_require__(46920), __webpack_require__.b);
+const local = {
+    codec: undefined,
+    decoder: undefined,
+    decodeConfig: {},
 };
-function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
-    const shouldShift = imageFrame.pixelRepresentation !== undefined &&
-        imageFrame.pixelRepresentation === 1;
-    const shift = shouldShift && imageFrame.bitsStored !== undefined
-        ? 32 - imageFrame.bitsStored
-        : undefined;
-    if (shouldShift && shift !== undefined) {
-        for (let i = 0; i < imageFrame.pixelData.length; i++) {
-            imageFrame.pixelData[i] = (imageFrame.pixelData[i] << shift) >> shift;
-        }
-    }
-    let pixelDataArray = imageFrame.pixelData;
-    imageFrame.pixelDataLength = imageFrame.pixelData.length;
-    const { min: minBeforeScale, max: maxBeforeScale } = (0,getMinMax/* default */.A)(imageFrame.pixelData);
-    const canRenderFloat = typeof options.allowFloatRendering !== 'undefined'
-        ? options.allowFloatRendering
-        : true;
-    let invalidType = (0,isColorImage/* default */.A)(imageFrame.photometricInterpretation) &&
-        options.targetBuffer?.offset === undefined;
-    const willScale = options.preScale?.enabled;
-    const hasFloatRescale = willScale &&
-        Object.values(options.preScale.scalingParameters).some((v) => typeof v === 'number' && !Number.isInteger(v));
-    const disableScale = !options.preScale.enabled || (!canRenderFloat && hasFloatRescale);
-    const type = options.targetBuffer?.type;
-    if (type && options.preScale.enabled && !disableScale) {
-        const scalingParameters = options.preScale.scalingParameters;
-        const scaledValues = _calculateScaledMinMax(minBeforeScale, maxBeforeScale, scalingParameters);
-        invalidType = !(0,getPixelDataTypeFromMinMax/* validatePixelDataType */.r)(scaledValues.min, scaledValues.max, typedArrayConstructors[type]);
-    }
-    if (type && !invalidType) {
-        pixelDataArray = _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelDataArray);
+function getExceptionMessage(exception) {
+    return typeof exception === 'number'
+        ? local.codec.getExceptionMessage(exception)
+        : exception;
+}
+function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.codec) {
+        return Promise.resolve();
     }
-    else if (options.preScale.enabled && !disableScale) {
-        pixelDataArray = _handlePreScaleSetup(options, minBeforeScale, maxBeforeScale, imageFrame);
+    const charlsModule = _cornerstonejs_codec_charls_decodewasmjs__WEBPACK_IMPORTED_MODULE_0___default()({
+        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,
+        };
     }
-    else {
-        pixelDataArray = _getDefaultPixelDataArray(minBeforeScale, maxBeforeScale, imageFrame);
+    catch (error) {
+        throw getExceptionMessage(error);
     }
-    let minAfterScale = minBeforeScale;
-    let maxAfterScale = maxBeforeScale;
-    if (options.preScale.enabled && !disableScale) {
-        const scalingParameters = options.preScale.scalingParameters;
-        _validateScalingParameters(scalingParameters);
-        const isRequiredScaling = _isRequiredScaling(scalingParameters);
-        if (isRequiredScaling) {
-            scaleArray(pixelDataArray, scalingParameters);
-            imageFrame.preScale = {
-                ...options.preScale,
-                scaled: true,
-            };
-            const scaledValues = _calculateScaledMinMax(minBeforeScale, maxBeforeScale, scalingParameters);
-            minAfterScale = scaledValues.min;
-            maxAfterScale = scaledValues.max;
+}
+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);
     }
-    else if (disableScale) {
-        imageFrame.preScale = {
-            enabled: true,
-            scaled: false,
-        };
-        minAfterScale = minBeforeScale;
-        maxAfterScale = maxBeforeScale;
+    if (signed) {
+        return new Int8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
     }
-    imageFrame.pixelData = pixelDataArray;
-    imageFrame.smallestPixelValue = minAfterScale;
-    imageFrame.largestPixelValue = maxAfterScale;
-    const end = new Date().getTime();
-    imageFrame.decodeTimeInMS = end - start;
-    return imageFrame;
-}
-function _isRequiredScaling(scalingParameters) {
-    const { rescaleSlope, rescaleIntercept, modality, doseGridScaling, suvbw } = scalingParameters;
-    const hasRescaleValues = typeof rescaleSlope === 'number' && typeof rescaleIntercept === 'number';
-    const isRTDOSEWithScaling = modality === 'RTDOSE' && typeof doseGridScaling === 'number';
-    const isPTWithSUV = modality === 'PT' && typeof suvbw === 'number';
-    return hasRescaleValues || isRTDOSEWithScaling || isPTWithSUV;
+    return new Uint8Array(decodedBuffer.buffer, decodedBuffer.byteOffset, decodedBuffer.byteLength);
 }
-function _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelDataArray) {
-    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, or doesn't exist.`);
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeAsync);
+
+
+/***/ }),
+
+/***/ 32856:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* unused harmony export initialize */
+const local = {
+    DecoderClass: undefined,
+    decodeConfig: {},
+};
+function initialize(decodeConfig) {
+    local.decodeConfig = decodeConfig;
+    if (local.DecoderClass) {
+        return Promise.resolve();
     }
-    if (rows && rows != imageFrame.rows) {
-        scaleImageFrame(imageFrame, options.targetBuffer, TypedArrayConstructor);
+    return new Promise((resolve, reject) => {
+        __webpack_require__.e(/* import() */ 732).then(__webpack_require__.bind(__webpack_require__, 10732)).then(({ Decoder }) => {
+            local.DecoderClass = Decoder;
+            resolve();
+        }, reject);
+    });
+}
+async function decodeJPEGLossless(imageFrame, pixelData) {
+    await initialize();
+    if (typeof local.DecoderClass === 'undefined') {
+        throw new Error('No JPEG Lossless decoder loaded');
     }
-    const imageFrameLength = imageFrame.pixelDataLength;
-    const offset = rawOffset;
-    const length = rawLength !== null && rawLength !== undefined
-        ? rawLength
-        : imageFrameLength - offset;
-    const imageFramePixelData = imageFrame.pixelData;
-    if (length !== imageFramePixelData.length) {
-        throw new Error(`target array for image does not have the same length (${length}) as the decoded image length (${imageFramePixelData.length}).`);
+    const decoder = new local.DecoderClass();
+    const byteOutput = imageFrame.bitsAllocated <= 8 ? 1 : 2;
+    const buffer = pixelData.buffer;
+    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;
     }
-    const typedArray = arrayBuffer
-        ? new TypedArrayConstructor(arrayBuffer, offset, length)
-        : new TypedArrayConstructor(length);
-    typedArray.set(imageFramePixelData, 0);
-    pixelDataArray = typedArray;
-    return pixelDataArray;
-}
-function _handlePreScaleSetup(options, minBeforeScale, maxBeforeScale, imageFrame) {
-    const scalingParameters = options.preScale.scalingParameters;
-    _validateScalingParameters(scalingParameters);
-    const scaledValues = _calculateScaledMinMax(minBeforeScale, maxBeforeScale, scalingParameters);
-    return _getDefaultPixelDataArray(scaledValues.min, scaledValues.max, imageFrame);
-}
-function _getDefaultPixelDataArray(min, max, imageFrame) {
-    const TypedArrayConstructor = (0,getPixelDataTypeFromMinMax/* default */.A)(min, max);
-    const typedArray = new TypedArrayConstructor(imageFrame.pixelData.length);
-    typedArray.set(imageFrame.pixelData, 0);
-    return typedArray;
+    imageFrame.pixelData = new Int16Array(decompressedData.buffer);
+    return imageFrame;
 }
-function _calculateScaledMinMax(minValue, maxValue, scalingParameters) {
-    const { rescaleSlope, rescaleIntercept, modality, doseGridScaling, suvbw } = scalingParameters;
-    if (modality === 'PT' && typeof suvbw === 'number' && !isNaN(suvbw)) {
-        return {
-            min: suvbw * (minValue * rescaleSlope + rescaleIntercept),
-            max: suvbw * (maxValue * rescaleSlope + rescaleIntercept),
-        };
-    }
-    else if (modality === 'RTDOSE' &&
-        typeof doseGridScaling === 'number' &&
-        !isNaN(doseGridScaling)) {
-        return {
-            min: minValue * doseGridScaling,
-            max: maxValue * doseGridScaling,
-        };
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeJPEGLossless);
+
+
+/***/ }),
+
+/***/ 67927:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+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 (typeof rescaleSlope === 'number' &&
-        typeof rescaleIntercept === 'number') {
-        return {
-            min: rescaleSlope * minValue + rescaleIntercept,
-            max: rescaleSlope * maxValue + rescaleIntercept,
-        };
+    else if (imageFrame.bitsAllocated === 8 || imageFrame.bitsAllocated === 1) {
+        imageFrame.pixelData = pixelData;
     }
-    else {
-        return {
-            min: minValue,
-            max: maxValue,
-        };
+    else if (imageFrame.bitsAllocated === 32) {
+        if (offset % 2) {
+            arrayBuffer = arrayBuffer.slice(offset);
+            offset = 0;
+        }
+        if (imageFrame.floatPixelData || imageFrame.doubleFloatPixelData) {
+            throw new Error('Float pixel data is not supported for parsing into ImageFrame');
+        }
+        if (imageFrame.pixelRepresentation === 0) {
+            imageFrame.pixelData = new Uint32Array(arrayBuffer, offset, length / 4);
+        }
+        else if (imageFrame.pixelRepresentation === 1) {
+            imageFrame.pixelData = new Int32Array(arrayBuffer, offset, length / 4);
+        }
+        else {
+            imageFrame.pixelData = new Float32Array(arrayBuffer, offset, length / 4);
+        }
     }
+    return imageFrame;
 }
-function _validateScalingParameters(scalingParameters) {
-    if (!scalingParameters) {
-        throw new Error('options.preScale.scalingParameters must be defined if preScale.enabled is true, and scalingParameters cannot be derived from the metadata providers.');
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeLittleEndian);
+
+
+/***/ }),
+
+/***/ 40115:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+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 createDestinationImage(imageFrame, targetBuffer, TypedArrayConstructor) {
-    const { samplesPerPixel } = imageFrame;
-    const { rows, columns } = targetBuffer;
-    const typedLength = rows * columns * samplesPerPixel;
-    const pixelData = new TypedArrayConstructor(typedLength);
-    const bytesPerPixel = pixelData.byteLength / typedLength;
-    return {
-        pixelData,
-        rows,
-        columns,
-        frameInfo: {
-            ...imageFrame.frameInfo,
-            rows,
-            columns,
-        },
-        imageInfo: {
-            ...imageFrame.imageInfo,
-            rows,
-            columns,
-            bytesPerPixel,
-        },
-    };
+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 scaleImageFrame(imageFrame, targetBuffer, TypedArrayConstructor) {
-    const dest = createDestinationImage(imageFrame, targetBuffer, TypedArrayConstructor);
-    const { scalingType = 'replicate' } = targetBuffer;
-    imageUtils[scalingType](imageFrame, dest);
-    Object.assign(imageFrame, dest);
-    imageFrame.pixelDataLength = imageFrame.pixelData.length;
+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;
 }
-async function decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn) {
-    const start = new Date().getTime();
-    let decodePromise = null;
-    let opts;
-    switch (transferSyntax) {
-        case '1.2.840.10008.1.2':
-        case '1.2.840.10008.1.2.1':
-            decodePromise = decoders_decodeLittleEndian(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.2':
-            decodePromise = decoders_decodeBigEndian(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.1.99':
-            decodePromise = decoders_decodeLittleEndian(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.5':
-            decodePromise = decoders_decodeRLE(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.4.50':
-            opts = {
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEGBaseline8Bit(pixelData, opts);
-            break;
-        case '1.2.840.10008.1.2.4.51':
-            decodePromise = decodeJPEGBaseline12Bit_js(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.4.57':
-            decodePromise = decoders_decodeJPEGLossless(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.4.70':
-            decodePromise = decoders_decodeJPEGLossless(imageFrame, pixelData);
-            break;
-        case '1.2.840.10008.1.2.4.80':
-            opts = {
-                signed: imageFrame.pixelRepresentation === 1,
-                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEGLS(pixelData, opts);
-            break;
-        case '1.2.840.10008.1.2.4.81':
-            opts = {
-                signed: imageFrame.pixelRepresentation === 1,
-                bytesPerPixel: imageFrame.bitsAllocated <= 8 ? 1 : 2,
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEGLS(pixelData, opts);
-            break;
-        case '1.2.840.10008.1.2.4.90':
-            opts = {
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEG2000(pixelData, opts);
-            break;
-        case '1.2.840.10008.1.2.4.91':
-            opts = {
-                ...imageFrame,
-            };
-            decodePromise = decodeJPEG2000(pixelData, opts);
-            break;
-        case '3.2.840.10008.1.2.4.96':
-        case '1.2.840.10008.1.2.4.201':
-        case '1.2.840.10008.1.2.4.202':
-        case '1.2.840.10008.1.2.4.203':
-            opts = {
-                ...imageFrame,
-            };
-            decodePromise = decodeHTJ2K(pixelData, opts);
-            break;
-        default:
-            throw new Error(`no decoder for transfer syntax ${transferSyntax}`);
+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 (!decodePromise) {
-        throw new Error('decodePromise not defined');
+    if (imageFrame.pixelRepresentation === 0) {
+        imageFrame.pixelData = new Uint16Array(outFrame);
     }
-    const decodedFrame = await decodePromise;
-    const postProcessed = postProcessDecodedPixels(decodedFrame, options, start, decodeConfig);
-    callbackFn?.(postProcessed);
-    return postProcessed;
+    else {
+        imageFrame.pixelData = new Int16Array(outFrame);
+    }
+    return imageFrame;
 }
-const obj = {
-    decodeTask({ imageFrame, transferSyntax, decodeConfig, options, pixelData, callbackFn, }) {
-        return decodeImageFrame(imageFrame, transferSyntax, pixelData, decodeConfig, options, callbackFn);
-    },
-};
-(0,comlink/* expose */.p)(obj);
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (decodeRLE);
 
 
 /***/ }),