ag-psd 31.0.3 → 33.0.0

package/dist-es/psdReader.js

@@ -12,6 +12,10 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.supportedColorModes = void 0;
+exports.getUtf8Decoder = getUtf8Decoder;
+exports.getUtf8StrictDecoder = getUtf8StrictDecoder;
+exports.getGbkStrictDecoder = getGbkStrictDecoder;
+exports.decodeUtf8 = decodeUtf8;
 exports.createReader = createReader;
 exports.warnOrThrow = warnOrThrow;
 exports.readUint8 = readUint8;
@@ -53,12 +57,15 @@ exports.readDataZip = readDataZip;
 exports.readDataRLE = readDataRLE;
 exports.readSection = readSection;
 exports.readColor = readColor;
+exports.readPatternSafe = readPatternSafe;
 exports.readPattern = readPattern;
+exports.consumeMemory = consumeMemory;
 const pako_1 = require("pako");
 const helpers_1 = require("./helpers");
 const additionalInfo_1 = require("./additionalInfo");
+const utf8_1 = require("./utf8");
 const imageResources_1 = require("./imageResources");
-exports.supportedColorModes = [0 /* ColorMode.Bitmap */, 1 /* ColorMode.Grayscale */, 3 /* ColorMode.RGB */, 2 /* ColorMode.Indexed */];
+exports.supportedColorModes = [0 /* ColorMode.Bitmap */, 1 /* ColorMode.Grayscale */, 3 /* ColorMode.RGB */, 2 /* ColorMode.Indexed */, 4 /* ColorMode.CMYK */];
 const colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', '', '', 'multichannel', 'duotone', 'lab'];
 function setupGrayscale(data) {
     const size = data.width * data.height * 4;
@@ -68,6 +75,37 @@ function setupGrayscale(data) {
         data.data[i + 2] = c;
     }
 }
+function createTextDecoder(label, options) {
+    try {
+        return typeof TextDecoder !== 'undefined' ? new TextDecoder(label, options) : null;
+    }
+    catch (_a) {
+        return null; // encoding not supported
+    }
+}
+// non-fatal UTF-8 decoder, malformed byte sequences are replaced with U+FFFD
+function getUtf8Decoder(reader) {
+    if (reader.utf8Decoder === undefined)
+        reader.utf8Decoder = createTextDecoder('utf-8', { ignoreBOM: true });
+    return reader.utf8Decoder;
+}
+// UTF-8 decoder that throws on malformed byte sequences
+function getUtf8StrictDecoder(reader) {
+    if (reader.utf8StrictDecoder === undefined)
+        reader.utf8StrictDecoder = createTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+    return reader.utf8StrictDecoder;
+}
+// GBK decoder that throws on malformed byte sequences
+function getGbkStrictDecoder(reader) {
+    if (reader.gbkDecoder === undefined)
+        reader.gbkDecoder = createTextDecoder('gbk', { fatal: true });
+    return reader.gbkDecoder;
+}
+function decodeUtf8(reader, buffer) {
+    // native decoder is faster only for longer strings
+    const decoder = buffer.byteLength > 1000 ? getUtf8Decoder(reader) : null;
+    return decoder ? decoder.decode(buffer) : (0, utf8_1.decodeString)(buffer);
+}
 function createReader(buffer, offset, length) {
     const view = new DataView(buffer, offset, length);
     return { view, offset: 0, strict: false, debug: false, large: false, globalAlpha: false, log: console.log };
@@ -125,22 +163,24 @@ function readFixedPoint32(reader) {
 function readFixedPointPath32(reader) {
     return readInt32(reader) / (1 << 24);
 }
+// NOTE: returned array may alias the reader's underlying buffer, never write into it
 function readBytes(reader, length) {
-    const start = reader.view.byteOffset + reader.offset;
+    const start = reader.offset;
+    const viewLength = reader.view.byteLength;
     reader.offset += length;
-    if ((start + length) > reader.view.buffer.byteLength) {
+    if ((start + length) > viewLength) {
         // fix for broken PSD files that are missing part of file at the end
         warnOrThrow(reader, 'Reading bytes exceeding buffer length');
         if (length > (100 * 1024 * 1024))
             throw new Error('Reading past end of file'); // limit to 100MB
         const result = new Uint8Array(length);
-        const len = Math.min(length, reader.view.byteLength - start);
+        const len = Math.min(length, viewLength - start);
         if (len > 0)
-            result.set(new Uint8Array(reader.view.buffer, start, len));
+            result.set(new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, len));
         return result;
     }
     else {
-        return new Uint8Array(reader.view.buffer, start, length);
+        return new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, length);
     }
 }
 function readSignature(reader) {
@@ -165,31 +205,52 @@ function readUnicodeString(reader) {
     const length = readUint32(reader);
     return readUnicodeStringWithLength(reader, length);
 }
-function readUnicodeStringWithLength(reader, length) {
+const STRING_CHUNK_SIZE = 0x2000;
+function checkReadBounds(reader, size) {
+    if (reader.offset < 0 || (reader.offset + size) > reader.view.byteLength) {
+        throw new RangeError('Offset is outside the bounds of the DataView');
+    }
+}
+function readUtf16String(reader, length, littleEndian) {
+    if (!(length > 0))
+        return '';
+    checkReadBounds(reader, length * 2);
+    const view = reader.view;
+    const codes = new Uint16Array(Math.min(length, STRING_CHUNK_SIZE));
+    let offset = reader.offset;
     let text = '';
-    while (length--) {
-        const value = readUint16(reader);
-        if (value || length > 0) { // remove trailing \0
-            text += String.fromCharCode(value);
+    for (let i = 0; i < length; i += STRING_CHUNK_SIZE) {
+        const count = Math.min(STRING_CHUNK_SIZE, length - i);
+        for (let j = 0; j < count; j++, offset += 2) {
+            codes[j] = view.getUint16(offset, littleEndian);
         }
+        text += String.fromCharCode.apply(null, (count === codes.length ? codes : codes.subarray(0, count)));
     }
+    reader.offset = offset;
+    // remove trailing \0
+    if (text.charCodeAt(text.length - 1) === 0)
+        text = text.substring(0, text.length - 1);
     return text;
 }
-function readUnicodeStringWithLengthLE(reader, length) {
+function bytesToString(bytes) {
     let text = '';
-    while (length--) {
-        const value = readUint16LE(reader);
-        if (value || length > 0) { // remove trailing \0
-            text += String.fromCharCode(value);
-        }
+    for (let i = 0; i < bytes.length; i += STRING_CHUNK_SIZE) {
+        text += String.fromCharCode.apply(null, bytes.subarray(i, i + STRING_CHUNK_SIZE));
     }
     return text;
 }
+function readUnicodeStringWithLength(reader, length) {
+    return readUtf16String(reader, length, false);
+}
+function readUnicodeStringWithLengthLE(reader, length) {
+    return readUtf16String(reader, length, true);
+}
 function readAsciiString(reader, length) {
-    let text = '';
-    while (length--) {
-        text += String.fromCharCode(readUint8(reader));
-    }
+    if (!(length > 0))
+        return '';
+    checkReadBounds(reader, length);
+    const text = bytesToString(new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length));
+    reader.offset += length;
     return text;
 }
 function skipBytes(reader, count) {
@@ -203,12 +264,7 @@ function checkSignature(reader, a, b) {
     }
 }
 function readShortString(reader, length) {
-    const buffer = readBytes(reader, length);
-    let result = '';
-    for (let i = 0; i < buffer.length; i++) {
-        result += String.fromCharCode(buffer[i]);
-    }
-    return result;
+    return bytesToString(readBytes(reader, length));
 }
 function isValidSignature(sig) {
     return sig === '8BIM' || sig === 'MeSa' || sig === 'AgHg' || sig === 'PHUT' || sig === 'DCSR';
@@ -229,7 +285,8 @@ function readPsd(reader, readOptions = {}) {
     const maxSize = version === 1 ? 30000 : 300000;
     if (width > maxSize || height > maxSize)
         throw new Error(`Invalid size: ${width}x${height}`);
-    if (channels > 16)
+    // up to 56 channels plus transparency of composite image (Photoshop CS3 writes 57 channels for 53 alpha channels)
+    if (channels < 1 || channels > 57)
         throw new Error(`Invalid channel count: ${channels}`);
     if (![1, 8, 16, 32].includes(bitsPerChannel))
         throw new Error(`Invalid bitsPerChannel: ${bitsPerChannel}`);
@@ -239,6 +296,7 @@ function readPsd(reader, readOptions = {}) {
     Object.assign(reader, readOptions);
     reader.large = version === 2;
     reader.globalAlpha = false;
+    reader.layersInGlobalInfo = false;
     if (!('totalMemoryLimit' in reader)) { // setting totalMemoryLimit to undefined explicitly disables memory limit
         reader.totalMemoryLimit = 2 * 1024 * 1024 * 1024; // default 2GB memory limit
     }
@@ -266,17 +324,21 @@ function readPsd(reader, readOptions = {}) {
     });
     // image resources
     const imageResources = {};
+    let unreadResourceBytes = 0;
     readSection(reader, 1, left => {
-        while (left() > 0) {
-            realignWithSignature(reader, isValidSignature);
+        // stop if there's not enough data left for resource header (some files have few trailing bytes in this section)
+        while (left() >= 12) {
+            const signature = realignWithSignature(reader, isValidSignature);
             const id = readUint16(reader);
-            readPascalString(reader, 2); // name
+            const nameLength = readUint8(reader);
+            const name = readBytes(reader, nameLength);
+            skipBytes(reader, (nameLength + 1) % 2); // pad to even size
             readSection(reader, 2, left => {
                 const handler = imageResources_1.resourceHandlersMap[id];
                 const skip = id === 1036 && !!reader.skipThumbnail;
                 if (handler && !skip) {
                     try {
-                        handler.read(reader, imageResources, left);
+                        handler.read(reader, imageResources, left, { signature, id, name, width, height });
                     }
                     catch (e) {
                         if (reader.throwForMissingFeatures)
@@ -285,13 +347,20 @@ function readPsd(reader, readOptions = {}) {
                     }
                 }
                 else {
-                    // options.logMissingFeatures && console.log(`Unhandled image resource: ${id} (${left()})`);
+                    reader.logMissingFeatures && reader.log(`Unhandled image resource: ${id} (${left()})`);
                     skipBytes(reader, left());
                 }
             });
         }
+        unreadResourceBytes = left();
+        skipBytes(reader, left());
     });
-    const { layersGroup, layerGroupsEnabledId } = imageResources, rest = __rest(imageResources, ["layersGroup", "layerGroupsEnabledId"]);
+    // some files have image resources section length few bytes larger than the data, layer and mask info section
+    // starts right after the last resource in that case
+    if (unreadResourceBytes && !sectionFits(reader, reader.offset) && sectionFits(reader, reader.offset - unreadResourceBytes)) {
+        reader.offset -= unreadResourceBytes;
+    }
+    const { layersGroup, layerGroupsEnabledId, savedPathsOrigination } = imageResources, rest = __rest(imageResources, ["layersGroup", "layerGroupsEnabledId", "savedPathsOrigination"]);
     if (Object.keys(rest).length) {
         psd.imageResources = rest;
     }
@@ -331,7 +400,12 @@ function readPsd(reader, readOptions = {}) {
     const skipComposite = reader.skipCompositeImageData && (reader.skipLayerImageData || hasChildren);
     if (!skipComposite) {
         if (reader.useRawData) {
-            psd.rawCompositeData = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset);
+            const rawOffset = Math.min(reader.offset, reader.view.byteLength);
+            const rawCompositeData = new Uint8Array(reader.view.buffer, reader.view.byteOffset + rawOffset, reader.view.byteLength - rawOffset);
+            psd.rawCompositeData = rawCompositeData;
+            psd.rawCompositeDataInfo = { large: reader.large, globalAlpha: reader.globalAlpha };
+            if (reader.layersInGlobalInfo)
+                psd.rawCompositeDataInfo.layersInGlobalInfo = true;
         }
         else {
             const imageData = readImageData(reader, psd);
@@ -343,9 +417,6 @@ function readPsd(reader, readOptions = {}) {
             }
         }
     }
-    // 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, imageResources) {
@@ -386,7 +457,9 @@ function readLayerInfo(reader, psd, imageResources) {
             stack.push(l);
         }
         else if (type === 3 /* SectionDividerType.BoundingSectionDivider */) {
-            stack.pop();
+            // ignore unmatched section dividers, never pop the root
+            if (stack.length > 1)
+                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 ?)
@@ -419,9 +492,12 @@ function readLayerRecord(reader, psd, imageResources) {
     }
     checkSignature(reader, '8BIM');
     const blendMode = readSignature(reader);
-    if (!helpers_1.toBlendMode[blendMode])
-        throw new Error(`Invalid blend mode: '${blendMode}'`);
-    layer.blendMode = helpers_1.toBlendMode[blendMode];
+    if (!helpers_1.toBlendMode[blendMode]) {
+        if (reader.throwForMissingFeatures)
+            throw new Error(`Invalid blend mode: '${blendMode}'`);
+        reader.logMissingFeatures && reader.log(`Unknown blend mode: '${blendMode}', using normal blend mode`);
+    }
+    layer.blendMode = helpers_1.toBlendMode[blendMode] || 'normal';
     layer.opacity = readUint8(reader) / 0xff;
     layer.clipping = readUint8(reader) === 1;
     const flags = readUint8(reader);
@@ -449,11 +525,20 @@ function readLayerRecord(reader, psd, imageResources) {
     });
     return { layer, channels };
 }
+// negative sizes are treated as empty (Photoshop writes them for some empty layers, like 0,0,-1,0 bounds of fill layer)
+// checks if length of section (layer and mask info) at given offset fits in the file
+function sectionFits(reader, offset) {
+    const lengthSize = reader.large ? 8 : 4;
+    if (offset < 0 || offset + lengthSize > reader.view.byteLength)
+        return false;
+    const length = reader.large ? reader.view.getUint32(offset) * 0x100000000 + reader.view.getUint32(offset + 4) : reader.view.getUint32(offset);
+    return offset + lengthSize + length <= reader.view.byteLength;
+}
 function isValidBoxSize(box, reader) {
     const width = (box.right || 0) - (box.left || 0);
     const height = (box.bottom || 0) - (box.top || 0);
     const maxSize = reader.large ? 300000 : 30000;
-    return width >= 0 && height >= 0 && width <= maxSize && height <= maxSize;
+    return width <= maxSize && height <= maxSize;
 }
 function readLayerMaskData(reader, layer) {
     return readSection(reader, 1, left => {
@@ -472,7 +557,7 @@ function readLayerMaskData(reader, layer) {
         mask.positionRelativeToLayer = (flags & 1 /* LayerMaskFlags.PositionRelativeToLayer */) !== 0;
         mask.disabled = (flags & 2 /* LayerMaskFlags.LayerMaskDisabled */) !== 0;
         mask.fromVectorData = (flags & 8 /* LayerMaskFlags.LayerMaskFromRenderingOtherData */) !== 0;
-        if (left() >= 18) {
+        if (hasRealMaskData(reader, flags, left())) {
             const realMask = {};
             layer.realMask = realMask;
             const realFlags = readUint8(reader);
@@ -501,6 +586,43 @@ function readLayerMaskData(reader, layer) {
         skipBytes(reader, left());
     });
 }
+function maskParamsSize(params) {
+    return 1 +
+        ((params & 1 /* MaskParams.UserMaskDensity */) ? 1 : 0) +
+        ((params & 2 /* MaskParams.UserMaskFeather */) ? 8 : 0) +
+        ((params & 4 /* MaskParams.VectorMaskDensity */) ? 1 : 0) +
+        ((params & 8 /* MaskParams.VectorMaskFeather */) ? 8 : 0);
+}
+// checks if data at offset is mask parameters followed by up to 3 bytes of zero padding, ending exactly at offset + left
+function isMaskParamsLayout(view, offset, left) {
+    if (left < 1)
+        return false;
+    const params = view.getUint8(offset);
+    if (params === 0 || (params & ~0x0f))
+        return false; // only 4 parameter flags exist
+    const size = maskParamsSize(params);
+    if (left < size || left - size > 3)
+        return false;
+    for (let i = size; i < left; i++) {
+        if (view.getUint8(offset + i) !== 0)
+            return false;
+    }
+    return true;
+}
+// real mask data (18 bytes) is followed by mask parameters (if flag is set) and padding
+function hasRealMaskData(reader, flags, left) {
+    if (left < 18)
+        return false;
+    if (!(flags & 16 /* LayerMaskFlags.MaskHasParametersAppliedToIt */))
+        return true;
+    const { view, offset } = reader;
+    if (isMaskParamsLayout(view, offset, left))
+        return false;
+    if (isMaskParamsLayout(view, offset + 18, left - 18))
+        return true;
+    // unknown layout, assume real mask if there's enough data for it (and mask parameters)
+    return left === 18 || left - 18 >= maskParamsSize(view.getUint8(offset + 18));
+}
 function readBlendingRange(reader) {
     return [readUint8(reader), readUint8(reader), readUint8(reader), readUint8(reader)];
 }
@@ -535,9 +657,9 @@ function readLayerChannelImageData(reader, psd, layer, channels) {
                 reader.offset -= 1;
                 compression = readUint16(reader);
             }
-            // try to fix broken files where there's 1 byte shift of channel
+            // try to fix broken files where there's 1 byte shift of channel (in the other direction)
             if (compression > 3) {
-                reader.offset -= 3;
+                reader.offset -= 4;
                 compression = readUint16(reader);
             }
             if (compression > 3)
@@ -567,8 +689,13 @@ function getCompositeImageData(psd) {
     if (!data)
         return undefined;
     const reader = createReader(data.buffer, data.byteOffset, data.byteLength);
-    const imageData = readImageData(reader, psd);
-    return imageData;
+    const info = psd.rawCompositeDataInfo;
+    if (info) {
+        reader.large = info.large;
+        reader.globalAlpha = info.globalAlpha;
+        reader.layersInGlobalInfo = !!info.layersInGlobalInfo;
+    }
+    return readImageData(reader, psd);
 }
 function getCompositeCanvas(psd) {
     return imageDataToCanvasSafe(getCompositeImageData(psd));
@@ -610,18 +737,18 @@ function decodeLayerPixels(layer, useImageData) {
 function decodeLayerImageData(layer, options) {
     var _a, _b, _c;
     let { throwForMissingFeatures, useImageData } = options;
-    const imageData = getDataFromLayer(layer, LayerDataType.Layer, throwForMissingFeatures, options.totalMemoryLimit);
+    const imageData = getDataFromLayer(layer, LayerDataType.Layer, throwForMissingFeatures, options.totalMemoryLimit, options);
     setImageDataOrCanvas(layer, imageData, useImageData);
     if (options.totalMemoryLimit !== undefined)
         options.totalMemoryLimit -= (_a = imageData === null || imageData === void 0 ? void 0 : imageData.data.byteLength) !== null && _a !== void 0 ? _a : 0;
     if (layer.mask) {
-        const maskData = getDataFromLayer(layer, LayerDataType.Mask, throwForMissingFeatures, options.totalMemoryLimit);
+        const maskData = getDataFromLayer(layer, LayerDataType.Mask, throwForMissingFeatures, options.totalMemoryLimit, options);
         setImageDataOrCanvas(layer.mask, maskData, useImageData);
         if (options.totalMemoryLimit !== undefined)
             options.totalMemoryLimit -= (_b = maskData === null || maskData === void 0 ? void 0 : maskData.data.byteLength) !== null && _b !== void 0 ? _b : 0;
     }
     if (layer.realMask) {
-        const maskData = getDataFromLayer(layer, LayerDataType.RealMask, throwForMissingFeatures, options.totalMemoryLimit);
+        const maskData = getDataFromLayer(layer, LayerDataType.RealMask, throwForMissingFeatures, options.totalMemoryLimit, options);
         setImageDataOrCanvas(layer.realMask, maskData, useImageData);
         if (options.totalMemoryLimit !== undefined)
             options.totalMemoryLimit -= (_c = maskData === null || maskData === void 0 ? void 0 : maskData.data.byteLength) !== null && _c !== void 0 ? _c : 0;
@@ -634,7 +761,8 @@ var LayerDataType;
     LayerDataType[LayerDataType["Mask"] = 1] = "Mask";
     LayerDataType[LayerDataType["RealMask"] = 2] = "RealMask";
 })(LayerDataType || (LayerDataType = {}));
-function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
+function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit, logOptions) {
+    var _a;
     if (!layer.rawData)
         return undefined;
     const { colorMode, bitsPerChannel, channels, large } = layer.rawData;
@@ -646,22 +774,23 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
     let initializedAlpha = false;
     if (layerWidth && layerHeight && read === LayerDataType.Layer) {
         if (cmyk) {
-            if (bitsPerChannel !== 8)
-                throw new Error('bitsPerChannel Not supproted');
-            imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) };
+            if (bitsPerChannel !== 8 && bitsPerChannel !== 16)
+                throw new Error('bitsPerChannel not supported');
+            imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel, 5, memoryLimit);
         }
         else {
             imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel, 4, memoryLimit);
         }
     }
-    if (helpers_1.RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-        layer.imageDataRaw = [];
-        layer.imageDataRawCompression = [];
-    }
     for (const { id, compression, data } of channels) {
         if (!data)
             continue;
         const dataReader = createReader(data.buffer, data.byteOffset, data.byteLength);
+        dataReader.debug = !!(logOptions === null || logOptions === void 0 ? void 0 : logOptions.debug);
+        if (logOptions === null || logOptions === void 0 ? void 0 : logOptions.log)
+            dataReader.log = logOptions.log;
+        if (memoryLimit !== undefined)
+            dataReader.totalMemoryLimit = Math.max(0, memoryLimit - ((_a = imageData === null || imageData === void 0 ? void 0 : imageData.data.byteLength) !== null && _a !== void 0 ? _a : 0));
         if (id === -2 /* ChannelID.UserMask */ || id === -3 /* ChannelID.RealUserMask */) {
             if (id === -2 /* ChannelID.UserMask */ && read !== LayerDataType.Mask)
                 continue;
@@ -674,17 +803,9 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
             const maskHeight = Math.max(0, (mask.bottom || 0) - (mask.top || 0));
             if (maskWidth && maskHeight) {
                 maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel, 4, memoryLimit);
+                if (memoryLimit !== undefined)
+                    dataReader.totalMemoryLimit = Math.max(0, dataReader.totalMemoryLimit - maskData.data.byteLength);
                 readData(dataReader, data.byteLength, maskData, compression, maskWidth, maskHeight, bitsPerChannel, 0, large, 4);
-                if (helpers_1.RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-                    if (id === -2 /* ChannelID.UserMask */) {
-                        layer.maskDataRawCompression = compression;
-                        layer.maskDataRaw = data;
-                    }
-                    else {
-                        layer.realMaskDataRawCompression = compression;
-                        layer.realMaskDataRaw = data;
-                    }
-                }
                 setupGrayscale(maskData);
                 resetAlpha(maskData, false);
             }
@@ -701,24 +822,20 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
                 }
             }
             readData(dataReader, data.byteLength, targetData, compression, layerWidth, layerHeight, bitsPerChannel, offset, large, cmyk ? 5 : 4);
-            if (helpers_1.RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-                layer.imageDataRawCompression[id] = compression;
-                layer.imageDataRaw[id] = data;
-            }
-            if (targetData && colorMode === 1 /* ColorMode.Grayscale */) {
-                setupGrayscale(targetData);
-            }
         }
         if (id === -1 /* ChannelID.Transparency */) {
             initializedAlpha = true;
         }
     }
     if (imageData) {
+        if (colorMode === 1 /* ColorMode.Grayscale */)
+            setupGrayscale(imageData);
         if (!initializedAlpha)
             resetAlpha(imageData, cmyk);
         if (cmyk) {
             const cmykData = imageData;
-            imageData = (0, helpers_1.createImageData)(cmykData.width, cmykData.height);
+            const rgbMemoryLimit = memoryLimit === undefined ? undefined : Math.max(0, memoryLimit - cmykData.data.byteLength);
+            imageData = createImageDataBitDepth(cmykData.width, cmykData.height, bitsPerChannel, 4, rgbMemoryLimit);
             cmykToRgb(cmykData, imageData, false);
         }
     }
@@ -729,7 +846,7 @@ function readData(reader, length, pixels, compression, width, height, bitDepth,
         return;
     if (compression === 0 /* Compression.RawData */) {
         if (length !== (width * height * Math.floor(bitDepth / 8))) {
-            reader.log(`Invalid length (${length}, ${width * height * Math.floor(bitDepth / 8)})`);
+            warnOrThrow(reader, `Invalid length (${length}, ${width * height * Math.floor(bitDepth / 8)})`);
         }
         const data = readBytes(reader, length);
         readDataRaw(data, pixels, bitDepth, step, offset);
@@ -740,11 +857,11 @@ function readData(reader, length, pixels, compression, width, height, bitDepth,
     }
     else if (compression === 2 /* Compression.ZipWithoutPrediction */) {
         const data = readBytes(reader, length);
-        readDataZip(data, pixels, width, height, bitDepth, step, offset, false);
+        readDataZip(data, pixels, width, height, bitDepth, step, offset, false, reader);
     }
     else if (compression === 3 /* Compression.ZipWithPrediction */) {
         const data = readBytes(reader, length);
-        readDataZip(data, pixels, width, height, bitDepth, step, offset, true);
+        readDataZip(data, pixels, width, height, bitDepth, step, offset, true, reader);
     }
     else {
         throw new Error(`Invalid Compression type: ${compression}`);
@@ -759,7 +876,7 @@ function readGlobalLayerMaskInfo(reader) {
         const colorSpace2 = readUint16(reader);
         const colorSpace3 = readUint16(reader);
         const colorSpace4 = readUint16(reader);
-        const opacity = readUint16(reader) / 0xff;
+        const opacity = readUint16(reader) / 100; // 0 - 100
         const kind = readUint8(reader);
         skipBytes(reader, left()); // 3 bytes of padding ?
         return { overlayColorSpace, colorSpace1, colorSpace2, colorSpace3, colorSpace4, opacity, kind };
@@ -791,7 +908,15 @@ function readAdditionalLayerInfo(reader, target, psd, imageResources) {
     const sig = realignWithSignature(reader, isValidAdditionalInfoSignature);
     const key = readSignature(reader);
     // `largeAdditionalInfoKeys` fallback, because some keys don't have 8B64 signature even when they are 64bit
-    const u64 = sig === '8B64' || (reader.large && helpers_1.largeAdditionalInfoKeys.indexOf(key) !== -1);
+    let u64 = sig === '8B64' || (reader.large && helpers_1.largeAdditionalInfoKeys.indexOf(key) !== -1);
+    // these keys were written by older versions of this library with 32bit length and 8BIM signature,
+    // 64bit length always has high 32bits set to 0 (lengths over 4GB are not supported)
+    if (reader.large && sig === '8BIM' && helpers_1.largeAdditionalInfoKeysObserved.indexOf(key) !== -1) {
+        // 32bit length of 0 is followed by signature of the next block, 64bit length would continue with its low 32bits
+        const next = reader.offset + 8 <= reader.view.byteLength ? reader.view.getUint32(reader.offset + 4) : 0;
+        const nextIsSignature = next === 0x3842494d /* 8BIM */ || next === 0x38423634 /* 8B64 */;
+        u64 = reader.view.getUint32(reader.offset) === 0 && !nextIsSignature;
+    }
     readSection(reader, 2, left => {
         const handler = additionalInfo_1.infoHandlersMap[key];
         if (handler) {
@@ -804,7 +929,7 @@ function readAdditionalLayerInfo(reader, target, psd, imageResources) {
             }
         }
         else {
-            reader.logMissingFeatures && reader.log(`Unhandled additional info: ${key}`);
+            reader.logMissingFeatures && key !== 'GenI' && key !== 'OCIO' && key !== 'CAI ' && reader.log(`Unhandled additional info: ${key}`);
             skipBytes(reader, left());
         }
         if (left()) {
@@ -836,14 +961,15 @@ function createImageDataBitDepth(width, height, bitDepth, channels, memoryLimit)
     }
 }
 function readImageData(reader, psd) {
-    var _a;
+    var _a, _b, _c;
     const compression = readUint16(reader);
     const bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
+    const { width, height } = psd;
     if (exports.supportedColorModes.indexOf(psd.colorMode) === -1)
         throw new Error(`Color mode not supported: ${psd.colorMode}`);
     if (compression !== 0 /* Compression.RawData */ && compression !== 1 /* Compression.RleCompressed */)
         throw new Error(`Compression type not supported: ${compression}`);
-    const imageData = createImageDataBitDepth(psd.width, psd.height, bitsPerChannel, 4, reader.totalMemoryLimit);
+    const imageData = createImageDataBitDepth(width, height, bitsPerChannel, 4, reader.totalMemoryLimit);
     if (reader.totalMemoryLimit !== undefined)
         reader.totalMemoryLimit -= imageData.data.byteLength;
     (0, helpers_1.resetImageData)(imageData);
@@ -851,47 +977,23 @@ function readImageData(reader, psd) {
         case 0 /* ColorMode.Bitmap */: {
             if (bitsPerChannel !== 1)
                 throw new Error('Invalid bitsPerChannel for bitmap color mode');
+            const rowBytes = Math.ceil(width / 8);
             let bytes;
             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, 8, 1, [0], reader.large);
+                bytes = readBytes(reader, rowBytes * height);
             }
             else {
-                throw new Error(`Compression not supported: ${compression}`);
+                bytes = new Uint8Array(rowBytes * height);
+                readDataRLE(reader, { data: bytes, width: rowBytes, height }, rowBytes, height, 8, 1, [0], reader.large);
             }
-            (0, helpers_1.decodeBitmap)(bytes, imageData.data, psd.width, psd.height);
+            (0, helpers_1.decodeBitmap)(bytes, imageData.data, width, height);
             break;
         }
         case 3 /* ColorMode.RGB */:
         case 1 /* ColorMode.Grayscale */: {
-            const channels = psd.colorMode === 1 /* ColorMode.Grayscale */ ? [0] : [0, 1, 2];
-            if (psd.channels && psd.channels > 3) {
-                for (let i = 3; i < psd.channels; i++) {
-                    // TODO: store these channels in additional image data
-                    channels.push(i);
-                }
-            }
-            else if (reader.globalAlpha) {
-                channels.push(3);
-            }
-            if (compression === 0 /* Compression.RawData */) {
-                for (let i = 0; i < channels.length; i++) {
-                    const data = readBytes(reader, psd.width * psd.height * Math.floor(bitsPerChannel / 8));
-                    readDataRaw(data, imageData, bitsPerChannel, 4, channels[i]);
-                }
-            }
-            else if (compression === 1 /* Compression.RleCompressed */) {
-                const start = reader.offset;
-                readDataRLE(reader, imageData, psd.width, psd.height, bitsPerChannel, 4, channels, reader.large);
-                if (helpers_1.RAW_IMAGE_DATA)
-                    psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
-            }
-            else {
-                throw new Error(`Compression not supported: ${compression}`);
-            }
+            const colorChannels = psd.colorMode === 1 /* ColorMode.Grayscale */ ? 1 : 3;
+            const offsets = compositeChannelOffsets(reader, psd, colorChannels, 3);
+            readCompositeChannels(reader, compression, imageData, bitsPerChannel, 4, offsets);
             if (psd.colorMode === 1 /* ColorMode.Grayscale */) {
                 setupGrayscale(imageData);
             }
@@ -899,288 +1001,450 @@ function readImageData(reader, psd) {
         }
         case 2 /* ColorMode.Indexed */: {
             if (bitsPerChannel !== 8)
-                throw new Error('bitsPerChannel Not supproted');
-            if (psd.channels !== 1)
-                throw new Error('Invalid channel count');
+                throw new Error('bitsPerChannel not supported');
             if (!psd.palette)
                 throw new Error('Missing color palette');
-            if (compression === 0 /* Compression.RawData */) {
-                throw new Error(`Compression not supported: ${compression}`);
-            }
-            else if (compression === 1 /* Compression.RleCompressed */) {
-                const indexedImageData = {
-                    width: imageData.width,
-                    height: imageData.height,
-                    data: new Uint8Array(imageData.width * imageData.height),
-                };
-                readDataRLE(reader, indexedImageData, psd.width, psd.height, bitsPerChannel, 1, [0], reader.large);
-                indexedToRgb(indexedImageData, imageData, psd.palette);
-            }
-            else {
-                throw new Error(`Compression not supported: ${compression}`);
-            }
+            const offsets = compositeChannelOffsets(reader, psd, 1, -1);
+            const indexedImageData = { width, height, data: new Uint8Array(width * height) };
+            readCompositeChannels(reader, compression, indexedImageData, 8, 1, offsets);
+            indexedToRgb(indexedImageData, imageData, psd.palette, (_c = (_b = psd.imageResources) === null || _b === void 0 ? void 0 : _b.transparencyIndex) !== null && _c !== void 0 ? _c : -1);
             break;
         }
         case 4 /* ColorMode.CMYK */: {
-            if (bitsPerChannel !== 8)
-                throw new Error('bitsPerChannel Not supproted');
-            if (psd.channels !== 4)
-                throw new Error(`Invalid channel count`);
-            const channels = [0, 1, 2, 3];
-            if (reader.globalAlpha)
-                channels.push(4);
-            if (compression === 0 /* Compression.RawData */) {
-                throw new Error(`Compression not supported: ${compression}`);
-                // TODO: ...
-                // for (let i = 0; i < channels.length; i++) {
-                // 	readDataRaw(reader, imageData, channels[i], psd.width, psd.height);
-                // }
-            }
-            else if (compression === 1 /* Compression.RleCompressed */) {
-                const cmykImageData = {
-                    width: imageData.width,
-                    height: imageData.height,
-                    data: new Uint8Array(imageData.width * imageData.height * 5),
-                };
-                const start = reader.offset;
-                readDataRLE(reader, cmykImageData, psd.width, psd.height, bitsPerChannel, 5, channels, reader.large);
-                cmykToRgb(cmykImageData, imageData, true);
-                if (helpers_1.RAW_IMAGE_DATA)
-                    psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+            if (bitsPerChannel !== 8 && bitsPerChannel !== 16)
+                throw new Error('bitsPerChannel not supported');
+            const offsets = compositeChannelOffsets(reader, psd, 4, 4);
+            const cmykImageData = createImageDataBitDepth(width, height, bitsPerChannel, 5, reader.totalMemoryLimit);
+            resetAlpha(cmykImageData, true);
+            readCompositeChannels(reader, compression, cmykImageData, bitsPerChannel, 5, offsets);
+            cmykToRgb(cmykImageData, imageData, !!reader.globalAlpha);
+            break;
+        }
+        default: throw new Error(`Color mode not supported: ${psd.colorMode}`);
+    }
+    // remove weird white matte (already removed when converting from CMYK)
+    if (reader.globalAlpha && psd.colorMode !== 4 /* ColorMode.CMYK */) {
+        removeWhiteMatte(imageData);
+    }
+    return imageData;
+}
+// returns target offset for each of the composite image channels stored in the file, -1 for channels that are skipped
+function compositeChannelOffsets(reader, psd, colorChannels, alphaOffset) {
+    var _a, _b, _c;
+    const channelCount = (_a = psd.channels) !== null && _a !== void 0 ? _a : (colorChannels + (reader.globalAlpha ? 1 : 0));
+    if (channelCount < colorChannels)
+        throw new Error(`Invalid channel count: ${channelCount}`);
+    // First extra channel is transparency if document has global alpha (negative layer count). Some non-Photoshop
+    // applications write transparency channel without setting global alpha, in that case extra channel is not
+    // listed in alpha channel names (Photoshop names all user alpha channels / saved selections).
+    // Photoshop also lists merged transparency as first alpha channel named "Transparency" (in documents marked with
+    // Mtrn/Mt16/Mt32 additional info, or in some 16bit documents with layers stored in Lr16 without any other mark)
+    const alphaNames = (_c = (_b = psd.imageResources) === null || _b === void 0 ? void 0 : _b.alphaChannelNames) !== null && _c !== void 0 ? _c : [];
+    const namedChannels = alphaNames.length;
+    const namedTransparency = !!reader.layersInGlobalInfo && alphaNames[0] === 'Transparency' && namedChannels === channelCount - colorChannels;
+    const hasTransparency = reader.globalAlpha || namedTransparency || (channelCount - colorChannels) > namedChannels;
+    const offsets = [];
+    for (let i = 0; i < channelCount; i++) {
+        if (i < colorChannels) {
+            offsets.push(i);
+        }
+        else if (i === colorChannels && hasTransparency && alphaOffset >= 0) {
+            offsets.push(alphaOffset);
+        }
+        else {
+            // TODO: store these channels (alpha channels / saved selections, spot colors) in additional image data
+            offsets.push(-1);
+        }
+    }
+    return offsets;
+}
+function readCompositeChannels(reader, compression, pixelData, bitsPerChannel, step, offsets) {
+    if (compression === 0 /* Compression.RawData */) {
+        const channelSize = pixelData.width * pixelData.height * bytesPerValue(bitsPerChannel);
+        for (const offset of offsets) {
+            if (offset < 0) {
+                skipBytes(reader, channelSize);
             }
             else {
-                throw new Error(`Compression not supported: ${compression}`);
+                readDataRaw(readBytes(reader, channelSize), pixelData, bitsPerChannel, step, offset);
+            }
+        }
+    }
+    else if (compression === 1 /* Compression.RleCompressed */) {
+        readDataRLE(reader, pixelData, pixelData.width, pixelData.height, bitsPerChannel, step, offsets, reader.large);
+    }
+    else {
+        throw new Error(`Compression not supported: ${compression}`);
+    }
+}
+// un-premultiplies colors from white matte, used for composite image of documents with global alpha
+function removeWhiteMatte({ data, width, height }) {
+    const size = width * height * 4;
+    if (data instanceof Float32Array) {
+        for (let i = 0; i < size; i += 4) {
+            const a = data[i + 3];
+            if (a > 0 && a < 1) {
+                const ra = 1 / a;
+                const invA = 1 - ra;
+                for (let j = 0; j < 3; j++) {
+                    const v = data[i + j] * ra + invA;
+                    data[i + j] = v < 0 ? 0 : v;
+                }
+            }
+        }
+    }
+    else if (data instanceof Uint16Array) {
+        for (let i = 0; i < size; i += 4) {
+            const pa = data[i + 3];
+            if (pa !== 0 && pa !== 0xffff) {
+                const ra = 0xffff / pa;
+                const invA = 0xffff * (1 - ra);
+                for (let j = 0; j < 3; j++) {
+                    const v = Math.round(data[i + j] * ra + invA);
+                    data[i + j] = v < 0 ? 0 : (v > 0xffff ? 0xffff : v);
+                }
             }
-            break;
         }
-        default: throw new Error(`Color mode not supported: ${psd.colorMode}`);
     }
-    // remove weird white matte
-    if (reader.globalAlpha) {
-        if (psd.bitsPerChannel !== 8)
-            throw new Error('bitsPerChannel Not supproted');
-        const p = imageData.data;
-        const size = imageData.width * imageData.height * 4;
+    else {
+        // Uint8ClampedArray clamps and rounds values on assignment
         for (let i = 0; i < size; i += 4) {
-            const pa = p[i + 3];
+            const pa = data[i + 3];
             if (pa != 0 && pa != 255) {
                 const a = pa / 255;
                 const ra = 1 / a;
                 const invA = 255 * (1 - ra);
-                p[i + 0] = p[i + 0] * ra + invA;
-                p[i + 1] = p[i + 1] * ra + invA;
-                p[i + 2] = p[i + 2] * ra + invA;
+                data[i + 0] = data[i + 0] * ra + invA;
+                data[i + 1] = data[i + 1] * ra + invA;
+                data[i + 2] = data[i + 2] * ra + invA;
             }
         }
     }
-    return imageData;
 }
-function cmykToRgb(cmyk, rgb, reverseAlpha) {
+// converts value in 0-255 range to target range, rounding and clamping it
+function toRange(value, max) {
+    value = Math.round(value * (max / 255));
+    return value <= 0 ? 0 : (value >= max ? max : value);
+}
+// Polynomial approximation of U.S. Web Coated (SWOP) v2 CMYK to RGB conversion (default CMYK profile of Photoshop).
+// Coefficients are taken from pdf.js (DeviceCmykCS in src/core/colorspace.js, https://github.com/mozilla/pdf.js),
+// Copyright 2012 Mozilla Foundation, licensed under the Apache License, Version 2.0
+// (http://www.apache.org/licenses/LICENSE-2.0)
+// cmyk - 8 or 16 bit data with 5 channels (cmyka), rgb - 8 or 16 bit data with 4 channels (rgba)
+// removeMatte - colors are blended with white (no ink), used for composite image of documents with global alpha
+function cmykToRgb(cmyk, rgb, removeMatte) {
     const size = rgb.width * rgb.height * 4;
     const srcData = cmyk.data;
     const dstData = rgb.data;
+    const srcMax = srcData instanceof Uint16Array ? 0xffff : 0xff;
+    const dstMax = dstData instanceof Uint16Array ? 0xffff : 0xff;
     for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
-        const c = srcData[src];
-        const m = srcData[src + 1];
-        const y = srcData[src + 2];
-        const k = srcData[src + 3];
-        dstData[dst] = ((((c * k) | 0) / 255) | 0);
-        dstData[dst + 1] = ((((m * k) | 0) / 255) | 0);
-        dstData[dst + 2] = ((((y * k) | 0) / 255) | 0);
-        dstData[dst + 3] = reverseAlpha ? 255 - srcData[src + 4] : srcData[src + 4];
-    }
-    // for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
-    // 	const c = 1 - (srcData[src + 0] / 255);
-    // 	const m = 1 - (srcData[src + 1] / 255);
-    // 	const y = 1 - (srcData[src + 2] / 255);
-    // 	// const k = srcData[src + 3] / 255;
-    // 	dstData[dst + 0] = ((1 - c * 0.8) * 255) | 0;
-    // 	dstData[dst + 1] = ((1 - m * 0.8) * 255) | 0;
-    // 	dstData[dst + 2] = ((1 - y * 0.8) * 255) | 0;
-    // 	dstData[dst + 3] = reverseAlpha ? 255 - srcData[src + 4] : srcData[src + 4];
-    // }
-}
-function indexedToRgb(indexed, rgb, palette) {
+        const a = srcData[src + 4];
+        // image data stores inverted values (0 = 100% ink)
+        let c = 1 - srcData[src] / srcMax;
+        let m = 1 - srcData[src + 1] / srcMax;
+        let y = 1 - srcData[src + 2] / srcMax;
+        let k = 1 - srcData[src + 3] / srcMax;
+        if (removeMatte && a > 0 && a < srcMax) {
+            const ra = srcMax / a;
+            c = Math.min(1, c * ra);
+            m = Math.min(1, m * ra);
+            y = Math.min(1, y * ra);
+            k = Math.min(1, k * ra);
+        }
+        dstData[dst] = toRange(255 +
+            c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k - 285.2331026137004) +
+            m * (1.7149763477362134 * m - 5.6096736904047315 * y - 17.873870861415444 * k - 5.497006427196366) +
+            y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) +
+            k * (-21.86122147463605 * k - 189.48180835922747), dstMax);
+        dstData[dst + 1] = toRange(255 +
+            c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k - 79.2970844816548) +
+            m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) +
+            y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) +
+            k * (-20.737325471181034 * k - 187.80453709719578), dstMax);
+        dstData[dst + 2] = toRange(255 +
+            c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k - 14.183576799673286) +
+            m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) +
+            y * (0.03296041114873217 * y + 115.60384449646641 * k - 193.58209356861505) +
+            k * (-22.33816807309886 * k - 180.12613974708367), dstMax);
+        dstData[dst + 3] = srcMax === dstMax ? a : Math.round(a * dstMax / srcMax);
+    }
+}
+// transparencyIndex - palette index of transparent color (-1 if there's none)
+function indexedToRgb(indexed, rgb, palette, transparencyIndex) {
     const size = indexed.width * indexed.height;
     const srcData = indexed.data;
     const dstData = rgb.data;
     for (let src = 0, dst = 0; src < size; src++, dst += 4) {
-        const c = palette[srcData[src]];
+        const index = srcData[src];
+        const c = palette[index];
         dstData[dst + 0] = c.r;
         dstData[dst + 1] = c.g;
         dstData[dst + 2] = c.b;
-        dstData[dst + 3] = 255;
+        dstData[dst + 3] = index === transparencyIndex ? 0 : 255;
     }
 }
-function verifyCompatible(a, b) {
-    if ((a.byteLength / a.length) !== (b.byteLength / b.length)) {
-        throw new Error('Invalid array types');
+// number of bytes used to store single channel value, 1-bit data is handled as bytes
+function bytesPerValue(bitDepth) {
+    switch (bitDepth) {
+        case 1:
+        case 8: return 1;
+        case 16: return 2;
+        case 32: return 4;
+        default: throw new Error(`Invalid bitDepth (${bitDepth})`);
     }
 }
-function bytesToArray(bytes, bitDepth) {
-    if (bitDepth === 8) {
-        return bytes;
+function verifyArrayType(data, bytesPerValue) {
+    if (data.BYTES_PER_ELEMENT !== bytesPerValue) {
+        throw new Error('Invalid array types');
     }
-    else if (bitDepth === 16) {
-        // PSD files store 16-bit channel data in big-endian byte order.
-        // Swap each pair of bytes so that Uint16Array (native-endian) reads the correct values.
-        for (let i = 0; i < bytes.byteLength; i += 2) {
-            const tmp = bytes[i];
-            bytes[i] = bytes[i + 1];
-            bytes[i + 1] = tmp;
-        }
-        if (bytes.byteOffset % 2) {
-            const 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);
+}
+// NOTE: `buffer` may alias input file data, it must not be modified here
+function readDataRaw(buffer, pixelData, bitDepth, step, offset) {
+    const bpv = bytesPerValue(bitDepth);
+    if (!pixelData || offset < 0 || offset >= step)
+        return;
+    const data = pixelData.data;
+    verifyArrayType(data, bpv);
+    const size = Math.min(pixelData.width * pixelData.height, Math.floor(buffer.byteLength / bpv)) | 0;
+    if (bpv === 1) {
+        for (let i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
+            data[p] = buffer[i];
         }
     }
-    else if (bitDepth === 32) {
-        if (bytes.byteOffset % 4) {
-            const 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 if (bpv === 2) {
+        for (let i = 0, j = 0, p = offset | 0; i < size; i++, j += 2, p = (p + step) | 0) {
+            data[p] = (buffer[j] << 8) | buffer[j + 1];
         }
     }
     else {
-        throw new Error(`Invalid bitDepth (${bitDepth})`);
-    }
-}
-function copyChannelToPixelData(pixelData, channel, offset, step) {
-    verifyCompatible(pixelData.data, channel);
-    const size = pixelData.width * pixelData.height;
-    const data = pixelData.data;
-    for (let i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
-        data[p] = channel[i];
-    }
-}
-function readDataRaw(buffer, pixelData, bitDepth, step, offset) {
-    if (bitDepth == 32) {
-        for (let i = 0; i < buffer.byteLength; i += 4) {
-            const a = buffer[i + 0];
-            const b = buffer[i + 1];
-            const c = buffer[i + 2];
-            const d = buffer[i + 3];
-            buffer[i + 0] = d;
-            buffer[i + 1] = c;
-            buffer[i + 2] = b;
-            buffer[i + 3] = a;
+        const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        for (let i = 0, j = 0, p = offset | 0; i < size; i++, j += 4, p = (p + step) | 0) {
+            data[p] = view.getFloat32(j, false);
         }
     }
-    const array = bytesToArray(buffer, bitDepth);
-    if (pixelData && offset < step) {
-        copyChannelToPixelData(pixelData, array, offset, step);
-    }
 }
-function decodePredicted(data, width, height, mod) {
+function decodePredicted(data, width, height) {
     for (let y = 0; y < height; y++) {
         const offset = y * width;
         for (let x = 1, o = offset + 1; x < width; x++, o++) {
-            data[o] = (data[o - 1] + data[o]) % mod;
-        }
-    }
-}
-function readDataZip(compressed, pixelData, width, height, bitDepth, step, offset, prediction) {
-    const decompressed = (0, pako_1.inflate)(compressed);
-    if (pixelData && offset < step) {
-        const 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);
-            let di = offset;
-            const dst = new Uint32Array(pixelData.data.buffer, pixelData.data.byteOffset, pixelData.data.length);
-            for (let y = 0; y < height; y++) {
-                let a = width * 4 * y;
-                for (let x = 0; x < width; x++, a++, di += step) {
-                    const b = a + width;
-                    const c = b + width;
-                    const d = c + width;
-                    dst[di] = ((decompressed[a] << 24) | (decompressed[b] << 16) | (decompressed[c] << 8) | decompressed[d]) >>> 0;
+            data[o] = data[o - 1] + data[o]; // Uint8Array wraps values on assignment
+        }
+    }
+}
+const zipOverflow = new Error('Decompressed data exceeds expected size');
+// inflates data, stopping when output exceeds expected size (protects against zip bombs)
+function inflateLimited(compressed, expectedSize, reader) {
+    const output = new Uint8Array(expectedSize);
+    let position = 0;
+    let overflow = false;
+    const inflator = new pako_1.Inflate({ chunkSize: Math.max(1024, Math.min(expectedSize, 0x10000)) });
+    inflator.onData = (chunk) => {
+        const data = chunk;
+        const count = Math.min(data.length, expectedSize - position);
+        if (count > 0)
+            output.set(count === data.length ? data : data.subarray(0, count), position);
+        position += count;
+        if (count < data.length) {
+            overflow = true;
+            throw zipOverflow;
+        }
+    };
+    inflator.onEnd = (status) => {
+        var _a;
+        // default handler collects all the chunks into result, we only need the error status
+        inflator.err = status;
+        inflator.msg = ((_a = inflator.strm) === null || _a === void 0 ? void 0 : _a.msg) || '';
+    };
+    try {
+        inflator.push(compressed, true);
+    }
+    catch (e) {
+        if (e !== zipOverflow)
+            throw e;
+    }
+    if (overflow) {
+        if (reader)
+            warnOrThrow(reader, zipOverflow.message);
+    }
+    else if (inflator.err) {
+        throw new Error(`Invalid zip data: ${inflator.msg}`);
+    }
+    return output;
+}
+function readDataZip(compressed, pixelData, width, height, bitDepth, step, offset, prediction, reader) {
+    const bpv = bytesPerValue(bitDepth);
+    if (!pixelData || offset < 0 || offset >= step)
+        return;
+    const data = pixelData.data;
+    verifyArrayType(data, bpv);
+    const expectedSize = width * height * bpv;
+    if (reader)
+        consumeMemory(reader, expectedSize);
+    try {
+        const decompressed = inflateLimited(compressed, expectedSize, reader);
+        if (bpv === 1) {
+            for (let y = 0, i = 0; y < height; y++) {
+                let prev = 0;
+                for (let x = 0, p = offset + y * width * step; x < width; x++, i++, p += step) {
+                    let v = decompressed[i];
+                    if (prediction)
+                        v = prev = (prev + v) & 0xff;
+                    data[p] = v;
+                }
+            }
+        }
+        else if (bpv === 2) {
+            for (let y = 0, i = 0; y < height; y++) {
+                let prev = 0;
+                for (let x = 0, p = offset + y * width * step; x < width; x++, i += 2, p += step) {
+                    let v = (decompressed[i] << 8) | decompressed[i + 1];
+                    if (prediction)
+                        v = prev = (prev + v) & 0xffff;
+                    data[p] = v;
                 }
             }
         }
         else {
-            throw new Error('Invalid bitDepth');
+            const dst = new Uint32Array(data.buffer, data.byteOffset, data.length);
+            if (prediction) {
+                // bytes are delta encoded per row and stored in planar order (all 1st bytes, all 2nd bytes, ...)
+                decodePredicted(decompressed, width * 4, height);
+                for (let y = 0, di = offset; y < height; y++) {
+                    let a = width * 4 * y;
+                    for (let x = 0; x < width; x++, a++, di += step) {
+                        const b = a + width;
+                        const c = b + width;
+                        const d = c + width;
+                        dst[di] = ((decompressed[a] << 24) | (decompressed[b] << 16) | (decompressed[c] << 8) | decompressed[d]) >>> 0;
+                    }
+                }
+            }
+            else {
+                const view = new DataView(decompressed.buffer, decompressed.byteOffset, decompressed.byteLength);
+                for (let i = 0, j = 0, di = offset, size = width * height; i < size; i++, j += 4, di += step) {
+                    dst[di] = view.getUint32(j, false);
+                }
+            }
         }
     }
-}
-function readDataRLE(reader, pixelData, width, height, _bitDepth, step, offsets, large) {
-    const data = pixelData && pixelData.data;
-    let lengths;
-    if (large) {
-        consumeMemory(reader, offsets.length * height * 4);
-        lengths = new Uint32Array(offsets.length * height);
-        for (let o = 0, li = 0; o < offsets.length; o++) {
-            for (let y = 0; y < height; y++, li++) {
-                lengths[li] = readUint32(reader);
+    finally {
+        if (reader)
+            recoverMemory(reader, expectedSize);
+    }
+}
+// decodes single PackBits row, returns number of decoded values
+function decodeRLERow(src, i, end, dst, p, step, count) {
+    let x = 0;
+    while (i < end && x < count) {
+        const header = src[i++];
+        if (header > 128) {
+            if (i >= end)
+                break;
+            const value = src[i++];
+            let n = 257 - header;
+            if (n > count - x)
+                n = count - x;
+            x += n;
+            for (; n > 0; n--, p += step) {
+                dst[p] = value;
+            }
+        }
+        else if (header < 128) {
+            let n = header + 1;
+            if (n > count - x)
+                n = count - x;
+            if (n > end - i)
+                n = end - i;
+            x += n;
+            for (; n > 0; n--, p += step) {
+                dst[p] = src[i++];
             }
         }
+        else {
+            // ignore 128
+        }
+    }
+    return x;
+}
+// converts big-endian 16/32-bit values from bytes and writes them to `data` starting at `p` with `step`
+function scatterValues(bytes, count, bpv, data, p, step) {
+    if (bpv === 2) {
+        for (let x = 0, i = 0; x < count; x++, i += 2, p += step) {
+            data[p] = (bytes[i] << 8) | bytes[i + 1];
+        }
     }
     else {
-        consumeMemory(reader, offsets.length * height * 2);
-        lengths = new Uint16Array(offsets.length * height);
-        for (let o = 0, li = 0; o < offsets.length; o++) {
-            for (let y = 0; y < height; y++, li++) {
-                lengths[li] = readUint16(reader);
-            }
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        for (let x = 0, i = 0; x < count; x++, i += 4, p += step) {
+            data[p] = view.getFloat32(i, false);
         }
     }
-    // if (bitDepth !== 1 && bitDepth !== 8) throw new Error(`Invalid bit depth (${bitDepth})`);
-    const extraLimit = (step - 1) | 0; // 3 for rgb, 4 for cmyk
-    for (let c = 0, li = 0; c < offsets.length; c++) {
-        const offset = offsets[c] | 0;
-        const extra = c > extraLimit || offset > extraLimit;
-        if (!data || extra) {
-            for (let y = 0; y < height; y++, li++) {
-                skipBytes(reader, lengths[li]);
-            }
+}
+// decodes RLE rows of single channel, each row starts at the beginning of the image row
+function decodeRLEChannel(src, lengths, li, pos, width, height, data, offset, step, bpv, row) {
+    const srcEnd = src.length;
+    const rowSize = width * bpv;
+    for (let y = 0; y < height; y++, li++) {
+        const rowStart = pos < srcEnd ? pos : srcEnd;
+        pos += lengths[li];
+        const rowEnd = pos < srcEnd ? pos : srcEnd;
+        if (rowStart >= rowEnd)
+            continue;
+        if (bpv === 1) {
+            decodeRLERow(src, rowStart, rowEnd, data, offset + y * width * step, step, width);
         }
         else {
-            for (let y = 0, p = offset | 0; y < height; y++, li++) {
-                const length = lengths[li];
-                const buffer = readBytes(reader, length);
-                for (let i = 0, x = 0; i < length; i++) {
-                    let header = buffer[i];
-                    if (header > 128) {
-                        const value = buffer[++i];
-                        header = (256 - header) | 0;
-                        for (let j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
-                            data[p] = value;
-                            p = (p + step) | 0;
-                        }
-                    }
-                    else if (header < 128) {
-                        for (let j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
-                            data[p] = buffer[++i];
-                            p = (p + step) | 0;
-                        }
-                    }
-                    else {
-                        // ignore 128
-                    }
-                    // This showed up on some images from non-photoshop programs, ignoring it seems to work just fine.
-                    // if (i >= length) throw new Error(`Invalid RLE data: exceeded buffer size ${i}/${length}`);
-                }
+            const decoded = decodeRLERow(src, rowStart, rowEnd, row, 0, 1, rowSize);
+            scatterValues(row, Math.floor(decoded / bpv), bpv, data, offset + y * width * step, step);
+        }
+    }
+}
+function readDataRLE(reader, pixelData, width, height, bitDepth, step, offsets, large) {
+    const data = pixelData && pixelData.data;
+    const rows = offsets.length * height;
+    const lengthSize = large ? 4 : 2;
+    consumeMemory(reader, rows * lengthSize);
+    try {
+        if ((reader.offset + rows * lengthSize) > reader.view.byteLength) {
+            throw new Error('RLE row lengths exceed buffer length');
+        }
+        const lengths = large ? new Uint32Array(rows) : new Uint16Array(rows);
+        let total = 0;
+        if (large) {
+            for (let i = 0; i < rows; i++)
+                total += (lengths[i] = readUint32(reader));
+        }
+        else {
+            for (let i = 0; i < rows; i++)
+                total += (lengths[i] = readUint16(reader));
+        }
+        const start = reader.offset;
+        const srcEnd = reader.view.byteLength;
+        if (total > (srcEnd - start)) {
+            // broken or truncated file, decode only data that is available
+            warnOrThrow(reader, 'RLE data exceeds buffer length');
+        }
+        const bpv = bytesPerValue(bitDepth);
+        if (data)
+            verifyArrayType(data, bpv);
+        const src = new Uint8Array(reader.view.buffer, reader.view.byteOffset, srcEnd);
+        const row = (data && bpv > 1) ? new Uint8Array(width * bpv) : undefined;
+        let pos = start;
+        for (let c = 0, li = 0; c < offsets.length; c++, li += height) {
+            const offset = offsets[c] | 0;
+            const channelStart = pos;
+            for (let y = 0; y < height; y++)
+                pos += lengths[li + y];
+            if (data && offset >= 0 && offset < step) {
+                decodeRLEChannel(src, lengths, li, channelStart, width, height, data, offset, step, bpv, row);
             }
         }
+        reader.offset = pos;
+    }
+    finally {
+        recoverMemory(reader, rows * lengthSize);
     }
-    recoverMemory(reader, lengths.byteLength);
 }
 function readSection(reader, round, func, skipEmpty = true, eightBytes = false) {
     let length = readUint32(reader);
@@ -1228,19 +1492,19 @@ function readColor(reader) {
             skipBytes(reader, 2);
             return { h, s, b };
         }
-        case 2 /* ColorSpace.CMYK */: {
-            const c = readUint16(reader) / 257;
-            const m = readUint16(reader) / 257;
-            const y = readUint16(reader) / 257;
-            const k = readUint16(reader) / 257;
+        case 2 /* ColorSpace.CMYK */: { // 0 = 100% ink
+            const c = (0xffff - readUint16(reader)) / 257;
+            const m = (0xffff - readUint16(reader)) / 257;
+            const y = (0xffff - readUint16(reader)) / 257;
+            const k = (0xffff - readUint16(reader)) / 257;
             return { c, m, y, k };
         }
         case 7 /* ColorSpace.Lab */: {
             const l = readInt16(reader) / 10000;
             const ta = readInt16(reader);
             const tb = readInt16(reader);
-            const a = ta < 0 ? (ta / 12800) : (ta / 12700);
-            const b = tb < 0 ? (tb / 12800) : (tb / 12700);
+            const a = (0, helpers_1.normalizeLabAB)(ta, 100);
+            const b = (0, helpers_1.normalizeLabAB)(tb, 100);
             skipBytes(reader, 2);
             return { l, a, b };
         }
@@ -1253,6 +1517,24 @@ function readColor(reader) {
             throw new Error('Invalid color space');
     }
 }
+const MAX_PATTERN_SIZE = 30000;
+// reads pattern, unsupported or invalid patterns are skipped (returns undefined) unless throwForMissingFeatures is set
+function readPatternSafe(reader) {
+    let length = reader.view.getUint32(reader.offset);
+    while (length % 4)
+        length++;
+    const end = reader.offset + 4 + length;
+    try {
+        return readPattern(reader);
+    }
+    catch (e) {
+        if (reader.throwForMissingFeatures)
+            throw e;
+        reader.logMissingFeatures && reader.log(`Skipped pattern: ${e.message}`);
+        reader.offset = end;
+        return undefined;
+    }
+}
 function readPattern(reader) {
     let length = readUint32(reader);
     while (length % 4)
@@ -1264,8 +1546,8 @@ function readPattern(reader) {
     const colorMode = readUint32(reader);
     const x = readInt16(reader);
     const y = readInt16(reader);
-    // we only support RGB and grayscale for now
-    if (colorMode !== 3 /* ColorMode.RGB */ && colorMode !== 1 /* ColorMode.Grayscale */ && colorMode !== 2 /* ColorMode.Indexed */) {
+    // we only support RGB, grayscale, indexed and CMYK for now
+    if (colorMode !== 3 /* ColorMode.RGB */ && colorMode !== 1 /* ColorMode.Grayscale */ && colorMode !== 2 /* ColorMode.Indexed */ && colorMode !== 4 /* ColorMode.CMYK */) {
         throw new Error(`Unsupported pattern color mode: ${colorMode}`);
     }
     let name = readUnicodeString(reader);
@@ -1279,7 +1561,9 @@ function readPattern(reader) {
                 b: readUint8(reader),
             });
         }
-        skipBytes(reader, 4); // no idea what this is
+        // some writers follow the palette with 4 extra bytes (unknown)
+        if (reader.view.getUint32(reader.offset) !== 3)
+            skipBytes(reader, 4);
     }
     // virtual memory array list
     const version2 = readUint32(reader);
@@ -1293,17 +1577,37 @@ function readPattern(reader) {
     const channelsCount = readUint32(reader);
     const width = right - left;
     const height = bottom - top;
+    if (width < 0 || height < 0)
+        throw new Error('Invalid pattern bounds');
+    if (width > MAX_PATTERN_SIZE || height > MAX_PATTERN_SIZE)
+        throw new Error(`Pattern too large (${width}x${height})`);
+    if (channelsCount > 64)
+        throw new Error(`Invalid pattern channel count: ${channelsCount}`);
+    // channels cover whole pattern, each 2 bytes of RLE data can produce at most 128 bytes
+    if (width * height > (Math.min(end, reader.view.byteLength) - reader.offset) * 64)
+        throw new Error('Pattern data out of bounds');
     const size = width * height * 4;
     consumeMemory(reader, size);
     const data = new Uint8Array(size);
     for (let i = 3; i < data.byteLength; i += 4) {
         data[i] = 255;
     }
-    for (let i = 0, ch = 0; i < (channelsCount + 2); i++) {
+    // first written arrays are color channels, next one is transparency (Photoshop stores it in the last, sheet mask, array)
+    const colorChannels = colorMode === 3 /* ColorMode.RGB */ ? 3 : (colorMode === 4 /* ColorMode.CMYK */ ? 4 : 1);
+    // CMYK channels are decoded into separate buffer (5 values per pixel, inverted, 0 = 100% ink) and converted to RGB at the end
+    const cmyk = colorMode === 4 /* ColorMode.CMYK */ ? new Uint8Array(width * height * 5).fill(255) : undefined;
+    if (cmyk)
+        consumeMemory(reader, cmyk.byteLength);
+    const alphaTarget = cmyk ? 4 : 3;
+    for (let i = 0, ch = 0; i < (channelsCount + 2) && reader.offset + 4 <= end; i++) {
         const has = readUint32(reader);
         if (!has)
             continue;
         const length = readUint32(reader);
+        if (!length)
+            continue;
+        if (length < 23)
+            throw new Error('Invalid pattern channel length');
         const pixelDepth = readUint32(reader);
         const ctop = readUint32(reader);
         const cleft = readUint32(reader);
@@ -1311,97 +1615,92 @@ function readPattern(reader) {
         const cright = readUint32(reader);
         const pixelDepth2 = readUint16(reader);
         const compressionMode = readUint8(reader); // 0 - raw, 1 - rle
-        const dataLength = length - (4 + 16 + 2 + 1);
-        const cdata = readBytes(reader, dataLength);
-        if (pixelDepth !== 8 || pixelDepth2 !== 8) {
-            throw new Error('16bit pixel depth not supported for patterns');
-        }
+        const cdata = readBytes(reader, length - 23);
+        const depth = (pixelDepth2 === 8 || pixelDepth2 === 16 || pixelDepth2 === 32) ? pixelDepth2 : pixelDepth;
+        if (depth !== 8 && depth !== 16 && depth !== 32)
+            throw new Error(`Unsupported pattern pixel depth: ${depth}`);
+        if (ctop < top || cleft < left || cbottom > bottom || cright > right || cbottom < ctop || cright < cleft) {
+            throw new Error('Pattern channel bounds outside of pattern bounds');
+        }
+        const target = ch < colorChannels ? ch : (ch === colorChannels ? alphaTarget : -1);
+        ch++;
+        if (target === -1)
+            continue;
         const w = cright - cleft;
         const h = cbottom - ctop;
-        const ox = cleft - left;
-        const oy = ctop - top;
+        const rowBytes = w * (depth / 8);
+        const channelSize = rowBytes * h;
+        let bytes;
         if (compressionMode === 0) {
-            if (colorMode === 3 /* ColorMode.RGB */ && ch < 3) {
-                for (let y = 0; y < h; y++) {
-                    for (let x = 0; x < w; x++) {
-                        const src = x + y * w;
-                        const dst = (ox + x + (y + oy) * width) * 4;
-                        data[dst + ch] = cdata[src];
-                    }
-                }
-            }
-            else if (colorMode === 1 /* ColorMode.Grayscale */ && ch < 1) {
-                for (let y = 0; y < h; y++) {
-                    for (let x = 0; x < w; x++) {
-                        const src = x + y * w;
-                        const dst = (ox + x + (y + oy) * width) * 4;
-                        const value = cdata[src];
-                        data[dst + 0] = value;
-                        data[dst + 1] = value;
-                        data[dst + 2] = value;
-                    }
-                }
-            }
-            else if (colorMode === 2 /* ColorMode.Indexed */) {
-                for (let y = 0; y < h; y++) {
-                    for (let x = 0; x < w; x++) {
-                        const src = x + y * w;
-                        const dst = (ox + x + (y + oy) * width) * 4;
-                        const index = cdata[src];
-                        const color = palette[index];
-                        data[dst + 0] = color.r;
-                        data[dst + 1] = color.g;
-                        data[dst + 2] = color.b;
-                    }
-                }
-            }
-            else {
-                if (reader.throwForMissingFeatures)
-                    throw new Error('Invalid color pattern');
-            }
+            if (cdata.byteLength < channelSize)
+                throw new Error('Pattern channel data out of bounds');
+            bytes = cdata;
         }
         else if (compressionMode === 1) {
-            consumeMemory(reader, w * h);
-            const pixelData = { data, width, height };
-            const tempData = { data: new Uint8Array(w * h), width: w, height: h };
+            // each 2 bytes of RLE data can produce at most 128 bytes
+            if (channelSize > cdata.byteLength * 64)
+                throw new Error('Pattern channel data out of bounds');
+            consumeMemory(reader, channelSize);
+            bytes = new Uint8Array(channelSize);
             const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
-            if (colorMode === 3 /* ColorMode.RGB */ && ch < 3) {
-                readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
-                copyChannelToRGBA(tempData, pixelData, ox, oy, ch);
-            }
-            if (colorMode === 1 /* ColorMode.Grayscale */ && ch < 1) {
-                readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
-                copyChannelToRGBA(tempData, pixelData, ox, oy, 0);
-                setupGrayscale(pixelData);
-            }
-            if (colorMode === 2 /* ColorMode.Indexed */) {
-                // TODO:
-                throw new Error('Indexed pattern color mode not implemented');
-            }
-            recoverMemory(reader, w * h);
+            readDataRLE(cdataReader, { data: bytes, width: rowBytes, height: h }, rowBytes, h, 8, 1, [0], false);
         }
         else {
             throw new Error('Invalid pattern compression mode');
         }
-        ch++;
+        const ox = cleft - left;
+        const oy = ctop - top;
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                const src = x + y * w;
+                const dst = (ox + x + (y + oy) * width) * 4;
+                const value = depth === 8 ? bytes[src] : patternValueTo8bit(bytes, src, depth);
+                if (cmyk) {
+                    cmyk[(ox + x + (y + oy) * width) * 5 + target] = value;
+                }
+                else if (target === 3) {
+                    data[dst + 3] = value;
+                }
+                else if (colorMode === 2 /* ColorMode.Indexed */) {
+                    const color = palette[value];
+                    data[dst + 0] = color.r;
+                    data[dst + 1] = color.g;
+                    data[dst + 2] = color.b;
+                }
+                else if (colorMode === 1 /* ColorMode.Grayscale */) {
+                    data[dst + 0] = value;
+                    data[dst + 1] = value;
+                    data[dst + 2] = value;
+                }
+                else {
+                    data[dst + target] = value;
+                }
+            }
+        }
+        if (compressionMode === 1)
+            recoverMemory(reader, channelSize);
+    }
+    if (cmyk) {
+        cmykToRgb({ width, height, data: cmyk }, { width, height, data }, false);
+        recoverMemory(reader, cmyk.byteLength);
     }
     reader.offset = end;
     return { id, name, x, y, bounds: { x: left, y: top, w: width, h: height }, data };
 }
-function copyChannelToRGBA(srcData, dstData, ox, oy, offset) {
-    const w = srcData.width;
-    const h = srcData.height;
-    const width = dstData.width;
-    for (let y = 0; y < h; y++) {
-        for (let x = 0; x < w; x++) {
-            const src = x + y * w;
-            const dst = (ox + x + (y + oy) * width) * 4;
-            const value = srcData.data[src];
-            dstData.data[dst + offset] = value;
-        }
+// converts big-endian 16bit or 32bit (float) value at given index to 8bit value
+function patternValueTo8bit(bytes, index, depth) {
+    if (depth === 16) {
+        return Math.round(((bytes[index * 2] << 8) | bytes[index * 2 + 1]) / 257);
+    }
+    else {
+        const view = new DataView(bytes.buffer, bytes.byteOffset + index * 4, 4);
+        const value = view.getFloat32(0, false);
+        return value > 0 ? (value < 1 ? Math.round(value * 255) : 255) : 0;
     }
 }
 function consumeMemory(reader, size) {
+    if (!(size >= 0))
+        throw new Error('Invalid size');
     if (reader.totalMemoryLimit !== undefined) {
         if (reader.totalMemoryLimit < size)
             throw new Error('Exceeded memory limit');