ag-psd 14.2.0 → 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 };
 }
@@ -680,15 +680,6 @@ addHandler('lyid', hasKey('id'), function (reader, target) { return target.id =
     psdWriter_1.writeUint32(writer, id);
     options.layerIds.push(id);
 });
-// some kind of ID ? ignore
-addHandler('lsdk', function (target) { return target._lsdk !== undefined; }, function (reader, target) {
-    var id = psdReader_1.readInt32(reader);
-    if (helpers_1.MOCK_HANDLERS)
-        target._lsdk = id;
-}, function (writer, target) {
-    if (helpers_1.MOCK_HANDLERS)
-        psdWriter_1.writeInt32(writer, target._lsdk);
-});
 addHandler('lsct', hasKey('sectionDivider'), function (reader, target, left) {
     target.sectionDivider = { type: psdReader_1.readUint32(reader) };
     if (left()) {
@@ -710,6 +701,9 @@ addHandler('lsct', hasKey('sectionDivider'), function (reader, target, left) {
         }
     }
 });
+// it seems lsdk is used when there's a layer is nested more than 6 levels, but I don't know why?
+// maybe some limitation of old version of PS?
+addHandlerAlias('lsdk', 'lsct');
 addHandler('clbl', hasKey('blendClippendElements'), function (reader, target) {
     target.blendClippendElements = !!psdReader_1.readUint8(reader);
     psdReader_1.skipBytes(reader, 3);
@@ -1047,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)
@@ -1055,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;
@@ -1065,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 } });
@@ -2299,6 +2296,20 @@ addHandler('extn', function (target) { return target._extn !== undefined; }, fun
     if (helpers_1.MOCK_HANDLERS)
         descriptor_1.writeVersionAndDescriptor(writer, '', 'null', target._extn);
 });
+addHandler('iOpa', hasKey('fillOpacity'), function (reader, target) {
+    target.fillOpacity = psdReader_1.readUint8(reader) / 0xff;
+    psdReader_1.skipBytes(reader, 3);
+}, function (writer, target) {
+    psdWriter_1.writeUint8(writer, target.fillOpacity * 0xff);
+    psdWriter_1.writeZeros(writer, 3);
+});
+addHandler('tsly', hasKey('transparencyShapesLayer'), function (reader, target) {
+    target.transparencyShapesLayer = !!psdReader_1.readUint8(reader);
+    psdReader_1.skipBytes(reader, 3);
+}, function (writer, target) {
+    psdWriter_1.writeUint8(writer, target.transparencyShapesLayer ? 1 : 0);
+    psdWriter_1.writeZeros(writer, 3);
+});
 // descriptor helpers
 function parseGradient(grad) {
     if (grad.GrdF === 'GrdF.CstS') {
@@ -3573,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',
@@ -4100,7 +4115,7 @@ var floatKeys = [
     'Axis', 'XY', 'Zone', 'WordSpacing', 'FirstLineIndent', 'GlyphSpacing', 'StartIndent', 'EndIndent', 'SpaceBefore',
     'SpaceAfter', 'LetterSpacing', 'Values', 'GridSize', 'GridLeading', 'PointBase', 'BoxBounds', 'TransformPoint0', 'TransformPoint1',
     'TransformPoint2', 'FontSize', 'Leading', 'HorizontalScale', 'VerticalScale', 'BaselineShift', 'Tsume',
-    'OutlineWidth',
+    'OutlineWidth', 'AutoLeading',
 ];
 var intArrays = ['RunLengthArray'];
 // TODO: handle /nil
@@ -4362,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";
@@ -4376,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;
     }
 }
@@ -4401,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;
     }
@@ -4981,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));
@@ -5472,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;
@@ -5510,10 +5532,10 @@ function readLayerInfo(reader, psd, options) {
             }
             else if (type === 3 /* BoundingSectionDivider */) {
                 stack.pop();
-            }
-            else if (l.name === '</Layer group>' && !l.sectionDivider && !l.top && !l.left && !l.bottom && !l.right) {
-                // sometimes layer group terminator doesn't have sectionDivider, so we just guess here (PS bug ?)
-                stack.pop();
+                // this was workaround because I didn't know what `lsdk` section was, now it's probably not needed anymore
+                // } else if (l.name === '</Layer group>' && !l.sectionDivider && !l.top && !l.left && !l.bottom && !l.right) {
+                // 	// sometimes layer group terminator doesn't have sectionDivider, so we just guess here (PS bug ?)
+                // 	stack.pop();
             }
             else {
                 stack[stack.length - 1].children.unshift(l);
@@ -5621,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);
@@ -5642,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);
                 }
@@ -5657,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;
@@ -5666,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);
             }
@@ -5676,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;
         }
@@ -5685,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);
@@ -5734,7 +5768,7 @@ function readAdditionalLayerInfo(reader, target, psd, options) {
             skipBytes(reader, left());
         }
         if (left()) {
-            options.logMissingFeatures && console.log("Unread " + left() + " bytes left for tag: " + key);
+            options.logMissingFeatures && console.log("Unread " + left() + " bytes left for additional info: " + key);
             skipBytes(reader, left());
         }
     }, false, u64);
@@ -5747,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;
@@ -5796,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];
         }
     }
@@ -5825,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]);
@@ -5940,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)
@@ -5963,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');
-            }
-            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 };
@@ -6216,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
@@ -6564,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) {
@@ -6598,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');