ag-psd 33.0.0 → 34.0.0

package/dist/additionalInfo.js

@@ -108,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);
@@ -401,10 +467,10 @@ addHandler('lmfx', target => target.effects !== undefined && !isGroupLayer(targe
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
     // console.log('READ', require('util').inspect(desc, false, 99, true));
     // discard if read in 'lrFX' or 'lfx2' section
-    target.effects = (0, descriptor_1.parseEffects)(desc, !!reader.logMissingFeatures);
+    target.effects = (0, descriptor_1.parseEffects)(desc, reader);
     (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target, _, options) => {
-    const desc = (0, descriptor_1.serializeEffects)(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target) => {
+    const desc = (0, descriptor_1.serializeEffects)(target.effects, writer, true);
     // console.log('WRITE', require('util').inspect(desc, false, 99, true));
     (0, psdWriter_1.writeUint32)(writer, 0); // version
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
@@ -539,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 = {
@@ -643,7 +761,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
                         if (f.FXRf)
                             frame.referencePoint = (0, descriptor_1.horzVrtcToXY)(f.FXRf);
                         if (f.Lefx)
-                            frame.effects = (0, descriptor_1.parseEffects)(f.Lefx, !!reader.logMissingFeatures);
+                            frame.effects = (0, descriptor_1.parseEffects)(f.Lefx, reader);
                         if (f.blendOptions && f.blendOptions.Opct)
                             frame.opacity = (0, descriptor_1.parsePercent)(f.blendOptions.Opct);
                         target.animationFrames.push(frame);
@@ -674,7 +792,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
                         audioLevel: desc.audioLevel,
                     };
                     if (desc.trackList) {
-                        timeline.tracks = (0, descriptor_1.parseTrackList)(desc.trackList, !!reader.logMissingFeatures);
+                        timeline.tracks = (0, descriptor_1.parseTrackList)(desc.trackList, reader);
                     }
                     target.timeline = timeline;
                     // console.log('tmln:result', target.name, target.id, require('util').inspect(timeline, false, 99, true));
@@ -756,7 +874,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
                 if (f.referencePoint)
                     frame.FXRf = (0, descriptor_1.xyToHorzVrtc)(f.referencePoint);
                 if (f.effects)
-                    frame.Lefx = (0, descriptor_1.serializeEffects)(f.effects, false, hasMultiEffects(f.effects));
+                    frame.Lefx = (0, descriptor_1.serializeEffects)(f.effects, writer, hasMultiEffects(f.effects));
                 if (f.opacity !== undefined)
                     frame.blendOptions = { Opct: (0, descriptor_1.unitsPercentF)(f.opacity) };
                 desc.LaSt.push(frame);
@@ -796,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));
@@ -1175,6 +1293,86 @@ function pointToHrznVrtc(point) {
         Vrtc: (0, descriptor_1.unitsValue)(point.y, 'y'),
     };
 }
+// Camera Raw Filter setting paths (in CameraRawFilterSettings) and their descriptor keys
+const cameraRawColorKeys = [
+    ['red', 'R'], ['orange', 'O'], ['yellow', 'Y'], ['green', 'G'], ['aqua', 'A'], ['blue', 'B'], ['purple', 'P'], ['magenta', 'M'],
+];
+const cameraRawSettings = [
+    ['version', 'CrVe'], ['processVersion', 'PrVN'], ['processVersionCode', 'PrVe'], ['whiteBalance', 'WBal'],
+    ['temperature', 'Temp'], ['tint', 'Tint'], ['exposure', 'Ex12'], ['contrast', 'Cr12'], ['highlights', 'Hi12'],
+    ['shadows', 'Sh12'], ['whites', 'Wh12'], ['blacks', 'Bk12'], ['texture', 'CrTx'], ['clarity', 'Cl12'],
+    ['dehaze', 'Dhze'], ['vibrance', 'Vibr'], ['saturation', 'Strt'],
+    ['parametricCurve.shadows', 'PC_S'], ['parametricCurve.darks', 'PC_D'], ['parametricCurve.lights', 'PC_L'],
+    ['parametricCurve.highlights', 'PC_H'], ['parametricCurve.shadowSplit', 'PC_1'], ['parametricCurve.midtoneSplit', 'PC_2'],
+    ['parametricCurve.highlightSplit', 'PC_3'],
+    ['pointCurve.composite', 'Crv '], ['pointCurve.red', 'CrvR'], ['pointCurve.green', 'CrvG'], ['pointCurve.blue', 'CrvB'],
+    ...cameraRawColorKeys.map(([name, key]) => [`hsl.hue.${name}`, `HA_${key}`]),
+    ...cameraRawColorKeys.map(([name, key]) => [`hsl.saturation.${name}`, `SA_${key}`]),
+    ...cameraRawColorKeys.map(([name, key]) => [`hsl.luminance.${name}`, `LA_${key}`]),
+    ['colorGrading.shadows.hue', 'STSH'], ['colorGrading.shadows.saturation', 'STSS'], ['colorGrading.shadows.luminance', 'CgSL'],
+    ['colorGrading.midtones.hue', 'CgMH'], ['colorGrading.midtones.saturation', 'CgMS'], ['colorGrading.midtones.luminance', 'CgML'],
+    ['colorGrading.highlights.hue', 'STHH'], ['colorGrading.highlights.saturation', 'STHS'], ['colorGrading.highlights.luminance', 'CgHL'],
+    ['colorGrading.global.hue', 'CgGH'], ['colorGrading.global.saturation', 'CgGS'], ['colorGrading.global.luminance', 'CgGL'],
+    ['colorGrading.blending', 'CgBl'], ['colorGrading.balance', 'STB '],
+    ['sharpening.amount', 'Shrp'], ['sharpening.radius', 'ShpR'], ['sharpening.detail', 'ShpD'], ['sharpening.masking', 'ShpM'],
+    ['noiseReduction.luminance', 'LNR '], ['noiseReduction.luminanceDetail', 'LNRD'], ['noiseReduction.luminanceContrast', 'LNRC'],
+    ['noiseReduction.color', 'CNR '], ['noiseReduction.colorDetail', 'CNRD'], ['noiseReduction.colorSmoothness', 'CNRS'],
+    ['grain.amount', 'GRNA'], ['grain.size', 'GRNS'], ['grain.roughness', 'GRNF'],
+    ['postCropVignette.amount', 'PCVA'], ['postCropVignette.midpoint', 'PCVM'], ['postCropVignette.feather', 'PCVF'],
+    ['postCropVignette.roundness', 'PCVR'],
+];
+const cameraRawCurveKeys = ['Crv ', 'CrvR', 'CrvG', 'CrvB'];
+const cameraRawFilterID = 2783;
+function parseCameraRawSettings(desc, reader) {
+    var _a;
+    const settings = {};
+    for (const [path, key] of cameraRawSettings) {
+        let value = desc[key];
+        if (value === undefined)
+            continue;
+        if (key === 'WBal') {
+            value = value.split('.')[1];
+        }
+        else if (cameraRawCurveKeys.includes(key)) {
+            const values = value;
+            value = [];
+            for (let i = 0; i + 1 < values.length; i += 2)
+                value.push({ input: values[i], output: values[i + 1] });
+        }
+        const parts = path.split('.');
+        let target = settings;
+        for (let i = 0; i < parts.length - 1; i++)
+            target = target[parts[i]] = (_a = target[parts[i]]) !== null && _a !== void 0 ? _a : {};
+        target[parts[parts.length - 1]] = value;
+    }
+    for (const key of Object.keys(desc)) {
+        if (key !== '_name' && key !== '_classID' && !cameraRawSettings.some(s => s[1] === key)) {
+            reader.logMissingFeatures && reader.log(`Unhandled Camera Raw Filter setting: ${key}`);
+        }
+    }
+    return settings;
+}
+function serializeCameraRawSettings(settings) {
+    const desc = { _name: '', _classID: descriptor_1.cameraRawFilterClassID };
+    for (const [path, key] of cameraRawSettings) {
+        let value = settings;
+        for (const part of path.split('.'))
+            value = value === null || value === void 0 ? void 0 : value[part];
+        if (value === undefined)
+            continue;
+        if (key === 'WBal') {
+            value = `WBal.${value}`;
+        }
+        else if (cameraRawCurveKeys.includes(key)) {
+            value = value.flatMap(p => [Math.round(p.input), Math.round(p.output)]);
+        }
+        else if (typeof value === 'number' && key !== 'Ex12' && key !== 'ShpR') {
+            value = Math.round(value);
+        }
+        desc[key] = value;
+    }
+    return desc;
+}
 function parseFilterFXItem(f, reader) {
     const base = {
         name: f['Nm  '],
@@ -1185,6 +1383,9 @@ function parseFilterFXItem(f, reader) {
         foregroundColor: (0, descriptor_1.parseColor)(f.FrgC),
         backgroundColor: (0, descriptor_1.parseColor)(f.BckC),
     };
+    if ('Fltr' in f && f.Fltr._classID === descriptor_1.cameraRawFilterClassID) {
+        return Object.assign(Object.assign({}, base), { type: 'camera raw', filter: parseCameraRawSettings(f.Fltr, reader) });
+    }
     if ('Fltr' in f) {
         switch (f.Fltr._classID) {
             case 'boxblur': return Object.assign(Object.assign({}, base), { type: 'box blur', filter: {
@@ -2083,6 +2284,7 @@ function serializeFilterFXItem(f) {
                     return adjustment;
                 }),
             } : {})), filterID: 1282829427 });
+        case 'camera raw': return Object.assign(Object.assign({}, base), { Fltr: serializeCameraRawSettings(f.filter), filterID: cameraRawFilterID });
         case 'brightness/contrast': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Brightness/Contrast',
                 _classID: 'BrgC',
@@ -2308,31 +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', // 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
-    // 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
-    target => !!(target.patterns && target.patterns.length > 0), (reader, target, left) => {
-        while (left() > 0) {
-            const pattern = (0, psdReader_1.readPatternSafe)(reader);
-            if (!pattern)
-                continue;
-            if (target.patterns === undefined)
-                target.patterns = [];
-            target.patterns.push(pattern);
-        }
-    }, (writer, target, _, _options) => {
-        const patterns = target.patterns || [];
-        for (const pattern of patterns) {
-            (0, psdWriter_1.writePattern)(writer, pattern);
-        }
-    });
-}
+addHandler('Patt', // 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
+// 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
+target => !!(target.patterns && target.patterns.length > 0), (reader, target, left) => {
+    while (left() > 0) {
+        const pattern = (0, psdReader_1.readPatternSafe)(reader);
+        if (!pattern)
+            continue;
+        if (target.patterns === undefined)
+            target.patterns = [];
+        target.patterns.push(pattern);
+    }
+}, (writer, target, _, _options) => {
+    const patterns = target.patterns || [];
+    for (const pattern of patterns) {
+        (0, psdWriter_1.writePattern)(writer, pattern);
+    }
+});
 addHandlerAlias('Pat2', 'Patt');
 addHandlerAlias('Pat3', 'Patt');
 /*
@@ -2724,10 +2918,10 @@ target => target.effects !== undefined && isGroupLayer(target), (reader, target,
     if (version !== 0)
         throw new Error(`Invalid lfxs version`);
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-    target.effects = (0, descriptor_1.parseEffects)(desc, !!reader.logMissingFeatures);
+    target.effects = (0, descriptor_1.parseEffects)(desc, reader);
     (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target, _, options) => {
-    const desc = (0, descriptor_1.serializeEffects)(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target) => {
+    const desc = (0, descriptor_1.serializeEffects)(target.effects, writer, true);
     (0, psdWriter_1.writeUint32)(writer, 0); // version
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
 });
@@ -2782,11 +2976,19 @@ addHandler('levl', adjustmentType('levels'), (reader, target, left) => {
         channels.push(readLevelsChannel(reader));
     }
     if (left() >= 8) {
-        if ((0, psdReader_1.readSignature)(reader) !== 'Lvls')
-            throw new Error(`Invalid levl signature`);
-        if ((0, psdReader_1.readUint16)(reader) !== 3)
-            throw new Error(`Invalid levl version`);
-        const totalChannelRecords = (0, psdReader_1.readUint16)(reader);
+        const signature = (0, psdReader_1.readSignature)(reader);
+        let totalChannelRecords;
+        if (signature === 'ls\x00\x03') {
+            // Clip Studio Paint writes 'ls' instead of 'Lvls' signature (version is part of the read signature)
+            totalChannelRecords = (0, psdReader_1.readUint16)(reader);
+        }
+        else {
+            if (signature !== 'Lvls')
+                throw new Error(`Invalid levl signature`);
+            if ((0, psdReader_1.readUint16)(reader) !== 3)
+                throw new Error(`Invalid levl version`);
+            totalChannelRecords = (0, psdReader_1.readUint16)(reader);
+        }
         while (channels.length < totalChannelRecords && left() >= 10) {
             channels.push(readLevelsChannel(reader));
         }
@@ -2827,58 +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 channelsMask = (0, psdReader_1.readUint16)(reader);
+    const countOrMask = (0, psdReader_1.readUint32)(reader);
     const channels = [];
-    for (let i = 0; i < 16; i++) {
-        if (channelsMask & (1 << i)) {
-            while (channels.length < i)
+    const readChannel = () => isMap ? Array.from((0, psdReader_1.readBytes)(reader, 256)) : readCurveChannel(reader);
+    if (version === 1) {
+        for (let i = 0; i < 32; i++) {
+            if (countOrMask & (1 << i)) {
+                while (channels.length < i)
+                    channels.push([]);
+                channels.push(readChannel());
+            }
+        }
+    }
+    else {
+        if (countOrMask > 64)
+            throw new Error('Invalid curv channel count');
+        for (let i = 0; i < countOrMask; i++)
+            channels.push(readChannel());
+    }
+    // extra section stores curves for all channels (including ones that don't fit in the mask)
+    if (version === 1 && left() >= 10 && (0, psdReader_1.readSignature)(reader) === 'Crv ') {
+        (0, psdReader_1.readUint16)(reader); // version
+        const count = (0, psdReader_1.readUint32)(reader);
+        for (let i = 0; i < count && left() >= 2; i++) {
+            const index = (0, psdReader_1.readUint16)(reader);
+            const channel = readChannel();
+            while (channels.length < index)
                 channels.push([]);
-            channels.push(readCurveChannel(reader));
+            channels[index] = channel;
         }
     }
-    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'curves', channels });
-    // ignoring, duplicate information
-    // checkSignature(reader, 'Crv ');
-    // const cVersion = readUint16(reader);
-    // readUint16(reader);
-    // const channelCount = readUint16(reader);
-    // for (let i = 0; i < channelCount; i++) {
-    // 	const index = readUint16(reader);
-    // 	const nodes = readUint16(reader);
-    // 	for (let j = 0; j < nodes; j++) {
-    // 		const output = readInt16(reader);
-    // 		const input = readInt16(reader);
-    // 	}
-    // }
+    target.adjustment = Object.assign(Object.assign(Object.assign({}, target.adjustment), { type: 'curves' }), (isMap ? { values: channels } : { channels: channels }));
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
     var _a;
-    const channels = (target.adjustment.channels || []).slice(0, 16);
+    const adjustment = target.adjustment;
+    const isMap = !!adjustment.values;
+    const channels = (isMap ? adjustment.values : adjustment.channels) || [];
     const used = [];
     let channelsMask = 0;
     for (let i = 0; i < channels.length; i++) {
         if ((_a = channels[i]) === null || _a === void 0 ? void 0 : _a.length) {
-            channelsMask |= 1 << i;
+            if (i < 32)
+                channelsMask |= 1 << i;
             used.push(i);
         }
     }
-    (0, psdWriter_1.writeUint8)(writer, 0);
+    const writeChannel = (channel) => {
+        var _a;
+        if (isMap) {
+            for (let i = 0; i < 256; i++)
+                (0, psdWriter_1.writeUint8)(writer, (0, helpers_1.clamp)(Math.round((_a = channel[i]) !== null && _a !== void 0 ? _a : i), 0, 255));
+        }
+        else {
+            writeCurveChannel(writer, channel);
+        }
+    };
+    (0, psdWriter_1.writeUint8)(writer, isMap ? 1 : 0);
     (0, psdWriter_1.writeUint16)(writer, 1); // version
-    (0, psdWriter_1.writeUint16)(writer, 0);
-    (0, psdWriter_1.writeUint16)(writer, channelsMask);
+    (0, psdWriter_1.writeUint32)(writer, channelsMask >>> 0);
     for (const i of used)
-        writeCurveChannel(writer, channels[i]);
+        if (i < 32)
+            writeChannel(channels[i]);
     (0, psdWriter_1.writeSignature)(writer, 'Crv ');
     (0, psdWriter_1.writeUint16)(writer, 4); // version
-    (0, psdWriter_1.writeUint16)(writer, 0);
-    (0, psdWriter_1.writeUint16)(writer, used.length);
+    (0, psdWriter_1.writeUint32)(writer, used.length);
     for (const i of used) {
         (0, psdWriter_1.writeUint16)(writer, i);
-        writeCurveChannel(writer, channels[i]);
+        writeChannel(channels[i]);
     }
 });
 addHandler('expA', adjustmentType('exposure'), (reader, target, left) => {
@@ -3590,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),
@@ -3650,10 +3876,10 @@ addHandler('lfx2', target => target.effects !== undefined && !isGroupLayer(targe
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
     // console.log('READ', require('util').inspect(desc, false, 99, true));
     // discard if read in 'lrFX' section ('lmfx' and 'lfx2' are never stored together)
-    target.effects = (0, descriptor_1.parseEffects)(desc, !!reader.logMissingFeatures);
+    target.effects = (0, descriptor_1.parseEffects)(desc, reader);
     (0, psdReader_1.skipBytes)(reader, left());
-}, (writer, target, _, options) => {
-    const desc = (0, descriptor_1.serializeEffects)(target.effects, !!options.logMissingFeatures, true);
+}, (writer, target) => {
+    const desc = (0, descriptor_1.serializeEffects)(target.effects, writer, true);
     // console.log('WRITE', require('util').inspect(desc, false, 99, true));
     (0, psdWriter_1.writeUint32)(writer, 0); // version
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
@@ -3715,6 +3941,66 @@ addHandler('extn', target => target.generatorSettings !== undefined && isDocumen
 }, (writer, target) => {
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', serializeGeneratorSettings(target.generatorSettings));
 });
+// generator settings stored by older versions of Photoshop (written back in 'shmd' or 'extn' section)
+addHandler('extd', () => false, (reader, target, left) => {
+    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+    if (desc.generatorSettings && target.generatorSettings === undefined) {
+        target.generatorSettings = parseGeneratorSettings(desc.generatorSettings);
+    }
+    (0, psdReader_1.skipBytes)(reader, left());
+}, () => { });
+addHandler('frgb', // frame tool group
+hasKey('framedGroup'), (reader, target, left) => {
+    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+    const rect = desc.framedGroupRect;
+    target.framedGroup = {
+        rect: { top: rect['Top '], left: rect.Left, bottom: rect.Btom, right: rect.Rght },
+        type: desc.framedGroupType,
+    };
+    if (desc.LockPPI !== undefined)
+        target.framedGroup.lockPPI = desc.LockPPI;
+    if (desc.PreferredResolution !== undefined)
+        target.framedGroup.preferredResolution = desc.PreferredResolution;
+    if (desc.SavedIteratedName !== undefined)
+        target.framedGroup.savedIteratedName = desc.SavedIteratedName;
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target) => {
+    const group = target.framedGroup;
+    const rect = group.rect;
+    const desc = {
+        framedGroupRect: { _name: '', _classID: 'classFloatRect', 'Top ': rect.top, Left: rect.left, Btom: rect.bottom, Rght: rect.right },
+        framedGroupType: group.type,
+    };
+    if (group.lockPPI !== undefined)
+        desc.LockPPI = group.lockPPI;
+    if (group.preferredResolution !== undefined)
+        desc.PreferredResolution = group.preferredResolution;
+    if (group.savedIteratedName !== undefined)
+        desc.SavedIteratedName = group.savedIteratedName;
+    (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'framedGroup', desc);
+});
+addHandler('anFX', hasKey('animationEffects'), (reader, target, left) => {
+    target.animationEffects = (0, psdReader_1.readBytes)(reader, left());
+}, (writer, target) => {
+    (0, psdWriter_1.writeBytes)(writer, target.animationEffects);
+});
+addHandler('PxSD', // pixel source data 2 (video layer frames)
+hasKey('pixelSourceData'), (reader, target, left) => {
+    target.pixelSourceData = [];
+    while (left() >= 8) {
+        const length = readLength64(reader);
+        if (length > left())
+            throw new Error('Invalid PxSD data length');
+        target.pixelSourceData.push((0, psdReader_1.readBytes)(reader, length));
+    }
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target) => {
+    for (const data of target.pixelSourceData) {
+        (0, psdWriter_1.writeUint32)(writer, 0);
+        (0, psdWriter_1.writeUint32)(writer, data.byteLength);
+        (0, psdWriter_1.writeBytes)(writer, data);
+    }
+});
 addHandler('iOpa', hasKey('fillOpacity'), (reader, target) => {
     target.fillOpacity = (0, psdReader_1.readUint8)(reader) / 0xff;
     (0, psdReader_1.skipBytes)(reader, 3);