ag-psd 32.0.0 → 34.0.0

package/dist/additionalInfo.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.booleanOperations = exports.infoHandlersMap = exports.infoHandlers = void 0;
 exports.readBezierKnot = readBezierKnot;
 exports.readVectorMask = readVectorMask;
+exports.writeVectorMask = writeVectorMask;
+exports.parseKeyDescriptorList = parseKeyDescriptorList;
+exports.serializeKeyDescriptorList = serializeKeyDescriptorList;
 exports.hasMultiEffects = hasMultiEffects;
 const base64_js_1 = require("base64-js");
 const effectsHelpers_1 = require("./effectsHelpers");
@@ -33,6 +36,7 @@ function readLength64(reader) {
     return (0, psdReader_1.readUint32)(reader);
 }
 addHandler('TySh', hasKey('text'), (reader, target, leftBytes) => {
+    var _a;
     if ((0, psdReader_1.readInt16)(reader) !== 1)
         throw new Error(`Invalid TySh version`);
     const transform = [];
@@ -79,7 +83,8 @@ addHandler('TySh', hasKey('text'), (reader, target, leftBytes) => {
         // require('fs').writeFileSync('before.txt', require('util').inspect(before, false, 99, false), 'utf8');
         // require('fs').writeFileSync('after.txt', require('util').inspect(after, false, 99, false), 'utf8');
         // console.log(require('util').inspect(parseEngineData(text.EngineData), false, 99, true));
-        target.text = Object.assign(Object.assign({}, target.text), textData);
+        // descriptor anti-alias value is more reliable than the one from engine data
+        target.text = Object.assign(Object.assign(Object.assign({}, target.text), textData), { antiAlias: (_a = target.text.antiAlias) !== null && _a !== void 0 ? _a : textData.antiAlias });
         // console.log(require('util').inspect(target.text, false, 99, true));
     }
     (0, psdReader_1.skipBytes)(reader, leftBytes());
@@ -103,11 +108,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);
@@ -209,25 +280,8 @@ function readVectorMask(reader, vectorMask, width, height, size) {
     }
     return paths;
 }
-addHandler('vmsk', hasKey('vectorMask'), (reader, target, left, { width, height }) => {
-    if ((0, psdReader_1.readUint32)(reader) !== 3)
-        throw new Error('Invalid vmsk version');
-    target.vectorMask = { paths: [] };
-    const vectorMask = target.vectorMask;
-    const flags = (0, psdReader_1.readUint32)(reader);
-    vectorMask.invert = (flags & 1) !== 0;
-    vectorMask.notLink = (flags & 2) !== 0;
-    vectorMask.disable = (flags & 4) !== 0;
-    readVectorMask(reader, vectorMask, width, height, left());
-    // drawBezierPaths(vectorMask.paths, width, height, 'out.png');
-    (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target, { width, height }) => {
-    const vectorMask = target.vectorMask;
-    const flags = (vectorMask.invert ? 1 : 0) |
-        (vectorMask.notLink ? 2 : 0) |
-        (vectorMask.disable ? 4 : 0);
-    (0, psdWriter_1.writeUint32)(writer, 3); // version
-    (0, psdWriter_1.writeUint32)(writer, flags);
+// componentIndices - write index of path component for each subpath (Photoshop writes them for layer vector masks)
+function writeVectorMask(writer, vectorMask, width, height, componentIndices = false) {
     // initial entry
     (0, psdWriter_1.writeUint16)(writer, 6);
     (0, psdWriter_1.writeZeros)(writer, 24);
@@ -244,12 +298,18 @@ addHandler('vmsk', hasKey('vectorMask'), (reader, target, left, { width, height
     (0, psdWriter_1.writeUint16)(writer, 8);
     (0, psdWriter_1.writeUint16)(writer, vectorMask.fillStartsWithAllPixels ? 1 : 0);
     (0, psdWriter_1.writeZeros)(writer, 22);
+    let componentIndex = -1;
     for (const path of vectorMask.paths) {
+        // subpaths without operation are part of the same path component as previous subpath
+        if (path.operation || componentIndex < 0)
+            componentIndex++;
         (0, psdWriter_1.writeUint16)(writer, path.open ? 3 : 0);
         (0, psdWriter_1.writeUint16)(writer, path.knots.length);
         (0, psdWriter_1.writeUint16)(writer, path.operation ? exports.booleanOperations.indexOf(path.operation) : -1); // -1 for undefined
         (0, psdWriter_1.writeUint16)(writer, path.fillRule === 'non-zero' ? 2 : 1);
-        (0, psdWriter_1.writeZeros)(writer, 18); // TODO: these are sometimes non-zero
+        (0, psdWriter_1.writeZeros)(writer, 4);
+        (0, psdWriter_1.writeUint32)(writer, componentIndices ? componentIndex : 0);
+        (0, psdWriter_1.writeZeros)(writer, 10);
         const linkedKnot = path.open ? 4 : 1;
         const unlinkedKnot = path.open ? 5 : 2;
         for (const { linked, points } of path.knots) {
@@ -257,8 +317,29 @@ addHandler('vmsk', hasKey('vectorMask'), (reader, target, left, { width, height
             writeBezierKnot(writer, points, width, height);
         }
     }
+}
+addHandler('vmsk', hasKey('vectorMask'), (reader, target, left, { width, height }) => {
+    if ((0, psdReader_1.readUint32)(reader) !== 3)
+        throw new Error('Invalid vmsk version');
+    target.vectorMask = { paths: [] };
+    const vectorMask = target.vectorMask;
+    const flags = (0, psdReader_1.readUint32)(reader);
+    vectorMask.invert = (flags & 1) !== 0;
+    vectorMask.notLink = (flags & 2) !== 0;
+    vectorMask.disable = (flags & 4) !== 0;
+    readVectorMask(reader, vectorMask, width, height, left());
+    // drawBezierPaths(vectorMask.paths, width, height, 'out.png');
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target, { width, height }) => {
+    const vectorMask = target.vectorMask;
+    const flags = (vectorMask.invert ? 1 : 0) |
+        (vectorMask.notLink ? 2 : 0) |
+        (vectorMask.disable ? 4 : 0);
+    (0, psdWriter_1.writeUint32)(writer, 3); // version
+    (0, psdWriter_1.writeUint32)(writer, flags);
+    writeVectorMask(writer, vectorMask, width, height, true);
 });
-// TODO: need to write vmsk if has outline ?
+// written instead of 'vmsk' for layers with vector stroke ('vscg' section)
 addHandlerAlias('vsms', 'vmsk');
 // addHandlerAlias('vmsk', 'vsms');
 addHandler('vowv', // something with vectors?
@@ -267,12 +348,8 @@ hasKey('vowv'), (reader, target) => {
 }, (writer, target) => {
     (0, psdWriter_1.writeUint32)(writer, target.vowv);
 });
-addHandler('vogk', hasKey('vectorOrigination'), (reader, target, left) => {
-    if ((0, psdReader_1.readInt32)(reader) !== 1)
-        throw new Error(`Invalid vogk version`);
-    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-    // console.log(require('util').inspect(desc, false, 99, true));
-    target.vectorOrigination = { keyDescriptorList: [] };
+function parseKeyDescriptorList(desc) {
+    const keyDescriptorList = [];
     for (const i of desc.keyDescriptorList) {
         const item = {};
         if (i.keyShapeInvalidated != null)
@@ -311,15 +388,14 @@ addHandler('vogk', hasKey('vectorOrigination'), (reader, target, left) => {
         if (trnf) {
             item.transform = [trnf.xx, trnf.xy, trnf.yx, trnf.yy, trnf.tx, trnf.ty];
         }
-        target.vectorOrigination.keyDescriptorList.push(item);
+        keyDescriptorList.push(item);
     }
-    (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target) => {
-    target;
-    const orig = target.vectorOrigination;
+    return keyDescriptorList;
+}
+function serializeKeyDescriptorList(keyDescriptorList) {
     const desc = { keyDescriptorList: [] };
-    for (let i = 0; i < orig.keyDescriptorList.length; i++) {
-        const item = orig.keyDescriptorList[i];
+    for (let i = 0; i < keyDescriptorList.length; i++) {
+        const item = keyDescriptorList[i];
         desc.keyDescriptorList.push({}); // we're adding keyOriginIndex at the end
         const out = desc.keyDescriptorList[desc.keyDescriptorList.length - 1];
         if (item.keyOriginType != null)
@@ -370,20 +446,31 @@ addHandler('vogk', hasKey('vectorOrigination'), (reader, target, left) => {
             out.keyShapeInvalidated = item.keyShapeInvalidated;
         out.keyOriginIndex = i;
     }
+    return desc;
+}
+addHandler('vogk', hasKey('vectorOrigination'), (reader, target, left) => {
+    if ((0, psdReader_1.readInt32)(reader) !== 1)
+        throw new Error(`Invalid vogk version`);
+    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+    // console.log(require('util').inspect(desc, false, 99, true));
+    target.vectorOrigination = { keyDescriptorList: parseKeyDescriptorList(desc) };
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target) => {
+    const desc = serializeKeyDescriptorList(target.vectorOrigination.keyDescriptorList);
     (0, psdWriter_1.writeInt32)(writer, 1); // version
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
 });
-addHandler('lmfx', target => target.effects !== undefined && hasMultiEffects(target.effects), (reader, target, left) => {
+addHandler('lmfx', target => target.effects !== undefined && !isGroupLayer(target) && hasMultiEffects(target.effects), (reader, target, left) => {
     const version = (0, psdReader_1.readUint32)(reader);
     if (version !== 0)
         throw new Error('Invalid lmfx version');
     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);
@@ -449,8 +536,12 @@ addHandler('lyid', target => target.id !== undefined || layerNeedsId(target), (r
     let id;
     if (target.id !== undefined) {
         id = target.id;
-        while (options.layerIds.has(id))
-            id += 100; // make sure we don't have duplicate layer ids
+        if (options.layerIds.has(id)) {
+            // make sure we don't have duplicate layer ids (and don't take id explicitly set on another layer)
+            const explicitIds = getExplicitLayerIds(psd, options);
+            while (options.layerIds.has(id) || explicitIds.has(id))
+                id += 100;
+        }
     }
     else {
         // generate id for layers that don't have it, if it's referenced by other sections
@@ -514,6 +605,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 = {
@@ -523,12 +666,15 @@ addHandler('lspf', hasKey('protected'), (reader, target) => {
     };
     if (flags & 0x08)
         target.protected.artboards = true;
+    if (flags & 0x80000000)
+        target.protected.all = true;
 }, (writer, target) => {
     const flags = (target.protected.transparency ? 0x01 : 0) |
         (target.protected.composite ? 0x02 : 0) |
         (target.protected.position ? 0x04 : 0) |
-        (target.protected.artboards ? 0x08 : 0);
-    (0, psdWriter_1.writeUint32)(writer, flags);
+        (target.protected.artboards ? 0x08 : 0) |
+        (target.protected.all ? 0x80000000 : 0);
+    (0, psdWriter_1.writeUint32)(writer, flags >>> 0);
 });
 addHandler('lclr', hasKey('layerColor'), (reader, target) => {
     const color = (0, psdReader_1.readUint16)(reader);
@@ -539,106 +685,160 @@ addHandler('lclr', hasKey('layerColor'), (reader, target) => {
     (0, psdWriter_1.writeUint16)(writer, index === -1 ? 0 : index);
     (0, psdWriter_1.writeZeros)(writer, 6);
 });
+function parseGeneratorSettings(settings) {
+    const result = {};
+    if (settings.exportAs) {
+        result.exportAs = {};
+        if (settings.exportAs.exportOption !== undefined)
+            result.exportAs.exportOption = settings.exportAs.exportOption;
+        if (settings.exportAs.scaleSettings !== undefined)
+            result.exportAs.scaleSettings = settings.exportAs.scaleSettings;
+    }
+    if (settings.generator_45_assets)
+        result.assets = settings.generator_45_assets.json;
+    if (settings.layerTime !== undefined)
+        result.layerTime = settings.layerTime;
+    if (settings.crema)
+        result.crema = settings.crema.json;
+    return result;
+}
+function serializeGeneratorSettings(generatorSettings) {
+    const settings = {
+        _name: '',
+        _classID: generatorSettings.assets !== undefined ? 'generatorSettings' : 'null',
+    };
+    if (generatorSettings.exportAs) {
+        settings.exportAs = { _name: '', _classID: 'null' };
+        if (generatorSettings.exportAs.exportOption !== undefined)
+            settings.exportAs.exportOption = generatorSettings.exportAs.exportOption;
+        if (generatorSettings.exportAs.scaleSettings !== undefined)
+            settings.exportAs.scaleSettings = generatorSettings.exportAs.scaleSettings;
+    }
+    if (generatorSettings.assets !== undefined)
+        settings.generator_45_assets = { _name: '', _classID: 'generatorSettings', json: generatorSettings.assets };
+    if (generatorSettings.layerTime !== undefined)
+        settings.layerTime = generatorSettings.layerTime;
+    if (generatorSettings.crema !== undefined)
+        settings.crema = { _name: '', _classID: 'null', json: generatorSettings.crema };
+    return { generatorSettings: settings };
+}
+// document (Psd object) stores generator settings in 'extn' section instead of 'shmd' section
+function isDocument(target) {
+    return target.width !== undefined;
+}
 addHandler('shmd', // Metadata setting
 // Metadata setting
-target => target.timestamp !== undefined || target.animationFrames !== undefined || target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined, (reader, target, left) => {
+target => target.timestamp !== undefined || target.animationFrames !== undefined || target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined ||
+    (target.generatorSettings !== undefined && !isDocument(target)), (reader, target, left) => {
     const count = (0, psdReader_1.readUint32)(reader);
     for (let i = 0; i < count; i++) {
-        (0, psdReader_1.checkSignature)(reader, '8BIM');
+        const signature = (0, psdReader_1.readSignature)(reader);
+        if (signature !== '8BIM' && signature !== '8ELE')
+            throw new Error(`Invalid shmd signature: '${signature}'`); // 8ELE in Photoshop Elements
         const key = (0, psdReader_1.readSignature)(reader);
         (0, psdReader_1.readUint8)(reader); // copy
         (0, psdReader_1.skipBytes)(reader, 3);
-        (0, psdReader_1.readSection)(reader, 1, left => {
-            if (key === 'cust') {
-                const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-                // console.log('cust', target.name, require('util').inspect(desc, false, 99, true));
-                if (desc.layerTime !== undefined)
-                    target.timestamp = desc.layerTime;
-            }
-            else if (key === 'mlst') {
-                const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-                // console.log('mlst', target.name, require('util').inspect(desc, false, 99, true));
-                target.animationFrames = [];
-                for (let i = 0; i < desc.LaSt.length; i++) {
-                    const f = desc.LaSt[i];
-                    const frame = { frames: f.FrLs };
-                    if (f.enab !== undefined)
-                        frame.enable = f.enab;
-                    if (f.Ofst)
-                        frame.offset = (0, descriptor_1.horzVrtcToXY)(f.Ofst);
-                    if (f.FXRf)
-                        frame.referencePoint = (0, descriptor_1.horzVrtcToXY)(f.FXRf);
-                    if (f.Lefx)
-                        frame.effects = (0, descriptor_1.parseEffects)(f.Lefx, !!reader.logMissingFeatures);
-                    if (f.blendOptions && f.blendOptions.Opct)
-                        frame.opacity = (0, descriptor_1.parsePercent)(f.blendOptions.Opct);
-                    target.animationFrames.push(frame);
+        const end = reader.offset + 4 + reader.view.getUint32(reader.offset);
+        try {
+            (0, psdReader_1.readSection)(reader, 1, left => {
+                if (key === 'cust') {
+                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+                    // console.log('cust', target.name, require('util').inspect(desc, false, 99, true));
+                    if (desc.layerTime !== undefined)
+                        target.timestamp = desc.layerTime;
                 }
-            }
-            else if (key === 'mdyn') {
-                // frame flags
-                (0, psdReader_1.readUint16)(reader); // unknown
-                const propagate = (0, psdReader_1.readUint8)(reader);
-                const flags = (0, psdReader_1.readUint8)(reader);
-                target.animationFrameFlags = {
-                    propagateFrameOne: !propagate,
-                    unifyLayerPosition: (flags & 1) !== 0,
-                    unifyLayerStyle: (flags & 2) !== 0,
-                    unifyLayerVisibility: (flags & 4) !== 0,
-                };
-            }
-            else if (key === 'tmln') {
-                const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-                const timeScope = desc.timeScope;
-                // console.log('tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
-                const timeline = {
-                    start: (0, descriptor_1.frac)(timeScope.Strt),
-                    duration: (0, descriptor_1.frac)(timeScope.duration),
-                    inTime: (0, descriptor_1.frac)(timeScope.inTime),
-                    outTime: (0, descriptor_1.frac)(timeScope.outTime),
-                    autoScope: desc.autoScope,
-                    audioLevel: desc.audioLevel,
-                };
-                if (desc.trackList) {
-                    timeline.tracks = (0, descriptor_1.parseTrackList)(desc.trackList, !!reader.logMissingFeatures);
+                else if (key === 'mlst') {
+                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+                    // console.log('mlst', target.name, require('util').inspect(desc, false, 99, true));
+                    target.animationFrames = [];
+                    for (let i = 0; i < desc.LaSt.length; i++) {
+                        const f = desc.LaSt[i];
+                        const frame = { frames: f.FrLs };
+                        if (f.enab !== undefined)
+                            frame.enable = f.enab;
+                        if (f.Ofst)
+                            frame.offset = (0, descriptor_1.horzVrtcToXY)(f.Ofst);
+                        if (f.FXRf)
+                            frame.referencePoint = (0, descriptor_1.horzVrtcToXY)(f.FXRf);
+                        if (f.Lefx)
+                            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);
+                    }
                 }
-                target.timeline = timeline;
-                // console.log('tmln:result', target.name, target.id, require('util').inspect(timeline, false, 99, true));
-            }
-            else if (key === 'cmls') {
-                const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-                // console.log('cmls', require('util').inspect(desc, false, 99, true));
-                target.comps = {
-                    settings: [],
-                };
-                if (desc.origFXRefPoint)
-                    target.comps.originalEffectsReferencePoint = { x: desc.origFXRefPoint.Hrzn, y: desc.origFXRefPoint.Vrtc };
-                for (const item of desc.layerSettings) {
-                    target.comps.settings.push({ compList: item.compList });
-                    const t = target.comps.settings[target.comps.settings.length - 1];
-                    if ('enab' in item)
-                        t.enabled = item.enab;
-                    if (item.Ofst)
-                        t.offset = { x: item.Ofst.Hrzn, y: item.Ofst.Vrtc };
-                    if (item.FXRefPoint)
-                        t.effectsReferencePoint = { x: item.FXRefPoint.Hrzn, y: item.FXRefPoint.Vrtc };
+                else if (key === 'mdyn') {
+                    // frame flags
+                    (0, psdReader_1.readUint16)(reader); // unknown
+                    const propagate = (0, psdReader_1.readUint8)(reader);
+                    const flags = (0, psdReader_1.readUint8)(reader);
+                    target.animationFrameFlags = {
+                        propagateFrameOne: !propagate,
+                        unifyLayerPosition: (flags & 1) !== 0,
+                        unifyLayerStyle: (flags & 2) !== 0,
+                        unifyLayerVisibility: (flags & 4) !== 0,
+                    };
                 }
-            }
-            else if (key === 'extn') {
-                const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-                // console.log(require('util').inspect(desc, false, 99, true));
-                desc; // TODO: save this
-                reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
-            }
-            else {
-                reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
-            }
-            (0, psdReader_1.skipBytes)(reader, left());
-        });
+                else if (key === 'tmln') {
+                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+                    const timeScope = desc.timeScope;
+                    // console.log('tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
+                    const timeline = {
+                        start: (0, descriptor_1.frac)(timeScope.Strt),
+                        duration: (0, descriptor_1.frac)(timeScope.duration),
+                        inTime: (0, descriptor_1.frac)(timeScope.inTime),
+                        outTime: (0, descriptor_1.frac)(timeScope.outTime),
+                        autoScope: desc.autoScope,
+                        audioLevel: desc.audioLevel,
+                    };
+                    if (desc.trackList) {
+                        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));
+                }
+                else if (key === 'cmls') {
+                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+                    // console.log('cmls', require('util').inspect(desc, false, 99, true));
+                    target.comps = {
+                        settings: [],
+                    };
+                    if (desc.origFXRefPoint)
+                        target.comps.originalEffectsReferencePoint = { x: desc.origFXRefPoint.Hrzn, y: desc.origFXRefPoint.Vrtc };
+                    for (const item of desc.layerSettings) {
+                        target.comps.settings.push({ compList: item.compList });
+                        const t = target.comps.settings[target.comps.settings.length - 1];
+                        if ('enab' in item)
+                            t.enabled = item.enab;
+                        if (item.Ofst)
+                            t.offset = { x: item.Ofst.Hrzn, y: item.Ofst.Vrtc };
+                        if (item.FXRefPoint)
+                            t.effectsReferencePoint = { x: item.FXRefPoint.Hrzn, y: item.FXRefPoint.Vrtc };
+                    }
+                }
+                else if (key === 'extn') {
+                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+                    if (desc.generatorSettings)
+                        target.generatorSettings = parseGeneratorSettings(desc.generatorSettings);
+                }
+                else {
+                    reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
+                }
+                (0, psdReader_1.skipBytes)(reader, left());
+            });
+        }
+        catch (e) {
+            // failure to read one item shouldn't drop all other items
+            if (reader.throwForMissingFeatures)
+                throw e;
+            reader.logMissingFeatures && reader.log(`Failed to read "shmd" section key ${key}: ${e.message}`);
+            reader.offset = end;
+        }
     }
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target, _, options) => {
     const { animationFrames, animationFrameFlags, timestamp, timeline, comps } = target;
+    const generatorSettings = isDocument(target) ? undefined : target.generatorSettings;
     let count = 0;
     if (animationFrames)
         count++;
@@ -650,6 +850,8 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
         count++;
     if (comps)
         count++;
+    if (generatorSettings)
+        count++;
     (0, psdWriter_1.writeUint32)(writer, count);
     if (animationFrames) {
         (0, psdWriter_1.writeSignature)(writer, '8BIM');
@@ -672,9 +874,9 @@ 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, false);
+                    frame.Lefx = (0, descriptor_1.serializeEffects)(f.effects, writer, hasMultiEffects(f.effects));
                 if (f.opacity !== undefined)
-                    frame.blendOptions = { Opct: (0, descriptor_1.unitsPercent)(f.opacity) };
+                    frame.blendOptions = { Opct: (0, descriptor_1.unitsPercentF)(f.opacity) };
                 desc.LaSt.push(frame);
             }
             (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
@@ -712,7 +914,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));
@@ -758,6 +960,15 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
             (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
         }, true);
     }
+    if (generatorSettings) {
+        (0, psdWriter_1.writeSignature)(writer, '8BIM');
+        (0, psdWriter_1.writeSignature)(writer, 'extn');
+        (0, psdWriter_1.writeUint8)(writer, 0); // copy (always false)
+        (0, psdWriter_1.writeZeros)(writer, 3);
+        (0, psdWriter_1.writeSection)(writer, 2, () => {
+            (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', serializeGeneratorSettings(generatorSettings));
+        }, true);
+    }
 });
 addHandler('PxSc', hasKey('pixelSource'), (reader, target) => {
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
@@ -837,7 +1048,7 @@ addHandler('vstk', hasKey('vectorStroke'), (reader, target, left) => {
         lineAlignment: descriptor_1.strokeStyleLineAlignment.decode(desc.strokeStyleLineAlignment),
         scaleLock: desc.strokeStyleScaleLock,
         strokeAdjust: desc.strokeStyleStrokeAdjust,
-        lineDashSet: desc.strokeStyleLineDashSet.map(descriptor_1.parseUnits),
+        lineDashSet: (desc.strokeStyleLineDashSet || []).map(descriptor_1.parseUnits),
         blendMode: descriptor_1.BlnM.decode(desc.strokeStyleBlendMode),
         opacity: (0, descriptor_1.parsePercent)(desc.strokeStyleOpacity),
         content: (0, descriptor_1.parseVectorContent)(desc.strokeStyleContent),
@@ -875,9 +1086,11 @@ hasKey('artboard'), (reader, target, left) => {
         rect: { top: rect['Top '], left: rect.Left, bottom: rect.Btom, right: rect.Rght },
         guideIndices: desc.guideIndeces,
         presetName: desc.artboardPresetName,
-        color: (0, descriptor_1.parseColor)(desc['Clr ']),
-        backgroundType: desc.artboardBackgroundType,
     };
+    if (desc['Clr '])
+        target.artboard.color = (0, descriptor_1.parseColor)(desc['Clr ']);
+    if (desc.artboardBackgroundType !== undefined)
+        target.artboard.backgroundType = desc.artboardBackgroundType;
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
     var _a;
@@ -983,14 +1196,15 @@ function encodeWarp(warp) {
     }
     return desc;
 }
-addHandler('PlLd', hasKey('placedLayer'), (reader, target, left) => {
+addHandler('PlLd', target => !!target.placedLayer && !target.placedLayer.external, // linked smart objects are stored in SoLE
+(reader, target, left) => {
     if ((0, psdReader_1.readSignature)(reader) !== 'plcL')
         throw new Error(`Invalid PlLd signature`);
     if ((0, psdReader_1.readInt32)(reader) !== 3)
         throw new Error(`Invalid PlLd version`);
     const id = (0, psdReader_1.readPascalString)(reader, 1);
     const pageNumber = (0, psdReader_1.readInt32)(reader);
-    const totalPages = (0, psdReader_1.readInt32)(reader); // TODO: check how this works ?
+    const totalPages = (0, psdReader_1.readInt32)(reader); // for multi-page documents (PDF)
     (0, psdReader_1.readInt32)(reader); // anitAliasPolicy 16
     const placedLayerType = (0, psdReader_1.readInt32)(reader); // 0 = unknown, 1 = vector, 2 = raster, 3 = image stack
     if (!placedLayerTypes[placedLayerType])
@@ -1035,6 +1249,8 @@ addHandler('PlLd', hasKey('placedLayer'), (reader, target, left) => {
     const type = isQuilt ? 'quiltWarp' : 'warp';
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', type, encodeWarp(warp), type);
 });
+const levelsFilterKeys = ['_name', '_classID', 'presetKind', 'Adjs'];
+const levelsFilterAdjustmentKeys = ['_name', '_classID', 'Chnl', 'Inpt', 'Otpt', 'Gmm '];
 function uint8ToFloat32(array) {
     const length = Math.floor(array.byteLength / 4);
     return new Float32Array(array.buffer.slice(array.byteOffset, array.byteOffset + length * 4), 0, length);
@@ -1077,7 +1293,87 @@ function pointToHrznVrtc(point) {
         Vrtc: (0, descriptor_1.unitsValue)(point.y, 'y'),
     };
 }
-function parseFilterFXItem(f, options) {
+// 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  '],
         opacity: (0, descriptor_1.parsePercent)(f.blendOptions.Opct),
@@ -1087,6 +1383,9 @@ function parseFilterFXItem(f, options) {
         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: {
@@ -1125,7 +1424,7 @@ function parseFilterFXItem(f, options) {
                     undefinedAreas: descriptor_1.UndA.decode(f.Fltr.UndA),
                     displacementFile: {
                         signature: f.Fltr.DspF.sig,
-                        path: f.Fltr.DspF.path, // TODO: this is decoded incorrectly ???
+                        path: f.Fltr.DspF.path,
                     },
                 } });
             case 'Pnch': return Object.assign(Object.assign({}, base), { type: 'pinch', filter: {
@@ -1312,8 +1611,7 @@ function parseFilterFXItem(f, options) {
                     ],
                     puppetShapeList: (f.Fltr.puppetShapeList || []).map(p => ({
                         rigidType: p.rigidType,
-                        // TODO: VrsM
-                        // TODO: VrsN
+                        // VrsM / VrsN - version (always 1.0)
                         originalVertexArray: uint8ToPoints(p.originalVertexArray),
                         deformedVertexArray: uint8ToPoints(p.deformedVertexArray),
                         indexArray: Array.from(uint8ToUint32(p.indexArray)),
@@ -1410,7 +1708,7 @@ function parseFilterFXItem(f, options) {
                 ;
             case 'Crvs':
                 {
-                    return Object.assign(Object.assign({}, base), { type: 'curves', filter: Object.assign({ presetKind: descriptor_1.presetKindType.decode(f.Fltr.presetKind) }, (f.Fltr.Adjs ? {
+                    return Object.assign(Object.assign({}, base), { type: 'curves', filter: Object.assign(Object.assign({}, (f.Fltr.presetKind !== undefined ? { presetKind: descriptor_1.presetKindType.decode(f.Fltr.presetKind) } : {})), (f.Fltr.Adjs ? {
                             adjustments: f.Fltr.Adjs.map(a => {
                                 const channels = a.Chnl.map(descriptor_1.Chnl.decode);
                                 if (a['Crv ']) {
@@ -1434,6 +1732,35 @@ function parseFilterFXItem(f, options) {
                         } : {})) });
                 }
                 ;
+            case 'Lvls':
+                {
+                    const adjustments = f.Fltr.Adjs;
+                    const isKnown = (obj, keys) => Object.keys(obj).every(k => keys.indexOf(k) !== -1);
+                    // skip filter with settings we don't know about
+                    if (!isKnown(f.Fltr, levelsFilterKeys) || (adjustments && !adjustments.every(a => isKnown(a, levelsFilterAdjustmentKeys)))) {
+                        if (reader.throwForMissingFeatures)
+                            throw new Error('Unknown levels filter settings');
+                        reader.logMissingFeatures && reader.log(`Skipped levels smart filter with unknown settings`);
+                        return undefined;
+                    }
+                    return Object.assign(Object.assign({}, base), { type: 'levels', filter: Object.assign(Object.assign({}, (f.Fltr.presetKind !== undefined ? { presetKind: descriptor_1.presetKindType.decode(f.Fltr.presetKind) } : {})), (adjustments ? {
+                            adjustments: adjustments.map(a => {
+                                const result = { channels: a.Chnl.map(descriptor_1.Chnl.decode) };
+                                if (a.Inpt) {
+                                    result.shadowInput = a.Inpt[0];
+                                    result.highlightInput = a.Inpt[1];
+                                }
+                                if (a.Otpt) {
+                                    result.shadowOutput = a.Otpt[0];
+                                    result.highlightOutput = a.Otpt[1];
+                                }
+                                if (a['Gmm '] !== undefined)
+                                    result.midtoneInput = a['Gmm '];
+                                return result;
+                            }),
+                        } : {})) });
+                }
+                ;
             case 'BrgC':
                 {
                     return Object.assign(Object.assign({}, base), { type: 'brightness/contrast', filter: {
@@ -1444,10 +1771,11 @@ function parseFilterFXItem(f, options) {
                 }
                 ;
             default:
-                if (options.throwForMissingFeatures) {
+                if (reader.throwForMissingFeatures) {
                     // console.log('FILTER', require('util').inspect(f, false, 99, true));
                     throw new Error(`Unknown filter classId: ${f.Fltr._classID}`);
                 }
+                reader.logMissingFeatures && reader.log(`Unhandled smart filter: ${f.Fltr._classID} (${f['Nm  ']})`);
                 return undefined;
         }
     }
@@ -1467,21 +1795,23 @@ function parseFilterFXItem(f, options) {
             case 1314149187: return Object.assign(Object.assign({}, base), { type: 'ntsc colors' });
             case 1231976050: return Object.assign(Object.assign({}, base), { type: 'invert' });
             default:
-                if (options.throwForMissingFeatures) {
+                if (reader.throwForMissingFeatures) {
                     // console.log('FILTER', require('util').inspect(f, false, 99, true));
                     throw new Error(`Unknown filterID: ${f.filterID}`);
                 }
+                reader.logMissingFeatures && reader.log(`Unhandled smart filter: ${f.filterID} (${f['Nm  ']})`);
+                return undefined;
         }
     }
 }
-function parseFilterFX(desc, options) {
+function parseFilterFX(desc, reader) {
     return {
         enabled: desc.enab,
         validAtPosition: desc.validAtPosition,
         maskEnabled: desc.filterMaskEnable,
         maskLinked: desc.filterMaskLinked,
         maskExtendWithWhite: desc.filterMaskExtendWithWhite,
-        list: desc.filterFXList.map(x => parseFilterFXItem(x, options)).filter((x) => !!x),
+        list: desc.filterFXList.map(x => parseFilterFXItem(x, reader)).filter((x) => !!x),
     };
 }
 function uvRadius(t) {
@@ -1837,14 +2167,14 @@ function serializeFilterFXItem(f) {
         case 'puppet': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Rigid Transform',
                 _classID: 'rigidTransform',
-                'null': ['Ordn.Trgt'], // TODO: ???
+                'null': ['Ordn.Trgt'], // target layer reference
                 rigidType: f.filter.rigidType,
                 puppetShapeList: (f.filter.puppetShapeList || []).map(p => ({
                     _name: '',
                     _classID: 'puppetShape',
                     rigidType: p.rigidType,
-                    VrsM: 1, // TODO: ???
-                    VrsN: 0, // TODO: ???
+                    VrsM: 1, // version major
+                    VrsN: 0, // version minor
                     originalVertexArray: toUint8(new Float32Array(pointsToArray(p.originalVertexArray))),
                     deformedVertexArray: toUint8(new Float32Array(pointsToArray(p.deformedVertexArray))),
                     indexArray: toUint8(new Uint32Array(p.indexArray)),
@@ -1926,7 +2256,7 @@ function serializeFilterFXItem(f) {
                 warpedVertices: f.filter.warpedVertices.map(pointToHrznVrtc),
                 quads: f.filter.quads.map(indices => ({ _name: '', _classID: 'quadIndices', indices })),
             }, filterID: 442 });
-        case 'curves': return Object.assign(Object.assign({}, base), { Fltr: Object.assign({ _name: 'Curves', _classID: 'Crvs', presetKind: descriptor_1.presetKindType.encode(f.filter.presetKind) }, (f.filter.adjustments ? {
+        case 'curves': return Object.assign(Object.assign({}, base), { Fltr: Object.assign(Object.assign({ _name: 'Curves', _classID: 'Crvs' }, (f.filter.presetKind !== undefined ? { presetKind: descriptor_1.presetKindType.encode(f.filter.presetKind) } : {})), (f.filter.adjustments ? {
                 Adjs: f.filter.adjustments.map(a => 'curve' in a ? {
                     _name: '',
                     _classID: 'CrvA',
@@ -1939,6 +2269,22 @@ function serializeFilterFXItem(f) {
                     Mpng: a.values,
                 })
             } : {})), filterID: 1131574899 });
+        case 'levels': return Object.assign(Object.assign({}, base), { Fltr: Object.assign(Object.assign({ _name: 'Levels', _classID: 'Lvls' }, (f.filter.presetKind !== undefined ? { presetKind: descriptor_1.presetKindType.encode(f.filter.presetKind) } : {})), (f.filter.adjustments ? {
+                Adjs: f.filter.adjustments.map(a => {
+                    var _a, _b, _c, _d;
+                    const adjustment = { _name: '', _classID: 'LvlA', Chnl: a.channels.map(descriptor_1.Chnl.encode) };
+                    if (a.shadowInput !== undefined || a.highlightInput !== undefined) {
+                        adjustment.Inpt = [Math.round((_a = a.shadowInput) !== null && _a !== void 0 ? _a : 0), Math.round((_b = a.highlightInput) !== null && _b !== void 0 ? _b : 255)];
+                    }
+                    if (a.shadowOutput !== undefined || a.highlightOutput !== undefined) {
+                        adjustment.Otpt = [Math.round((_c = a.shadowOutput) !== null && _c !== void 0 ? _c : 0), Math.round((_d = a.highlightOutput) !== null && _d !== void 0 ? _d : 255)];
+                    }
+                    if (a.midtoneInput !== undefined)
+                        adjustment['Gmm '] = a.midtoneInput;
+                    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',
@@ -1989,7 +2335,8 @@ function getWarpFromPlacedLayer(placed) {
         },
     };
 }
-addHandler('SoLd', hasKey('placedLayer'), (reader, target, left) => {
+addHandler('SoLd', target => !!target.placedLayer && !target.placedLayer.external, // linked smart objects are stored in SoLE
+(reader, target, left) => {
     if ((0, psdReader_1.readSignature)(reader) !== 'soLD')
         throw new Error(`Invalid SoLd type`);
     const version = (0, psdReader_1.readInt32)(reader);
@@ -2046,13 +2393,18 @@ addHandler('SoLd', hasKey('placedLayer'), (reader, target, left) => {
     const placedType = placedLayerTypes.indexOf(placed.type);
     if (placedType === -1)
         throw new Error('Invalid placedLayer type');
+    const warp = getWarpFromPlacedLayer(placed);
+    // size of linked image matches warp bounds if it's not provided
+    const bounds = warp.bounds;
+    const width = placed.width || (bounds ? bounds.right.value - bounds.left.value : 0);
+    const height = placed.height || (bounds ? bounds.bottom.value - bounds.top.value : 0);
     const desc = Object.assign(Object.assign({ Idnt: placed.id, placed: (_a = placed.placed) !== null && _a !== void 0 ? _a : placed.id, PgNm: placed.pageNumber || 1, totalPages: placed.totalPages || 1 }, (placed.crop ? { Crop: placed.crop } : {})), { frameStep: placed.frameStep || { numerator: 0, denominator: 600 }, duration: placed.duration || { numerator: 0, denominator: 600 }, frameCount: placed.frameCount || 0, Annt: 16, Type: placedType, Trnf: placed.transform, nonAffineTransform: (_b = placed.nonAffineTransform) !== null && _b !== void 0 ? _b : placed.transform, 
         // quiltWarp: {} as any,
-        warp: encodeWarp(getWarpFromPlacedLayer(placed)), 'Sz  ': {
+        warp: encodeWarp(warp), 'Sz  ': {
             _name: '',
             _classID: 'Pnt ',
-            Wdth: placed.width || 0, // TODO: find size ?
-            Hght: placed.height || 0, // TODO: find size ?
+            Wdth: width,
+            Hght: height,
         }, Rslt: placed.resolution ? (0, descriptor_1.unitsValue)(placed.resolution, 'resolution') : { units: 'Density', value: 72 } });
     if (placed.filter) {
         desc.filterFX = {
@@ -2066,14 +2418,6 @@ addHandler('SoLd', hasKey('placedLayer'), (reader, target, left) => {
             filterFXList: placed.filter.list.map(f => serializeFilterFXItem(f)),
         };
     }
-    // TODO:
-    // desc.comp = -1;
-    // desc.compInfo = { _name: '', _classID: 'null', compID: -1, originalCompID: -1 } as any;
-    // desc.ClMg = {
-    // 	_name: '',
-    // 	_classID: 'ClMg',
-    // 	placedLayerOCIOConversion: 'placedLayerOCIOConversion.placedLayerOCIOConvertEmbedded'
-    // } as any;
     // if (JSON.stringify(t) !== JSON.stringify(desc)) {
     // 	console.log('read', require('util').inspect(t, false, 99, true));
     // 	console.log('write', require('util').inspect(desc, false, 99, true));
@@ -2103,7 +2447,13 @@ addHandler('SoLd', hasKey('placedLayer'), (reader, target, left) => {
         desc.compInfo = placed.compInfo;
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc, desc.quiltWarp ? 'quiltWarp' : 'warp');
 });
-addHandlerAlias('SoLE', 'SoLd');
+const soLdHandler = exports.infoHandlersMap['SoLd'];
+addHandler('SoLE', // linked smart object (Photoshop doesn't write PlLd for these)
+// linked smart object (Photoshop doesn't write PlLd for these)
+target => { var _a; return !!((_a = target.placedLayer) === null || _a === void 0 ? void 0 : _a.external); }, (reader, target, left, psd, imageResources) => {
+    soLdHandler.read(reader, target, left, psd, imageResources);
+    target.placedLayer.external = true;
+}, soLdHandler.write);
 addHandler('fxrp', hasKey('referencePoint'), (reader, target) => {
     target.referencePoint = {
         x: (0, psdReader_1.readFloat64)(reader),
@@ -2113,14 +2463,37 @@ addHandler('fxrp', hasKey('referencePoint'), (reader, target) => {
     (0, psdWriter_1.writeFloat64)(writer, target.referencePoint.x);
     (0, psdWriter_1.writeFloat64)(writer, target.referencePoint.y);
 });
-addHandler('Lr16', () => false, (reader, _target, _left, psd, imageResources) => {
-    (0, psdReader_1.readLayerInfo)(reader, psd, imageResources);
-}, (_writer, _target) => {
-});
-addHandler('Lr32', () => false, (reader, _target, _left, psd, imageResources) => {
-    (0, psdReader_1.readLayerInfo)(reader, psd, imageResources);
-}, (_writer, _target) => {
-});
+function createGlobalLayerInfoHandler(key, bitsPerChannel) {
+    addHandler(key, () => false, (reader, _target, left, psd, imageResources) => {
+        var _a;
+        // Photoshop writes empty (or 8bit compatibility) layer info section alongside Lr16/Lr32 in 16/32bit documents,
+        // layers from global info with matching bit depth replace layers from that section, other ones are only used
+        // if the section is empty
+        if (!reader.layersInGlobalInfo && (psd.bitsPerChannel === bitsPerChannel || !((_a = psd.children) === null || _a === void 0 ? void 0 : _a.length))) {
+            const sectionLayers = psd.children;
+            psd.children = [];
+            try {
+                (0, psdReader_1.readLayerInfo)(reader, psd, imageResources);
+            }
+            catch (e) {
+                psd.children = sectionLayers; // keep layers from layer info section if global info is broken
+                throw e;
+            }
+            reader.layersInGlobalInfo = true;
+        }
+        (0, psdReader_1.skipBytes)(reader, left());
+    }, () => { });
+}
+createGlobalLayerInfoHandler('Lr16', 16);
+createGlobalLayerInfoHandler('Lr32', 32);
+createGlobalLayerInfoHandler('Layr', undefined);
+// merged transparency markers, first extra channel of composite image is transparency
+for (const key of ['Mtrn', 'Mt16', 'Mt32']) {
+    addHandler(key, () => false, (reader, _target, left) => {
+        reader.globalAlpha = true;
+        (0, psdReader_1.skipBytes)(reader, left());
+    }, () => { });
+}
 addHandler('LMsk', hasKey('userMask'), (reader, target) => {
     target.userMask = {
         colorSpace: (0, psdReader_1.readColor)(reader),
@@ -2137,29 +2510,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', // TODO: handle also Pat2 & Pat3
-    // TODO: handle also Pat2 & Pat3
-    target => !!(target.patterns && target.patterns.length > 0), (reader, target, left) => {
-        while (left() > 0) {
-            const pattern = (0, psdReader_1.readPattern)(reader);
-            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');
 /*
@@ -2336,6 +2703,10 @@ addHandler('Anno', target => target.annotations !== undefined, (reader, target,
         writer.view.setUint32(dataOffset - 4, writer.offset - dataOffset, false);
     }
 });
+function readFileTypeSignature(reader) {
+    const value = (0, psdReader_1.readSignature)(reader);
+    return /^[\0 ]*$/.test(value) ? '' : value.trim(); // empty value is stored as spaces or zeros
+}
 function createLnkHandler(tag) {
     addHandler(tag, (target) => {
         const psd = target;
@@ -2357,8 +2728,8 @@ function createLnkHandler(tag) {
             const version = (0, psdReader_1.readInt32)(reader);
             const id = (0, psdReader_1.readPascalString)(reader, 1);
             const name = (0, psdReader_1.readUnicodeString)(reader);
-            const fileType = (0, psdReader_1.readSignature)(reader).trim(); // '    ' if empty
-            const fileCreator = (0, psdReader_1.readSignature)(reader).trim(); // '    ' or '\0\0\0\0' if empty
+            const fileType = readFileTypeSignature(reader); // '    ' if empty
+            const fileCreator = readFileTypeSignature(reader); // '    ' or '\0\0\0\0' if empty
             const dataSize = readLength64(reader);
             const hasFileOpenDescriptor = (0, psdReader_1.readUint8)(reader);
             const fileOpenDescriptor = hasFileOpenDescriptor ? (0, descriptor_1.readVersionAndDescriptor)(reader) : undefined;
@@ -2509,36 +2880,48 @@ createLnkHandler('lnk2');
 createLnkHandler('lnkE');
 addHandlerAlias('lnkD', 'lnk2');
 addHandlerAlias('lnk3', 'lnk2');
-addHandler('pths', hasKey('pathList'), (reader, target) => {
+// unicode names of saved paths (path data is stored in image resources 2000-2998)
+addHandler('pths', target => { var _a; return ((_a = target.imageResources) === null || _a === void 0 ? void 0 : _a.savedPaths) !== undefined; }, (reader, _target, left, psd) => {
+    var _a, _b;
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
-    // console.log(require('util').inspect(desc, false, 99, true));
-    // if (options.throwForMissingFeatures && desc?.pathList?.length) throw new Error('non-empty pathList in `pths`');
-    desc;
-    target.pathList = []; // TODO: read paths
-}, (writer, _target) => {
+    const imageResources = (_a = psd.imageResources) !== null && _a !== void 0 ? _a : (psd.imageResources = {});
+    const savedPaths = (_b = imageResources.savedPaths) !== null && _b !== void 0 ? _b : (imageResources.savedPaths = []);
+    for (let i = 0; i < desc.pathList.length && i < savedPaths.length; i++) {
+        const { pathUnicodeName, pathSymmetryClass } = desc.pathList[i];
+        const path = savedPaths[i];
+        // clipping path is referenced by (non-unicode) name
+        if (imageResources.clippingPath && imageResources.clippingPath.name === path.name) {
+            imageResources.clippingPath.name = pathUnicodeName;
+        }
+        path.name = pathUnicodeName;
+        if (pathSymmetryClass)
+            path.symmetryMode = pathSymmetryClass.pathSymmetryMode.split('.')[1];
+    }
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, _target, psd) => {
     const desc = {
-        pathList: [], // TODO: write paths
+        pathList: psd.imageResources.savedPaths.map(path => (Object.assign({ _name: '', _classID: 'pathInfoClass', pathUnicodeName: path.name }, (path.symmetryMode ? {
+            pathSymmetryClass: {
+                _name: '',
+                _classID: 'pathSymmetryClass',
+                pathSymmetryMode: `pathSymmetryModeEnum.${path.symmetryMode}`,
+            },
+        } : {})))),
     };
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'pathsDataClass', desc);
 });
 addHandler('lyvr', hasKey('version'), (reader, target) => target.version = (0, psdReader_1.readUint32)(reader), (writer, target) => (0, psdWriter_1.writeUint32)(writer, target.version));
-addHandler('lfxs', () => false, // TODO: not sure when we actually need to write this section
-// NOTE: this might be insufficient
-// target => target.effects !== undefined && (
-// 	!!target.effects.dropShadow?.some(e => e.choke) ||
-// 	!!target.effects.innerShadow?.some(e => e.choke) ||
-// 	!!target.effects.outerGlow?.choke ||
-// 	!!target.effects.innerGlow?.choke
-// ),
-(reader, target, left) => {
+addHandler('lfxs', // effects of group layers (instead of 'lfx2' / 'lmfx')
+// effects of group layers (instead of 'lfx2' / 'lmfx')
+target => target.effects !== undefined && isGroupLayer(target), (reader, target, left) => {
     const version = (0, psdReader_1.readUint32)(reader);
     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);
 });
@@ -2574,6 +2957,10 @@ function readLevelsChannel(reader) {
     const midtoneInput = (0, psdReader_1.readInt16)(reader) / 100;
     return { shadowInput, highlightInput, shadowOutput, highlightOutput, midtoneInput };
 }
+const defaultLevelsChannel = { shadowInput: 0, highlightInput: 255, shadowOutput: 0, highlightOutput: 255, midtoneInput: 1 };
+function isDefaultLevelsChannel(c) {
+    return c.shadowInput === 0 && c.highlightInput === 255 && c.shadowOutput === 0 && c.highlightOutput === 255 && c.midtoneInput === 1;
+}
 function writeLevelsChannel(writer, channel) {
     (0, psdWriter_1.writeInt16)(writer, channel.shadowInput);
     (0, psdWriter_1.writeInt16)(writer, channel.highlightInput);
@@ -2584,48 +2971,44 @@ function writeLevelsChannel(writer, channel) {
 addHandler('levl', adjustmentType('levels'), (reader, target, left) => {
     if ((0, psdReader_1.readUint16)(reader) !== 2)
         throw new Error('Invalid levl version');
-    const levels = [];
-    for (let i = 0; i < 29 && left(); i++) {
-        levels.push(readLevelsChannel(reader));
-    }
-    const [rgb, red, green, blue] = levels;
-    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'levels', rgb,
-        red,
-        green,
-        blue });
-    if (left()) {
-        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);
-        for (let i = 0; i < (totalChannelRecords - levels.length) && left(); i++) {
-            levels.push(readLevelsChannel(reader));
+    const channels = [];
+    for (let i = 0; i < 29 && left() >= 10; i++) {
+        channels.push(readLevelsChannel(reader));
+    }
+    if (left() >= 8) {
+        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));
         }
     }
+    // records for all possible channels are stored, skip unused ones
+    while (channels.length && isDefaultLevelsChannel(channels[channels.length - 1]))
+        channels.pop();
+    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'levels', channels });
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
-    const info = target.adjustment;
-    const defaultChannel = {
-        shadowInput: 0,
-        highlightInput: 255,
-        shadowOutput: 0,
-        highlightOutput: 255,
-        midtoneInput: 1,
-    };
+    const channels = target.adjustment.channels || [];
     (0, psdWriter_1.writeUint16)(writer, 2); // version
-    writeLevelsChannel(writer, info.rgb || defaultChannel);
-    writeLevelsChannel(writer, info.red || defaultChannel);
-    writeLevelsChannel(writer, info.green || defaultChannel);
-    writeLevelsChannel(writer, info.blue || defaultChannel);
-    for (let i = 0; i < (29 - 4); i++) {
-        writeLevelsChannel(writer, defaultChannel);
+    for (let i = 0; i < 29; i++) {
+        writeLevelsChannel(writer, channels[i] || defaultLevelsChannel);
     }
     (0, psdWriter_1.writeSignature)(writer, 'Lvls');
     (0, psdWriter_1.writeUint16)(writer, 3); // version
     (0, psdWriter_1.writeUint16)(writer, 62); // total count
-    for (let i = 0; i < (62 - 29); i++) {
-        writeLevelsChannel(writer, defaultChannel);
+    for (let i = 29; i < 62; i++) {
+        writeLevelsChannel(writer, channels[i] || defaultLevelsChannel);
     }
 });
 function readCurveChannel(reader) {
@@ -2646,87 +3029,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 channels = (0, psdReader_1.readUint16)(reader);
-    const info = { type: 'curves' };
-    if (channels & 1)
-        info.rgb = readCurveChannel(reader);
-    if (channels & 2)
-        info.red = readCurveChannel(reader);
-    if (channels & 4)
-        info.green = readCurveChannel(reader);
-    if (channels & 8)
-        info.blue = readCurveChannel(reader);
-    target.adjustment = Object.assign(Object.assign({}, target.adjustment), info);
-    // 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);
-    // 	}
-    // }
-    (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target) => {
-    const info = target.adjustment;
-    const { rgb, red, green, blue } = info;
-    let channels = 0;
-    let channelCount = 0;
-    if (rgb && rgb.length) {
-        channels |= 1;
-        channelCount++;
-    }
-    if (red && red.length) {
-        channels |= 2;
-        channelCount++;
+    const countOrMask = (0, psdReader_1.readUint32)(reader);
+    const channels = [];
+    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());
+            }
+        }
     }
-    if (green && green.length) {
-        channels |= 4;
-        channelCount++;
+    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[index] = channel;
+        }
     }
-    if (blue && blue.length) {
-        channels |= 8;
-        channelCount++;
+    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 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) {
+            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, channels);
-    if (rgb && rgb.length)
-        writeCurveChannel(writer, rgb);
-    if (red && red.length)
-        writeCurveChannel(writer, red);
-    if (green && green.length)
-        writeCurveChannel(writer, green);
-    if (blue && blue.length)
-        writeCurveChannel(writer, blue);
+    (0, psdWriter_1.writeUint32)(writer, channelsMask >>> 0);
+    for (const i of used)
+        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, channelCount);
-    if (rgb && rgb.length) {
-        (0, psdWriter_1.writeUint16)(writer, 0);
-        writeCurveChannel(writer, rgb);
-    }
-    if (red && red.length) {
-        (0, psdWriter_1.writeUint16)(writer, 1);
-        writeCurveChannel(writer, red);
-    }
-    if (green && green.length) {
-        (0, psdWriter_1.writeUint16)(writer, 2);
-        writeCurveChannel(writer, green);
-    }
-    if (blue && blue.length) {
-        (0, psdWriter_1.writeUint16)(writer, 3);
-        writeCurveChannel(writer, blue);
+    (0, psdWriter_1.writeUint32)(writer, used.length);
+    for (const i of used) {
+        (0, psdWriter_1.writeUint16)(writer, i);
+        writeChannel(channels[i]);
     }
 });
 addHandler('expA', adjustmentType('exposure'), (reader, target, left) => {
@@ -2783,12 +3157,34 @@ function writeHueChannel(writer, channel) {
 addHandler('hue2', adjustmentType('hue/saturation'), (reader, target, left) => {
     if ((0, psdReader_1.readUint16)(reader) !== 2)
         throw new Error('Invalid hue2 version');
-    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'hue/saturation', master: readHueChannel(reader), reds: readHueChannel(reader), yellows: readHueChannel(reader), greens: readHueChannel(reader), cyans: readHueChannel(reader), blues: readHueChannel(reader), magentas: readHueChannel(reader) });
+    const colorize = !!(0, psdReader_1.readUint8)(reader);
+    (0, psdReader_1.skipBytes)(reader, 1);
+    const colorizeHue = (0, psdReader_1.readInt16)(reader); // stored as -180..180
+    const colorizeSaturation = (0, psdReader_1.readInt16)(reader);
+    const colorizeLightness = (0, psdReader_1.readInt16)(reader);
+    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'hue/saturation', colorize, colorization: {
+            hue: colorizeHue < 0 ? colorizeHue + 360 : colorizeHue,
+            saturation: colorizeSaturation,
+            lightness: colorizeLightness,
+        }, master: {
+            hue: (0, psdReader_1.readInt16)(reader),
+            saturation: (0, psdReader_1.readInt16)(reader),
+            lightness: (0, psdReader_1.readInt16)(reader),
+        }, reds: readHueChannel(reader), yellows: readHueChannel(reader), greens: readHueChannel(reader), cyans: readHueChannel(reader), blues: readHueChannel(reader), magentas: readHueChannel(reader) });
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     const info = target.adjustment;
     (0, psdWriter_1.writeUint16)(writer, 2); // version
-    writeHueChannel(writer, info.master);
+    (0, psdWriter_1.writeUint8)(writer, info.colorize ? 1 : 0);
+    (0, psdWriter_1.writeUint8)(writer, 0);
+    const colorizeHue = Math.round((_b = (_a = info.colorization) === null || _a === void 0 ? void 0 : _a.hue) !== null && _b !== void 0 ? _b : 0);
+    (0, psdWriter_1.writeInt16)(writer, colorizeHue > 180 ? colorizeHue - 360 : colorizeHue);
+    (0, psdWriter_1.writeInt16)(writer, Math.round((_d = (_c = info.colorization) === null || _c === void 0 ? void 0 : _c.saturation) !== null && _d !== void 0 ? _d : 0));
+    (0, psdWriter_1.writeInt16)(writer, Math.round((_f = (_e = info.colorization) === null || _e === void 0 ? void 0 : _e.lightness) !== null && _f !== void 0 ? _f : 0));
+    (0, psdWriter_1.writeInt16)(writer, Math.round((_h = (_g = info.master) === null || _g === void 0 ? void 0 : _g.hue) !== null && _h !== void 0 ? _h : 0));
+    (0, psdWriter_1.writeInt16)(writer, Math.round((_k = (_j = info.master) === null || _j === void 0 ? void 0 : _j.saturation) !== null && _k !== void 0 ? _k : 0));
+    (0, psdWriter_1.writeInt16)(writer, Math.round((_m = (_l = info.master) === null || _l === void 0 ? void 0 : _l.lightness) !== null && _m !== void 0 ? _m : 0));
     writeHueChannel(writer, info.reds);
     writeHueChannel(writer, info.yellows);
     writeHueChannel(writer, info.greens);
@@ -2867,16 +3263,18 @@ addHandler('phfl', adjustmentType('photo filter'), (reader, target, left) => {
         color = (0, psdReader_1.readColor)(reader);
     }
     else { // version 3
-        // TODO: test this, this is probably wrong
-        // values are stored as L (0..100), a, b (-128..127) multiplied by 100,
-        // normalize them to the same scale as readColor() so they can be written back as version 2
-        const l = (0, psdReader_1.readInt32)(reader) / 100;
-        const a = (0, psdReader_1.readInt32)(reader) / 100;
-        const b = (0, psdReader_1.readInt32)(reader) / 100;
+        // XYZ color relative to D50 white point, 32768 = 1.0 (not documented, matches colors of Photoshop presets),
+        // converted to Lab (same scale as readColor()) so it can be written back as version 2
+        const x = (0, psdReader_1.readInt32)(reader) / 32768;
+        const y = (0, psdReader_1.readInt32)(reader) / 32768;
+        const z = (0, psdReader_1.readInt32)(reader) / 32768;
+        if (!(x >= 0 && y >= 0 && z >= 0 && x <= 2 && y <= 2 && z <= 2))
+            throw new Error('Invalid phfl XYZ color');
+        const f = (t) => t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
         color = {
-            l: l / 100,
-            a: (0, helpers_1.normalizeLabAB)(a),
-            b: (0, helpers_1.normalizeLabAB)(b),
+            l: Math.max(0, 116 * f(y) - 16) / 100,
+            a: (0, helpers_1.normalizeLabAB)(500 * (f(x) - f(y))),
+            b: (0, helpers_1.normalizeLabAB)(200 * (f(y) - f(z))),
         };
     }
     target.adjustment = {
@@ -3044,7 +3442,7 @@ addHandler('grdm', adjustmentType('gradient map'), (reader, target, left) => {
     reader.offset--;
     if (hasMethod) {
         const method = (0, psdReader_1.readSignature)(reader);
-        info.method = descriptor_1.gradientInterpolationMethodType.decode(method);
+        info.method = descriptor_1.gradientInterpolationMethodType.decode(`gradientInterpolationMethodType.${method}`);
     }
     info.name = (0, psdReader_1.readUnicodeString)(reader);
     info.colorStops = [];
@@ -3106,7 +3504,7 @@ addHandler('grdm', adjustmentType('gradient map'), (reader, target, left) => {
     (0, psdWriter_1.writeUint8)(writer, info.reverse ? 1 : 0);
     (0, psdWriter_1.writeUint8)(writer, info.dither ? 1 : 0);
     if (info.method !== undefined) {
-        (0, psdWriter_1.writeSignature)(writer, descriptor_1.gradientInterpolationMethodType.encode(info.method));
+        (0, psdWriter_1.writeSignature)(writer, descriptor_1.gradientInterpolationMethodType.encode(info.method).split('.')[1]);
     }
     (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, info.name || '');
     (0, psdWriter_1.writeUint16)(writer, info.colorStops && info.colorStops.length || 0);
@@ -3414,6 +3812,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),
@@ -3428,17 +3830,22 @@ addHandler('artd', // document-wide artboard info
 // document-wide artboard info
 target => target.artboards !== undefined, (reader, target, left) => {
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-    target.artboards = {
-        count: desc['Cnt '],
-        autoExpandOffset: { horizontal: desc.autoExpandOffset.Hrzn, vertical: desc.autoExpandOffset.Vrtc },
-        origin: { horizontal: desc.origin.Hrzn, vertical: desc.origin.Vrtc },
-        autoExpandEnabled: desc.autoExpandEnabled,
-        autoNestEnabled: desc.autoNestEnabled,
-        autoPositionEnabled: desc.autoPositionEnabled,
-        shrinkwrapOnSaveEnabled: !!desc.shrinkwrapOnSaveEnabled,
-        docDefaultNewArtboardBackgroundColor: (0, descriptor_1.parseColor)(desc.docDefaultNewArtboardBackgroundColor),
-        docDefaultNewArtboardBackgroundType: desc.docDefaultNewArtboardBackgroundType,
-    };
+    const artboards = target.artboards = { count: desc['Cnt '] };
+    if (desc.autoExpandOffset)
+        artboards.autoExpandOffset = { horizontal: desc.autoExpandOffset.Hrzn, vertical: desc.autoExpandOffset.Vrtc };
+    if (desc.origin)
+        artboards.origin = { horizontal: desc.origin.Hrzn, vertical: desc.origin.Vrtc };
+    if (desc.autoExpandEnabled !== undefined)
+        artboards.autoExpandEnabled = desc.autoExpandEnabled;
+    if (desc.autoNestEnabled !== undefined)
+        artboards.autoNestEnabled = desc.autoNestEnabled;
+    if (desc.autoPositionEnabled !== undefined)
+        artboards.autoPositionEnabled = desc.autoPositionEnabled;
+    artboards.shrinkwrapOnSaveEnabled = !!desc.shrinkwrapOnSaveEnabled;
+    if (desc.docDefaultNewArtboardBackgroundColor)
+        artboards.docDefaultNewArtboardBackgroundColor = (0, descriptor_1.parseColor)(desc.docDefaultNewArtboardBackgroundColor);
+    if (desc.docDefaultNewArtboardBackgroundType !== undefined)
+        artboards.docDefaultNewArtboardBackgroundType = desc.docDefaultNewArtboardBackgroundType;
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
     var _a, _b, _c, _d, _e;
@@ -3456,21 +3863,23 @@ target => target.artboards !== undefined, (reader, target, left) => {
     };
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc, 'artd');
 });
+function isGroupLayer(target) {
+    return !!target.children;
+}
 function hasMultiEffects(effects) {
     return Object.keys(effects).map(key => effects[key]).some(v => Array.isArray(v) && v.length > 1);
 }
-addHandler('lfx2', target => target.effects !== undefined && !hasMultiEffects(target.effects), (reader, target, left) => {
+addHandler('lfx2', target => target.effects !== undefined && !isGroupLayer(target) && !hasMultiEffects(target.effects), (reader, target, left) => {
     const version = (0, psdReader_1.readUint32)(reader);
     if (version !== 0)
         throw new Error(`Invalid lfx2 version`);
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
     // console.log('READ', require('util').inspect(desc, false, 99, true));
-    // TODO: don't discard if we got it from lmfx
-    // discard if read in 'lrFX' section
-    target.effects = (0, descriptor_1.parseEffects)(desc, !!reader.logMissingFeatures);
+    // discard if read in 'lrFX' section ('lmfx' and 'lfx2' are never stored together)
+    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);
@@ -3523,16 +3932,74 @@ addHandler('cinf', hasKey('compositorUsed'), (reader, target, left) => {
         desc.compCoreGPUSupport = `reason.${cinf.compCoreGPUSupport}`;
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
 });
-// extension settings ?, ignore it
-addHandler('extn', target => target._extn !== undefined, (reader, target) => {
+// generator settings of the document (layers store them in 'shmd' section)
+addHandler('extn', target => target.generatorSettings !== undefined && isDocument(target), (reader, target, left) => {
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-    // console.log(require('util').inspect(desc, false, 99, true));
-    if (helpers_1.MOCK_HANDLERS)
-        target._extn = desc;
+    if (desc.generatorSettings)
+        target.generatorSettings = parseGeneratorSettings(desc.generatorSettings);
+    (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
-    // TODO: need to add correct types for desc fields (resources/src.psd)
-    if (helpers_1.MOCK_HANDLERS)
-        (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', target._extn);
+    (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;