ag-psd 31.0.2 → 32.0.0

package/dist-es/psdReader.js

@@ -125,22 +125,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 +167,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 +226,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 +247,7 @@ 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)
+    if (channels < 1 || channels > 56)
         throw new Error(`Invalid channel count: ${channels}`);
     if (![1, 8, 16, 32].includes(bitsPerChannel))
         throw new Error(`Invalid bitsPerChannel: ${bitsPerChannel}`);
@@ -331,7 +349,10 @@ 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 };
         }
         else {
             const imageData = readImageData(reader, psd);
@@ -386,7 +407,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 ?)
@@ -472,7 +495,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 +524,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)];
 }
@@ -567,8 +627,12 @@ 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;
+    }
+    return readImageData(reader, psd);
 }
 function getCompositeCanvas(psd) {
     return imageDataToCanvasSafe(getCompositeImageData(psd));
@@ -610,18 +674,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 +698,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;
@@ -647,7 +712,7 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
     if (layerWidth && layerHeight && read === LayerDataType.Layer) {
         if (cmyk) {
             if (bitsPerChannel !== 8)
-                throw new Error('bitsPerChannel Not supproted');
+                throw new Error('bitsPerChannel not supported');
             imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) };
         }
         else {
@@ -662,6 +727,11 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
         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,6 +744,8 @@ 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 */) {
@@ -705,15 +777,14 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
                 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) {
@@ -729,7 +800,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 +811,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 +830,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 };
@@ -839,11 +910,12 @@ function readImageData(reader, psd) {
     var _a;
     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,46 +923,26 @@ 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);
+            const start = reader.offset;
+            readCompositeChannels(reader, compression, imageData, bitsPerChannel, 4, offsets);
+            if (helpers_1.RAW_IMAGE_DATA && compression === 1 /* Compression.RleCompressed */) {
+                psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
             }
             if (psd.colorMode === 1 /* ColorMode.Grayscale */) {
                 setupGrayscale(imageData);
@@ -899,57 +951,25 @@ 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);
             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);
-            }
-            else {
-                throw new Error(`Compression not supported: ${compression}`);
+                throw new Error('bitsPerChannel not supported');
+            const offsets = compositeChannelOffsets(reader, psd, 4, 4);
+            const cmykImageData = { width, height, data: new Uint8Array(width * height * 5) };
+            const start = reader.offset;
+            readCompositeChannels(reader, compression, cmykImageData, 8, 5, offsets);
+            cmykToRgb(cmykImageData, imageData, true);
+            if (helpers_1.RAW_IMAGE_DATA && compression === 1 /* Compression.RleCompressed */) {
+                psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
             }
             break;
         }
@@ -957,23 +977,98 @@ function readImageData(reader, psd) {
     }
     // 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;
+        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, _d;
+    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).
+    const namedChannels = (_d = (_c = (_b = psd.imageResources) === null || _b === void 0 ? void 0 : _b.alphaChannelNames) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+    const hasTransparency = reader.globalAlpha || (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 {
+                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 = p[i + 3];
+            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);
+                }
+            }
+        }
+    }
+    else {
+        // Uint8ClampedArray clamps and rounds values on assignment
+        for (let i = 0; i < size; i += 4) {
+            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) {
     const size = rgb.width * rgb.height * 4;
@@ -1012,175 +1107,267 @@ function indexedToRgb(indexed, rgb, palette) {
         dstData[dst + 3] = 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);
@@ -1239,8 +1426,8 @@ function readColor(reader) {
             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 };
         }