ag-psd 14.3.1 → 14.3.5

package/dist/bundle.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readAbr = void 0;
 var descriptor_1 = require("./descriptor");
 var psdReader_1 = require("./psdReader");
-var dynamicsControl = ['off', 'fade', 'pen pressure', 'pen tilt', 'stylus sheel', 'initial direction', 'direction', 'initial rotation', 'rotation'];
+var dynamicsControl = ['off', 'fade', 'pen pressure', 'pen tilt', 'stylus wheel', 'initial direction', 'direction', 'initial rotation', 'rotation'];
 function parseDynamics(desc) {
     return {
         control: dynamicsControl[desc.bVTy],
@@ -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 };
 }
@@ -1041,6 +1041,9 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
         resolution: descriptor_1.parseUnits(desc.Rslt),
         warp: parseWarp((desc.quiltWarp || desc.warp)),
     };
+    if (desc.nonAffineTransform && desc.nonAffineTransform.some(function (x, i) { return x !== desc.Trnf[i]; })) {
+        target.placedLayer.nonAffineTransform = desc.nonAffineTransform;
+    }
     if (desc.Crop)
         target.placedLayer.crop = desc.Crop;
     if (desc.comp)
@@ -1049,7 +1052,7 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
         target.placedLayer.compInfo = desc.compInfo;
     psdReader_1.skipBytes(reader, left()); // HACK
 }, function (writer, target) {
-    var _a;
+    var _a, _b;
     psdWriter_1.writeSignature(writer, 'soLD');
     psdWriter_1.writeInt32(writer, 4); // version
     var placed = target.placedLayer;
@@ -1059,7 +1062,7 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
         }, duration: {
             numerator: 0,
             denominator: 600
-        }, frameCount: 1, Annt: 16, Type: placedLayerTypes.indexOf(placed.type), Trnf: placed.transform, nonAffineTransform: placed.transform, quiltWarp: {}, warp: encodeWarp(placed.warp || {}), 'Sz  ': {
+        }, frameCount: 1, Annt: 16, Type: placedLayerTypes.indexOf(placed.type), Trnf: placed.transform, nonAffineTransform: (_b = placed.nonAffineTransform) !== null && _b !== void 0 ? _b : placed.transform, quiltWarp: {}, warp: encodeWarp(placed.warp || {}), 'Sz  ': {
             Wdth: placed.width || 0,
             Hght: placed.height || 0, // TODO: find size ?
         }, Rslt: placed.resolution ? descriptor_1.unitsValue(placed.resolution, 'resolution') : { units: 'Density', value: 72 } });
@@ -3581,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',
@@ -4370,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";
@@ -4384,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;
     }
 }
@@ -4409,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;
     }
@@ -4989,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));
@@ -5267,7 +5278,7 @@ function setupGrayscale(data) {
 }
 function createReader(buffer, offset, length) {
     var view = new DataView(buffer, offset, length);
-    return { view: view, offset: 0 };
+    return { view: view, offset: 0, strict: false };
 }
 exports.createReader = createReader;
 function readUint8(reader) {
@@ -5480,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;
@@ -5629,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);
@@ -5650,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);
                 }
@@ -5665,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;
@@ -5674,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);
             }
@@ -5684,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;
         }
@@ -5693,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);
@@ -5755,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;
@@ -5804,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];
         }
     }
@@ -5833,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]);
@@ -5886,10 +5970,13 @@ function readSection(reader, round, func, skipEmpty, eightBytes) {
         return undefined;
     var end = reader.offset + length;
     var result = func(function () { return end - reader.offset; });
-    if (reader.offset > end)
+    if (reader.offset > end) {
         throw new Error('Exceeded section limits');
-    if (reader.offset !== end)
-        throw new Error("Unread section data: " + (end - reader.offset) + " bytes at 0x" + reader.offset.toString(16));
+    }
+    if (reader.offset !== end && reader.strict) {
+        // throw new Error(`Unread section data: ${end - reader.offset} bytes at 0x${reader.offset.toString(16)}`);
+        console.warn('Unread section data');
+    }
     while (end % round)
         end++;
     reader.offset = end;
@@ -5948,11 +6035,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)
@@ -5971,60 +6069,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');
-            }
-            else {
-                throw new Error('Invalid palette compression mode');
+            if (colorMode === 2 /* Indexed */) {
+                // TODO:
+                throw new Error('Indexed pattern color mode not implemented');
             }
-            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 };
@@ -6224,7 +6329,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
@@ -6572,9 +6677,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) {
@@ -6606,15 +6711,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');