ag-psd 33.0.0 → 34.0.0

package/dist/bundle.js

@@ -245,7 +245,7 @@ function readSampleBitmap(reader, brushEnd, id) {
     if (minDataSize > brushEnd - reader.offset) {
         throw new Error('Brush sample data out of bounds');
     }
-    (0, psdReader_1.consumeMemory)(reader, w * h * (compression === 1 && bithDepth === 16 ? 3 : 1));
+    (0, psdReader_1.consumeMemory)(reader, w * h * (bithDepth === 16 ? 3 : 1));
     const alpha = new Uint8Array(w * h);
     if (bithDepth === 8) {
         if (compression === 0) {
@@ -259,21 +259,26 @@ function readSampleBitmap(reader, brushEnd, id) {
         }
     }
     else if (bithDepth === 16) {
+        const data = new Uint16Array(w * h);
         if (compression === 0) {
-            for (let i = 0; i < alpha.byteLength; i++) {
-                alpha[i] = (0, psdReader_1.readUint16)(reader) >> 8; // convert to 8bit values
+            for (let i = 0; i < data.length; i++) {
+                data[i] = (0, psdReader_1.readUint16)(reader);
             }
         }
         else if (compression === 1) {
-            const data = new Uint16Array(w * h);
             (0, psdReader_1.readDataRLE)(reader, { width: w, height: h, data }, w, h, bithDepth, 1, [0], false);
-            for (let i = 0; i < alpha.byteLength; i++) {
-                alpha[i] = data[i] >> 8; // convert to 8bit values
-            }
         }
         else {
             throw new Error('Invalid compression');
         }
+        // Photoshop uses 0-32768 range for 16bit values internally, use full 0-65535 range only if there are values outside of it
+        let max = 0;
+        for (let i = 0; i < data.length; i++)
+            max = Math.max(max, data[i]);
+        const scale = max > 32768 ? 255 / 65535 : 255 / 32768;
+        for (let i = 0; i < alpha.byteLength; i++) {
+            alpha[i] = Math.round(data[i] * scale); // convert to 8bit values
+        }
     }
     else {
         throw new Error('Invalid depth');
@@ -494,7 +499,7 @@ function parseBrush(brush) {
     return b;
 }
 
-},{"./descriptor":4,"./psdReader":13}],2:[function(require,module,exports){
+},{"./descriptor":5,"./psdReader":14}],2:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.booleanOperations = exports.infoHandlersMap = exports.infoHandlers = void 0;
@@ -605,11 +610,77 @@ addHandler('TySh', hasKey('text'), (reader, target, leftBytes) => {
     (0, psdWriter_1.writeFloat32)(writer, (_d = text.bottom) !== null && _d !== void 0 ? _d : 0);
     // writeZeros(writer, 2);
 });
+// type tool info from Photoshop 5.0 and 5.5, converted to regular text data (written as 'TySh')
+addHandler('tySh', () => false, (reader, target, left) => {
+    if ((0, psdReader_1.readInt16)(reader) !== 1)
+        throw new Error(`Invalid tySh version`);
+    const transform = [];
+    for (let i = 0; i < 6; i++)
+        transform.push((0, psdReader_1.readFloat64)(reader));
+    if ((0, psdReader_1.readInt16)(reader) !== 6)
+        throw new Error(`Invalid tySh font version`);
+    const data = { transform, faces: [], styles: [], lines: [], color: { r: 0, g: 0, b: 0 }, antiAlias: false };
+    const facesCount = (0, psdReader_1.readInt16)(reader);
+    for (let i = 0; i < facesCount; i++) {
+        const mark = (0, psdReader_1.readInt16)(reader);
+        (0, psdReader_1.readInt32)(reader); // font type
+        const name = (0, psdReader_1.readPascalString)(reader, 1);
+        const familyName = (0, psdReader_1.readPascalString)(reader, 1);
+        const styleName = (0, psdReader_1.readPascalString)(reader, 1);
+        const script = (0, psdReader_1.readInt16)(reader);
+        const axesCount = (0, psdReader_1.readInt32)(reader);
+        if (axesCount < 0 || axesCount * 4 > left())
+            throw new Error(`Invalid tySh design axes count`);
+        (0, psdReader_1.skipBytes)(reader, axesCount * 4);
+        data.faces.push({ mark, name, familyName, styleName, script });
+    }
+    const stylesCount = (0, psdReader_1.readInt16)(reader);
+    for (let i = 0; i < stylesCount; i++) {
+        const mark = (0, psdReader_1.readInt16)(reader);
+        const faceMark = (0, psdReader_1.readInt16)(reader);
+        const size = (0, psdReader_1.readInt32)(reader);
+        const tracking = (0, psdReader_1.readInt32)(reader);
+        const kerning = (0, psdReader_1.readInt32)(reader);
+        const leading = (0, psdReader_1.readInt32)(reader);
+        const baselineShift = (0, psdReader_1.readInt32)(reader);
+        const autoKerning = !!(0, psdReader_1.readUint8)(reader);
+        (0, psdReader_1.readUint8)(reader); // rotate
+        data.styles.push({ mark, faceMark, size, tracking, kerning, leading, baselineShift, autoKerning });
+    }
+    (0, psdReader_1.readInt16)(reader); // type (0 = point, 1 = paragraph)
+    (0, psdReader_1.readInt32)(reader); // scaling factor
+    (0, psdReader_1.readInt32)(reader); // character count
+    (0, psdReader_1.readInt32)(reader); // horizontal placement
+    (0, psdReader_1.readInt32)(reader); // vertical placement
+    (0, psdReader_1.readInt32)(reader); // select start
+    (0, psdReader_1.readInt32)(reader); // select end
+    const linesCount = (0, psdReader_1.readInt16)(reader);
+    for (let i = 0; i < linesCount; i++) {
+        const charCount = (0, psdReader_1.readInt32)(reader);
+        const orientation = (0, psdReader_1.readInt16)(reader);
+        const alignment = (0, psdReader_1.readInt16)(reader);
+        if (charCount < 0 || charCount * 4 > left())
+            throw new Error(`Invalid tySh character count`);
+        const chars = [];
+        for (let j = 0; j < charCount; j++) {
+            const code = (0, psdReader_1.readUint16)(reader);
+            const style = (0, psdReader_1.readInt16)(reader);
+            chars.push({ code, style });
+        }
+        data.lines.push({ orientation, alignment, chars });
+    }
+    data.color = (0, psdReader_1.readColor)(reader);
+    data.antiAlias = !!(0, psdReader_1.readUint8)(reader);
+    if (!target.text)
+        target.text = (0, text_1.decodeLegacyTextData)(data);
+    (0, psdReader_1.skipBytes)(reader, left());
+}, () => { });
 // vector fills
 addHandler('SoCo', target => target.vectorFill !== undefined && target.vectorStroke === undefined &&
-    target.vectorFill.type === 'color', (reader, target) => {
+    target.vectorFill.type === 'color', (reader, target, left) => {
     const descriptor = (0, descriptor_1.readVersionAndDescriptor)(reader);
     target.vectorFill = (0, descriptor_1.parseVectorContent)(descriptor);
+    (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
     const { descriptor } = (0, descriptor_1.serializeVectorContent)(target.vectorFill);
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', descriptor);
@@ -898,10 +969,10 @@ addHandler('lmfx', target => target.effects !== undefined && !isGroupLayer(targe
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
     // console.log('READ', require('util').inspect(desc, false, 99, true));
     // discard if read in 'lrFX' or 'lfx2' section
-    target.effects = (0, descriptor_1.parseEffects)(desc, !!reader.logMissingFeatures);
+    target.effects = (0, descriptor_1.parseEffects)(desc, reader);
     (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target, _, options) => {
-    const desc = (0, descriptor_1.serializeEffects)(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target) => {
+    const desc = (0, descriptor_1.serializeEffects)(target.effects, writer, true);
     // console.log('WRITE', require('util').inspect(desc, false, 99, true));
     (0, psdWriter_1.writeUint32)(writer, 0); // version
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
@@ -1036,6 +1107,58 @@ addHandler('lmgm', hasKey('layerMaskAsGlobalMask'), (reader, target) => {
     (0, psdWriter_1.writeUint8)(writer, target.layerMaskAsGlobalMask ? 1 : 0);
     (0, psdWriter_1.writeZeros)(writer, 3);
 });
+addHandler('vmgm', hasKey('vectorMaskAsGlobalMask'), (reader, target) => {
+    target.vectorMaskAsGlobalMask = !!(0, psdReader_1.readUint8)(reader);
+    (0, psdReader_1.skipBytes)(reader, 3);
+}, (writer, target) => {
+    (0, psdWriter_1.writeUint8)(writer, target.vectorMaskAsGlobalMask ? 1 : 0);
+    (0, psdWriter_1.writeZeros)(writer, 3);
+});
+addHandler('ffxi', hasKey('foreignEffectId'), (reader, target) => {
+    target.foreignEffectId = (0, psdReader_1.readInt32)(reader);
+}, (writer, target) => {
+    (0, psdWriter_1.writeInt32)(writer, target.foreignEffectId);
+});
+addHandler('shpa', hasKey('patternData'), (reader, target, left) => {
+    if ((0, psdReader_1.readInt32)(reader) !== 0)
+        throw new Error(`Invalid shpa version`);
+    const count = (0, psdReader_1.readInt32)(reader);
+    target.patternData = [];
+    for (let i = 0; i < count && left() > 0; i++) {
+        const signature = (0, psdReader_1.readSignature)(reader);
+        const key = (0, psdReader_1.readSignature)(reader);
+        const patternsCount = (0, psdReader_1.readInt32)(reader);
+        const copyOnSheetDuplication = !!(0, psdReader_1.readUint8)(reader);
+        (0, psdReader_1.skipBytes)(reader, 3);
+        const patterns = [];
+        for (let j = 0; j < patternsCount && left() > 0; j++) {
+            const colorHandling = descriptor_1.patternColorHandling.decode('.' + (0, psdReader_1.readSignature)(reader));
+            (0, psdReader_1.readPascalString)(reader, 1); // name
+            const name = (0, psdReader_1.readUnicodeString)(reader);
+            const id = (0, psdReader_1.readPascalString)(reader, 1);
+            patterns.push({ colorHandling, name, id });
+        }
+        target.patternData.push({ signature, key, copyOnSheetDuplication, patterns });
+    }
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target) => {
+    const sets = target.patternData;
+    (0, psdWriter_1.writeInt32)(writer, 0); // version
+    (0, psdWriter_1.writeInt32)(writer, sets.length);
+    for (const set of sets) {
+        (0, psdWriter_1.writeSignature)(writer, set.signature);
+        (0, psdWriter_1.writeSignature)(writer, set.key);
+        (0, psdWriter_1.writeInt32)(writer, set.patterns.length);
+        (0, psdWriter_1.writeUint8)(writer, set.copyOnSheetDuplication ? 1 : 0);
+        (0, psdWriter_1.writeZeros)(writer, 3);
+        for (const pattern of set.patterns) {
+            (0, psdWriter_1.writeSignature)(writer, descriptor_1.patternColorHandling.encode(pattern.colorHandling).split('.')[1]);
+            (0, psdWriter_1.writePascalString)(writer, pattern.name.replace(/[^\x20-\x7e]/g, '?'), 1);
+            (0, psdWriter_1.writeUnicodeString)(writer, pattern.name);
+            (0, psdWriter_1.writePascalString)(writer, pattern.id, 1);
+        }
+    }
+});
 addHandler('lspf', hasKey('protected'), (reader, target) => {
     const flags = (0, psdReader_1.readUint32)(reader);
     target.protected = {
@@ -1140,7 +1263,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
                         if (f.FXRf)
                             frame.referencePoint = (0, descriptor_1.horzVrtcToXY)(f.FXRf);
                         if (f.Lefx)
-                            frame.effects = (0, descriptor_1.parseEffects)(f.Lefx, !!reader.logMissingFeatures);
+                            frame.effects = (0, descriptor_1.parseEffects)(f.Lefx, reader);
                         if (f.blendOptions && f.blendOptions.Opct)
                             frame.opacity = (0, descriptor_1.parsePercent)(f.blendOptions.Opct);
                         target.animationFrames.push(frame);
@@ -1171,7 +1294,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
                         audioLevel: desc.audioLevel,
                     };
                     if (desc.trackList) {
-                        timeline.tracks = (0, descriptor_1.parseTrackList)(desc.trackList, !!reader.logMissingFeatures);
+                        timeline.tracks = (0, descriptor_1.parseTrackList)(desc.trackList, reader);
                     }
                     target.timeline = timeline;
                     // console.log('tmln:result', target.name, target.id, require('util').inspect(timeline, false, 99, true));
@@ -1253,7 +1376,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
                 if (f.referencePoint)
                     frame.FXRf = (0, descriptor_1.xyToHorzVrtc)(f.referencePoint);
                 if (f.effects)
-                    frame.Lefx = (0, descriptor_1.serializeEffects)(f.effects, false, hasMultiEffects(f.effects));
+                    frame.Lefx = (0, descriptor_1.serializeEffects)(f.effects, writer, hasMultiEffects(f.effects));
                 if (f.opacity !== undefined)
                     frame.blendOptions = { Opct: (0, descriptor_1.unitsPercentF)(f.opacity) };
                 desc.LaSt.push(frame);
@@ -1293,7 +1416,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
                 audioLevel: timeline.audioLevel,
             };
             if (timeline.tracks) {
-                desc.trackList = (0, descriptor_1.serializeTrackList)(timeline.tracks);
+                desc.trackList = (0, descriptor_1.serializeTrackList)(timeline.tracks, writer);
             }
             desc.LyrI = getLayerId(target, options);
             // console.log('WRITE:tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
@@ -1672,6 +1795,86 @@ function pointToHrznVrtc(point) {
         Vrtc: (0, descriptor_1.unitsValue)(point.y, 'y'),
     };
 }
+// Camera Raw Filter setting paths (in CameraRawFilterSettings) and their descriptor keys
+const cameraRawColorKeys = [
+    ['red', 'R'], ['orange', 'O'], ['yellow', 'Y'], ['green', 'G'], ['aqua', 'A'], ['blue', 'B'], ['purple', 'P'], ['magenta', 'M'],
+];
+const cameraRawSettings = [
+    ['version', 'CrVe'], ['processVersion', 'PrVN'], ['processVersionCode', 'PrVe'], ['whiteBalance', 'WBal'],
+    ['temperature', 'Temp'], ['tint', 'Tint'], ['exposure', 'Ex12'], ['contrast', 'Cr12'], ['highlights', 'Hi12'],
+    ['shadows', 'Sh12'], ['whites', 'Wh12'], ['blacks', 'Bk12'], ['texture', 'CrTx'], ['clarity', 'Cl12'],
+    ['dehaze', 'Dhze'], ['vibrance', 'Vibr'], ['saturation', 'Strt'],
+    ['parametricCurve.shadows', 'PC_S'], ['parametricCurve.darks', 'PC_D'], ['parametricCurve.lights', 'PC_L'],
+    ['parametricCurve.highlights', 'PC_H'], ['parametricCurve.shadowSplit', 'PC_1'], ['parametricCurve.midtoneSplit', 'PC_2'],
+    ['parametricCurve.highlightSplit', 'PC_3'],
+    ['pointCurve.composite', 'Crv '], ['pointCurve.red', 'CrvR'], ['pointCurve.green', 'CrvG'], ['pointCurve.blue', 'CrvB'],
+    ...cameraRawColorKeys.map(([name, key]) => [`hsl.hue.${name}`, `HA_${key}`]),
+    ...cameraRawColorKeys.map(([name, key]) => [`hsl.saturation.${name}`, `SA_${key}`]),
+    ...cameraRawColorKeys.map(([name, key]) => [`hsl.luminance.${name}`, `LA_${key}`]),
+    ['colorGrading.shadows.hue', 'STSH'], ['colorGrading.shadows.saturation', 'STSS'], ['colorGrading.shadows.luminance', 'CgSL'],
+    ['colorGrading.midtones.hue', 'CgMH'], ['colorGrading.midtones.saturation', 'CgMS'], ['colorGrading.midtones.luminance', 'CgML'],
+    ['colorGrading.highlights.hue', 'STHH'], ['colorGrading.highlights.saturation', 'STHS'], ['colorGrading.highlights.luminance', 'CgHL'],
+    ['colorGrading.global.hue', 'CgGH'], ['colorGrading.global.saturation', 'CgGS'], ['colorGrading.global.luminance', 'CgGL'],
+    ['colorGrading.blending', 'CgBl'], ['colorGrading.balance', 'STB '],
+    ['sharpening.amount', 'Shrp'], ['sharpening.radius', 'ShpR'], ['sharpening.detail', 'ShpD'], ['sharpening.masking', 'ShpM'],
+    ['noiseReduction.luminance', 'LNR '], ['noiseReduction.luminanceDetail', 'LNRD'], ['noiseReduction.luminanceContrast', 'LNRC'],
+    ['noiseReduction.color', 'CNR '], ['noiseReduction.colorDetail', 'CNRD'], ['noiseReduction.colorSmoothness', 'CNRS'],
+    ['grain.amount', 'GRNA'], ['grain.size', 'GRNS'], ['grain.roughness', 'GRNF'],
+    ['postCropVignette.amount', 'PCVA'], ['postCropVignette.midpoint', 'PCVM'], ['postCropVignette.feather', 'PCVF'],
+    ['postCropVignette.roundness', 'PCVR'],
+];
+const cameraRawCurveKeys = ['Crv ', 'CrvR', 'CrvG', 'CrvB'];
+const cameraRawFilterID = 2783;
+function parseCameraRawSettings(desc, reader) {
+    var _a;
+    const settings = {};
+    for (const [path, key] of cameraRawSettings) {
+        let value = desc[key];
+        if (value === undefined)
+            continue;
+        if (key === 'WBal') {
+            value = value.split('.')[1];
+        }
+        else if (cameraRawCurveKeys.includes(key)) {
+            const values = value;
+            value = [];
+            for (let i = 0; i + 1 < values.length; i += 2)
+                value.push({ input: values[i], output: values[i + 1] });
+        }
+        const parts = path.split('.');
+        let target = settings;
+        for (let i = 0; i < parts.length - 1; i++)
+            target = target[parts[i]] = (_a = target[parts[i]]) !== null && _a !== void 0 ? _a : {};
+        target[parts[parts.length - 1]] = value;
+    }
+    for (const key of Object.keys(desc)) {
+        if (key !== '_name' && key !== '_classID' && !cameraRawSettings.some(s => s[1] === key)) {
+            reader.logMissingFeatures && reader.log(`Unhandled Camera Raw Filter setting: ${key}`);
+        }
+    }
+    return settings;
+}
+function serializeCameraRawSettings(settings) {
+    const desc = { _name: '', _classID: descriptor_1.cameraRawFilterClassID };
+    for (const [path, key] of cameraRawSettings) {
+        let value = settings;
+        for (const part of path.split('.'))
+            value = value === null || value === void 0 ? void 0 : value[part];
+        if (value === undefined)
+            continue;
+        if (key === 'WBal') {
+            value = `WBal.${value}`;
+        }
+        else if (cameraRawCurveKeys.includes(key)) {
+            value = value.flatMap(p => [Math.round(p.input), Math.round(p.output)]);
+        }
+        else if (typeof value === 'number' && key !== 'Ex12' && key !== 'ShpR') {
+            value = Math.round(value);
+        }
+        desc[key] = value;
+    }
+    return desc;
+}
 function parseFilterFXItem(f, reader) {
     const base = {
         name: f['Nm  '],
@@ -1682,6 +1885,9 @@ function parseFilterFXItem(f, reader) {
         foregroundColor: (0, descriptor_1.parseColor)(f.FrgC),
         backgroundColor: (0, descriptor_1.parseColor)(f.BckC),
     };
+    if ('Fltr' in f && f.Fltr._classID === descriptor_1.cameraRawFilterClassID) {
+        return Object.assign(Object.assign({}, base), { type: 'camera raw', filter: parseCameraRawSettings(f.Fltr, reader) });
+    }
     if ('Fltr' in f) {
         switch (f.Fltr._classID) {
             case 'boxblur': return Object.assign(Object.assign({}, base), { type: 'box blur', filter: {
@@ -2580,6 +2786,7 @@ function serializeFilterFXItem(f) {
                     return adjustment;
                 }),
             } : {})), filterID: 1282829427 });
+        case 'camera raw': return Object.assign(Object.assign({}, base), { Fltr: serializeCameraRawSettings(f.filter), filterID: cameraRawFilterID });
         case 'brightness/contrast': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Brightness/Contrast',
                 _classID: 'BrgC',
@@ -2805,31 +3012,23 @@ addHandler('LMsk', hasKey('userMask'), (reader, target) => {
     (0, psdWriter_1.writeUint8)(writer, 128);
     (0, psdWriter_1.writeZeros)(writer, 1);
 });
-if (helpers_1.MOCK_HANDLERS) {
-    addHandler('Patt', target => target._Patt !== undefined, (reader, target, left) => {
-        // console.log('additional info: Patt');
-        target._Patt = (0, psdReader_1.readBytes)(reader, left());
-    }, (writer, target) => false && (0, psdWriter_1.writeBytes)(writer, target._Patt));
-}
-else {
-    addHandler('Patt', // 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
-    // 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
-    target => !!(target.patterns && target.patterns.length > 0), (reader, target, left) => {
-        while (left() > 0) {
-            const pattern = (0, psdReader_1.readPatternSafe)(reader);
-            if (!pattern)
-                continue;
-            if (target.patterns === undefined)
-                target.patterns = [];
-            target.patterns.push(pattern);
-        }
-    }, (writer, target, _, _options) => {
-        const patterns = target.patterns || [];
-        for (const pattern of patterns) {
-            (0, psdWriter_1.writePattern)(writer, pattern);
-        }
-    });
-}
+addHandler('Patt', // 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
+// 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
+target => !!(target.patterns && target.patterns.length > 0), (reader, target, left) => {
+    while (left() > 0) {
+        const pattern = (0, psdReader_1.readPatternSafe)(reader);
+        if (!pattern)
+            continue;
+        if (target.patterns === undefined)
+            target.patterns = [];
+        target.patterns.push(pattern);
+    }
+}, (writer, target, _, _options) => {
+    const patterns = target.patterns || [];
+    for (const pattern of patterns) {
+        (0, psdWriter_1.writePattern)(writer, pattern);
+    }
+});
 addHandlerAlias('Pat2', 'Patt');
 addHandlerAlias('Pat3', 'Patt');
 /*
@@ -3221,10 +3420,10 @@ target => target.effects !== undefined && isGroupLayer(target), (reader, target,
     if (version !== 0)
         throw new Error(`Invalid lfxs version`);
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-    target.effects = (0, descriptor_1.parseEffects)(desc, !!reader.logMissingFeatures);
+    target.effects = (0, descriptor_1.parseEffects)(desc, reader);
     (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target, _, options) => {
-    const desc = (0, descriptor_1.serializeEffects)(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target) => {
+    const desc = (0, descriptor_1.serializeEffects)(target.effects, writer, true);
     (0, psdWriter_1.writeUint32)(writer, 0); // version
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
 });
@@ -3279,11 +3478,19 @@ addHandler('levl', adjustmentType('levels'), (reader, target, left) => {
         channels.push(readLevelsChannel(reader));
     }
     if (left() >= 8) {
-        if ((0, psdReader_1.readSignature)(reader) !== 'Lvls')
-            throw new Error(`Invalid levl signature`);
-        if ((0, psdReader_1.readUint16)(reader) !== 3)
-            throw new Error(`Invalid levl version`);
-        const totalChannelRecords = (0, psdReader_1.readUint16)(reader);
+        const signature = (0, psdReader_1.readSignature)(reader);
+        let totalChannelRecords;
+        if (signature === 'ls\x00\x03') {
+            // Clip Studio Paint writes 'ls' instead of 'Lvls' signature (version is part of the read signature)
+            totalChannelRecords = (0, psdReader_1.readUint16)(reader);
+        }
+        else {
+            if (signature !== 'Lvls')
+                throw new Error(`Invalid levl signature`);
+            if ((0, psdReader_1.readUint16)(reader) !== 3)
+                throw new Error(`Invalid levl version`);
+            totalChannelRecords = (0, psdReader_1.readUint16)(reader);
+        }
         while (channels.length < totalChannelRecords && left() >= 10) {
             channels.push(readLevelsChannel(reader));
         }
@@ -3324,58 +3531,78 @@ function writeCurveChannel(writer, channel) {
     }
 }
 addHandler('curv', adjustmentType('curves'), (reader, target, left) => {
-    (0, psdReader_1.readUint8)(reader);
-    if ((0, psdReader_1.readUint16)(reader) !== 1)
+    const isMap = !!(0, psdReader_1.readUint8)(reader); // curves drawn with pencil tool (lookup tables instead of points)
+    const version = (0, psdReader_1.readUint16)(reader);
+    if (version !== 1 && version !== 4)
         throw new Error('Invalid curv version');
-    (0, psdReader_1.readUint16)(reader);
-    const channelsMask = (0, psdReader_1.readUint16)(reader);
+    const countOrMask = (0, psdReader_1.readUint32)(reader);
     const channels = [];
-    for (let i = 0; i < 16; i++) {
-        if (channelsMask & (1 << i)) {
-            while (channels.length < i)
+    const readChannel = () => isMap ? Array.from((0, psdReader_1.readBytes)(reader, 256)) : readCurveChannel(reader);
+    if (version === 1) {
+        for (let i = 0; i < 32; i++) {
+            if (countOrMask & (1 << i)) {
+                while (channels.length < i)
+                    channels.push([]);
+                channels.push(readChannel());
+            }
+        }
+    }
+    else {
+        if (countOrMask > 64)
+            throw new Error('Invalid curv channel count');
+        for (let i = 0; i < countOrMask; i++)
+            channels.push(readChannel());
+    }
+    // extra section stores curves for all channels (including ones that don't fit in the mask)
+    if (version === 1 && left() >= 10 && (0, psdReader_1.readSignature)(reader) === 'Crv ') {
+        (0, psdReader_1.readUint16)(reader); // version
+        const count = (0, psdReader_1.readUint32)(reader);
+        for (let i = 0; i < count && left() >= 2; i++) {
+            const index = (0, psdReader_1.readUint16)(reader);
+            const channel = readChannel();
+            while (channels.length < index)
                 channels.push([]);
-            channels.push(readCurveChannel(reader));
-        }
-    }
-    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'curves', channels });
-    // ignoring, duplicate information
-    // checkSignature(reader, 'Crv ');
-    // const cVersion = readUint16(reader);
-    // readUint16(reader);
-    // const channelCount = readUint16(reader);
-    // for (let i = 0; i < channelCount; i++) {
-    // 	const index = readUint16(reader);
-    // 	const nodes = readUint16(reader);
-    // 	for (let j = 0; j < nodes; j++) {
-    // 		const output = readInt16(reader);
-    // 		const input = readInt16(reader);
-    // 	}
-    // }
+            channels[index] = channel;
+        }
+    }
+    target.adjustment = Object.assign(Object.assign(Object.assign({}, target.adjustment), { type: 'curves' }), (isMap ? { values: channels } : { channels: channels }));
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
     var _a;
-    const channels = (target.adjustment.channels || []).slice(0, 16);
+    const adjustment = target.adjustment;
+    const isMap = !!adjustment.values;
+    const channels = (isMap ? adjustment.values : adjustment.channels) || [];
     const used = [];
     let channelsMask = 0;
     for (let i = 0; i < channels.length; i++) {
         if ((_a = channels[i]) === null || _a === void 0 ? void 0 : _a.length) {
-            channelsMask |= 1 << i;
+            if (i < 32)
+                channelsMask |= 1 << i;
             used.push(i);
         }
     }
-    (0, psdWriter_1.writeUint8)(writer, 0);
+    const writeChannel = (channel) => {
+        var _a;
+        if (isMap) {
+            for (let i = 0; i < 256; i++)
+                (0, psdWriter_1.writeUint8)(writer, (0, helpers_1.clamp)(Math.round((_a = channel[i]) !== null && _a !== void 0 ? _a : i), 0, 255));
+        }
+        else {
+            writeCurveChannel(writer, channel);
+        }
+    };
+    (0, psdWriter_1.writeUint8)(writer, isMap ? 1 : 0);
     (0, psdWriter_1.writeUint16)(writer, 1); // version
-    (0, psdWriter_1.writeUint16)(writer, 0);
-    (0, psdWriter_1.writeUint16)(writer, channelsMask);
+    (0, psdWriter_1.writeUint32)(writer, channelsMask >>> 0);
     for (const i of used)
-        writeCurveChannel(writer, channels[i]);
+        if (i < 32)
+            writeChannel(channels[i]);
     (0, psdWriter_1.writeSignature)(writer, 'Crv ');
     (0, psdWriter_1.writeUint16)(writer, 4); // version
-    (0, psdWriter_1.writeUint16)(writer, 0);
-    (0, psdWriter_1.writeUint16)(writer, used.length);
+    (0, psdWriter_1.writeUint32)(writer, used.length);
     for (const i of used) {
         (0, psdWriter_1.writeUint16)(writer, i);
-        writeCurveChannel(writer, channels[i]);
+        writeChannel(channels[i]);
     }
 });
 addHandler('expA', adjustmentType('exposure'), (reader, target, left) => {
@@ -4087,6 +4314,10 @@ addHandler('FEid', hasKey('filterEffectsMasks'), (reader, target, leftBytes) =>
     }
 });
 addHandlerAlias('FXid', 'FEid');
+addHandlerAlias('FELS', 'FEid'); // filter effects 3
+addHandlerAlias('hue ', 'hue2'); // old hue/saturation (Photoshop 4.0), same structure as 'hue2'
+addHandlerAlias('plLd', 'PlLd'); // old placed layer key
+addHandlerAlias('abdd', 'artb'); // artboard data 3
 addHandler('FMsk', hasKey('filterMask'), (reader, target) => {
     target.filterMask = {
         colorSpace: (0, psdReader_1.readColor)(reader),
@@ -4147,10 +4378,10 @@ addHandler('lfx2', target => target.effects !== undefined && !isGroupLayer(targe
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
     // console.log('READ', require('util').inspect(desc, false, 99, true));
     // discard if read in 'lrFX' section ('lmfx' and 'lfx2' are never stored together)
-    target.effects = (0, descriptor_1.parseEffects)(desc, !!reader.logMissingFeatures);
+    target.effects = (0, descriptor_1.parseEffects)(desc, reader);
     (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target, _, options) => {
-    const desc = (0, descriptor_1.serializeEffects)(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target) => {
+    const desc = (0, descriptor_1.serializeEffects)(target.effects, writer, true);
     // console.log('WRITE', require('util').inspect(desc, false, 99, true));
     (0, psdWriter_1.writeUint32)(writer, 0); // version
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
@@ -4212,6 +4443,66 @@ addHandler('extn', target => target.generatorSettings !== undefined && isDocumen
 }, (writer, target) => {
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', serializeGeneratorSettings(target.generatorSettings));
 });
+// generator settings stored by older versions of Photoshop (written back in 'shmd' or 'extn' section)
+addHandler('extd', () => false, (reader, target, left) => {
+    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+    if (desc.generatorSettings && target.generatorSettings === undefined) {
+        target.generatorSettings = parseGeneratorSettings(desc.generatorSettings);
+    }
+    (0, psdReader_1.skipBytes)(reader, left());
+}, () => { });
+addHandler('frgb', // frame tool group
+hasKey('framedGroup'), (reader, target, left) => {
+    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+    const rect = desc.framedGroupRect;
+    target.framedGroup = {
+        rect: { top: rect['Top '], left: rect.Left, bottom: rect.Btom, right: rect.Rght },
+        type: desc.framedGroupType,
+    };
+    if (desc.LockPPI !== undefined)
+        target.framedGroup.lockPPI = desc.LockPPI;
+    if (desc.PreferredResolution !== undefined)
+        target.framedGroup.preferredResolution = desc.PreferredResolution;
+    if (desc.SavedIteratedName !== undefined)
+        target.framedGroup.savedIteratedName = desc.SavedIteratedName;
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target) => {
+    const group = target.framedGroup;
+    const rect = group.rect;
+    const desc = {
+        framedGroupRect: { _name: '', _classID: 'classFloatRect', 'Top ': rect.top, Left: rect.left, Btom: rect.bottom, Rght: rect.right },
+        framedGroupType: group.type,
+    };
+    if (group.lockPPI !== undefined)
+        desc.LockPPI = group.lockPPI;
+    if (group.preferredResolution !== undefined)
+        desc.PreferredResolution = group.preferredResolution;
+    if (group.savedIteratedName !== undefined)
+        desc.SavedIteratedName = group.savedIteratedName;
+    (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'framedGroup', desc);
+});
+addHandler('anFX', hasKey('animationEffects'), (reader, target, left) => {
+    target.animationEffects = (0, psdReader_1.readBytes)(reader, left());
+}, (writer, target) => {
+    (0, psdWriter_1.writeBytes)(writer, target.animationEffects);
+});
+addHandler('PxSD', // pixel source data 2 (video layer frames)
+hasKey('pixelSourceData'), (reader, target, left) => {
+    target.pixelSourceData = [];
+    while (left() >= 8) {
+        const length = readLength64(reader);
+        if (length > left())
+            throw new Error('Invalid PxSD data length');
+        target.pixelSourceData.push((0, psdReader_1.readBytes)(reader, length));
+    }
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target) => {
+    for (const data of target.pixelSourceData) {
+        (0, psdWriter_1.writeUint32)(writer, 0);
+        (0, psdWriter_1.writeUint32)(writer, data.byteLength);
+        (0, psdWriter_1.writeBytes)(writer, data);
+    }
+});
 addHandler('iOpa', hasKey('fillOpacity'), (reader, target) => {
     target.fillOpacity = (0, psdReader_1.readUint8)(reader) / 0xff;
     (0, psdReader_1.skipBytes)(reader, 3);
@@ -4237,7 +4528,92 @@ addHandler('tsly', hasKey('transparencyShapesLayer'), (reader, target) => {
     (0, psdWriter_1.writeZeros)(writer, 3);
 });
 
-},{"./descriptor":4,"./effectsHelpers":5,"./engineData":6,"./engineData2":7,"./helpers":8,"./psdReader":13,"./psdWriter":14,"./text":15,"base64-js":17}],3:[function(require,module,exports){
+},{"./descriptor":5,"./effectsHelpers":6,"./engineData":7,"./engineData2":8,"./helpers":9,"./psdReader":14,"./psdWriter":15,"./text":16,"base64-js":18}],3:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAse = readAse;
+const psdReader_1 = require("./psdReader");
+function readAse(buffer, options = {}) {
+    const reader = (0, psdReader_1.createReader)(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const signature = (0, psdReader_1.readSignature)(reader); // ASEF
+    if (signature !== 'ASEF')
+        throw new Error('Invalid signature');
+    const versionMajor = (0, psdReader_1.readUint16)(reader); // 1
+    (0, psdReader_1.readUint16)(reader); // minor version: 0
+    if (versionMajor !== 1)
+        throw new Error('Invalid version');
+    const blocksCount = (0, psdReader_1.readUint32)(reader);
+    const ase = { colors: [] };
+    let group = ase;
+    for (let i = 0; i < blocksCount && reader.offset + 6 <= reader.view.byteLength; i++) {
+        const type = (0, psdReader_1.readUint16)(reader);
+        const length = (0, psdReader_1.readUint32)(reader);
+        const end = Math.min(reader.offset + length, reader.view.byteLength);
+        // block reader, so invalid lengths can't make us read data of following blocks
+        const block = (0, psdReader_1.createReader)(reader.view.buffer, reader.view.byteOffset + reader.offset, end - reader.offset);
+        try {
+            switch (type) {
+                case 0x0001: { // color
+                    const color = readAseColor(block);
+                    if (color) {
+                        group.colors.push(color);
+                    }
+                    else {
+                        if (options.throwForMissingFeatures)
+                            throw new Error('Unsupported color mode');
+                        options.logMissingFeatures && reader.log('Skipped color with unsupported color mode');
+                    }
+                    break;
+                }
+                case 0xC001: { // group start
+                    const nameLength = (0, psdReader_1.readUint16)(block);
+                    const name = (0, psdReader_1.readUnicodeStringWithLength)(block, nameLength);
+                    ase.colors.push(group = { name, colors: [] });
+                    break;
+                }
+                case 0xC002: // group end
+                    group = ase;
+                    break;
+                default:
+                    if (options.throwForMissingFeatures)
+                        throw new Error(`Invalid block type: ${type}`);
+                    options.logMissingFeatures && reader.log(`Skipped unknown block type: ${type}`);
+            }
+        }
+        catch (e) {
+            if (options.throwForMissingFeatures)
+                throw e;
+            options.logMissingFeatures && reader.log(`Skipped invalid block: ${e.message}`);
+        }
+        reader.offset = end;
+    }
+    return ase;
+}
+function readAseColor(reader) {
+    const nameLength = (0, psdReader_1.readUint16)(reader);
+    const name = (0, psdReader_1.readUnicodeStringWithLength)(reader, nameLength);
+    const colorMode = (0, psdReader_1.readSignature)(reader);
+    // NaN and infinite values are replaced with 0
+    const value = () => {
+        const v = (0, psdReader_1.readFloat32)(reader);
+        return isFinite(v) ? v : 0;
+    };
+    // color type is sometimes missing, unknown types are treated as process (normal) colors
+    const colorType = () => {
+        const index = reader.offset + 2 <= reader.view.byteLength ? (0, psdReader_1.readUint16)(reader) : 2;
+        return colorTypes[index] || 'normal';
+    };
+    switch (colorMode) {
+        case 'RGB ': return { name, color: { r: value(), g: value(), b: value(), type: colorType() } };
+        case 'CMYK': return { name, color: { c: value(), m: value(), y: value(), k: value(), type: colorType() } };
+        case 'Gray': return { name, color: { k: value(), type: colorType() } };
+        case 'LAB ': return { name, color: { l: value(), a: value(), b: value(), type: colorType() } };
+        default: return undefined;
+    }
+}
+const colorTypes = ['global', 'spot', 'normal'];
+
+},{"./psdReader":14}],4:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readCsh = readCsh;
@@ -4274,7 +4650,7 @@ function readCsh(buffer) {
     return csh;
 }
 
-},{"./additionalInfo":2,"./psdReader":13}],4:[function(require,module,exports){
+},{"./additionalInfo":2,"./psdReader":14}],5:[function(require,module,exports){
 "use strict";
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
@@ -4288,9 +4664,8 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Drct = exports.WndM = exports.CntE = exports.FlCl = exports.ExtR = exports.ExtT = exports.DfsM = exports.blurType = exports.Lns = exports.MztT = exports.Chnl = exports.Dstr = exports.ZZTy = exports.Wvtp = exports.SphM = exports.RplS = exports.Cnvr = exports.UndA = exports.DspM = exports.SmBQ = exports.SmBM = exports.BlrQ = exports.BlrM = exports.strokeStyleLineAlignment = exports.strokeStyleLineJoinType = exports.strokeStyleLineCapType = exports.ESliceBGColorType = exports.ESliceOrigin = exports.ESliceVertAlign = exports.ESliceHorzAlign = exports.ESliceType = exports.FrFl = exports.FStl = exports.ClrS = exports.Clry = exports.gradientInterpolationMethodType = exports.stdTrackID = exports.animInterpStyleEnum = exports.GrdT = exports.IGSr = exports.BETE = exports.BESs = exports.bvlT = exports.BESl = exports.BlnM = exports.warpStyle = exports.Annt = exports.Ornt = exports.textGridding = exports.outputSettingsRoot = void 0;
-exports.presetKindType = exports.prjM = exports.FlMd = exports.IntC = exports.IntE = void 0;
-exports.setLogErrors = setLogErrors;
+exports.CntE = exports.FlCl = exports.ExtR = exports.ExtT = exports.DfsM = exports.blurType = exports.Lns = exports.MztT = exports.Chnl = exports.Dstr = exports.ZZTy = exports.Wvtp = exports.SphM = exports.RplS = exports.Cnvr = exports.UndA = exports.DspM = exports.SmBQ = exports.SmBM = exports.BlrQ = exports.BlrM = exports.strokeStyleLineAlignment = exports.strokeStyleLineJoinType = exports.strokeStyleLineCapType = exports.ESliceBGColorType = exports.ESliceOrigin = exports.ESliceVertAlign = exports.ESliceHorzAlign = exports.ESliceType = exports.FrFl = exports.FStl = exports.ClrS = exports.Clry = exports.gradientInterpolationMethodType = exports.stdTrackID = exports.animInterpStyleEnum = exports.GrdT = exports.IGSr = exports.BETE = exports.BESs = exports.bvlT = exports.BESl = exports.BlnM = exports.warpStyle = exports.Annt = exports.Ornt = exports.textGridding = exports.outputSettingsRoot = exports.cameraRawFilterKeyTypes = exports.cameraRawFilterClassID = void 0;
+exports.patternColorHandling = exports.presetKindType = exports.prjM = exports.FlMd = exports.IntC = exports.IntE = exports.Drct = exports.WndM = void 0;
 exports.readAsciiStringOrClassId = readAsciiStringOrClassId;
 exports.writeAsciiStringOrClassId = writeAsciiStringOrClassId;
 exports.readDescriptorStructure = readDescriptorStructure;
@@ -4344,10 +4719,6 @@ const unitsMap = {
     'RrCm': 'Centimeters',
 };
 const unitsMapRev = revMap(unitsMap);
-let logErrors = false;
-function setLogErrors(value) {
-    logErrors = value;
-}
 function makeType(name, classID) {
     return { name, classID };
 }
@@ -4393,6 +4764,7 @@ const fieldToExtType = {
     psVersion: nullType,
     docDefaultNewArtboardBackgroundColor: makeType('', 'RGBC'),
     artboardRect: makeType('', 'classFloatRect'),
+    framedGroupRect: makeType('', 'classFloatRect'),
     keyOriginRRectRadii: makeType('', 'radii'),
     keyOriginBoxCorners: nullType,
     rectangleCornerA: makeType('', 'Pnt '),
@@ -4478,7 +4850,7 @@ const fieldToArrayExtType = {
 const typeToField = {
     'TEXT': [
         'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName', 'exportOption', 'scaleSettings',
-        'BackgroundImagePath', 'ImageSubfolderName',
+        'BackgroundImagePath', 'ImageSubfolderName', 'SavedIteratedName',
         'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
         'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
         'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath', 'Bk  ', 'pathUnicodeName',
@@ -4505,7 +4877,7 @@ const typeToField = {
         'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN', 'NmbG', 'WLMn', 'WLMx', 'AmMn', 'AmMx', 'SclH', 'SclV',
         'Lvl ', 'TlNm', 'TlOf', 'FlRs', 'Thsh', 'ShrS', 'ShrE', 'FlRs', 'Vrnc', 'Strg', 'ExtS', 'ExtD',
         'HrzS', 'VrtS', 'NmbR', 'EdgF', 'Ang1', 'Ang2', 'Ang3', 'Ang4', 'lastAppliedComp', 'capturedInfo',
-        'pixelSourceType',
+        'pixelSourceType', 'framedGroupType',
     ],
     'enum': [
         'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
@@ -4529,7 +4901,7 @@ const typeToField = {
         'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
         'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
         'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
-        'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn',
+        'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn', 'LockPPI',
     ],
     'doub': [
         'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght', 'Gmm ',
@@ -4537,7 +4909,7 @@ const typeToField = {
         'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
         'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
         'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3',
-        'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity',
+        'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity', 'PreferredResolution',
     ],
     'UntF': [
         'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -4566,6 +4938,12 @@ const channels = [
 // color classes whose channel values are written as doubles ('GRYC' and 'LABC' are kept for backwards compatibility)
 const doubleColorClasses = ['Grsc', 'LbCl', 'GRYC', 'LABC'];
 // fallback for unknown keys, based on the type of the value
+exports.cameraRawFilterClassID = 'Adobe Camera Raw Filter';
+// types of Camera Raw Filter settings (keys clash with other descriptors so they're typed by class)
+exports.cameraRawFilterKeyTypes = {
+    CrVe: 'TEXT', PrVN: 'long', PrVe: 'long', WBal: 'enum', Ex12: 'doub', ShpR: 'doub',
+    'Crv ': 'VlLs', CrvR: 'VlLs', CrvG: 'VlLs', CrvB: 'VlLs',
+};
 function guessOSType(value) {
     if (typeof value === 'boolean')
         return 'bool';
@@ -4741,8 +5119,9 @@ function readDescriptorStructure(reader, includeClass) {
 }
 exports.outputSettingsRoot = 'outputSettings';
 function writeDescriptorStructure(writer, name, classId, value, root) {
-    if (logErrors && !classId)
-        console.log('Missing classId for: ', name, classId, value);
+    var _a;
+    if (writer.logMissingFeatures && !classId)
+        writer.log('Missing classId for: ', name, classId, value);
     // write class structure
     (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
     if (root === exports.outputSettingsRoot && classId === 'null') {
@@ -4760,6 +5139,10 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
         let type = getTypeByKey(key, value[key], root, value);
         let childRoot = root;
         let extType = fieldToExtType[key];
+        if (classId === exports.cameraRawFilterClassID) {
+            type = (_a = exports.cameraRawFilterKeyTypes[key]) !== null && _a !== void 0 ? _a : 'long'; // other settings are integer levels
+            childRoot = exports.cameraRawFilterClassID; // lists (curves) contain integer levels
+        }
         if (key === 'bounds' && root === 'text') {
             extType = makeType('', 'bounds');
         }
@@ -4856,7 +5239,7 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
                 extType = makeType('', 'patternLayer');
             }
             else {
-                logErrors && console.log('Invalid strokeStyleContent value', value[key]);
+                writer.logMissingFeatures && writer.log('Invalid strokeStyleContent value', value[key]);
             }
         }
         else if (key === 'bounds' && root === 'quiltWarp') {
@@ -4878,8 +5261,8 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
         writeAsciiStringOrClassId(writer, key);
         (0, psdWriter_1.writeSignature)(writer, type || 'long');
         writeOSType(writer, type || 'long', value[key], key, extType, childRoot);
-        if (logErrors && !type)
-            console.log(`Missing descriptor field type for: '${key}' in`, value);
+        if (writer.logMissingFeatures && !type)
+            writer.log(`Missing descriptor field type for: '${key}' in`, value);
     }
 }
 function readOSType(reader, type, includeClass) {
@@ -5000,11 +5383,11 @@ function writeOSType(writer, type, value, key, extType, root) {
                 throw new Error(`Invalid list value: ${JSON.stringify(value)}, key: ${key}`);
             (0, psdWriter_1.writeInt32)(writer, value.length);
             for (let i = 0; i < value.length; i++) {
-                const type = (_a = fieldToArrayType[key]) !== null && _a !== void 0 ? _a : guessOSType(value[i]);
+                const type = root === exports.cameraRawFilterClassID ? 'long' : ((_a = fieldToArrayType[key]) !== null && _a !== void 0 ? _a : guessOSType(value[i]));
                 (0, psdWriter_1.writeSignature)(writer, type || 'long');
                 writeOSType(writer, type || 'long', value[i], `${key}[]`, fieldToArrayExtType[key], root);
-                if (logErrors && !type)
-                    console.log(`Missing descriptor array type for: '${key}' in`, value);
+                if (writer.logMissingFeatures && !type)
+                    writer.log(`Missing descriptor array type for: '${key}' in`, value);
             }
             break;
         case 'doub': // Double
@@ -5304,7 +5687,7 @@ function serializeFxObject(stroke) {
         FrFX.overprint = !!stroke.overprint;
     return FrFX;
 }
-function serializeEffects(e, log, multi) {
+function serializeEffects(e, writer, multi) {
     var _a, _b, _c;
     const info = multi ? {
         'Scl ': unitsPercentF((_a = e.scale) !== null && _a !== void 0 ? _a : 1),
@@ -5321,33 +5704,33 @@ function serializeEffects(e, log, multi) {
     const useMulti = (arr) => !!arr && arr.length > 1 && multi;
     const useSingle = (arr) => !!arr && arr.length >= 1 && (!multi || arr.length === 1);
     if (useSingle(e.dropShadow))
-        info.DrSh = serializeEffectObject(e.dropShadow[0], 'dropShadow', log);
+        info.DrSh = serializeEffectObject(e.dropShadow[0], 'dropShadow', writer);
     if (useMulti(e.dropShadow))
-        info.dropShadowMulti = e.dropShadow.map(i => serializeEffectObject(i, 'dropShadow', log));
+        info.dropShadowMulti = e.dropShadow.map(i => serializeEffectObject(i, 'dropShadow', writer));
     if (useSingle(e.innerShadow))
-        info.IrSh = serializeEffectObject(e.innerShadow[0], 'innerShadow', log);
+        info.IrSh = serializeEffectObject(e.innerShadow[0], 'innerShadow', writer);
     if (useMulti(e.innerShadow))
-        info.innerShadowMulti = e.innerShadow.map(i => serializeEffectObject(i, 'innerShadow', log));
+        info.innerShadowMulti = e.innerShadow.map(i => serializeEffectObject(i, 'innerShadow', writer));
     if (e.outerGlow)
-        info.OrGl = serializeEffectObject(e.outerGlow, 'outerGlow', log);
+        info.OrGl = serializeEffectObject(e.outerGlow, 'outerGlow', writer);
     if (useMulti(e.solidFill))
-        info.solidFillMulti = e.solidFill.map(i => serializeEffectObject(i, 'solidFill', log));
+        info.solidFillMulti = e.solidFill.map(i => serializeEffectObject(i, 'solidFill', writer));
     if (useMulti(e.gradientOverlay))
-        info.gradientFillMulti = e.gradientOverlay.map(i => serializeEffectObject(i, 'gradientOverlay', log));
+        info.gradientFillMulti = e.gradientOverlay.map(i => serializeEffectObject(i, 'gradientOverlay', writer));
     if (useMulti(e.stroke))
         info.frameFXMulti = e.stroke.map(i => serializeFxObject(i));
     if (e.innerGlow)
-        info.IrGl = serializeEffectObject(e.innerGlow, 'innerGlow', log);
+        info.IrGl = serializeEffectObject(e.innerGlow, 'innerGlow', writer);
     if (e.bevel)
-        info.ebbl = serializeEffectObject(e.bevel, 'bevel', log);
+        info.ebbl = serializeEffectObject(e.bevel, 'bevel', writer);
     if (useSingle(e.solidFill))
-        info.SoFi = serializeEffectObject(e.solidFill[0], 'solidFill', log);
+        info.SoFi = serializeEffectObject(e.solidFill[0], 'solidFill', writer);
     if (e.patternOverlay)
-        info.patternFill = serializeEffectObject(e.patternOverlay, 'patternOverlay', log);
+        info.patternFill = serializeEffectObject(e.patternOverlay, 'patternOverlay', writer);
     if (useSingle(e.gradientOverlay))
-        info.GrFl = serializeEffectObject(e.gradientOverlay[0], 'gradientOverlay', log);
+        info.GrFl = serializeEffectObject(e.gradientOverlay[0], 'gradientOverlay', writer);
     if (e.satin)
-        info.ChFX = serializeEffectObject(e.satin, 'satin', log);
+        info.ChFX = serializeEffectObject(e.satin, 'satin', writer);
     if (useSingle(e.stroke))
         info.FrFX = serializeFxObject((_c = e.stroke) === null || _c === void 0 ? void 0 : _c[0]);
     if (multi) {
@@ -5369,7 +5752,7 @@ function serializeEffects(e, log, multi) {
     }
     return info;
 }
-function parseEffects(info, log) {
+function parseEffects(info, reader) {
     const effects = {};
     const _a = info, { _name, _classID, 'Scl ': scale, masterFXSwitch, DrSh, dropShadowMulti, IrSh, innerShadowMulti, OrGl, IrGl, ebbl, SoFi, solidFillMulti, patternFill, GrFl, gradientFillMulti, ChFX, FrFX, frameFXMulti, numModifyingFX } = _a, rest = __rest(_a, ["_name", "_classID", 'Scl ', "masterFXSwitch", "DrSh", "dropShadowMulti", "IrSh", "innerShadowMulti", "OrGl", "IrGl", "ebbl", "SoFi", "solidFillMulti", "patternFill", "GrFl", "gradientFillMulti", "ChFX", "FrFX", "frameFXMulti", "numModifyingFX"]);
     if (!masterFXSwitch)
@@ -5377,40 +5760,40 @@ function parseEffects(info, log) {
     if (scale)
         effects.scale = parsePercent(scale);
     if (DrSh)
-        effects.dropShadow = [parseEffectObject(DrSh, log)];
+        effects.dropShadow = [parseEffectObject(DrSh, reader)];
     if (dropShadowMulti)
-        effects.dropShadow = dropShadowMulti.map(i => parseEffectObject(i, log));
+        effects.dropShadow = dropShadowMulti.map(i => parseEffectObject(i, reader));
     if (IrSh)
-        effects.innerShadow = [parseEffectObject(IrSh, log)];
+        effects.innerShadow = [parseEffectObject(IrSh, reader)];
     if (innerShadowMulti)
-        effects.innerShadow = innerShadowMulti.map(i => parseEffectObject(i, log));
+        effects.innerShadow = innerShadowMulti.map(i => parseEffectObject(i, reader));
     if (OrGl)
-        effects.outerGlow = parseEffectObject(OrGl, log);
+        effects.outerGlow = parseEffectObject(OrGl, reader);
     if (IrGl)
-        effects.innerGlow = parseEffectObject(IrGl, log);
+        effects.innerGlow = parseEffectObject(IrGl, reader);
     if (ebbl)
-        effects.bevel = parseEffectObject(ebbl, log, 'bevel');
+        effects.bevel = parseEffectObject(ebbl, reader, 'bevel');
     if (SoFi)
-        effects.solidFill = [parseEffectObject(SoFi, log)];
+        effects.solidFill = [parseEffectObject(SoFi, reader)];
     if (solidFillMulti)
-        effects.solidFill = solidFillMulti.map(i => parseEffectObject(i, log));
+        effects.solidFill = solidFillMulti.map(i => parseEffectObject(i, reader));
     if (patternFill)
-        effects.patternOverlay = parseEffectObject(patternFill, log);
+        effects.patternOverlay = parseEffectObject(patternFill, reader);
     if (GrFl)
-        effects.gradientOverlay = [parseEffectObject(GrFl, log)];
+        effects.gradientOverlay = [parseEffectObject(GrFl, reader)];
     if (gradientFillMulti)
-        effects.gradientOverlay = gradientFillMulti.map(i => parseEffectObject(i, log));
+        effects.gradientOverlay = gradientFillMulti.map(i => parseEffectObject(i, reader));
     if (ChFX)
-        effects.satin = parseEffectObject(ChFX, log);
+        effects.satin = parseEffectObject(ChFX, reader);
     if (FrFX)
         effects.stroke = [parseFxObject(FrFX)];
     if (frameFXMulti)
         effects.stroke = frameFXMulti.map(i => parseFxObject(i));
-    if (log && Object.keys(rest).length)
-        console.log('Unhandled effect keys:', rest);
+    if (reader.logMissingFeatures && Object.keys(rest).length)
+        reader.log('Unhandled effect keys:', rest);
     return effects;
 }
-function parseKeyList(keyList, logMissingFeatures) {
+function parseKeyList(keyList, reader) {
     const keys = [];
     for (let j = 0; j < keyList.length; j++) {
         const key = keyList[j];
@@ -5433,7 +5816,7 @@ function parseKeyList(keyList, logMissingFeatures) {
             case 'keyType.sheetStyle': {
                 const key = { interpolation, time, selected, type: 'style' };
                 if (animKey.sheetStyle.Lefx)
-                    key.style = parseEffects(animKey.sheetStyle.Lefx, logMissingFeatures);
+                    key.style = parseEffects(animKey.sheetStyle.Lefx, reader);
                 keys.push(key);
                 break;
             }
@@ -5449,7 +5832,7 @@ function parseKeyList(keyList, logMissingFeatures) {
     }
     return keys;
 }
-function serializeKeyList(keys) {
+function serializeKeyList(keys, writer) {
     const keyList = [];
     for (let j = 0; j < keys.length; j++) {
         const key = keys[j];
@@ -5469,7 +5852,7 @@ function serializeKeyList(keys) {
             case 'style':
                 animKey = { Type: 'keyType.sheetStyle', sheetStyle: { Vrsn: 1, blendOptions: {} } };
                 if (key.style)
-                    animKey.sheetStyle = { Vrsn: 1, Lefx: serializeEffects(key.style, false, false), blendOptions: {} };
+                    animKey.sheetStyle = { Vrsn: 1, Lefx: serializeEffects(key.style, writer, false), blendOptions: {} };
                 break;
             case 'globalLighting': {
                 animKey = { Type: 'keyType.globalLighting', gblA: key.globalAngle, globalAltitude: key.globalAltitude };
@@ -5481,41 +5864,41 @@ function serializeKeyList(keys) {
     }
     return keyList;
 }
-function parseTrackList(trackList, logMissingFeatures) {
+function parseTrackList(trackList, reader) {
     const tracks = [];
     for (let i = 0; i < trackList.length; i++) {
         const tr = trackList[i];
         const track = {
             type: exports.stdTrackID.decode(tr.trackID),
             enabled: tr.enab,
-            keys: parseKeyList(tr.keyList, logMissingFeatures),
+            keys: parseKeyList(tr.keyList, reader),
         };
         if (tr.effectParams) {
             track.effectParams = {
                 fillCanvas: tr.effectParams.fillCanvas,
                 zoomOrigin: tr.effectParams.zoomOrigin,
-                keys: parseKeyList(tr.effectParams.keyList, logMissingFeatures),
+                keys: parseKeyList(tr.effectParams.keyList, reader),
             };
         }
         tracks.push(track);
     }
     return tracks;
 }
-function serializeTrackList(tracks) {
+function serializeTrackList(tracks, writer) {
     const trackList = [];
     for (let i = 0; i < tracks.length; i++) {
         const t = tracks[i];
         trackList.push(Object.assign(Object.assign({ trackID: exports.stdTrackID.encode(t.type), Vrsn: 1, enab: !!t.enabled, Effc: !!t.effectParams }, (t.effectParams ? {
             effectParams: {
-                keyList: serializeKeyList(t.effectParams.keys),
+                keyList: serializeKeyList(t.effectParams.keys, writer),
                 fillCanvas: t.effectParams.fillCanvas,
                 zoomOrigin: t.effectParams.zoomOrigin,
             }
-        } : {})), { keyList: serializeKeyList(t.keys) }));
+        } : {})), { keyList: serializeKeyList(t.keys, writer) }));
     }
     return trackList;
 }
-function parseEffectObject(obj, reportErrors, objName) {
+function parseEffectObject(obj, reader, objName) {
     const result = {};
     for (const key of Object.keys(obj)) {
         const val = obj[key];
@@ -5668,12 +6051,12 @@ function parseEffectObject(obj, reportErrors, objName) {
             case '_classID':
                 break;
             default:
-                reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+                reader.logMissingFeatures && reader.log(`Invalid effect key: '${key}', value:`, val);
         }
     }
     return result;
 }
-function serializeEffectObject(obj, objName, reportErrors) {
+function serializeEffectObject(obj, objName, writer) {
     const result = {
         enab: false,
     };
@@ -5823,7 +6206,7 @@ function serializeEffectObject(obj, objName, reportErrors) {
                 result[key] = val;
                 break;
             default:
-                reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+                writer.logMissingFeatures && writer.log(`Invalid effect key: '${key}', value:`, val);
         }
     }
     return result;
@@ -6068,6 +6451,21 @@ function isBookColor(color) {
     return color._classID === 'BkCl' || 'Bk  ' in color || 'bookID' in color;
 }
 function parseColor(color) {
+    var _a, _b, _c;
+    const result = parseColorValues(color);
+    if (isBookColor(color)) {
+        const book = color;
+        const key = book.bookKey;
+        result.book = {
+            book: (_a = book['Bk  ']) !== null && _a !== void 0 ? _a : '',
+            name: (_b = book['Nm  ']) !== null && _b !== void 0 ? _b : '',
+            bookID: (_c = book.bookID) !== null && _c !== void 0 ? _c : 0,
+            bookKey: typeof key === 'string' ? key : (key ? String.fromCharCode(...Array.from(key)) : ''),
+        };
+    }
+    return result;
+}
+function parseColorValues(color) {
     if ('H   ' in color) {
         return { h: parsePercentOrAngle(color['H   ']), s: color.Strt / 100, b: color.Brgh / 100 };
     }
@@ -6092,13 +6490,24 @@ function parseColor(color) {
         return { fr: color.redFloat, fg: color.greenFloat, fb: color.blueFloat };
     }
     else if (isBookColor(color)) {
-        return { r: 0, g: 0, b: 0 }; // book (Pantone) colors are not supported
+        return { r: 0, g: 0, b: 0 }; // book (Pantone) color without color values
     }
     else {
         throw new Error('Unsupported color descriptor');
     }
 }
 function serializeColor(color) {
+    const result = serializeColorValues(color);
+    if (color === null || color === void 0 ? void 0 : color.book) {
+        const { book, name, bookID, bookKey } = color.book;
+        const key = new Uint8Array(bookKey.length);
+        for (let i = 0; i < key.length; i++)
+            key[i] = bookKey.charCodeAt(i) & 0xff;
+        Object.assign(result, { 'Bk  ': book, 'Nm  ': name, bookID, bookKey: key });
+    }
+    return result;
+}
+function serializeColorValues(color) {
     if (!color) {
         return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
     }
@@ -6524,8 +6933,13 @@ exports.presetKindType = (0, helpers_1.createEnum)('presetKindType', 'custom', {
     custom: 'presetKindCustom',
     default: 'presetKindDefault',
 });
+exports.patternColorHandling = (0, helpers_1.createEnum)('', 'convert', {
+    'convert': 'conv',
+    'avoid conversion': 'avod',
+    'luminance only': 'lumi',
+});
 
-},{"./helpers":8,"./psdReader":13,"./psdWriter":14}],5:[function(require,module,exports){
+},{"./helpers":9,"./psdReader":14,"./psdWriter":15}],6:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEffects = readEffects;
@@ -6813,7 +7227,7 @@ function writeEffects(writer, effects) {
     }
 }
 
-},{"./helpers":8,"./psdReader":13,"./psdWriter":14}],6:[function(require,module,exports){
+},{"./helpers":9,"./psdReader":14,"./psdWriter":15}],7:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setProperty = setProperty;
@@ -7174,7 +7588,7 @@ function serializeEngineData(data, condensed = false) {
     return buffer.slice(0, offset);
 }
 
-},{}],7:[function(require,module,exports){
+},{}],8:[function(require,module,exports){
 "use strict";
 /// Engine data 2 experiments
 // /test/engineData2.json:1109 is character codes
@@ -7614,7 +8028,7 @@ function decodeEngineData2(data) {
     return result;
 }
 
-},{"./engineData":6}],8:[function(require,module,exports){
+},{"./engineData":7}],9:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createImageData = exports.createCanvas = exports.MaskParams = exports.LayerMaskFlags = exports.ColorSpace = exports.largeAdditionalInfoKeys = exports.largeAdditionalInfoKeysObserved = exports.layerColors = exports.toBlendMode = exports.fromBlendMode = exports.MOCK_HANDLERS = void 0;
@@ -7625,11 +8039,16 @@ exports.normalizeLabAB = normalizeLabAB;
 exports.denormalizeLabAB = denormalizeLabAB;
 exports.clamp = clamp;
 exports.hasAlpha = hasAlpha;
+exports.cmykToRgbValues = cmykToRgbValues;
+exports.rgbToCmykValues = rgbToCmykValues;
 exports.resetImageData = resetImageData;
 exports.imageDataToCanvas = imageDataToCanvas;
 exports.decodeBitmap = decodeBitmap;
 exports.writeDataRaw = writeDataRaw;
 exports.writeDataRLE = writeDataRLE;
+exports.planarToBytes = planarToBytes;
+exports.writeDataRLEBytes = writeDataRLEBytes;
+exports.writeDataZipWithPrediction = writeDataZipWithPrediction;
 exports.writeDataZipWithoutPrediction = writeDataZipWithoutPrediction;
 exports.createCanvasFromData = createCanvasFromData;
 exports.initializeCanvas = initializeCanvas;
@@ -7669,7 +8088,7 @@ exports.toBlendMode = {
 };
 Object.keys(exports.toBlendMode).forEach(key => exports.fromBlendMode[exports.toBlendMode[key]] = key);
 exports.layerColors = [
-    'none', 'red', 'orange', 'yellow', 'green', 'blue', 'violet', 'gray'
+    'none', 'red', 'orange', 'yellow', 'green', 'blue', 'violet', 'gray', 'seafoam', 'indigo', 'magenta', 'fuchsia',
 ];
 // keys not listed in documentation that Photoshop writes with 64bit length in PSB files (with 8B64 signature)
 exports.largeAdditionalInfoKeysObserved = ['lnk3', 'lnkE', 'pths', 'extd', 'extn', 'FELS', 'artd'];
@@ -7756,13 +8175,152 @@ function clamp(value, min, max) {
 }
 function hasAlpha(data) {
     const size = data.width * data.height * 4;
+    const max = data.data instanceof Float32Array ? 1 : (data.data instanceof Uint16Array ? 0xffff : 0xff);
     for (let i = 3; i < size; i += 4) {
-        if (data.data[i] !== 255) {
+        if (data.data[i] !== max) {
             return true;
         }
     }
     return false;
 }
+// Polynomial approximation of U.S. Web Coated (SWOP) v2 CMYK to RGB conversion (default CMYK profile of Photoshop).
+// Coefficients are taken from pdf.js (DeviceCmykCS in src/core/colorspace.js, https://github.com/mozilla/pdf.js),
+// Copyright 2012 Mozilla Foundation, licensed under the Apache License, Version 2.0
+// (http://www.apache.org/licenses/LICENSE-2.0)
+// c, m, y, k - ink values (0 - 1), output - RGB values (0 - 255, not rounded or clamped)
+function cmykToRgbValues(c, m, y, k, out) {
+    out[0] = 255 +
+        c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k - 285.2331026137004) +
+        m * (1.7149763477362134 * m - 5.6096736904047315 * y - 17.873870861415444 * k - 5.497006427196366) +
+        y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) +
+        k * (-21.86122147463605 * k - 189.48180835922747);
+    out[1] = 255 +
+        c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k - 79.2970844816548) +
+        m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) +
+        y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) +
+        k * (-20.737325471181034 * k - 187.80453709719578);
+    out[2] = 255 +
+        c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k - 14.183576799673286) +
+        m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) +
+        y * (0.03296041114873217 * y + 115.60384449646641 * k - 193.58209356861505) +
+        k * (-22.33816807309886 * k - 180.12613974708367);
+}
+const clamp01 = (v) => v < 0 ? 0 : (v > 1 ? 1 : v);
+// finds c, m, y (with fixed k) for given RGB color using Gauss-Newton method, returns squared error
+function solveCmy(r, g, b, k, x) {
+    const f = [0, 0, 0], f2 = [0, 0, 0], e = [0, 0, 0];
+    const J = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+    const h = 1e-4;
+    for (let iteration = 0; iteration < 20; iteration++) {
+        cmykToRgbValues(x[0], x[1], x[2], k, f);
+        e[0] = f[0] - r;
+        e[1] = f[1] - g;
+        e[2] = f[2] - b;
+        if ((e[0] * e[0] + e[1] * e[1] + e[2] * e[2]) < 1e-6)
+            break;
+        for (let j = 0; j < 3; j++) {
+            const s = x[j];
+            x[j] = s + h;
+            cmykToRgbValues(x[0], x[1], x[2], k, f2);
+            x[j] = s;
+            for (let i = 0; i < 3; i++)
+                J[i][j] = (f2[i] - f[i]) / h;
+        }
+        const [[a, b_, c], [d, e_, f_], [g_, h_, i_]] = J;
+        const det = a * (e_ * i_ - f_ * h_) - b_ * (d * i_ - f_ * g_) + c * (d * h_ - e_ * g_);
+        if (Math.abs(det) < 1e-12)
+            break;
+        const inverse = [
+            [(e_ * i_ - f_ * h_), (c * h_ - b_ * i_), (b_ * f_ - c * e_)],
+            [(f_ * g_ - d * i_), (a * i_ - c * g_), (c * d - a * f_)],
+            [(d * h_ - e_ * g_), (b_ * g_ - a * h_), (a * e_ - b_ * d)],
+        ];
+        let changed = 0;
+        for (let j = 0; j < 3; j++) {
+            const delta = -(inverse[j][0] * e[0] + inverse[j][1] * e[1] + inverse[j][2] * e[2]) / det;
+            const value = clamp01(x[j] + delta);
+            changed += Math.abs(value - x[j]);
+            x[j] = value;
+        }
+        if (changed < 1e-9)
+            break;
+    }
+    cmykToRgbValues(x[0], x[1], x[2], k, f);
+    return (f[0] - r) * (f[0] - r) + (f[1] - g) * (f[1] - g) + (f[2] - b) * (f[2] - b);
+}
+// finds CMYK ink values (0 - 1) for RGB color (0 - 255), out of gamut colors are approximated
+function rgbToCmykExact(r, g, b, out) {
+    const max = Math.max(r, g, b) / 255;
+    const blackGeneration = Math.pow(clamp01((1 - max - 0.2) / 0.8), 1.3);
+    const x = [0, 0, 0];
+    let bestScore = Infinity, bestError = Infinity;
+    const tryBlack = (k) => {
+        x[0] = clamp01(1 - r / 255 - k);
+        x[1] = clamp01(1 - g / 255 - k);
+        x[2] = clamp01(1 - b / 255 - k);
+        const error = solveCmy(r, g, b, k, x);
+        // prefer solutions close to black generation value if the error is small enough
+        const score = Math.max(error, 0.1) + Math.abs(k - blackGeneration) * 0.01;
+        if (score < bestScore) {
+            bestScore = score;
+            bestError = error;
+            out[0] = x[0];
+            out[1] = x[1];
+            out[2] = x[2];
+            out[3] = k;
+        }
+    };
+    tryBlack(blackGeneration);
+    if (bestError > 0.1) {
+        for (let i = 0; i <= 10; i++)
+            tryBlack(i / 10);
+    }
+    if (bestError > 0.1) {
+        const k = out[3];
+        for (let i = -5; i <= 5; i++)
+            tryBlack(clamp01(k + i / 100));
+    }
+}
+const cmykLutSize = 33;
+let cmykLut;
+function getCmykLut() {
+    if (!cmykLut) {
+        const n = cmykLutSize;
+        const lut = new Float32Array(n * n * n * 4);
+        const out = [0, 0, 0, 0];
+        for (let r = 0, o = 0; r < n; r++) {
+            for (let g = 0; g < n; g++) {
+                for (let b = 0; b < n; b++, o += 4) {
+                    rgbToCmykExact(r * 255 / (n - 1), g * 255 / (n - 1), b * 255 / (n - 1), out);
+                    lut[o] = out[0];
+                    lut[o + 1] = out[1];
+                    lut[o + 2] = out[2];
+                    lut[o + 3] = out[3];
+                }
+            }
+        }
+        cmykLut = lut;
+    }
+    return cmykLut;
+}
+// inverse of cmykToRgbValues, r, g, b - RGB values (0 - 1), output - CMYK ink values (0 - 1)
+function rgbToCmykValues(r, g, b, out) {
+    const lut = getCmykLut();
+    const n1 = cmykLutSize - 1;
+    const fr = clamp01(r) * n1, fg = clamp01(g) * n1, fb = clamp01(b) * n1;
+    const r0 = Math.min(n1 - 1, Math.floor(fr)), g0 = Math.min(n1 - 1, Math.floor(fg)), b0 = Math.min(n1 - 1, Math.floor(fb));
+    const dr = fr - r0, dg = fg - g0, db = fb - b0;
+    out[0] = out[1] = out[2] = out[3] = 0;
+    for (let i = 0; i < 8; i++) {
+        const ir = i >> 2, ig = (i >> 1) & 1, ib = i & 1;
+        const w = (ir ? dr : 1 - dr) * (ig ? dg : 1 - dg) * (ib ? db : 1 - db);
+        const o = (((r0 + ir) * cmykLutSize + g0 + ig) * cmykLutSize + b0 + ib) * 4;
+        out[0] += w * lut[o];
+        out[1] += w * lut[o + 1];
+        out[2] += w * lut[o + 2];
+        out[3] += w * lut[o + 3];
+    }
+}
 function resetImageData({ data }) {
     const alpha = (data instanceof Float32Array) ? 1.0 : ((data instanceof Uint16Array) ? 0xffff : 0xff);
     for (let p = 0, size = data.length | 0; p < size; p = (p + 4) | 0) {
@@ -7921,6 +8479,102 @@ function writeDataRLE(buffer, { data, width, height }, offsets, large) {
     // returns view of the buffer, copy the data if the buffer is going to be reused
     return buffer.subarray(0, o);
 }
+// converts channel values to big-endian bytes
+function planarToBytes(values) {
+    if (values instanceof Uint8Array)
+        return values;
+    const bytes = new Uint8Array(values.byteLength);
+    const view = new DataView(bytes.buffer);
+    if (values instanceof Uint16Array) {
+        for (let i = 0; i < values.length; i++)
+            view.setUint16(i * 2, values[i], false);
+    }
+    else {
+        for (let i = 0; i < values.length; i++)
+            view.setFloat32(i * 4, values[i], false);
+    }
+    return bytes;
+}
+// RLE (PackBits) compression of rows of bytes, prefixed with byte counts of each row
+function writeDataRLEBytes(bytes, rowBytes, height, large) {
+    const countSize = large ? 4 : 2;
+    const buffer = new Uint8Array(height * (countSize + rowBytes + Math.ceil(rowBytes / 128)));
+    let o = countSize * height;
+    for (let y = 0; y < height; y++) {
+        const start = o;
+        const rowStart = y * rowBytes;
+        const rowEnd = rowStart + rowBytes;
+        let i = rowStart;
+        while (i < rowEnd) {
+            let run = 1;
+            while (i + run < rowEnd && run < 128 && bytes[i + run] === bytes[i])
+                run++;
+            if (run > 1) {
+                buffer[o++] = 257 - run;
+                buffer[o++] = bytes[i];
+                i += run;
+            }
+            else {
+                // literal bytes until a run of at least 3 equal bytes
+                const countIndex = o++;
+                let count = 0;
+                while (i < rowEnd && count < 128) {
+                    if (i + 2 < rowEnd && bytes[i] === bytes[i + 1] && bytes[i] === bytes[i + 2])
+                        break;
+                    buffer[o++] = bytes[i++];
+                    count++;
+                }
+                buffer[countIndex] = count - 1;
+            }
+        }
+        const length = o - start;
+        for (let j = 0; j < countSize; j++) {
+            buffer[y * countSize + j] = (length >>> ((countSize - j - 1) * 8)) & 0xff;
+        }
+    }
+    return buffer.subarray(0, o);
+}
+// zip compression with prediction (values are delta encoded per row, 32bit values are split into byte planes first)
+function writeDataZipWithPrediction(values, width, height) {
+    let bytes;
+    if (values instanceof Uint8Array) {
+        bytes = new Uint8Array(width * height);
+        for (let y = 0, i = 0; y < height; y++) {
+            for (let x = 0, prev = 0; x < width; x++, i++) {
+                bytes[i] = values[i] - prev; // Uint8Array wraps values on assignment
+                prev = values[i];
+            }
+        }
+    }
+    else if (values instanceof Uint16Array) {
+        bytes = new Uint8Array(width * height * 2);
+        for (let y = 0, i = 0; y < height; y++) {
+            for (let x = 0, prev = 0; x < width; x++, i++) {
+                const delta = (values[i] - prev) & 0xffff;
+                bytes[i * 2] = delta >> 8;
+                bytes[i * 2 + 1] = delta & 0xff;
+                prev = values[i];
+            }
+        }
+    }
+    else {
+        const rowBytes = width * 4;
+        const source = planarToBytes(values);
+        bytes = new Uint8Array(rowBytes * height);
+        for (let y = 0; y < height; y++) {
+            const row = y * rowBytes;
+            for (let x = 0; x < width; x++) {
+                for (let b = 0; b < 4; b++) {
+                    bytes[row + b * width + x] = source[row + x * 4 + b];
+                }
+            }
+            for (let x = rowBytes - 1; x > 0; x--) {
+                bytes[row + x] -= bytes[row + x - 1];
+            }
+        }
+    }
+    return (0, pako_1.deflate)(bytes);
+}
 function writeDataZipWithoutPrediction({ data, width, height }, offsets) {
     const size = width * height;
     const channel = new Uint8Array(size);
@@ -7985,7 +8639,7 @@ function initializeCanvas(createCanvasMethod, createImageDataMethod) {
     exports.createImageData = createImageDataMethod || exports.createImageData;
 }
 
-},{"./jpeg":11,"pako":20}],9:[function(require,module,exports){
+},{"./jpeg":12,"pako":21}],10:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resourceHandlersMap = exports.resourceHandlers = void 0;
@@ -8501,6 +9155,38 @@ function writeTransferFunctions(writer, functions) {
         (0, psdWriter_1.writeUint16)(writer, f.override ? 1 : 0);
     }
 }
+addHandler(1014, // Duotone halftoning information
+// Duotone halftoning information
+target => target.duotoneHalftoneScreens !== undefined, (reader, target, left) => target.duotoneHalftoneScreens = readHalftoneScreens(reader, left), (writer, target) => writeHalftoneScreens(writer, target.duotoneHalftoneScreens));
+addHandler(1017, // Duotone transfer functions
+// Duotone transfer functions
+target => target.duotoneTransferFunctions !== undefined, (reader, target, left) => target.duotoneTransferFunctions = readTransferFunctions(reader, left), (writer, target) => writeTransferFunctions(writer, target.duotoneTransferFunctions));
+addHandler(1018, // Duotone image information
+// Duotone image information
+target => target.duotoneImageInformation !== undefined, (reader, target, left) => target.duotoneImageInformation = (0, psdReader_1.readBytes)(reader, left()), (writer, target) => (0, psdWriter_1.writeBytes)(writer, target.duotoneImageInformation));
+addHandler(1066, // Alternate duotone colors
+// Alternate duotone colors
+target => target.alternateDuotoneColors !== undefined, (reader, target, left) => {
+    if ((0, psdReader_1.readUint16)(reader) !== 1)
+        throw new Error('Invalid alternate duotone colors version');
+    const colors = [];
+    const count = (0, psdReader_1.readUint16)(reader);
+    for (let i = 0; i < count && left() >= 10; i++)
+        colors.push((0, psdReader_1.readColor)(reader));
+    const labCount = (0, psdReader_1.readUint16)(reader);
+    if (labCount * 3 > left())
+        throw new Error('Invalid alternate duotone colors Lab table size');
+    const labColors = (0, psdReader_1.readBytes)(reader, labCount * 3);
+    target.alternateDuotoneColors = { colors, labColors };
+}, (writer, target) => {
+    const { colors, labColors } = target.alternateDuotoneColors;
+    (0, psdWriter_1.writeUint16)(writer, 1); // version
+    (0, psdWriter_1.writeUint16)(writer, colors.length);
+    for (const color of colors)
+        (0, psdWriter_1.writeColor)(writer, color);
+    (0, psdWriter_1.writeUint16)(writer, Math.floor(labColors.byteLength / 3));
+    (0, psdWriter_1.writeBytes)(writer, labColors.subarray(0, Math.floor(labColors.byteLength / 3) * 3));
+});
 addHandler(1015, // Grayscale and multichannel transfer function
 // Grayscale and multichannel transfer function
 target => target.grayscaleTransferFunctions !== undefined, (reader, target, left) => target.grayscaleTransferFunctions = readTransferFunctions(reader, left), (writer, target) => writeTransferFunctions(writer, target.grayscaleTransferFunctions));
@@ -8766,7 +9452,7 @@ target => target.timelineInformation !== undefined, (reader, target) => {
         workOutTime: (0, descriptor_1.frac)(desc.workOutTime),
         repeats: desc.LCnt,
         hasMotion: desc.hasMotion,
-        globalTracks: (0, descriptor_1.parseTrackList)(desc.globalTrackList, !!reader.logMissingFeatures),
+        globalTracks: (0, descriptor_1.parseTrackList)(desc.globalTrackList, reader),
     };
     if ((_b = (_a = desc.audioClipGroupList) === null || _a === void 0 ? void 0 : _a.audioClipGroupList) === null || _b === void 0 ? void 0 : _b.length) {
         target.timelineInformation.audioClipGroups = desc.audioClipGroupList.audioClipGroupList.map(g => ({
@@ -8805,7 +9491,7 @@ target => target.timelineInformation !== undefined, (reader, target) => {
         workInTime: timeline.workInTime,
         workOutTime: timeline.workOutTime,
         LCnt: timeline.repeats,
-        globalTrackList: (0, descriptor_1.serializeTrackList)(timeline.globalTracks),
+        globalTrackList: (0, descriptor_1.serializeTrackList)(timeline.globalTracks, writer),
         audioClipGroupList: {
             audioClipGroupList: ((_a = timeline.audioClipGroups) !== null && _a !== void 0 ? _a : []).map(a => ({
                 groupID: a.id,
@@ -9063,10 +9749,13 @@ target => target.iccProfile !== undefined, (reader, target, left) => {
 addHandler(1044, target => target.idsSeedNumber !== undefined, (reader, target) => target.idsSeedNumber = (0, psdReader_1.readUint32)(reader), (writer, target) => (0, psdWriter_1.writeUint32)(writer, target.idsSeedNumber));
 addHandler(1038, // Color samplers (Photoshop 5.0, replaced by 1073 in CS3)
 // Color samplers (Photoshop 5.0, replaced by 1073 in CS3)
-target => target.colorSamplers !== undefined, (reader, target, left) => {
+target => target.colorSamplers !== undefined && !target.colorSamplers.some(s => s.depth !== undefined), (reader, target, left) => {
+    var _a;
     const version = (0, psdReader_1.readUint32)(reader);
     if (version !== 1)
         throw new Error(`Invalid color samplers version: ${version}`);
+    if ((_a = target.colorSamplers) === null || _a === void 0 ? void 0 : _a.some(s => s.depth !== undefined))
+        return (0, psdReader_1.skipBytes)(reader, left()); // already read from 1073
     const count = (0, psdReader_1.readUint32)(reader);
     target.colorSamplers = [];
     for (let i = 0; i < count && left() >= 10; i++) {
@@ -9086,6 +9775,52 @@ target => target.colorSamplers !== undefined, (reader, target, left) => {
         (0, psdWriter_1.writeInt16)(writer, sampler.colorSpace);
     }
 });
+addHandler(1073, // Color samplers (Photoshop CS3)
+// Color samplers (Photoshop CS3)
+target => target.colorSamplers !== undefined && target.colorSamplers.some(s => s.depth !== undefined), (reader, target, left) => {
+    const version = (0, psdReader_1.readUint32)(reader);
+    if (version < 1 || version > 3)
+        throw new Error(`Invalid color samplers version: ${version}`);
+    const count = (0, psdReader_1.readUint32)(reader);
+    target.colorSamplers = [];
+    for (let i = 0; i < count && left() >= 10; i++) {
+        // position is fixed point value for sampler version 1 (stored the same way as in 1038 resource) or float for version 2
+        const samplerVersion = version === 3 ? (0, psdReader_1.readUint32)(reader) : version;
+        const y = samplerVersion === 1 ? (0, psdReader_1.readInt32)(reader) / 16 : (0, psdReader_1.readFloat32)(reader);
+        const x = samplerVersion === 1 ? (0, psdReader_1.readInt32)(reader) / 16 : (0, psdReader_1.readFloat32)(reader);
+        const colorSpace = (0, psdReader_1.readInt16)(reader);
+        const depth = version >= 2 ? (0, psdReader_1.readInt16)(reader) : 1;
+        target.colorSamplers.push({ x, y, colorSpace, depth });
+    }
+}, (writer, target) => {
+    var _a;
+    (0, psdWriter_1.writeUint32)(writer, 3); // version
+    (0, psdWriter_1.writeUint32)(writer, target.colorSamplers.length);
+    for (const sampler of target.colorSamplers) {
+        (0, psdWriter_1.writeUint32)(writer, 1); // sampler version
+        (0, psdWriter_1.writeInt32)(writer, Math.round(sampler.y * 16));
+        (0, psdWriter_1.writeInt32)(writer, Math.round(sampler.x * 16));
+        (0, psdWriter_1.writeInt16)(writer, sampler.colorSpace);
+        (0, psdWriter_1.writeInt16)(writer, (_a = sampler.depth) !== null && _a !== void 0 ? _a : 1);
+    }
+});
+addHandler(1022, // Quick Mask information
+// Quick Mask information
+target => target.quickMaskInfo !== undefined, (reader, target) => {
+    const channelId = (0, psdReader_1.readUint16)(reader);
+    const initiallyEmpty = !!(0, psdReader_1.readUint8)(reader);
+    target.quickMaskInfo = { channelId, initiallyEmpty };
+}, (writer, target) => {
+    (0, psdWriter_1.writeUint16)(writer, target.quickMaskInfo.channelId);
+    (0, psdWriter_1.writeUint8)(writer, target.quickMaskInfo.initiallyEmpty ? 1 : 0);
+});
+addHandler(1074, // Measurement scale
+// Measurement scale
+target => target.measurementScale !== undefined, (reader, target, left) => {
+    target.measurementScale = (0, psdReader_1.readBytes)(reader, left());
+}, (writer, target) => {
+    (0, psdWriter_1.writeBytes)(writer, target.measurementScale);
+});
 addHandler(1042, // Effects visible (only present when effects are hidden)
 // Effects visible (only present when effects are hidden)
 target => target.effectsVisible !== undefined, (reader, target) => {
@@ -9419,7 +10154,7 @@ target => pluginResourceKeys(target).length, (reader, target, left) => {
     }
 }, { keyCount: 1000 });
 
-},{"./additionalInfo":2,"./descriptor":4,"./helpers":8,"./psdReader":13,"./psdWriter":14,"./utf8":16,"base64-js":17}],10:[function(require,module,exports){
+},{"./additionalInfo":2,"./descriptor":5,"./helpers":9,"./psdReader":14,"./psdWriter":15,"./utf8":17,"base64-js":18}],11:[function(require,module,exports){
 (function (Buffer){(function (){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -9456,6 +10191,7 @@ Object.defineProperty(exports, "getCompositeCanvas", { enumerable: true, get: fu
 const base64_js_1 = require("base64-js");
 __exportStar(require("./abr"), exports);
 __exportStar(require("./csh"), exports);
+__exportStar(require("./ase"), exports);
 var helpers_1 = require("./helpers");
 Object.defineProperty(exports, "initializeCanvas", { enumerable: true, get: function () { return helpers_1.initializeCanvas; } });
 __exportStar(require("./psd"), exports);
@@ -9485,7 +10221,7 @@ function writePsdBuffer(psd, options) {
 }
 
 }).call(this)}).call(this,require("buffer").Buffer)
-},{"./abr":1,"./csh":3,"./helpers":8,"./psd":12,"./psdReader":13,"./psdWriter":14,"base64-js":17,"buffer":18}],11:[function(require,module,exports){
+},{"./abr":1,"./ase":3,"./csh":4,"./helpers":9,"./psd":13,"./psdReader":14,"./psdWriter":15,"base64-js":18,"buffer":19}],12:[function(require,module,exports){
 "use strict";
 // based on https://github.com/jpeg-js/jpeg-js
 /*
@@ -10539,7 +11275,7 @@ function decodeJpeg(encoded, createImageData) {
     return imageData;
 }
 
-},{}],12:[function(require,module,exports){
+},{}],13:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compression = exports.ChannelID = exports.LayerCompCapturedInfo = exports.SectionDividerType = exports.ColorMode = void 0;
@@ -10588,7 +11324,7 @@ var Compression;
     Compression[Compression["ZipWithPrediction"] = 3] = "ZipWithPrediction";
 })(Compression || (exports.Compression = Compression = {}));
 
-},{}],13:[function(require,module,exports){
+},{}],14:[function(require,module,exports){
 "use strict";
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
@@ -10797,6 +11533,8 @@ function readUnicodeString(reader) {
     return readUnicodeStringWithLength(reader, length);
 }
 const STRING_CHUNK_SIZE = 0x2000;
+// shorter strings (most descriptor keys, OSTypes and names) are faster to build with simple loop than String.fromCharCode.apply
+const SHORT_STRING_LENGTH = 64;
 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');
@@ -10807,9 +11545,18 @@ function readUtf16String(reader, length, littleEndian) {
         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 = '';
+    if (length <= SHORT_STRING_LENGTH) {
+        for (let i = 0; i < length; i++, offset += 2) {
+            text += String.fromCharCode(view.getUint16(offset, littleEndian));
+        }
+        reader.offset = offset;
+        if (text.charCodeAt(text.length - 1) === 0)
+            text = text.substring(0, text.length - 1);
+        return text;
+    }
+    const codes = new Uint16Array(Math.min(length, STRING_CHUNK_SIZE));
     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) {
@@ -10840,6 +11587,15 @@ function readAsciiString(reader, length) {
     if (!(length > 0))
         return '';
     checkReadBounds(reader, length);
+    if (length <= SHORT_STRING_LENGTH) {
+        const view = reader.view;
+        let text = '';
+        for (let i = 0, offset = reader.offset; i < length; i++, offset++) {
+            text += String.fromCharCode(view.getUint8(offset));
+        }
+        reader.offset += length;
+        return text;
+    }
     const text = bytesToString(new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length));
     reader.offset += length;
     return text;
@@ -10855,7 +11611,14 @@ function checkSignature(reader, a, b) {
     }
 }
 function readShortString(reader, length) {
-    return bytesToString(readBytes(reader, length));
+    const bytes = readBytes(reader, length);
+    if (length > SHORT_STRING_LENGTH)
+        return bytesToString(bytes);
+    let text = '';
+    for (let i = 0; i < bytes.length; i++) {
+        text += String.fromCharCode(bytes[i]);
+    }
+    return text;
 }
 function isValidSignature(sig) {
     return sig === '8BIM' || sig === 'MeSa' || sig === 'AgHg' || sig === 'PHUT' || sig === 'DCSR';
@@ -11041,6 +11804,9 @@ function readLayerInfo(reader, psd, imageResources) {
         if (type === 1 /* SectionDividerType.OpenFolder */ || type === 2 /* SectionDividerType.ClosedFolder */) {
             l.opened = type === 1 /* SectionDividerType.OpenFolder */;
             l.children = [];
+            // group layers can't have image data, some broken files have it, ignore it like Photoshop does
+            delete l.canvas;
+            delete l.imageData;
             if ((_a = l.sectionDivider) === null || _a === void 0 ? void 0 : _a.key) {
                 l.blendMode = (_b = helpers_1.toBlendMode[l.sectionDivider.key]) !== null && _b !== void 0 ? _b : l.blendMode;
             }
@@ -11239,9 +12005,8 @@ function readLayerChannelImageData(reader, psd, layer, channels) {
         const start = reader.offset;
         let compression = 0 /* Compression.RawData */;
         let data = undefined;
-        if (channel.length === 1)
-            throw new Error('Invalid channel length');
-        if (channel.length) {
+        // channel length of 1 is invalid (should be 0 or at least 2), skip the byte and treat channel as empty
+        if (channel.length >= 2) {
             compression = readUint16(reader);
             // try to fix broken files where there's 1 byte shift of channel
             if (compression > 3) {
@@ -11263,7 +12028,16 @@ function readLayerChannelImageData(reader, psd, layer, channels) {
         layer.rawData.channels.push({ id: channel.id, compression, data });
     }
     if (!reader.useRawData) {
-        decodeLayerImageData(layer, reader);
+        try {
+            decodeLayerImageData(layer, reader);
+        }
+        catch (e) {
+            // corrupted image data of one layer shouldn't prevent reading rest of the file
+            if (reader.throwForMissingFeatures || e.message === 'Exceeded memory limit')
+                throw e;
+            reader.logMissingFeatures && reader.log(`Failed to decode layer image data: ${e.message}`);
+            delete layer.rawData;
+        }
     }
 }
 function resetAlpha({ data }, cmyk) {
@@ -11467,7 +12241,7 @@ function readGlobalLayerMaskInfo(reader) {
         const colorSpace2 = readUint16(reader);
         const colorSpace3 = readUint16(reader);
         const colorSpace4 = readUint16(reader);
-        const opacity = readUint16(reader) / 100; // 0 - 100
+        const opacity = Math.min(readUint16(reader), 100) / 100; // 0 - 100 (some files have values out of range)
         const kind = readUint8(reader);
         skipBytes(reader, left()); // 3 bytes of padding ?
         return { overlayColorSpace, colorSpace1, colorSpace2, colorSpace3, colorSpace4, opacity, kind };
@@ -11717,10 +12491,7 @@ function toRange(value, max) {
     value = Math.round(value * (max / 255));
     return value <= 0 ? 0 : (value >= max ? max : value);
 }
-// Polynomial approximation of U.S. Web Coated (SWOP) v2 CMYK to RGB conversion (default CMYK profile of Photoshop).
-// Coefficients are taken from pdf.js (DeviceCmykCS in src/core/colorspace.js, https://github.com/mozilla/pdf.js),
-// Copyright 2012 Mozilla Foundation, licensed under the Apache License, Version 2.0
-// (http://www.apache.org/licenses/LICENSE-2.0)
+// converts CMYK data to RGB using approximation of U.S. Web Coated (SWOP) v2 profile (see cmykToRgbValues)
 // cmyk - 8 or 16 bit data with 5 channels (cmyka), rgb - 8 or 16 bit data with 4 channels (rgba)
 // removeMatte - colors are blended with white (no ink), used for composite image of documents with global alpha
 function cmykToRgb(cmyk, rgb, removeMatte) {
@@ -11729,6 +12500,7 @@ function cmykToRgb(cmyk, rgb, removeMatte) {
     const dstData = rgb.data;
     const srcMax = srcData instanceof Uint16Array ? 0xffff : 0xff;
     const dstMax = dstData instanceof Uint16Array ? 0xffff : 0xff;
+    const out = [0, 0, 0];
     for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
         const a = srcData[src + 4];
         // image data stores inverted values (0 = 100% ink)
@@ -11743,21 +12515,10 @@ function cmykToRgb(cmyk, rgb, removeMatte) {
             y = Math.min(1, y * ra);
             k = Math.min(1, k * ra);
         }
-        dstData[dst] = toRange(255 +
-            c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k - 285.2331026137004) +
-            m * (1.7149763477362134 * m - 5.6096736904047315 * y - 17.873870861415444 * k - 5.497006427196366) +
-            y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) +
-            k * (-21.86122147463605 * k - 189.48180835922747), dstMax);
-        dstData[dst + 1] = toRange(255 +
-            c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k - 79.2970844816548) +
-            m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) +
-            y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) +
-            k * (-20.737325471181034 * k - 187.80453709719578), dstMax);
-        dstData[dst + 2] = toRange(255 +
-            c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k - 14.183576799673286) +
-            m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) +
-            y * (0.03296041114873217 * y + 115.60384449646641 * k - 193.58209356861505) +
-            k * (-22.33816807309886 * k - 180.12613974708367), dstMax);
+        (0, helpers_1.cmykToRgbValues)(c, m, y, k, out);
+        dstData[dst] = toRange(out[0], dstMax);
+        dstData[dst + 1] = toRange(out[1], dstMax);
+        dstData[dst + 2] = toRange(out[2], dstMax);
         dstData[dst + 3] = srcMax === dstMax ? a : Math.round(a * dstMax / srcMax);
     }
 }
@@ -11924,8 +12685,8 @@ function readDataZip(compressed, pixelData, width, height, bitDepth, step, offse
             recoverMemory(reader, expectedSize);
     }
 }
-// decodes single PackBits row, returns number of decoded values
-function decodeRLERow(src, i, end, dst, p, step, count) {
+// decodes single PackBits row into byte buffer, returns number of decoded bytes
+function decodeRLERow(src, i, end, dst, count) {
     let x = 0;
     while (i < end && x < count) {
         const header = src[i++];
@@ -11936,10 +12697,8 @@ function decodeRLERow(src, i, end, dst, p, step, count) {
             let n = 257 - header;
             if (n > count - x)
                 n = count - x;
+            dst.fill(value, x, x + n);
             x += n;
-            for (; n > 0; n--, p += step) {
-                dst[p] = value;
-            }
         }
         else if (header < 128) {
             let n = header + 1;
@@ -11947,9 +12706,8 @@ function decodeRLERow(src, i, end, dst, p, step, count) {
                 n = count - x;
             if (n > end - i)
                 n = end - i;
-            x += n;
-            for (; n > 0; n--, p += step) {
-                dst[p] = src[i++];
+            for (; n > 0; n--) {
+                dst[x++] = src[i++];
             }
         }
         else {
@@ -11958,6 +12716,47 @@ function decodeRLERow(src, i, end, dst, p, step, count) {
     }
     return x;
 }
+// decodes RLE rows of single 8bit channel, writing values to `data` with `step`
+// (kept as single function with the loops, inlining row decoder into readDataRLE makes V8 generate much slower code)
+function decodeRLEChannel8(src, lengths, li, pos, width, height, data, offset, step) {
+    const srcEnd = src.length | 0;
+    for (let y = 0; y < height; y++, li++) {
+        let i = (pos < srcEnd ? pos : srcEnd) | 0;
+        pos += lengths[li];
+        const end = (pos < srcEnd ? pos : srcEnd) | 0;
+        let p = (offset + y * width * step) | 0;
+        let x = 0;
+        while (i < end && x < width) {
+            const header = src[i++] | 0;
+            if (header > 128) {
+                if (i >= end)
+                    break;
+                const value = src[i++] | 0;
+                let n = (257 - header) | 0;
+                if (n > width - x)
+                    n = (width - x) | 0;
+                x = (x + n) | 0;
+                for (const pe = (p + n * step) | 0; p < pe; p = (p + step) | 0) {
+                    data[p] = value;
+                }
+            }
+            else if (header < 128) {
+                let n = (header + 1) | 0;
+                if (n > width - x)
+                    n = (width - x) | 0;
+                if (n > end - i)
+                    n = (end - i) | 0;
+                x = (x + n) | 0;
+                for (const ie = (i + n) | 0; i < ie; i = (i + 1) | 0, p = (p + step) | 0) {
+                    data[p] = src[i];
+                }
+            }
+            else {
+                // ignore 128
+            }
+        }
+    }
+}
 // 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) {
@@ -11972,8 +12771,8 @@ function scatterValues(bytes, count, bpv, data, p, step) {
         }
     }
 }
-// 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) {
+// decodes RLE rows of single 16bit or 32bit channel, each row is decoded into `row` buffer and then converted to values
+function decodeRLEChannelWide(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++) {
@@ -11982,25 +12781,24 @@ function decodeRLEChannel(src, lengths, li, pos, width, height, data, offset, st
         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 {
-            const decoded = decodeRLERow(src, rowStart, rowEnd, row, 0, 1, rowSize);
-            scatterValues(row, Math.floor(decoded / bpv), bpv, data, offset + y * width * step, step);
-        }
+        const decoded = decodeRLERow(src, rowStart, rowEnd, row, 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);
+    const lengthsMemory = rows * lengthSize;
+    const srcEnd = reader.view.byteLength;
+    const bpv = bytesPerValue(bitDepth); // throws before consuming memory
+    let lengths;
+    consumeMemory(reader, lengthsMemory);
     try {
-        if ((reader.offset + rows * lengthSize) > reader.view.byteLength) {
+        if ((reader.offset + lengthsMemory) > srcEnd) {
             throw new Error('RLE row lengths exceed buffer length');
         }
-        const lengths = large ? new Uint32Array(rows) : new Uint16Array(rows);
+        lengths = large ? new Uint32Array(rows) : new Uint16Array(rows);
         let total = 0;
         if (large) {
             for (let i = 0; i < rows; i++)
@@ -12010,32 +12808,37 @@ function readDataRLE(reader, pixelData, width, height, bitDepth, step, offsets,
             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)) {
+        if (total > (srcEnd - reader.offset)) {
             // 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);
+    }
+    catch (e) {
+        recoverMemory(reader, lengthsMemory);
+        throw e;
+    }
+    // decoding can't throw, it's kept outside of try block because V8 generates much slower code for loops inlined into try block
+    const src = new Uint8Array(reader.view.buffer, reader.view.byteOffset, srcEnd);
+    const row = (data && bpv > 1) ? new Uint8Array(width * bpv) : undefined;
+    let pos = reader.offset;
+    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) {
+            if (bpv === 1) {
+                decodeRLEChannel8(src, lengths, li, channelStart, width, height, data, offset, step);
+            }
+            else {
+                decodeRLEChannelWide(src, lengths, li, channelStart, width, height, data, offset, step, bpv, row);
             }
         }
-        reader.offset = pos;
-    }
-    finally {
-        recoverMemory(reader, rows * lengthSize);
     }
+    reader.offset = pos;
+    recoverMemory(reader, lengthsMemory);
 }
 function readSection(reader, round, func, skipEmpty = true, eightBytes = false) {
     let length = readUint32(reader);
@@ -12177,19 +12980,13 @@ function readPattern(reader) {
     // channels cover whole pattern, each 2 bytes of RLE data can produce at most 128 bytes
     if (width * height > (Math.min(end, reader.view.byteLength) - reader.offset) * 64)
         throw new Error('Pattern data out of bounds');
-    const size = width * height * 4;
-    consumeMemory(reader, size);
-    const data = new Uint8Array(size);
-    for (let i = 3; i < data.byteLength; i += 4) {
-        data[i] = 255;
-    }
     // first written arrays are color channels, next one is transparency (Photoshop stores it in the last, sheet mask, array)
     const colorChannels = colorMode === 3 /* ColorMode.RGB */ ? 3 : (colorMode === 4 /* ColorMode.CMYK */ ? 4 : 1);
-    // CMYK channels are decoded into separate buffer (5 values per pixel, inverted, 0 = 100% ink) and converted to RGB at the end
-    const cmyk = colorMode === 4 /* ColorMode.CMYK */ ? new Uint8Array(width * height * 5).fill(255) : undefined;
-    if (cmyk)
-        consumeMemory(reader, cmyk.byteLength);
-    const alphaTarget = cmyk ? 4 : 3;
+    const isCmyk = colorMode === 4 /* ColorMode.CMYK */;
+    const alphaTarget = isCmyk ? 4 : 3;
+    const channels = [];
+    let maxDecodeSize = 0;
+    // validate all channels before allocating any image data
     for (let i = 0, ch = 0; i < (channelsCount + 2) && reader.offset + 4 <= end; i++) {
         const has = readUint32(reader);
         if (!has)
@@ -12221,72 +13018,107 @@ function readPattern(reader) {
         const h = cbottom - ctop;
         const rowBytes = w * (depth / 8);
         const channelSize = rowBytes * h;
-        let bytes;
         if (compressionMode === 0) {
             if (cdata.byteLength < channelSize)
                 throw new Error('Pattern channel data out of bounds');
-            bytes = cdata;
         }
         else if (compressionMode === 1) {
             // each 2 bytes of RLE data can produce at most 128 bytes
             if (channelSize > cdata.byteLength * 64)
                 throw new Error('Pattern channel data out of bounds');
-            consumeMemory(reader, channelSize);
-            bytes = new Uint8Array(channelSize);
-            const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
-            readDataRLE(cdataReader, { data: bytes, width: rowBytes, height: h }, rowBytes, h, 8, 1, [0], false);
+            maxDecodeSize = Math.max(maxDecodeSize, channelSize);
         }
         else {
             throw new Error('Invalid pattern compression mode');
         }
+        channels.push({ target, depth, compressionMode, cdata, ctop, cleft, w, h, rowBytes, channelSize });
+    }
+    // check peak memory up front (image data, CMYK buffer and largest RLE decode buffer),
+    // image data is consumed only after successful decoding so failed patterns don't reduce the limit
+    const size = width * height * 4;
+    const cmykSize = isCmyk ? width * height * 5 : 0;
+    consumeMemory(reader, size + cmykSize + maxDecodeSize);
+    recoverMemory(reader, size + cmykSize + maxDecodeSize);
+    const data = new Uint8Array(size);
+    for (let i = 3; i < data.byteLength; i += 4) {
+        data[i] = 255;
+    }
+    // CMYK channels are decoded into separate buffer (5 values per pixel, inverted, 0 = 100% ink) and converted to RGB at the end
+    const cmyk = isCmyk ? new Uint8Array(cmykSize).fill(255) : undefined;
+    for (const { target, depth, compressionMode, cdata, ctop, cleft, w, h, rowBytes, channelSize } of channels) {
+        let bytes = cdata;
+        if (compressionMode === 1) {
+            bytes = new Uint8Array(channelSize);
+            const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
+            readDataRLE(cdataReader, { data: bytes, width: rowBytes, height: h }, rowBytes, h, 8, 1, [0], false);
+        }
+        if (depth !== 8)
+            bytes = patternChannelTo8bit(bytes, w * h, depth);
         const ox = cleft - left;
         const oy = ctop - top;
-        for (let y = 0; y < h; y++) {
-            for (let x = 0; x < w; x++) {
-                const src = x + y * w;
-                const dst = (ox + x + (y + oy) * width) * 4;
-                const value = depth === 8 ? bytes[src] : patternValueTo8bit(bytes, src, depth);
-                if (cmyk) {
-                    cmyk[(ox + x + (y + oy) * width) * 5 + target] = value;
-                }
-                else if (target === 3) {
-                    data[dst + 3] = value;
-                }
-                else if (colorMode === 2 /* ColorMode.Indexed */) {
-                    const color = palette[value];
-                    data[dst + 0] = color.r;
-                    data[dst + 1] = color.g;
-                    data[dst + 2] = color.b;
+        if (cmyk) {
+            copyPatternChannel(bytes, cmyk, w, h, (ox + oy * width) * 5 + target, width * 5, 5);
+        }
+        else if (target === 3 || colorMode === 3 /* ColorMode.RGB */) {
+            copyPatternChannel(bytes, data, w, h, (ox + oy * width) * 4 + target, width * 4, 4);
+        }
+        else if (colorMode === 2 /* ColorMode.Indexed */) {
+            const colors = new Uint8Array(256 * 3);
+            for (let i = 0; i < 256; i++) {
+                colors[i * 3 + 0] = palette[i].r;
+                colors[i * 3 + 1] = palette[i].g;
+                colors[i * 3 + 2] = palette[i].b;
+            }
+            for (let y = 0; y < h; y++) {
+                for (let x = 0, src = y * w, dst = (ox + (y + oy) * width) * 4; x < w; x++, src++, dst += 4) {
+                    const index = bytes[src] * 3;
+                    data[dst + 0] = colors[index + 0];
+                    data[dst + 1] = colors[index + 1];
+                    data[dst + 2] = colors[index + 2];
                 }
-                else if (colorMode === 1 /* ColorMode.Grayscale */) {
+            }
+        }
+        else { // grayscale
+            for (let y = 0; y < h; y++) {
+                for (let x = 0, src = y * w, dst = (ox + (y + oy) * width) * 4; x < w; x++, src++, dst += 4) {
+                    const value = bytes[src];
                     data[dst + 0] = value;
                     data[dst + 1] = value;
                     data[dst + 2] = value;
                 }
-                else {
-                    data[dst + target] = value;
-                }
             }
         }
-        if (compressionMode === 1)
-            recoverMemory(reader, channelSize);
     }
     if (cmyk) {
         cmykToRgb({ width, height, data: cmyk }, { width, height, data }, false);
-        recoverMemory(reader, cmyk.byteLength);
     }
+    consumeMemory(reader, size);
     reader.offset = end;
     return { id, name, x, y, bounds: { x: left, y: top, w: width, h: height }, data };
 }
-// converts big-endian 16bit or 32bit (float) value at given index to 8bit value
-function patternValueTo8bit(bytes, index, depth) {
+// converts big-endian 16bit or 32bit (float) values to 8bit values
+function patternChannelTo8bit(bytes, count, depth) {
+    const result = new Uint8Array(count);
     if (depth === 16) {
-        return Math.round(((bytes[index * 2] << 8) | bytes[index * 2 + 1]) / 257);
+        for (let i = 0; i < count; i++) {
+            result[i] = Math.round(((bytes[i * 2] << 8) | bytes[i * 2 + 1]) / 257);
+        }
     }
     else {
-        const view = new DataView(bytes.buffer, bytes.byteOffset + index * 4, 4);
-        const value = view.getFloat32(0, false);
-        return value > 0 ? (value < 1 ? Math.round(value * 255) : 255) : 0;
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        for (let i = 0; i < count; i++) {
+            const value = view.getFloat32(i * 4, false);
+            result[i] = value > 0 ? (value < 1 ? Math.round(value * 255) : 255) : 0;
+        }
+    }
+    return result;
+}
+// copies w x h channel values into interleaved data starting at `offset`
+function copyPatternChannel(bytes, data, w, h, offset, stride, step) {
+    for (let y = 0, src = 0; y < h; y++) {
+        for (let x = 0, dst = offset + y * stride; x < w; x++, src++, dst += step) {
+            data[dst] = bytes[src];
+        }
     }
 }
 function consumeMemory(reader, size) {
@@ -12304,7 +13136,7 @@ function recoverMemory(reader, size) {
     }
 }
 
-},{"./additionalInfo":2,"./helpers":8,"./imageResources":9,"./utf8":16,"pako":20}],14:[function(require,module,exports){
+},{"./additionalInfo":2,"./helpers":9,"./imageResources":10,"./utf8":17,"pako":21}],15:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWriter = createWriter;
@@ -12337,6 +13169,7 @@ exports.writePsd = writePsd;
 exports.writeColor = writeColor;
 exports.writePattern = writePattern;
 const helpers_1 = require("./helpers");
+const pako_1 = require("pako");
 const additionalInfo_1 = require("./additionalInfo");
 const imageResources_1 = require("./imageResources");
 const psdReader_1 = require("./psdReader");
@@ -12509,10 +13342,33 @@ function writeSection(writer, round, func, writeTotalLength = false, large = fal
 function verifyPixelData(data, name) {
     // check element size instead of instanceof, so arrays from other realms (iframes, workers, vm) are accepted
     const bytesPerElement = data && data.data.BYTES_PER_ELEMENT;
-    if (bytesPerElement !== undefined && bytesPerElement !== 1) {
-        throw new Error(`${name} has incorrect bitDepth (only 8-bit Uint8Array or Uint8ClampedArray data is supported for writing)`);
+    if (bytesPerElement !== undefined && bytesPerElement !== 1 && bytesPerElement !== 2 && !(data.data instanceof Float32Array)) {
+        throw new Error(`${name} has incorrect bitDepth (only Uint8Array, Uint8ClampedArray, Uint16Array and Float32Array data is supported for writing)`);
     }
 }
+// supported bit depths for each color mode
+const writeBitDepths = {
+    [0 /* ColorMode.Bitmap */]: [1],
+    [1 /* ColorMode.Grayscale */]: [8, 16, 32],
+    [2 /* ColorMode.Indexed */]: [8],
+    [3 /* ColorMode.RGB */]: [8, 16, 32],
+    [4 /* ColorMode.CMYK */]: [8, 16],
+};
+const colorModeNames = {
+    [0 /* ColorMode.Bitmap */]: 'Bitmap', [1 /* ColorMode.Grayscale */]: 'Grayscale', [2 /* ColorMode.Indexed */]: 'Indexed', [3 /* ColorMode.RGB */]: 'RGB',
+    [4 /* ColorMode.CMYK */]: 'CMYK', [7 /* ColorMode.Multichannel */]: 'Multichannel', [8 /* ColorMode.Duotone */]: 'Duotone', [9 /* ColorMode.Lab */]: 'Lab',
+};
+function colorChannelsCount(colorMode) {
+    return colorMode === 3 /* ColorMode.RGB */ ? 3 : (colorMode === 4 /* ColorMode.CMYK */ ? 4 : 1);
+}
+// HDR toning settings that Photoshop stores in color mode data of 32bit documents (default values of new document),
+// Photoshop refuses to open 32bit documents without them
+const hdrToningData = [
+    104, 100, 114, 116, 0, 0, 0, 3, 62, 107, 133, 31, 0, 0, 0, 2, 0, 0, 0, 7, 0, 76, 0, 105, 0, 110, 0, 101, 0, 97, 0, 114, 0, 0,
+    0, 2, 0, 2, 0, 0, 0, 0, 0, 255, 0, 255, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 65, 128, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 63, 128, 0, 0,
+    104, 100, 114, 97, 0, 0, 0, 6, 0, 0, 0, 0, 65, 160, 0, 0, 65, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 128, 0, 0, 0, 0, 0, 0,
+    0, 0,
+];
 function verifyBitCount(target) {
     var _a, _b, _c;
     (_a = target.children) === null || _a === void 0 ? void 0 : _a.forEach(verifyBitCount);
@@ -12523,34 +13379,37 @@ function verifyBitCount(target) {
         verifyPixelData((_c = target.realMask) === null || _c === void 0 ? void 0 : _c.imageData, 'realMask imageData');
 }
 function writePsd(writer, psd, options = {}) {
-    var _a;
+    var _a, _b, _c, _d;
     if (!(+psd.width > 0 && +psd.height > 0))
         throw new Error('Invalid document size');
     if ((psd.width > 30000 || psd.height > 30000) && !options.psb)
         throw new Error('Document size is too large (max is 30000x30000, use PSB format instead)');
-    const bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
-    if (bitsPerChannel !== 8)
-        throw new Error('bitsPerChannel other than 8 are not supported for writing');
+    const colorMode = (_a = psd.colorMode) !== null && _a !== void 0 ? _a : 3 /* ColorMode.RGB */;
+    const bitsPerChannel = (_b = psd.bitsPerChannel) !== null && _b !== void 0 ? _b : (colorMode === 0 /* ColorMode.Bitmap */ ? 1 : 8);
+    const bitDepths = writeBitDepths[colorMode];
+    if (!bitDepths)
+        throw new Error(`${(_c = colorModeNames[colorMode]) !== null && _c !== void 0 ? _c : colorMode} color mode is not supported for writing`);
+    if (bitDepths.indexOf(bitsPerChannel) === -1)
+        throw new Error(`bitsPerChannel ${bitsPerChannel} is not supported for writing in ${colorModeNames[colorMode]} color mode`);
+    // Photoshop doesn't support layers in bitmap and indexed color modes
+    const layersAllowed = colorMode !== 0 /* ColorMode.Bitmap */ && colorMode !== 2 /* ColorMode.Indexed */;
+    if (!layersAllowed && ((_d = psd.children) === null || _d === void 0 ? void 0 : _d.length))
+        throw new Error(`Layers are not supported in ${colorModeNames[colorMode]} color mode`);
+    if (colorMode === 2 /* ColorMode.Indexed */ && !psd.palette)
+        throw new Error('Missing color palette for Indexed color mode');
     if (options.log)
         writer.log = options.log;
+    if (options.logMissingFeatures)
+        writer.logMissingFeatures = true;
     const layers = [];
     addChildren(layers, psd.children);
-    if (!layers.length)
+    if (!layers.length && layersAllowed)
         layers.push({});
     verifyBitCount(psd);
     const imageResources = Object.assign({}, psd.imageResources);
-    const opt = Object.assign(Object.assign({}, options), { layerIds: new Set(), layerToId: new Map() });
-    // document is always written in RGB color mode, skip resources specific to original color mode
-    if (psd.colorMode !== undefined && psd.colorMode !== 3 /* ColorMode.RGB */) {
-        delete imageResources.iccProfile;
-        delete imageResources.indexedColorCount;
-        delete imageResources.transparencyIndex;
-        delete imageResources.alphaChannelDisplayInfo;
-        delete imageResources.colorHalftoneScreens;
-        delete imageResources.grayscaleHalftoneScreens;
-        delete imageResources.colorTransferFunctions;
-        delete imageResources.grayscaleTransferFunctions;
-    }
+    const opt = Object.assign(Object.assign({}, options), { layerIds: new Set(), layerToId: new Map(), colorMode, bitsPerChannel });
+    // 16 and 32 bit documents store layers in Lr16 / Lr32 section of global additional info
+    const layersInGlobalInfo = bitsPerChannel === 16 || bitsPerChannel === 32;
     if (opt.generateThumbnail) {
         imageResources.thumbnail = createThumbnail(psd);
     }
@@ -12563,20 +13422,34 @@ function writePsd(writer, psd, options = {}) {
     }
     if (imageData && (psd.width !== imageData.width || psd.height !== imageData.height))
         throw new Error('Document canvas must have the same size as document');
-    const globalAlpha = !!imageData && (0, helpers_1.hasAlpha)(imageData);
+    const globalAlpha = !!imageData && layersAllowed && (0, helpers_1.hasAlpha)(imageData);
     // only used for encoding a single layer channel at a time, composite image is encoded directly into the writer buffer
     writer.tempBuffer = new Uint8Array(getLargestLayerSize(psd.children, !!options.psb));
     // header
     writeSignature(writer, '8BPS');
     writeUint16(writer, options.psb ? 2 : 1); // version
     writeZeros(writer, 6);
-    writeUint16(writer, globalAlpha ? 4 : 3); // channels
+    writeUint16(writer, colorChannelsCount(colorMode) + (globalAlpha ? 1 : 0)); // channels
     writeUint32(writer, psd.height);
     writeUint32(writer, psd.width);
     writeUint16(writer, bitsPerChannel); // bits per channel
-    writeUint16(writer, 3 /* ColorMode.RGB */); // we only support saving RGB right now
-    // color mode data (empty for RGB color mode)
-    writeUint32(writer, 0);
+    writeUint16(writer, colorMode);
+    // color mode data
+    writeSection(writer, 1, () => {
+        var _a, _b, _c, _d, _e, _f;
+        if (colorMode === 2 /* ColorMode.Indexed */) {
+            const palette = psd.palette;
+            for (let i = 0; i < 256; i++)
+                writeUint8(writer, (_b = (_a = palette[i]) === null || _a === void 0 ? void 0 : _a.r) !== null && _b !== void 0 ? _b : 0);
+            for (let i = 0; i < 256; i++)
+                writeUint8(writer, (_d = (_c = palette[i]) === null || _c === void 0 ? void 0 : _c.g) !== null && _d !== void 0 ? _d : 0);
+            for (let i = 0; i < 256; i++)
+                writeUint8(writer, (_f = (_e = palette[i]) === null || _e === void 0 ? void 0 : _e.b) !== null && _f !== void 0 ? _f : 0);
+        }
+        else if (bitsPerChannel === 32) {
+            writeBytes(writer, new Uint8Array(hdrToningData));
+        }
+    });
     // image resources
     imageResources.layersGroup = layers.map(l => l.linkGroup || 0);
     imageResources.layerGroupsEnabledId = layers.map(l => l.linkGroupEnabled == false ? 0 : 1);
@@ -12596,20 +13469,202 @@ function writePsd(writer, psd, options = {}) {
     });
     // layer and mask info
     writeSection(writer, 2, () => {
-        writeLayerInfo(writer, layers, psd, globalAlpha, opt);
+        if (layersInGlobalInfo || !layersAllowed) {
+            writeSection(writer, 4, () => { }, true, opt.psb); // empty layer info
+        }
+        else {
+            writeLayerInfo(writer, layers, psd, globalAlpha, opt);
+        }
         writeGlobalLayerMaskInfo(writer, psd.globalLayerMaskInfo);
+        if (layersInGlobalInfo) {
+            if (globalAlpha)
+                writeGlobalInfoSection(writer, bitsPerChannel === 16 ? 'Mt16' : 'Mt32', !!opt.psb, () => { });
+            writeGlobalInfoSection(writer, bitsPerChannel === 16 ? 'Lr16' : 'Lr32', !!opt.psb, () => {
+                writeLayerInfoData(writer, layers, psd, globalAlpha, opt);
+            });
+        }
         writeAdditionalLayerInfo(writer, psd, psd, opt);
     }, undefined, !!opt.psb);
     writer.tempBuffer = undefined;
     // image data
-    writeUint16(writer, 1 /* Compression.RleCompressed */); // Photoshop doesn't support zip compression of composite image data
-    const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
-    const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
-    // encode directly into the writer buffer
-    const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
-    ensureSize(writer, writer.offset + maxSize);
-    const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
-    writer.offset += (0, helpers_1.writeDataRLE)(buffer, data, channels, !!options.psb).length;
+    if (colorMode === 3 /* ColorMode.RGB */ && bitsPerChannel === 8 && (!imageData || is8bit(imageData))) {
+        writeUint16(writer, 1 /* Compression.RleCompressed */); // Photoshop doesn't support zip compression of composite image data
+        const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
+        const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
+        // encode directly into the writer buffer
+        const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
+        ensureSize(writer, writer.offset + maxSize);
+        const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
+        writer.offset += (0, helpers_1.writeDataRLE)(buffer, data, channels, !!options.psb).length;
+    }
+    else {
+        writeCompositeImageData(writer, psd, imageData, colorMode, bitsPerChannel, globalAlpha, !!options.psb);
+    }
+}
+function writeGlobalInfoSection(writer, key, psb, func) {
+    writeSignature(writer, psb ? '8B64' : '8BIM');
+    writeSignature(writer, key);
+    writeSection(writer, 4, func, false, psb);
+}
+function is8bit(data) {
+    return data.data.BYTES_PER_ELEMENT === 1;
+}
+// converts image data (8, 16 or 32 bit RGBA data) to channels of the document color mode and bit depth
+function getPlanarChannels(imageData, colorMode, bitsPerChannel, matte) {
+    const { data, width, height } = imageData;
+    const size = width * height;
+    const srcFloat = data instanceof Float32Array;
+    const srcMax = srcFloat ? 1 : (data instanceof Uint16Array ? 0xffff : 0xff);
+    const dstFloat = bitsPerChannel === 32;
+    const dstMax = dstFloat ? 1 : (bitsPerChannel === 16 ? 0xffff : 0xff);
+    const colorCount = colorChannelsCount(colorMode);
+    const create = () => dstFloat ? new Float32Array(size) : (bitsPerChannel === 16 ? new Uint16Array(size) : new Uint8Array(size));
+    const colors = [];
+    for (let i = 0; i < colorCount; i++)
+        colors.push(create());
+    const alpha = create();
+    // color values are gamma corrected when converting between float (linear) and integer values (same as imageDataToCanvas)
+    const toNormalized = (v) => srcFloat ? Math.pow((0, helpers_1.clamp)(v, 0, 1), 1 / 2.2) : v / srcMax;
+    const fromNormalized = (v) => dstFloat ? Math.pow(v, 2.2) : Math.round((0, helpers_1.clamp)(v, 0, 1) * dstMax);
+    const sameType = srcFloat === dstFloat && srcMax === dstMax;
+    const convertColor = (v) => sameType ? (dstFloat ? v : Math.round(v)) : fromNormalized(toNormalized(v));
+    const convertAlpha = (v) => sameType ? v : (dstFloat ? v / srcMax : Math.round((0, helpers_1.clamp)(v / srcMax, 0, 1) * dstMax));
+    const cmyk = [0, 0, 0, 0];
+    for (let i = 0, p = 0; i < size; i++, p += 4) {
+        const a = data[p + 3];
+        const alphaValue = convertAlpha(a);
+        alpha[i] = alphaValue;
+        // composite image colors are blended with white (or no ink) for documents with transparency
+        const blend = matte && a !== srcMax && a > 0 ? (0, helpers_1.clamp)(a / srcMax, 0, 1) : 1;
+        if (colorMode === 4 /* ColorMode.CMYK */) {
+            (0, helpers_1.rgbToCmykValues)(toNormalized(data[p]), toNormalized(data[p + 1]), toNormalized(data[p + 2]), cmyk);
+            for (let j = 0; j < 4; j++) {
+                colors[j][i] = Math.round((1 - (0, helpers_1.clamp)(cmyk[j] * blend, 0, 1)) * dstMax); // stored inverted (0 = 100% ink)
+            }
+        }
+        else {
+            for (let j = 0; j < colorCount; j++) {
+                let value;
+                if (colorMode === 3 /* ColorMode.RGB */) {
+                    value = convertColor(data[p + j]);
+                }
+                else {
+                    const r = data[p], g = data[p + 1], b = data[p + 2];
+                    value = convertColor((r === g && g === b) ? r : (0.299 * r + 0.587 * g + 0.114 * b));
+                }
+                if (blend !== 1)
+                    value = dstFloat ? value * blend + 1 - blend : Math.round(value * blend + dstMax * (1 - blend));
+                colors[j][i] = value;
+            }
+        }
+    }
+    return { colors, alpha };
+}
+function encodeChannel(values, width, height, options) {
+    if (!(values instanceof Uint8Array)) {
+        return { data: (0, helpers_1.writeDataZipWithPrediction)(values, width, height), compression: 3 /* Compression.ZipWithPrediction */ };
+    }
+    else if (options.compress) {
+        return { data: (0, pako_1.deflate)(values), compression: 2 /* Compression.ZipWithoutPrediction */ };
+    }
+    else {
+        return { data: (0, helpers_1.writeDataRLEBytes)(values, width, height, !!options.psb), compression: 1 /* Compression.RleCompressed */ };
+    }
+}
+function writeCompositeImageData(writer, psd, imageData, colorMode, bitsPerChannel, globalAlpha, psb) {
+    var _a;
+    const { width, height } = psd;
+    const data = imageData !== null && imageData !== void 0 ? imageData : { data: new Uint8Array(width * height * 4), width, height };
+    const parts = [];
+    if (colorMode === 0 /* ColorMode.Bitmap */ || colorMode === 2 /* ColorMode.Indexed */) {
+        const values = colorMode === 0 /* ColorMode.Bitmap */ ?
+            getBitmapData(data) :
+            getIndexedData(data, psd.palette, (_a = psd.imageResources) === null || _a === void 0 ? void 0 : _a.transparencyIndex);
+        const rowBytes = colorMode === 0 /* ColorMode.Bitmap */ ? Math.ceil(width / 8) : width;
+        if (colorMode === 0 /* ColorMode.Bitmap */) {
+            writeUint16(writer, 0 /* Compression.RawData */);
+            parts.push(values);
+        }
+        else {
+            writeUint16(writer, 1 /* Compression.RleCompressed */);
+            parts.push((0, helpers_1.writeDataRLEBytes)(values, rowBytes, height, psb));
+        }
+    }
+    else {
+        const { colors, alpha } = getPlanarChannels(data, colorMode, bitsPerChannel, globalAlpha);
+        const channels = globalAlpha ? [...colors, alpha] : colors;
+        if (bitsPerChannel === 8) {
+            // row byte counts for all channels are stored before data of all channels
+            const encoded = channels.map(c => (0, helpers_1.writeDataRLEBytes)(c, width, height, psb));
+            const countsSize = height * (psb ? 4 : 2);
+            writeUint16(writer, 1 /* Compression.RleCompressed */);
+            for (const e of encoded)
+                parts.push(e.subarray(0, countsSize));
+            for (const e of encoded)
+                parts.push(e.subarray(countsSize));
+        }
+        else {
+            writeUint16(writer, 0 /* Compression.RawData */); // Photoshop writes 16 and 32 bit composite image without compression
+            for (const c of channels)
+                parts.push((0, helpers_1.planarToBytes)(c));
+        }
+    }
+    for (const part of parts)
+        writeBytes(writer, part);
+}
+function getBitmapData({ data, width, height }) {
+    const rowBytes = Math.ceil(width / 8);
+    const result = new Uint8Array(rowBytes * height);
+    const max = data instanceof Float32Array ? 1 : (data instanceof Uint16Array ? 0xffff : 0xff);
+    for (let y = 0, p = 0; y < height; y++) {
+        for (let x = 0; x < width; x++, p += 4) {
+            const a = data[p + 3] / max;
+            const value = ((0.299 * data[p] + 0.587 * data[p + 1] + 0.114 * data[p + 2]) / max) * a + (1 - a); // blend with white
+            if (value < 0.5)
+                result[y * rowBytes + (x >> 3)] |= 0x80 >> (x & 7); // 1 = black
+        }
+    }
+    return result;
+}
+function getIndexedData({ data, width, height }, palette, transparencyIndex) {
+    const size = width * height;
+    const result = new Uint8Array(size);
+    const shift = data instanceof Uint16Array ? 8 : 0;
+    const cache = new Map();
+    for (let i = 0; i < palette.length && i < 256; i++) {
+        const key = (palette[i].r << 16) | (palette[i].g << 8) | palette[i].b;
+        if (i !== transparencyIndex && !cache.has(key))
+            cache.set(key, i);
+    }
+    for (let i = 0, p = 0; i < size; i++, p += 4) {
+        const read = (v) => data instanceof Float32Array ? Math.round(Math.pow((0, helpers_1.clamp)(v, 0, 1), 1 / 2.2) * 255) : (v >>> shift);
+        const a = data instanceof Float32Array ? data[p + 3] * 255 : (data[p + 3] >>> shift);
+        if (transparencyIndex !== undefined && transparencyIndex >= 0 && a < 128) {
+            result[i] = transparencyIndex;
+            continue;
+        }
+        const r = read(data[p]), g = read(data[p + 1]), b = read(data[p + 2]);
+        const key = (r << 16) | (g << 8) | b;
+        let index = cache.get(key);
+        if (index === undefined) {
+            // use closest color from the palette
+            let best = Infinity;
+            index = 0;
+            for (let j = 0; j < palette.length && j < 256; j++) {
+                if (j === transparencyIndex)
+                    continue;
+                const dr = palette[j].r - r, dg = palette[j].g - g, db = palette[j].b - b;
+                const distance = dr * dr + dg * dg + db * db;
+                if (distance < best) {
+                    best = distance;
+                    index = j;
+                }
+            }
+            cache.set(key, index);
+        }
+        result[i] = index;
+    }
+    return result;
 }
 function getCompositeData(imageData, width, height, globalAlpha) {
     if (!imageData)
@@ -12635,60 +13690,61 @@ function getCompositeData(imageData, width, height, globalAlpha) {
     return dst ? { data: dst, width, height } : imageData;
 }
 function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
-    writeSection(writer, 4, () => {
-        var _a;
-        writeInt16(writer, globalAlpha ? -layers.length : layers.length);
-        const layersData = layers.map((l, i) => getChannels(writer, l, i === 0, options));
-        // layer records
-        for (const layerData of layersData) {
-            const { layer, top, left, bottom, right, channels } = layerData;
-            writeInt32(writer, top);
-            writeInt32(writer, left);
-            writeInt32(writer, bottom);
-            writeInt32(writer, right);
-            writeUint16(writer, channels.length);
-            for (const c of channels) {
-                writeInt16(writer, c.id);
-                if (options.psb) {
-                    writeUint64(writer, c.length);
-                }
-                else {
-                    writeUint32(writer, c.length);
-                }
+    writeSection(writer, 4, () => writeLayerInfoData(writer, layers, psd, globalAlpha, options), true, options.psb);
+}
+function writeLayerInfoData(writer, layers, psd, globalAlpha, options) {
+    var _a;
+    writeInt16(writer, globalAlpha ? -layers.length : layers.length);
+    const layersData = layers.map((l, i) => getChannels(writer, l, i === 0, options));
+    // layer records
+    for (const layerData of layersData) {
+        const { layer, top, left, bottom, right, channels } = layerData;
+        writeInt32(writer, top);
+        writeInt32(writer, left);
+        writeInt32(writer, bottom);
+        writeInt32(writer, right);
+        writeUint16(writer, channels.length);
+        for (const c of channels) {
+            writeInt16(writer, c.id);
+            if (options.psb) {
+                writeUint64(writer, c.length);
             }
-            writeSignature(writer, '8BIM');
-            writeSignature(writer, helpers_1.fromBlendMode[layer.blendMode] || 'norm');
-            writeUint8(writer, Math.round((0, helpers_1.clamp)((_a = layer.opacity) !== null && _a !== void 0 ? _a : 1, 0, 1) * 255));
-            writeUint8(writer, layer.clipping ? 1 : 0);
-            let flags = 0x08; // 1 for Photoshop 5.0 and later, tells if bit 4 has useful information
-            if (layer.transparencyProtected)
-                flags |= 0x01;
-            if (layer.hidden)
-                flags |= 0x02;
-            if (layer.vectorMask || (layer.sectionDivider && layer.sectionDivider.type !== 0 /* SectionDividerType.Other */) || layer.adjustment) {
-                flags |= 0x10; // pixel data irrelevant to appearance of document
+            else {
+                writeUint32(writer, c.length);
             }
-            if (layer.effectsOpen)
-                flags |= 0x20;
-            writeUint8(writer, flags);
-            writeUint8(writer, 0); // filler
-            writeSection(writer, 1, () => {
-                writeLayerMaskData(writer, layer, layerData);
-                writeLayerBlendingRanges(writer, layer);
-                writePascalString(writer, (layer.name || '').substring(0, 255), 4);
-                writeAdditionalLayerInfo(writer, layer, psd, options);
-            });
         }
-        // layer channel image data
-        for (const layerData of layersData) {
-            for (const channel of layerData.channels) {
-                writeUint16(writer, channel.compression);
-                if (channel.data) {
-                    writeBytes(writer, channel.data);
-                }
+        writeSignature(writer, '8BIM');
+        writeSignature(writer, helpers_1.fromBlendMode[layer.blendMode] || 'norm');
+        writeUint8(writer, Math.round((0, helpers_1.clamp)((_a = layer.opacity) !== null && _a !== void 0 ? _a : 1, 0, 1) * 255));
+        writeUint8(writer, layer.clipping ? 1 : 0);
+        let flags = 0x08; // 1 for Photoshop 5.0 and later, tells if bit 4 has useful information
+        if (layer.transparencyProtected)
+            flags |= 0x01;
+        if (layer.hidden)
+            flags |= 0x02;
+        if (layer.vectorMask || (layer.sectionDivider && layer.sectionDivider.type !== 0 /* SectionDividerType.Other */) || layer.adjustment) {
+            flags |= 0x10; // pixel data irrelevant to appearance of document
+        }
+        if (layer.effectsOpen)
+            flags |= 0x20;
+        writeUint8(writer, flags);
+        writeUint8(writer, 0); // filler
+        writeSection(writer, 1, () => {
+            writeLayerMaskData(writer, layer, layerData);
+            writeLayerBlendingRanges(writer, layer);
+            writePascalString(writer, (layer.name || '').substring(0, 255), 4);
+            writeAdditionalLayerInfo(writer, layer, psd, options);
+        });
+    }
+    // layer channel image data
+    for (const layerData of layersData) {
+        for (const channel of layerData.channels) {
+            writeUint16(writer, channel.compression);
+            if (channel.data) {
+                writeBytes(writer, channel.data);
             }
         }
-    }, true, options.psb);
+    }
 }
 // real mask is only stored separately if layer has both vector and pixel masks, otherwise it's stored as the main mask
 function getMasks(layer) {
@@ -12891,6 +13947,7 @@ function createThumbnail(psd) {
     return canvas;
 }
 function getMaskChannels(tempBuffer, layerData, mask, options, realMask) {
+    var _a;
     let top = mask.top | 0;
     let left = mask.left | 0;
     let right = mask.right | 0;
@@ -12907,10 +13964,15 @@ function getMaskChannels(tempBuffer, layerData, mask, options, realMask) {
     bottom = top + height;
     let buffer;
     let compression;
+    const bitsPerChannel = (_a = options.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
     if (!imageData) {
         buffer = new Uint8Array(0);
         compression = 1 /* Compression.RleCompressed */;
     }
+    else if (bitsPerChannel !== 8 || !is8bit(imageData)) {
+        const { colors } = getPlanarChannels(imageData, 3 /* ColorMode.RGB */, bitsPerChannel, false);
+        ({ data: buffer, compression } = encodeChannel(colors[0], width, height, options));
+    }
     else if (options.compress) {
         buffer = (0, helpers_1.writeDataZipWithoutPrediction)(imageData, [0]);
         compression = 2 /* Compression.ZipWithoutPrediction */;
@@ -12931,16 +13993,16 @@ function bounds(obj) {
     } : undefined;
 }
 function getChannels(writer, layer, background, options) {
+    var _a, _b;
     let source = layer;
     if (layer.rawData) {
         const { colorMode, bitsPerChannel, large } = layer.rawData;
-        if (large === !!options.psb && colorMode === 3 /* ColorMode.RGB */ && bitsPerChannel === 8) {
+        const opt = options;
+        if (large === !!options.psb && colorMode === ((_a = opt.colorMode) !== null && _a !== void 0 ? _a : 3 /* ColorMode.RGB */) && bitsPerChannel === ((_b = opt.bitsPerChannel) !== null && _b !== void 0 ? _b : 8)) {
             // same mask mapping as in writeLayerMaskData
             const { mask, realMask } = getMasks(layer);
             return Object.assign(Object.assign({ layer, channels: layer.rawData.channels.map(c => { var _a, _b; return (Object.assign(Object.assign({}, c), { length: 2 + ((_b = (_a = c.data) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0) })); }) }, bounds(layer)), { mask: bounds(mask), realMask: bounds(realMask) });
         }
-        if (bitsPerChannel !== 8)
-            throw new Error('Layer raw data with bitsPerChannel other than 8 is not supported for writing');
         // raw data is in different format than the one we're writing, decode it so it can be re-encoded
         source = Object.assign(Object.assign({}, layer), { rawData: undefined, canvas: undefined, imageData: (0, psdReader_1.getLayerImageData)(layer), mask: layer.mask && Object.assign(Object.assign({}, layer.mask), { canvas: undefined, imageData: (0, psdReader_1.getLayerMaskImageData)(layer) }), realMask: layer.realMask && Object.assign(Object.assign({}, layer.realMask), { canvas: undefined, imageData: (0, psdReader_1.getLayerRealMaskImageData)(layer) }) });
         // temp buffer is sized only for layers with image data, grow it and keep it for following layers
@@ -12966,10 +14028,8 @@ function getLayerDimentions({ canvas, imageData }) {
     return { width, height };
 }
 function cropImageData(data, left, top, width, height) {
-    if (data.data instanceof Uint32Array || data.data instanceof Uint16Array) {
-        throw new Error('imageData has incorrect bit depth');
-    }
-    const croppedData = (0, helpers_1.createImageData)(width, height);
+    const croppedData = is8bit(data) ? (0, helpers_1.createImageData)(width, height) :
+        { width, height, data: new data.data.constructor(width * height * 4) };
     const srcData = data.data;
     const dstData = croppedData.data;
     for (let y = 0; y < height; y++) {
@@ -12985,6 +14045,7 @@ function cropImageData(data, left, top, width, height) {
     return croppedData;
 }
 function getLayerChannels(tempBuffer, layer, background, options) {
+    var _a, _b;
     let top = layer.top | 0;
     let left = layer.left | 0;
     let right = layer.right | 0;
@@ -12997,8 +14058,11 @@ function getLayerChannels(tempBuffer, layer, background, options) {
     ];
     let { width, height } = getLayerDimentions(layer);
     if (!(layer.canvas || layer.imageData) || !width || !height) {
-        right = left;
-        bottom = top;
+        // layer without image data is empty, keep inverted (negative size) bounds from some files as they are
+        if (layer.right === undefined || right > left)
+            right = left;
+        if (layer.bottom === undefined || bottom > top)
+            bottom = top;
         return { layer, top, left, right, bottom, channels };
     }
     right = left + width;
@@ -13026,6 +14090,19 @@ function getLayerChannels(tempBuffer, layer, background, options) {
     if (!background || options.noBackground || layer.mask || (0, helpers_1.hasAlpha)(imageData)) {
         channelIds.unshift(-1 /* ChannelID.Transparency */);
     }
+    const colorMode = (_a = options.colorMode) !== null && _a !== void 0 ? _a : 3 /* ColorMode.RGB */;
+    const bitsPerChannel = (_b = options.bitsPerChannel) !== null && _b !== void 0 ? _b : 8;
+    if (colorMode !== 3 /* ColorMode.RGB */ || bitsPerChannel !== 8 || !is8bit(imageData)) {
+        const { colors, alpha } = getPlanarChannels(imageData, colorMode, bitsPerChannel, false);
+        const ids = channelIds[0] === -1 /* ChannelID.Transparency */ ? [-1 /* ChannelID.Transparency */] : [];
+        for (let i = 0; i < colors.length; i++)
+            ids.push(i);
+        channels = ids.map(id => {
+            const { data, compression } = encodeChannel(id === -1 /* ChannelID.Transparency */ ? alpha : colors[id], width, height, options);
+            return { id, compression, data, length: 2 + data.length };
+        });
+        return { layer, top, left, right, bottom, channels };
+    }
     channels = channelIds.map(id => {
         const offset = (0, helpers_1.offsetForChannel)(id, false); // image data is always RGBA
         let data;
@@ -13183,10 +14260,11 @@ function writePattern(writer, pattern) {
     writer.view.setUint32(pattsOffset - 4, pattsLength, false);
 }
 
-},{"./additionalInfo":2,"./helpers":8,"./imageResources":9,"./psdReader":13}],15:[function(require,module,exports){
+},{"./additionalInfo":2,"./helpers":9,"./imageResources":10,"./psdReader":14,"pako":21}],16:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeEngineData = decodeEngineData;
+exports.decodeLegacyTextData = decodeLegacyTextData;
 exports.encodeEngineData = encodeEngineData;
 const helpers_1 = require("./helpers");
 const defaultFont = {
@@ -13613,6 +14691,63 @@ function decodeEngineData(engineData) {
         delete result.styleRuns;
     return result;
 }
+const fixed = (value) => value / 0x10000; // 16.16 fixed point value
+function decodeLegacyTextData(data) {
+    var _a, _b, _c, _d;
+    const styleRuns = [];
+    let text = '';
+    for (const line of data.lines) {
+        for (const { code, style } of line.chars) {
+            text += String.fromCharCode(code);
+            const last = styleRuns[styleRuns.length - 1];
+            if (last && last.mark === style) {
+                last.length++;
+            }
+            else {
+                styleRuns.push({ length: 1, mark: style });
+            }
+        }
+    }
+    // remove one trailing new line (Photoshop always appends it)
+    if (text.endsWith('\r')) {
+        text = text.slice(0, -1);
+        if (--styleRuns[styleRuns.length - 1].length === 0)
+            styleRuns.pop();
+    }
+    const runs = styleRuns.map(({ length, mark }) => {
+        var _a, _b;
+        const s = (_a = data.styles.find(s => s.mark === mark)) !== null && _a !== void 0 ? _a : data.styles[0];
+        const face = s && ((_b = data.faces.find(f => f.mark === s.faceMark)) !== null && _b !== void 0 ? _b : data.faces[0]);
+        const style = {};
+        if (face)
+            style.font = { name: face.name, script: face.script };
+        if (s) {
+            style.fontSize = fixed(s.size);
+            style.autoLeading = s.leading === 0;
+            if (s.leading)
+                style.leading = fixed(s.leading);
+            style.tracking = Math.round(fixed(s.tracking) * 1000); // stored in ems
+            style.autoKerning = s.autoKerning;
+            style.kerning = Math.round(fixed(s.kerning) * 1000); // stored in ems
+            style.baselineShift = fixed(s.baselineShift);
+        }
+        style.fillColor = data.color;
+        return { length, style };
+    });
+    const result = {
+        text: text.replace(/\r/g, '\n'),
+        transform: data.transform,
+        antiAlias: data.antiAlias ? 'smooth' : 'none',
+        orientation: ((_a = data.lines[0]) === null || _a === void 0 ? void 0 : _a.orientation) === 1 ? 'vertical' : 'horizontal',
+        paragraphStyle: { justification: (_d = justification[(_c = (_b = data.lines[0]) === null || _b === void 0 ? void 0 : _b.alignment) !== null && _c !== void 0 ? _c : 0]) !== null && _d !== void 0 ? _d : 'left' },
+        style: {},
+        styleRuns: runs,
+    };
+    deduplicateValues(result.style, result.styleRuns, styleKeys);
+    if (!result.styleRuns.length)
+        delete result.styleRuns;
+    return result;
+}
 // Adjusts run lengths (specified in terms of the original text) for characters removed from the text
 // (\r characters of \r\n pairs that are collapsed into single \r)
 function adjustRunLengths(runs, removed) {
@@ -13851,7 +14986,7 @@ function encodeEngineData(data) {
     return engineData;
 }
 
-},{"./helpers":8}],16:[function(require,module,exports){
+},{"./helpers":9}],17:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringLengthInBytes = stringLengthInBytes;
@@ -14038,7 +15173,7 @@ function decodeString(value) {
     return result.join('');
 }
 
-},{}],17:[function(require,module,exports){
+},{}],18:[function(require,module,exports){
 'use strict'
 
 exports.byteLength = byteLength
@@ -14190,7 +15325,7 @@ function fromByteArray (uint8) {
   return parts.join('')
 }
 
-},{}],18:[function(require,module,exports){
+},{}],19:[function(require,module,exports){
 (function (Buffer){(function (){
 /*!
  * The buffer module from node.js, for the browser.
@@ -15971,7 +17106,7 @@ function numberIsNaN (obj) {
 }
 
 }).call(this)}).call(this,require("buffer").Buffer)
-},{"base64-js":17,"buffer":18,"ieee754":19}],19:[function(require,module,exports){
+},{"base64-js":18,"buffer":19,"ieee754":20}],20:[function(require,module,exports){
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 exports.read = function (buffer, offset, isLE, mLen, nBytes) {
   var e, m
@@ -16058,7 +17193,7 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
   buffer[offset + i - d] |= s * 128
 }
 
-},{}],20:[function(require,module,exports){
+},{}],21:[function(require,module,exports){
 // Top level file is just a mixin of submodules & constants
 'use strict';
 
@@ -16078,7 +17213,7 @@ module.exports.inflateRaw = inflateRaw;
 module.exports.ungzip = ungzip;
 module.exports.constants = constants;
 
-},{"./lib/deflate":21,"./lib/inflate":22,"./lib/zlib/constants":26}],21:[function(require,module,exports){
+},{"./lib/deflate":22,"./lib/inflate":23,"./lib/zlib/constants":27}],22:[function(require,module,exports){
 'use strict';
 
 
@@ -16460,7 +17595,7 @@ module.exports.deflateRaw = deflateRaw;
 module.exports.gzip = gzip;
 module.exports.constants = require('./zlib/constants');
 
-},{"./utils/common":23,"./utils/strings":24,"./zlib/constants":26,"./zlib/deflate":28,"./zlib/messages":33,"./zlib/zstream":35}],22:[function(require,module,exports){
+},{"./utils/common":24,"./utils/strings":25,"./zlib/constants":27,"./zlib/deflate":29,"./zlib/messages":34,"./zlib/zstream":36}],23:[function(require,module,exports){
 'use strict';
 
 
@@ -16881,7 +18016,7 @@ module.exports.inflateRaw = inflateRaw;
 module.exports.ungzip = inflate;
 module.exports.constants = require('./zlib/constants');
 
-},{"./utils/common":23,"./utils/strings":24,"./zlib/constants":26,"./zlib/gzheader":29,"./zlib/inflate":31,"./zlib/messages":33,"./zlib/zstream":35}],23:[function(require,module,exports){
+},{"./utils/common":24,"./utils/strings":25,"./zlib/constants":27,"./zlib/gzheader":30,"./zlib/inflate":32,"./zlib/messages":34,"./zlib/zstream":36}],24:[function(require,module,exports){
 'use strict';
 
 
@@ -16931,7 +18066,7 @@ module.exports.flattenChunks = (chunks) => {
   return result;
 };
 
-},{}],24:[function(require,module,exports){
+},{}],25:[function(require,module,exports){
 // String encode/decode helpers
 'use strict';
 
@@ -17107,7 +18242,7 @@ module.exports.utf8border = (buf, max) => {
   return (pos + _utf8len[buf[pos]] > max) ? pos : max;
 };
 
-},{}],25:[function(require,module,exports){
+},{}],26:[function(require,module,exports){
 'use strict';
 
 // Note: adler32 takes 12% for level 0 and 2% for level 6.
@@ -17160,7 +18295,7 @@ const adler32 = (adler, buf, len, pos) => {
 
 module.exports = adler32;
 
-},{}],26:[function(require,module,exports){
+},{}],27:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -17230,7 +18365,7 @@ module.exports = {
   //Z_NULL:                 null // Use -1 or null inline, depending on var type
 };
 
-},{}],27:[function(require,module,exports){
+},{}],28:[function(require,module,exports){
 'use strict';
 
 // Note: we can't get significant speed boost here.
@@ -17291,7 +18426,7 @@ const crc32 = (crc, buf, len, pos) => {
 
 module.exports = crc32;
 
-},{}],28:[function(require,module,exports){
+},{}],29:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -19341,7 +20476,7 @@ module.exports.deflatePrime = deflatePrime;
 module.exports.deflateTune = deflateTune;
 */
 
-},{"./adler32":25,"./constants":26,"./crc32":27,"./messages":33,"./trees":34}],29:[function(require,module,exports){
+},{"./adler32":26,"./constants":27,"./crc32":28,"./messages":34,"./trees":35}],30:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -19401,7 +20536,7 @@ function GZheader() {
 
 module.exports = GZheader;
 
-},{}],30:[function(require,module,exports){
+},{}],31:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -19747,7 +20882,7 @@ module.exports = function inflate_fast(strm, start) {
   return;
 };
 
-},{}],31:[function(require,module,exports){
+},{}],32:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -21321,7 +22456,7 @@ module.exports.inflateUndermine = inflateUndermine;
 module.exports.inflateValidate = inflateValidate;
 */
 
-},{"./adler32":25,"./constants":26,"./crc32":27,"./inffast":30,"./inftrees":32}],32:[function(require,module,exports){
+},{"./adler32":26,"./constants":27,"./crc32":28,"./inffast":31,"./inftrees":33}],33:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -21663,7 +22798,7 @@ const inflate_table = (type, lens, lens_index, codes, table, table_index, work,
 
 module.exports = inflate_table;
 
-},{}],33:[function(require,module,exports){
+},{}],34:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -21697,7 +22832,7 @@ module.exports = {
   '-6':   'incompatible version' /* Z_VERSION_ERROR (-6) */
 };
 
-},{}],34:[function(require,module,exports){
+},{}],35:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -22878,7 +24013,7 @@ module.exports._tr_flush_block  = _tr_flush_block;
 module.exports._tr_tally = _tr_tally;
 module.exports._tr_align = _tr_align;
 
-},{}],35:[function(require,module,exports){
+},{}],36:[function(require,module,exports){
 'use strict';
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -22927,5 +24062,5 @@ function ZStream() {
 
 module.exports = ZStream;
 
-},{}]},{},[10])(10)
+},{}]},{},[11])(11)
 });