ag-psd 14.3.2 → 14.3.3

package/dist/bundle.js

@@ -42,7 +42,7 @@ function readAbr(buffer, options) {
     if (version === 1 || version === 2) {
         throw new Error("Unsupported ABR version (" + version + ")"); // TODO: ...
     }
-    else if (version === 6 || version === 7 || version === 10) {
+    else if (version === 6 || version === 7 || version === 9 || version === 10) {
         var minorVersion = psdReader_1.readInt16(reader);
         if (minorVersion !== 1 && minorVersion !== 2)
             throw new Error('Unsupported ABR minor version');
@@ -254,7 +254,7 @@ function readAbr(buffer, options) {
         }
     }
     else {
-        throw new Error('Unsupported ABR version');
+        throw new Error("Unsupported ABR version (" + version + ")");
     }
     return { samples: samples, patterns: patterns, brushes: brushes };
 }
@@ -3584,6 +3584,10 @@ exports.BlnM = helpers_1.createEnum('BlnM', 'normal', {
     'saturation': 'Strt',
     'color': 'Clr ',
     'luminosity': 'Lmns',
+    // used in ABR
+    'linear height': 'linearHeight',
+    'height': 'Hght',
+    'subtraction': 'Sbtr', // 2nd version of subtract ?
 });
 exports.BESl = helpers_1.createEnum('BESl', 'inner bevel', {
     'inner bevel': 'InrB',
@@ -4373,9 +4377,10 @@ var MaskParams;
 })(MaskParams = exports.MaskParams || (exports.MaskParams = {}));
 var ChannelID;
 (function (ChannelID) {
-    ChannelID[ChannelID["Red"] = 0] = "Red";
-    ChannelID[ChannelID["Green"] = 1] = "Green";
-    ChannelID[ChannelID["Blue"] = 2] = "Blue";
+    ChannelID[ChannelID["Color0"] = 0] = "Color0";
+    ChannelID[ChannelID["Color1"] = 1] = "Color1";
+    ChannelID[ChannelID["Color2"] = 2] = "Color2";
+    ChannelID[ChannelID["Color3"] = 3] = "Color3";
     ChannelID[ChannelID["Transparency"] = -1] = "Transparency";
     ChannelID[ChannelID["UserMask"] = -2] = "UserMask";
     ChannelID[ChannelID["RealUserMask"] = -3] = "RealUserMask";
@@ -4387,12 +4392,13 @@ var Compression;
     Compression[Compression["ZipWithoutPrediction"] = 2] = "ZipWithoutPrediction";
     Compression[Compression["ZipWithPrediction"] = 3] = "ZipWithPrediction";
 })(Compression = exports.Compression || (exports.Compression = {}));
-function offsetForChannel(channelId) {
+function offsetForChannel(channelId, cmyk) {
     switch (channelId) {
-        case 0 /* Red */: return 0;
-        case 1 /* Green */: return 1;
-        case 2 /* Blue */: return 2;
-        case -1 /* Transparency */: return 3;
+        case 0 /* Color0 */: return 0;
+        case 1 /* Color1 */: return 1;
+        case 2 /* Color2 */: return 2;
+        case 3 /* Color3 */: return cmyk ? 3 : channelId + 1;
+        case -1 /* Transparency */: return cmyk ? 4 : 3;
         default: return channelId + 1;
     }
 }
@@ -4412,9 +4418,9 @@ function hasAlpha(data) {
 }
 exports.hasAlpha = hasAlpha;
 function resetImageData(_a) {
-    var width = _a.width, height = _a.height, data = _a.data;
-    var size = (width * height) | 0;
+    var data = _a.data;
     var buffer = new Uint32Array(data.buffer);
+    var size = buffer.length | 0;
     for (var p = 0; p < size; p = (p + 1) | 0) {
         buffer[p] = 0xff000000;
     }
@@ -4992,6 +4998,8 @@ addHandler(1036, function (target) { return target.thumbnail !== undefined || ta
         data = target.thumbnailRaw.data;
     }
     else {
+        if (!target.thumbnail)
+            throw new Error('Missing thumbnail');
         width = target.thumbnail.width;
         height = target.thumbnail.height;
         data = base64_js_1.toByteArray(target.thumbnail.toDataURL('image/jpeg', 1).substr('data:image/jpeg;base64,'.length));
@@ -5483,6 +5491,9 @@ function readPsd(reader, options) {
     if (!skipComposite) {
         readImageData(reader, psd, globalAlpha, opt);
     }
+    // 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;
 }
 exports.readPsd = readPsd;
@@ -5632,14 +5643,21 @@ function readLayerBlendingRanges(reader) {
 function readLayerChannelImageData(reader, psd, layer, channels, options) {
     var layerWidth = (layer.right || 0) - (layer.left || 0);
     var layerHeight = (layer.bottom || 0) - (layer.top || 0);
+    var cmyk = psd.colorMode === 4 /* CMYK */;
     var imageData;
     if (layerWidth && layerHeight) {
-        imageData = helpers_1.createImageData(layerWidth, layerHeight);
-        helpers_1.resetImageData(imageData);
+        if (cmyk) {
+            imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) };
+            for (var p = 4; p < imageData.data.byteLength; p += 5)
+                imageData.data[p] = 255;
+        }
+        else {
+            imageData = helpers_1.createImageData(layerWidth, layerHeight);
+            helpers_1.resetImageData(imageData);
+        }
     }
-    if (helpers_1.RAW_IMAGE_DATA) {
+    if (helpers_1.RAW_IMAGE_DATA)
         layer.imageDataRaw = [];
-    }
     for (var _i = 0, channels_1 = channels; _i < channels_1.length; _i++) {
         var channel = channels_1[_i];
         var compression = readUint16(reader);
@@ -5653,7 +5671,7 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
                 var maskData = helpers_1.createImageData(maskWidth, maskHeight);
                 helpers_1.resetImageData(maskData);
                 var start = reader.offset;
-                readData(reader, maskData, compression, maskWidth, maskHeight, 0, options.large);
+                readData(reader, maskData, compression, maskWidth, maskHeight, 0, options.large, 4);
                 if (helpers_1.RAW_IMAGE_DATA) {
                     layer.maskDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
                 }
@@ -5668,7 +5686,7 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
             }
         }
         else {
-            var offset = helpers_1.offsetForChannel(channel.id);
+            var offset = helpers_1.offsetForChannel(channel.id, cmyk);
             var targetData = imageData;
             if (offset < 0) {
                 targetData = undefined;
@@ -5677,7 +5695,7 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
                 }
             }
             var start = reader.offset;
-            readData(reader, targetData, compression, layerWidth, layerHeight, offset, options.large);
+            readData(reader, targetData, compression, layerWidth, layerHeight, offset, options.large, cmyk ? 5 : 4);
             if (helpers_1.RAW_IMAGE_DATA) {
                 layer.imageDataRaw[channel.id] = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
             }
@@ -5687,6 +5705,11 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
         }
     }
     if (imageData) {
+        if (cmyk) {
+            var cmykData = imageData;
+            imageData = helpers_1.createImageData(cmykData.width, cmykData.height);
+            cmykToRgb(cmykData, imageData, false);
+        }
         if (options.useImageData) {
             layer.imageData = imageData;
         }
@@ -5696,12 +5719,12 @@ function readLayerChannelImageData(reader, psd, layer, channels, options) {
         }
     }
 }
-function readData(reader, data, compression, width, height, offset, large) {
+function readData(reader, data, compression, width, height, offset, large, step) {
     if (compression === 0 /* RawData */) {
-        readDataRaw(reader, data, offset, width, height);
+        readDataRaw(reader, data, offset, width, height, step);
     }
     else if (compression === 1 /* RleCompressed */) {
-        readDataRLE(reader, data, width, height, 4, [offset], large);
+        readDataRLE(reader, data, width, height, step, [offset], large);
     }
     else {
         throw new Error("Compression type not supported: " + compression);
@@ -5758,46 +5781,78 @@ function readImageData(reader, psd, globalAlpha, options) {
         throw new Error("Compression type not supported: " + compression);
     var imageData = helpers_1.createImageData(psd.width, psd.height);
     helpers_1.resetImageData(imageData);
-    if (psd.colorMode === 0 /* Bitmap */) {
-        var bytes = void 0;
-        if (compression === 0 /* RawData */) {
-            bytes = readBytes(reader, Math.ceil(psd.width / 8) * psd.height);
-        }
-        else if (compression === 1 /* RleCompressed */) {
-            bytes = new Uint8Array(psd.width * psd.height);
-            readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, 1, [0], options.large);
-        }
-        else {
-            throw new Error("Bitmap compression not supported: " + compression);
-        }
-        helpers_1.decodeBitmap(bytes, imageData.data, psd.width, psd.height);
-    }
-    else {
-        var channels = psd.colorMode === 1 /* Grayscale */ ? [0] : [0, 1, 2];
-        if (psd.channels && psd.channels > 3) {
-            for (var i = 3; i < psd.channels; i++) {
-                // TODO: store these channels in additional image data
-                channels.push(i);
+    switch (psd.colorMode) {
+        case 0 /* Bitmap */: {
+            var bytes = void 0;
+            if (compression === 0 /* RawData */) {
+                bytes = readBytes(reader, Math.ceil(psd.width / 8) * psd.height);
             }
-        }
-        else if (globalAlpha) {
-            channels.push(3);
-        }
-        if (compression === 0 /* RawData */) {
-            for (var i = 0; i < channels.length; i++) {
-                readDataRaw(reader, imageData, channels[i], psd.width, psd.height);
+            else if (compression === 1 /* RleCompressed */) {
+                bytes = new Uint8Array(psd.width * psd.height);
+                readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, 1, [0], options.large);
+            }
+            else {
+                throw new Error("Bitmap compression not supported: " + compression);
             }
+            helpers_1.decodeBitmap(bytes, imageData.data, psd.width, psd.height);
+            break;
         }
-        else if (compression === 1 /* RleCompressed */) {
-            var start = reader.offset;
-            readDataRLE(reader, imageData, psd.width, psd.height, 4, channels, options.large);
-            if (helpers_1.RAW_IMAGE_DATA) {
-                psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+        case 3 /* RGB */:
+        case 1 /* Grayscale */: {
+            var channels = psd.colorMode === 1 /* Grayscale */ ? [0] : [0, 1, 2];
+            if (psd.channels && psd.channels > 3) {
+                for (var i = 3; i < psd.channels; i++) {
+                    // TODO: store these channels in additional image data
+                    channels.push(i);
+                }
+            }
+            else if (globalAlpha) {
+                channels.push(3);
             }
+            if (compression === 0 /* RawData */) {
+                for (var i = 0; i < channels.length; i++) {
+                    readDataRaw(reader, imageData, channels[i], psd.width, psd.height, 4);
+                }
+            }
+            else if (compression === 1 /* RleCompressed */) {
+                var start = reader.offset;
+                readDataRLE(reader, imageData, psd.width, psd.height, 4, channels, options.large);
+                if (helpers_1.RAW_IMAGE_DATA)
+                    psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+            }
+            if (psd.colorMode === 1 /* Grayscale */) {
+                setupGrayscale(imageData);
+            }
+            break;
         }
-        if (psd.colorMode === 1 /* Grayscale */) {
-            setupGrayscale(imageData);
+        case 4 /* CMYK */: {
+            if (psd.channels !== 4)
+                throw new Error("Invalid channel count");
+            var channels = [0, 1, 2, 3];
+            if (globalAlpha)
+                channels.push(4);
+            if (compression === 0 /* RawData */) {
+                throw new Error("Not implemented");
+                // TODO: ...
+                // for (let i = 0; i < channels.length; i++) {
+                // 	readDataRaw(reader, imageData, channels[i], psd.width, psd.height);
+                // }
+            }
+            else if (compression === 1 /* RleCompressed */) {
+                var cmykImageData = {
+                    width: imageData.width,
+                    height: imageData.height,
+                    data: new Uint8Array(imageData.width * imageData.height * 5),
+                };
+                var start = reader.offset;
+                readDataRLE(reader, cmykImageData, psd.width, psd.height, 5, channels, options.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);
+            }
+            break;
         }
+        default: throw new Error("Color mode not supported: " + psd.colorMode);
     }
     if (options.useImageData) {
         psd.imageData = imageData;
@@ -5807,12 +5862,37 @@ function readImageData(reader, psd, globalAlpha, options) {
         psd.canvas.getContext('2d').putImageData(imageData, 0, 0);
     }
 }
-function readDataRaw(reader, pixelData, offset, width, height) {
+function cmykToRgb(cmyk, rgb, reverseAlpha) {
+    var size = rgb.width * rgb.height * 4;
+    var srcData = cmyk.data;
+    var dstData = rgb.data;
+    for (var src = 0, dst = 0; dst < size; src += 5, dst += 4) {
+        var c = srcData[src];
+        var m = srcData[src + 1];
+        var y = srcData[src + 2];
+        var 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 readDataRaw(reader, pixelData, offset, width, height, step) {
     var size = width * height;
     var buffer = readBytes(reader, size);
-    if (pixelData && offset < 4) {
+    if (pixelData && offset < step) {
         var data = pixelData.data;
-        for (var i = 0, p = offset | 0; i < size; i++, p = (p + 4) | 0) {
+        for (var i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
             data[p] = buffer[i];
         }
     }
@@ -5836,9 +5916,10 @@ function readDataRLE(reader, pixelData, _width, height, step, offsets, large) {
             }
         }
     }
+    var extraLimit = (step - 1) | 0; // 3 for rgb, 4 for cmyk
     for (var c = 0, li = 0; c < offsets.length; c++) {
         var offset = offsets[c] | 0;
-        var extra = c > 3 || offset > 3;
+        var extra = c > extraLimit || offset > extraLimit;
         if (!data || extra) {
             for (var y = 0; y < height; y++, li++) {
                 skipBytes(reader, lengths[li]);
@@ -5951,11 +6032,22 @@ function readPattern(reader) {
     var x = readInt16(reader);
     var y = readInt16(reader);
     // we only support RGB and grayscale for now
-    if (colorMode !== 3 /* RGB */ && colorMode !== 1 /* Grayscale */)
-        throw new Error('Unsupported pattern color mode');
+    if (colorMode !== 3 /* RGB */ && colorMode !== 1 /* Grayscale */ && colorMode !== 2 /* Indexed */) {
+        throw new Error("Unsupported pattern color mode: " + colorMode);
+    }
     var name = readUnicodeString(reader);
     var id = readPascalString(reader, 1);
-    // TODO: index color table here (only for indexed color mode, not supported right now)
+    var palette = [];
+    if (colorMode === 2 /* Indexed */) {
+        for (var i = 0; i < 256; i++) {
+            palette.push({
+                r: readUint8(reader),
+                g: readUint8(reader),
+                b: readUint8(reader),
+            });
+        }
+        skipBytes(reader, 4); // no idea what this is
+    }
     // virtual memory array list
     var version2 = readUint32(reader);
     if (version2 !== 3)
@@ -5974,60 +6066,67 @@ function readPattern(reader) {
     }
     for (var i = 0, ch = 0; i < (channelsCount + 2); i++) {
         var has = readUint32(reader);
-        if (has) {
-            var length_2 = readUint32(reader);
-            var pixelDepth = readUint32(reader);
-            var ctop = readUint32(reader);
-            var cleft = readUint32(reader);
-            var cbottom = readUint32(reader);
-            var cright = readUint32(reader);
-            var pixelDepth2 = readUint16(reader);
-            var compressionMode = readUint8(reader); // 0 - raw, 1 - zip
-            var dataLength = length_2 - (4 + 16 + 2 + 1);
-            var cdata = readBytes(reader, dataLength);
-            if (pixelDepth !== 8 || pixelDepth2 !== 8)
-                throw new Error('16bit pixel depth not supported for palettes');
-            var w = cright - cleft;
-            var h = cbottom - ctop;
-            var ox = cleft - left;
-            var oy = ctop - top;
-            if (compressionMode === 0) {
-                if (colorMode === 3 /* RGB */ && ch < 3) {
-                    for (var y_1 = 0; y_1 < h; y_1++) {
-                        for (var x_1 = 0; x_1 < w; x_1++) {
-                            var src = x_1 + y_1 * w;
-                            var dst = (ox + x_1 + (y_1 + oy) * width) * 4;
-                            data[dst + ch] = cdata[src];
-                        }
+        if (!has)
+            continue;
+        var length_2 = readUint32(reader);
+        var pixelDepth = readUint32(reader);
+        var ctop = readUint32(reader);
+        var cleft = readUint32(reader);
+        var cbottom = readUint32(reader);
+        var cright = readUint32(reader);
+        var pixelDepth2 = readUint16(reader);
+        var compressionMode = readUint8(reader); // 0 - raw, 1 - zip
+        var dataLength = length_2 - (4 + 16 + 2 + 1);
+        var cdata = readBytes(reader, dataLength);
+        if (pixelDepth !== 8 || pixelDepth2 !== 8) {
+            throw new Error('16bit pixel depth not supported for patterns');
+        }
+        var w = cright - cleft;
+        var h = cbottom - ctop;
+        var ox = cleft - left;
+        var oy = ctop - top;
+        if (compressionMode === 0) {
+            if (colorMode === 3 /* RGB */ && ch < 3) {
+                for (var y_1 = 0; y_1 < h; y_1++) {
+                    for (var x_1 = 0; x_1 < w; x_1++) {
+                        var src = x_1 + y_1 * w;
+                        var dst = (ox + x_1 + (y_1 + oy) * width) * 4;
+                        data[dst + ch] = cdata[src];
                     }
                 }
-                if (colorMode === 1 /* Grayscale */ && ch < 1) {
-                    for (var y_2 = 0; y_2 < h; y_2++) {
-                        for (var x_2 = 0; x_2 < w; x_2++) {
-                            var src = x_2 + y_2 * w;
-                            var dst = (ox + x_2 + (y_2 + oy) * width) * 4;
-                            var value = cdata[src];
-                            data[dst + 0] = value;
-                            data[dst + 1] = value;
-                            data[dst + 2] = value;
-                        }
+            }
+            if (colorMode === 1 /* Grayscale */ && ch < 1) {
+                for (var y_2 = 0; y_2 < h; y_2++) {
+                    for (var x_2 = 0; x_2 < w; x_2++) {
+                        var src = x_2 + y_2 * w;
+                        var dst = (ox + x_2 + (y_2 + oy) * width) * 4;
+                        var value = cdata[src];
+                        data[dst + 0] = value;
+                        data[dst + 1] = value;
+                        data[dst + 2] = value;
                     }
                 }
             }
-            else if (compressionMode === 1) {
-                // console.log({ colorMode });
-                // require('fs').writeFileSync('zip.bin', Buffer.from(cdata));
-                // const data = require('zlib').inflateRawSync(cdata);
-                // const data = require('zlib').unzipSync(cdata);
-                // console.log(data);
-                // throw new Error('Zip compression not supported for palettes');
-                throw new Error('Unsupported palette compression mode');
+            if (colorMode === 2 /* Indexed */) {
+                // TODO:
+                throw new Error('Indexed pattern color mode not implemented');
             }
-            else {
-                throw new Error('Invalid palette compression mode');
-            }
-            ch++;
         }
+        else if (compressionMode === 1) {
+            // console.log({ colorMode });
+            // require('fs').writeFileSync('zip.bin', Buffer.from(cdata));
+            // const data = require('zlib').inflateRawSync(cdata);
+            // const data = require('zlib').unzipSync(cdata);
+            // console.log(data);
+            // throw new Error('Zip compression not supported for pattern');
+            // throw new Error('Unsupported pattern compression');
+            console.error('Unsupported pattern compression');
+            name += ' (failed to decode)';
+        }
+        else {
+            throw new Error('Invalid pattern compression mode');
+        }
+        ch++;
     }
     // TODO: use canvas instead of data ?
     return { id: id, name: name, x: x, y: y, bounds: { x: left, y: top, w: width, h: height }, data: data };
@@ -6227,7 +6326,7 @@ function writePsd(writer, psd, options) {
     writeUint32(writer, psd.height);
     writeUint32(writer, psd.width);
     writeUint16(writer, 8); // bits per channel
-    writeUint16(writer, 3 /* RGB */);
+    writeUint16(writer, 3 /* RGB */); // we only support saving RGB right now
     // color mode data
     writeSection(writer, 1, function () {
         // TODO: implement
@@ -6575,9 +6674,9 @@ function getLayerChannels(tempBuffer, layer, background, options) {
     var _b = layer.top, top = _b === void 0 ? 0 : _b, _c = layer.left, left = _c === void 0 ? 0 : _c, _d = layer.right, right = _d === void 0 ? 0 : _d, _e = layer.bottom, bottom = _e === void 0 ? 0 : _e;
     var channels = [
         { channelId: -1 /* Transparency */, compression: 0 /* RawData */, buffer: undefined, length: 2 },
-        { channelId: 0 /* Red */, compression: 0 /* RawData */, buffer: undefined, length: 2 },
-        { channelId: 1 /* Green */, compression: 0 /* RawData */, buffer: undefined, length: 2 },
-        { channelId: 2 /* Blue */, compression: 0 /* RawData */, buffer: undefined, length: 2 },
+        { channelId: 0 /* Color0 */, compression: 0 /* RawData */, buffer: undefined, length: 2 },
+        { channelId: 1 /* Color1 */, compression: 0 /* RawData */, buffer: undefined, length: 2 },
+        { channelId: 2 /* Color2 */, compression: 0 /* RawData */, buffer: undefined, length: 2 },
     ];
     var _f = getLayerDimentions(layer), width = _f.width, height = _f.height;
     if (!(layer.canvas || layer.imageData) || !width || !height) {
@@ -6609,15 +6708,15 @@ function getLayerChannels(tempBuffer, layer, background, options) {
         }
     }
     var channelIds = [
-        0 /* Red */,
-        1 /* Green */,
-        2 /* Blue */,
+        0 /* Color0 */,
+        1 /* Color1 */,
+        2 /* Color2 */,
     ];
     if (!background || options.noBackground || layer.mask || helpers_1.hasAlpha(data) || (helpers_1.RAW_IMAGE_DATA && ((_a = layer.imageDataRaw) === null || _a === void 0 ? void 0 : _a['-1']))) {
         channelIds.unshift(-1 /* Transparency */);
     }
     channels = channelIds.map(function (channel) {
-        var offset = helpers_1.offsetForChannel(channel);
+        var offset = helpers_1.offsetForChannel(channel, false); // TODO: psd.colorMode === ColorMode.CMYK);
         var buffer = helpers_1.writeDataRLE(tempBuffer, data, width, height, [offset], !!options.psb);
         if (helpers_1.RAW_IMAGE_DATA && layer.imageDataRaw) {
             // console.log('written raw layer image data');