ag-psd 19.0.1 → 20.1.0

package/dist-es/psdReader.js

@@ -9,8 +9,8 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { inflate } from 'pako';
-import { resetImageData, offsetForChannel, decodeBitmap, createCanvas, createImageData, toBlendMode, RAW_IMAGE_DATA, largeAdditionalInfoKeys } from './helpers';
+import { inflateSync } from 'zlib';
+import { resetImageData, offsetForChannel, decodeBitmap, createImageData, toBlendMode, RAW_IMAGE_DATA, largeAdditionalInfoKeys, imageDataToCanvas } from './helpers';
 import { infoHandlersMap } from './additionalInfo';
 import { resourceHandlersMap } from './imageResources';
 export var supportedColorModes = [0 /* ColorMode.Bitmap */, 1 /* ColorMode.Grayscale */, 3 /* ColorMode.RGB */];
@@ -160,9 +160,9 @@ function readShortString(reader, length) {
 function isValidSignature(sig) {
     return sig === '8BIM' || sig === 'MeSa' || sig === 'AgHg' || sig === 'PHUT' || sig === 'DCSR';
 }
-export function readPsd(reader, options) {
+export function readPsd(reader, readOptions) {
     var _a;
-    if (options === void 0) { options = {}; }
+    if (readOptions === void 0) { readOptions = {}; }
     // header
     checkSignature(reader, '8BPS');
     var version = readUint16(reader);
@@ -176,20 +176,27 @@ export function readPsd(reader, options) {
     var colorMode = readUint16(reader);
     var maxSize = version === 1 ? 30000 : 300000;
     if (width > maxSize || height > maxSize)
-        throw new Error("Invalid size");
+        throw new Error("Invalid size: ".concat(width, "x").concat(height));
     if (channels > 16)
-        throw new Error("Invalid channel count");
-    if (bitsPerChannel > 32)
-        throw new Error("Invalid bitsPerChannel count");
+        throw new Error("Invalid channel count: ".concat(channels));
+    if (![1, 8, 16, 32].includes(bitsPerChannel))
+        throw new Error("Invalid bitsPerChannel: ".concat(bitsPerChannel));
     if (supportedColorModes.indexOf(colorMode) === -1)
         throw new Error("Color mode not supported: ".concat((_a = colorModes[colorMode]) !== null && _a !== void 0 ? _a : colorMode));
     var psd = { width: width, height: height, channels: channels, bitsPerChannel: bitsPerChannel, colorMode: colorMode };
-    var opt = __assign(__assign({}, options), { large: version === 2 });
+    var options = __assign(__assign({}, readOptions), { large: version === 2, globalAlpha: false });
     var fixOffsets = [0, 1, -1, 2, -2, 3, -3, 4, -4];
     // color mode data
     readSection(reader, 1, function (left) {
-        if (opt.throwForMissingFeatures)
-            throw new Error('Color mode data not supported');
+        if (!left())
+            return;
+        // const numbers: number[] = [];
+        // console.log('color mode', left());
+        // while (left()) {
+        // 	numbers.push(readUint32(reader));
+        // }
+        // console.log('color mode', numbers);
+        // if (options.throwForMissingFeatures) throw new Error('Color mode data not supported');
         skipBytes(reader, left());
     });
     // image resources
@@ -215,22 +222,22 @@ export function readPsd(reader, options) {
             readPascalString(reader, 2); // name
             readSection(reader, 2, function (left) {
                 var handler = resourceHandlersMap[id];
-                var skip = id === 1036 && !!opt.skipThumbnail;
+                var skip = id === 1036 && !!options.skipThumbnail;
                 if (!psd.imageResources) {
                     psd.imageResources = {};
                 }
                 if (handler && !skip) {
                     try {
-                        handler.read(reader, psd.imageResources, left, opt);
+                        handler.read(reader, psd.imageResources, left, options);
                     }
                     catch (e) {
-                        if (opt.throwForMissingFeatures)
+                        if (options.throwForMissingFeatures)
                             throw e;
                         skipBytes(reader, left());
                     }
                 }
                 else {
-                    // options.logMissingFeatures && console.log(`Unhandled image resource: ${id}`);
+                    // options.logMissingFeatures && console.log(`Unhandled image resource: ${id} (${left()})`);
                     skipBytes(reader, left());
                 }
             });
@@ -240,9 +247,11 @@ export function readPsd(reader, options) {
         }
     });
     // layer and mask info
-    var globalAlpha = false;
     readSection(reader, 1, function (left) {
-        globalAlpha = readLayerInfo(reader, psd, opt);
+        readSection(reader, 2, function (left) {
+            readLayerInfo(reader, psd, options);
+            skipBytes(reader, left());
+        }, undefined, options.large);
         // SAI does not include this section
         if (left() > 0) {
             var globalLayerMaskInfo = readGlobalLayerMaskInfo(reader);
@@ -261,70 +270,65 @@ export function readPsd(reader, options) {
                 skipBytes(reader, 1);
             }
             if (left() >= 12) {
-                readAdditionalLayerInfo(reader, psd, psd, opt);
+                readAdditionalLayerInfo(reader, psd, psd, options);
             }
             else {
                 // opt.logMissingFeatures && console.log('skipping leftover bytes', left());
                 skipBytes(reader, left());
             }
         }
-    }, undefined, opt.large);
+    }, undefined, options.large);
     var hasChildren = psd.children && psd.children.length;
-    var skipComposite = opt.skipCompositeImageData && (opt.skipLayerImageData || hasChildren);
+    var skipComposite = options.skipCompositeImageData && (options.skipLayerImageData || hasChildren);
     if (!skipComposite) {
-        readImageData(reader, psd, globalAlpha, opt);
+        readImageData(reader, psd, options);
     }
     // TODO: show converted color mode instead of original PSD file color mode
     //       but add option to preserve file color mode (need to return image data instead of canvas in that case)
     // psd.colorMode = ColorMode.RGB; // we convert all color modes to RGB
     return psd;
 }
-function readLayerInfo(reader, psd, options) {
-    var globalAlpha = false;
-    readSection(reader, 2, function (left) {
-        var layerCount = readInt16(reader);
-        if (layerCount < 0) {
-            globalAlpha = true;
-            layerCount = -layerCount;
-        }
-        var layers = [];
-        var layerChannels = [];
+export function readLayerInfo(reader, psd, options) {
+    var layerCount = readInt16(reader);
+    if (layerCount < 0) {
+        options.globalAlpha = true;
+        layerCount = -layerCount;
+    }
+    var layers = [];
+    var layerChannels = [];
+    for (var i = 0; i < layerCount; i++) {
+        var _a = readLayerRecord(reader, psd, options), layer = _a.layer, channels = _a.channels;
+        layers.push(layer);
+        layerChannels.push(channels);
+    }
+    if (!options.skipLayerImageData) {
         for (var i = 0; i < layerCount; i++) {
-            var _a = readLayerRecord(reader, psd, options), layer = _a.layer, channels = _a.channels;
-            layers.push(layer);
-            layerChannels.push(channels);
+            readLayerChannelImageData(reader, psd, layers[i], layerChannels[i], options);
         }
-        if (!options.skipLayerImageData) {
-            for (var i = 0; i < layerCount; i++) {
-                readLayerChannelImageData(reader, psd, layers[i], layerChannels[i], options);
-            }
+    }
+    if (!psd.children)
+        psd.children = [];
+    var stack = [psd];
+    for (var i = layers.length - 1; i >= 0; i--) {
+        var l = layers[i];
+        var type = l.sectionDivider ? l.sectionDivider.type : 0 /* SectionDividerType.Other */;
+        if (type === 1 /* SectionDividerType.OpenFolder */ || type === 2 /* SectionDividerType.ClosedFolder */) {
+            l.opened = type === 1 /* SectionDividerType.OpenFolder */;
+            l.children = [];
+            stack[stack.length - 1].children.unshift(l);
+            stack.push(l);
         }
-        skipBytes(reader, left());
-        if (!psd.children)
-            psd.children = [];
-        var stack = [psd];
-        for (var i = layers.length - 1; i >= 0; i--) {
-            var l = layers[i];
-            var type = l.sectionDivider ? l.sectionDivider.type : 0 /* SectionDividerType.Other */;
-            if (type === 1 /* SectionDividerType.OpenFolder */ || type === 2 /* SectionDividerType.ClosedFolder */) {
-                l.opened = type === 1 /* SectionDividerType.OpenFolder */;
-                l.children = [];
-                stack[stack.length - 1].children.unshift(l);
-                stack.push(l);
-            }
-            else if (type === 3 /* SectionDividerType.BoundingSectionDivider */) {
-                stack.pop();
-                // this was workaround because I didn't know what `lsdk` section was, now it's probably not needed anymore
-                // } else if (l.name === '</Layer group>' && !l.sectionDivider && !l.top && !l.left && !l.bottom && !l.right) {
-                // 	// sometimes layer group terminator doesn't have sectionDivider, so we just guess here (PS bug ?)
-                // 	stack.pop();
-            }
-            else {
-                stack[stack.length - 1].children.unshift(l);
-            }
+        else if (type === 3 /* SectionDividerType.BoundingSectionDivider */) {
+            stack.pop();
+            // this was workaround because I didn't know what `lsdk` section was, now it's probably not needed anymore
+            // } else if (l.name === '</Layer group>' && !l.sectionDivider && !l.top && !l.left && !l.bottom && !l.right) {
+            // 	// sometimes layer group terminator doesn't have sectionDivider, so we just guess here (PS bug ?)
+            // 	stack.pop();
         }
-    }, undefined, options.large);
-    return globalAlpha;
+        else {
+            stack[stack.length - 1].children.unshift(l);
+        }
+    }
 }
 function readLayerRecord(reader, psd, options) {
     var layer = {};
@@ -426,18 +430,21 @@ function readLayerBlendingRanges(reader) {
     });
 }
 function readLayerChannelImageData(reader, psd, layer, channels, options) {
+    var _a, _b, _c, _d;
     var layerWidth = (layer.right || 0) - (layer.left || 0);
     var layerHeight = (layer.bottom || 0) - (layer.top || 0);
     var cmyk = psd.colorMode === 4 /* ColorMode.CMYK */;
     var imageData;
     if (layerWidth && layerHeight) {
         if (cmyk) {
+            if (psd.bitsPerChannel !== 8)
+                throw new Error('bitsPerChannel Not supproted');
             imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) };
             for (var p = 4; p < imageData.data.byteLength; p += 5)
                 imageData.data[p] = 255;
         }
         else {
-            imageData = createImageData(layerWidth, layerHeight);
+            imageData = createImageDataBitDepth(layerWidth, layerHeight, (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8);
             resetImageData(imageData);
         }
     }
@@ -470,10 +477,10 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
             var maskWidth = (mask.right || 0) - (mask.left || 0);
             var maskHeight = (mask.bottom || 0) - (mask.top || 0);
             if (maskWidth && maskHeight) {
-                var maskData = createImageData(maskWidth, maskHeight);
+                var maskData = createImageDataBitDepth(maskWidth, maskHeight, (_b = psd.bitsPerChannel) !== null && _b !== void 0 ? _b : 8);
                 resetImageData(maskData);
                 var start_1 = reader.offset;
-                readData(reader, channel.length, maskData, compression, maskWidth, maskHeight, 0, options.large, 4);
+                readData(reader, channel.length, maskData, compression, maskWidth, maskHeight, (_c = psd.bitsPerChannel) !== null && _c !== void 0 ? _c : 8, 0, options.large, 4);
                 if (RAW_IMAGE_DATA) {
                     layer.maskDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start_1, reader.offset - start_1);
                 }
@@ -482,8 +489,7 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
                     mask.imageData = maskData;
                 }
                 else {
-                    mask.canvas = createCanvas(maskWidth, maskHeight);
-                    mask.canvas.getContext('2d').putImageData(maskData, 0, 0);
+                    mask.canvas = imageDataToCanvas(maskData);
                 }
             }
         }
@@ -496,7 +502,7 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
                     throw new Error("Channel not supported: ".concat(channel.id));
                 }
             }
-            readData(reader, channel.length, targetData, compression, layerWidth, layerHeight, offset, options.large, cmyk ? 5 : 4);
+            readData(reader, channel.length, targetData, compression, layerWidth, layerHeight, (_d = psd.bitsPerChannel) !== null && _d !== void 0 ? _d : 8, offset, options.large, cmyk ? 5 : 4);
             if (RAW_IMAGE_DATA) {
                 layer.imageDataRaw[channel.id] = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start + 2, channel.length - 2);
             }
@@ -516,29 +522,28 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
             layer.imageData = imageData;
         }
         else {
-            layer.canvas = createCanvas(layerWidth, layerHeight);
-            layer.canvas.getContext('2d').putImageData(imageData, 0, 0);
+            layer.canvas = imageDataToCanvas(imageData);
         }
     }
 }
-function readData(reader, length, data, compression, width, height, offset, large, step) {
+function readData(reader, length, data, compression, width, height, bitDepth, offset, large, step) {
     if (compression === 0 /* Compression.RawData */) {
-        readDataRaw(reader, data, width, height, step, offset);
+        readDataRaw(reader, data, width, height, bitDepth, step, offset);
     }
     else if (compression === 1 /* Compression.RleCompressed */) {
-        readDataRLE(reader, data, width, height, step, [offset], large);
+        readDataRLE(reader, data, width, height, bitDepth, step, [offset], large);
     }
     else if (compression === 2 /* Compression.ZipWithoutPrediction */) {
-        readDataZipWithoutPrediction(reader, length, data, width, height, step, offset);
+        readDataZip(reader, length, data, width, height, bitDepth, step, offset, false);
     }
     else if (compression === 3 /* Compression.ZipWithPrediction */) {
-        throw new Error("Compression type not supported: ".concat(compression));
+        readDataZip(reader, length, data, width, height, bitDepth, step, offset, true);
     }
     else {
         throw new Error("Invalid Compression type: ".concat(compression));
     }
 }
-function readGlobalLayerMaskInfo(reader) {
+export function readGlobalLayerMaskInfo(reader) {
     return readSection(reader, 1, function (left) {
         if (!left())
             return undefined;
@@ -553,7 +558,7 @@ function readGlobalLayerMaskInfo(reader) {
         return { overlayColorSpace: overlayColorSpace, colorSpace1: colorSpace1, colorSpace2: colorSpace2, colorSpace3: colorSpace3, colorSpace4: colorSpace4, opacity: opacity, kind: kind };
     });
 }
-function readAdditionalLayerInfo(reader, target, psd, options) {
+export function readAdditionalLayerInfo(reader, target, psd, options) {
     var sig = readSignature(reader);
     if (sig !== '8BIM' && sig !== '8B64')
         throw new Error("Invalid signature: '".concat(sig, "' at 0x").concat((reader.offset - 4).toString(16)));
@@ -581,23 +586,41 @@ function readAdditionalLayerInfo(reader, target, psd, options) {
         }
     }, false, u64);
 }
-function readImageData(reader, psd, globalAlpha, options) {
+function createImageDataBitDepth(width, height, bitDepth) {
+    if (bitDepth === 1 || bitDepth === 8) {
+        return createImageData(width, height);
+    }
+    else if (bitDepth === 16) {
+        return { width: width, height: height, data: new Uint16Array(width * height * 4) };
+    }
+    else if (bitDepth === 32) {
+        return { width: width, height: height, data: new Float32Array(width * height * 4) };
+    }
+    else {
+        throw new Error("Invalid bitDepth (".concat(bitDepth, ")"));
+    }
+}
+function readImageData(reader, psd, options) {
+    var _a, _b;
     var compression = readUint16(reader);
+    var bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
     if (supportedColorModes.indexOf(psd.colorMode) === -1)
         throw new Error("Color mode not supported: ".concat(psd.colorMode));
     if (compression !== 0 /* Compression.RawData */ && compression !== 1 /* Compression.RleCompressed */)
         throw new Error("Compression type not supported: ".concat(compression));
-    var imageData = createImageData(psd.width, psd.height);
+    var imageData = createImageDataBitDepth(psd.width, psd.height, bitsPerChannel);
     resetImageData(imageData);
     switch (psd.colorMode) {
         case 0 /* ColorMode.Bitmap */: {
+            if (bitsPerChannel !== 1)
+                throw new Error('Invalid bitsPerChannel for bitmap color mode');
             var bytes = void 0;
             if (compression === 0 /* Compression.RawData */) {
                 bytes = readBytes(reader, Math.ceil(psd.width / 8) * psd.height);
             }
             else if (compression === 1 /* Compression.RleCompressed */) {
                 bytes = new Uint8Array(psd.width * psd.height);
-                readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, 1, [0], options.large);
+                readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, 8, 1, [0], options.large);
             }
             else {
                 throw new Error("Bitmap compression not supported: ".concat(compression));
@@ -614,17 +637,17 @@ function readImageData(reader, psd, globalAlpha, options) {
                     channels.push(i);
                 }
             }
-            else if (globalAlpha) {
+            else if (options.globalAlpha) {
                 channels.push(3);
             }
             if (compression === 0 /* Compression.RawData */) {
                 for (var i = 0; i < channels.length; i++) {
-                    readDataRaw(reader, imageData, psd.width, psd.height, 4, channels[i]);
+                    readDataRaw(reader, imageData, psd.width, psd.height, bitsPerChannel, 4, channels[i]);
                 }
             }
             else if (compression === 1 /* Compression.RleCompressed */) {
                 var start = reader.offset;
-                readDataRLE(reader, imageData, psd.width, psd.height, 4, channels, options.large);
+                readDataRLE(reader, imageData, psd.width, psd.height, bitsPerChannel, 4, channels, options.large);
                 if (RAW_IMAGE_DATA)
                     psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
             }
@@ -634,10 +657,12 @@ function readImageData(reader, psd, globalAlpha, options) {
             break;
         }
         case 4 /* ColorMode.CMYK */: {
+            if (psd.bitsPerChannel !== 8)
+                throw new Error('bitsPerChannel Not supproted');
             if (psd.channels !== 4)
                 throw new Error("Invalid channel count");
             var channels = [0, 1, 2, 3];
-            if (globalAlpha)
+            if (options.globalAlpha)
                 channels.push(4);
             if (compression === 0 /* Compression.RawData */) {
                 throw new Error("Not implemented");
@@ -653,7 +678,7 @@ function readImageData(reader, psd, globalAlpha, options) {
                     data: new Uint8Array(imageData.width * imageData.height * 5),
                 };
                 var start = reader.offset;
-                readDataRLE(reader, cmykImageData, psd.width, psd.height, 5, channels, options.large);
+                readDataRLE(reader, cmykImageData, psd.width, psd.height, (_b = psd.bitsPerChannel) !== null && _b !== void 0 ? _b : 8, 5, channels, options.large);
                 cmykToRgb(cmykImageData, imageData, true);
                 if (RAW_IMAGE_DATA)
                     psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
@@ -663,7 +688,9 @@ function readImageData(reader, psd, globalAlpha, options) {
         default: throw new Error("Color mode not supported: ".concat(psd.colorMode));
     }
     // remove weird white matte
-    if (globalAlpha) {
+    if (options.globalAlpha) {
+        if (psd.bitsPerChannel !== 8)
+            throw new Error('bitsPerChannel Not supproted');
         var p = imageData.data;
         var size = imageData.width * imageData.height * 4;
         for (var i = 0; i < size; i += 4) {
@@ -682,8 +709,7 @@ function readImageData(reader, psd, globalAlpha, options) {
         psd.imageData = imageData;
     }
     else {
-        psd.canvas = createCanvas(psd.width, psd.height);
-        psd.canvas.getContext('2d').putImageData(imageData, 0, 0);
+        psd.canvas = imageDataToCanvas(imageData);
     }
 }
 function cmykToRgb(cmyk, rgb, reverseAlpha) {
@@ -711,28 +737,110 @@ function cmykToRgb(cmyk, rgb, reverseAlpha) {
     // 	dstData[dst + 3] = reverseAlpha ? 255 - srcData[src + 4] : srcData[src + 4];
     // }
 }
-function readDataRaw(reader, pixelData, width, height, step, offset) {
-    var size = width * height;
-    var buffer = readBytes(reader, size);
+function verifyCompatible(a, b) {
+    if ((a.byteLength / a.length) !== (b.byteLength / b.length)) {
+        throw new Error('Invalid array types');
+    }
+}
+function bytesToArray(bytes, bitDepth) {
+    if (bitDepth === 8) {
+        return bytes;
+    }
+    else if (bitDepth === 16) {
+        if (bytes.byteOffset % 2) {
+            var result = new Uint16Array(bytes.byteLength / 2);
+            new Uint8Array(result.buffer, result.byteOffset, result.byteLength).set(bytes);
+            return result;
+        }
+        else {
+            return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
+        }
+    }
+    else if (bitDepth === 32) {
+        if (bytes.byteOffset % 4) {
+            var result = new Float32Array(bytes.byteLength / 4);
+            new Uint8Array(result.buffer, result.byteOffset, result.byteLength).set(bytes);
+            return result;
+        }
+        else {
+            return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+        }
+    }
+    else {
+        throw new Error("Invalid bitDepth (".concat(bitDepth, ")"));
+    }
+}
+function copyChannelToPixelData(pixelData, channel, offset, step) {
+    verifyCompatible(pixelData.data, channel);
+    var size = pixelData.width * pixelData.height;
+    var data = pixelData.data;
+    for (var i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
+        data[p] = channel[i];
+    }
+}
+function readDataRaw(reader, pixelData, width, height, bitDepth, step, offset) {
+    var buffer = readBytes(reader, width * height * Math.floor(bitDepth / 8));
+    if (bitDepth == 32) {
+        for (var i = 0; i < buffer.byteLength; i += 4) {
+            var a = buffer[i + 0];
+            var b = buffer[i + 1];
+            var c = buffer[i + 2];
+            var d = buffer[i + 3];
+            buffer[i + 0] = d;
+            buffer[i + 1] = c;
+            buffer[i + 2] = b;
+            buffer[i + 3] = a;
+        }
+    }
+    var array = bytesToArray(buffer, bitDepth);
     if (pixelData && offset < step) {
-        var data = pixelData.data;
-        for (var i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
-            data[p] = buffer[i];
+        copyChannelToPixelData(pixelData, array, offset, step);
+    }
+}
+function decodePredicted(data, width, height, mod) {
+    for (var y = 0; y < height; y++) {
+        var offset = y * width;
+        for (var x = 1, o = offset + 1; x < width; x++, o++) {
+            data[o] = (data[o - 1] + data[o]) % mod;
         }
     }
 }
-export function readDataZipWithoutPrediction(reader, length, pixelData, width, height, step, offset) {
+export function readDataZip(reader, length, pixelData, width, height, bitDepth, step, offset, prediction) {
     var compressed = readBytes(reader, length);
-    var decompressed = inflate(compressed);
-    var size = width * height;
+    var decompressed = inflateSync(compressed);
     if (pixelData && offset < step) {
-        var data = pixelData.data;
-        for (var i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
-            data[p] = decompressed[i];
+        var array = bytesToArray(decompressed, bitDepth);
+        if (bitDepth === 8) {
+            if (prediction)
+                decodePredicted(decompressed, width, height, 0x100);
+            copyChannelToPixelData(pixelData, decompressed, offset, step);
+        }
+        else if (bitDepth === 16) {
+            if (prediction)
+                decodePredicted(array, width, height, 0x10000);
+            copyChannelToPixelData(pixelData, array, offset, step);
+        }
+        else if (bitDepth === 32) {
+            if (prediction)
+                decodePredicted(decompressed, width * 4, height, 0x100);
+            var di = offset;
+            var dst = new Uint32Array(pixelData.data.buffer, pixelData.data.byteOffset, pixelData.data.length);
+            for (var y = 0; y < height; y++) {
+                var a = width * 4 * y;
+                for (var x = 0; x < width; x++, a++, di += step) {
+                    var b = a + width;
+                    var c = b + width;
+                    var d = c + width;
+                    dst[di] = ((decompressed[a] << 24) | (decompressed[b] << 16) | (decompressed[c] << 8) | decompressed[d]) >>> 0;
+                }
+            }
+        }
+        else {
+            throw new Error('Invalid bitDepth');
         }
     }
 }
-export function readDataRLE(reader, pixelData, _width, height, step, offsets, large) {
+export function readDataRLE(reader, pixelData, _width, height, bitDepth, step, offsets, large) {
     var data = pixelData && pixelData.data;
     var lengths;
     if (large) {
@@ -751,6 +859,8 @@ export function readDataRLE(reader, pixelData, _width, height, step, offsets, la
             }
         }
     }
+    if (bitDepth !== 1 && bitDepth !== 8)
+        throw new Error("Invalid bit depth (".concat(bitDepth, ")"));
     var extraLimit = (step - 1) | 0; // 3 for rgb, 4 for cmyk
     for (var c = 0, li = 0; c < offsets.length; c++) {
         var offset = offsets[c] | 0;