ag-psd 32.0.0 → 33.0.0

package/dist/bundle.js

@@ -99,261 +99,92 @@ function parseHeightmap(array) {
     // return result;
 }
 function readAbr(buffer, options = {}) {
-    var _a, _b, _c, _d;
     const reader = (0, psdReader_1.createReader)(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    reader.logMissingFeatures = options.logMissingFeatures;
+    reader.throwForMissingFeatures = options.throwForMissingFeatures;
+    reader.totalMemoryLimit = 'totalMemoryLimit' in options ? options.totalMemoryLimit : 2 * 1024 * 1024 * 1024;
+    // skips invalid or unsupported part of the file
+    const skip = (e, what) => {
+        if (options.throwForMissingFeatures)
+            throw e;
+        options.logMissingFeatures && reader.log(`Skipped ${what}: ${e.message}`);
+    };
+    if (reader.view.byteLength < 4)
+        throw new Error('Invalid ABR file');
     const version = (0, psdReader_1.readInt16)(reader);
     const samples = [];
     const brushes = [];
     const patterns = [];
+    const brushByPreset = []; // brush for each preset in 'desc' section (brushes that fail to parse are skipped)
+    let hierarchy;
     if (version === 1 || version === 2) {
-        throw new Error(`Unsupported ABR version (${version})`); // TODO: ...
+        readLegacyBrushes(reader, version, samples, brushes, skip);
     }
     else if (version === 6 || version === 7 || version === 9 || version === 10) {
         const minorVersion = (0, psdReader_1.readInt16)(reader);
         if (minorVersion !== 1 && minorVersion !== 2)
             throw new Error('Unsupported ABR minor version');
-        while (reader.offset < reader.view.byteLength) {
+        // section header is 12 bytes, ignore any shorter trailing data
+        while (reader.offset + 12 <= reader.view.byteLength) {
             (0, psdReader_1.checkSignature)(reader, '8BIM');
             const type = (0, psdReader_1.readSignature)(reader);
             const size = (0, psdReader_1.readUint32)(reader);
-            const end = reader.offset + size;
-            switch (type) {
-                case 'samp': {
-                    while (reader.offset < end) {
-                        let brushLength = (0, psdReader_1.readUint32)(reader);
-                        while (brushLength & 0b11)
-                            brushLength++; // pad to 4 byte alignment
-                        const brushEnd = reader.offset + brushLength;
-                        const id = (0, psdReader_1.readPascalString)(reader, 1);
-                        // v1 - Skip the Int16 bounds rectangle and the unknown Int16.
-                        // v2 - Skip the unknown bytes.
-                        (0, psdReader_1.skipBytes)(reader, minorVersion === 1 ? 10 : 264);
-                        const y = (0, psdReader_1.readInt32)(reader);
-                        const x = (0, psdReader_1.readInt32)(reader);
-                        const h = (0, psdReader_1.readInt32)(reader) - y;
-                        const w = (0, psdReader_1.readInt32)(reader) - x;
-                        if (w <= 0 || h <= 0)
-                            throw new Error('Invalid bounds');
-                        if (w > MAX_BRUSH_SIZE || h > MAX_BRUSH_SIZE) {
-                            throw new Error(`Brush sample too large (${w}x${h})`);
-                        }
-                        const bithDepth = (0, psdReader_1.readInt16)(reader);
-                        const compression = (0, psdReader_1.readUint8)(reader); // 0 - raw, 1 - RLE
-                        if (compression === 0 && w * h * (bithDepth === 16 ? 2 : 1) > brushEnd - reader.offset) {
-                            throw new Error('Brush sample data out of bounds');
-                        }
-                        const alpha = new Uint8Array(w * h);
-                        if (bithDepth === 8) {
-                            if (compression === 0) {
-                                alpha.set((0, psdReader_1.readBytes)(reader, alpha.byteLength));
-                            }
-                            else if (compression === 1) {
-                                (0, psdReader_1.readDataRLE)(reader, { width: w, height: h, data: alpha }, w, h, bithDepth, 1, [0], false);
+            const end = Math.min(reader.offset + size, reader.view.byteLength);
+            try {
+                switch (type) {
+                    case 'samp': {
+                        while (reader.offset + 4 <= end) {
+                            let brushLength = (0, psdReader_1.readUint32)(reader);
+                            while (brushLength & 0b11)
+                                brushLength++; // pad to 4 byte alignment
+                            const brushEnd = Math.min(reader.offset + brushLength, end);
+                            try {
+                                const sample = readSample(reader, brushEnd, minorVersion);
+                                samples.push(sample);
                             }
-                            else {
-                                throw new Error('Invalid compression');
+                            catch (e) {
+                                skip(e, 'brush sample');
                             }
+                            reader.offset = brushEnd;
                         }
-                        else if (bithDepth === 16) {
-                            if (compression === 0) {
-                                for (let i = 0; i < alpha.byteLength; i++) {
-                                    alpha[i] = (0, psdReader_1.readUint16)(reader) >> 8; // convert to 8bit values
-                                }
-                            }
-                            else if (compression === 1) {
-                                throw new Error('not implemented (16bit RLE)'); // TODO: ...
+                        break;
+                    }
+                    case 'desc': {
+                        const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
+                        for (const [index, brush] of (desc.Brsh || []).entries()) {
+                            try {
+                                const parsed = parseBrush(brush);
+                                brushes.push(parsed);
+                                brushByPreset[index] = parsed;
                             }
-                            else {
-                                throw new Error('Invalid compression');
+                            catch (e) {
+                                skip(e, `brush "${brush['Nm  ']}"`);
                             }
                         }
-                        else {
-                            throw new Error('Invalid depth');
-                        }
-                        samples.push({ id, bounds: { x, y, w, h }, alpha });
-                        reader.offset = brushEnd;
+                        break;
                     }
-                    break;
-                }
-                case 'desc': {
-                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
-                    // console.log(require('util').inspect(desc, false, 99, true));
-                    // require('fs').writeFileSync('test.log', require('util').inspect(desc, false, 99, false), 'utf8');
-                    for (const brush of desc.Brsh) {
-                        const b = {
-                            name: brush['Nm  '],
-                            shape: parseBrushShape(brush.Brsh),
-                            spacing: (0, descriptor_1.parsePercent)(brush.Spcn),
-                            // TODO: brushGroup ???
-                            wetEdges: brush.Wtdg,
-                            noise: brush.Nose,
-                            // TODO: TxtC ??? smoothing / build-up ?
-                            // TODO: 'Rpt ' ???
-                            useBrushSize: brush.useBrushSize, // ???
-                        };
-                        if (brush.interpretation != null)
-                            b.interpretation = brush.interpretation;
-                        if (brush.protectTexture != null)
-                            b.protectTexture = brush.protectTexture;
-                        if (brush.useTipDynamics) {
-                            b.shapeDynamics = {
-                                tiltScale: (0, descriptor_1.parsePercent)(brush.tiltScale),
-                                sizeDynamics: parseDynamics(brush.szVr),
-                                angleDynamics: parseDynamics(brush.angleDynamics),
-                                roundnessDynamics: parseDynamics(brush.roundnessDynamics),
-                                flipX: brush.flipX,
-                                flipY: brush.flipY,
-                                brushProjection: brush.brushProjection,
-                                minimumDiameter: (0, descriptor_1.parsePercent)(brush.minimumDiameter),
-                                minimumRoundness: (0, descriptor_1.parsePercent)(brush.minimumRoundness),
-                            };
-                        }
-                        if (brush.useScatter) {
-                            b.scatter = {
-                                count: brush['Cnt '],
-                                bothAxes: brush.bothAxes,
-                                countDynamics: parseDynamics(brush.countDynamics),
-                                scatterDynamics: parseDynamics(brush.scatterDynamics),
-                            };
-                        }
-                        if (brush.useTexture && brush.Txtr) {
-                            b.texture = {
-                                id: brush.Txtr.Idnt,
-                                name: brush.Txtr['Nm  '],
-                                blendMode: descriptor_1.BlnM.decode(brush.textureBlendMode),
-                                depth: (0, descriptor_1.parsePercent)(brush.textureDepth),
-                                depthMinimum: (0, descriptor_1.parsePercent)(brush.minimumDepth),
-                                depthDynamics: parseDynamics(brush.textureDepthDynamics),
-                                scale: (0, descriptor_1.parsePercent)(brush.textureScale),
-                                invert: brush.InvT,
-                                brightness: brush.textureBrightness,
-                                contrast: brush.textureContrast,
-                                textureEachTip: !!brush.TxtC,
-                            };
-                        }
-                        const db = brush.dualBrush;
-                        if (db && db.useDualBrush) {
-                            b.dualBrush = {
-                                flip: db.Flip,
-                                shape: parseBrushShape(db.Brsh),
-                                blendMode: descriptor_1.BlnM.decode(db.BlnM),
-                                useScatter: db.useScatter,
-                                spacing: (0, descriptor_1.parsePercent)(db.Spcn),
-                                count: db['Cnt '],
-                                bothAxes: db.bothAxes,
-                                countDynamics: parseDynamics(db.countDynamics),
-                                scatterDynamics: parseDynamics(db.scatterDynamics),
-                            };
+                    case 'patt': {
+                        while (reader.offset + 4 <= end) {
+                            const pattern = (0, psdReader_1.readPatternSafe)(reader);
+                            if (pattern)
+                                patterns.push(pattern);
                         }
-                        if (brush.useColorDynamics) {
-                            b.colorDynamics = {
-                                foregroundBackground: parseDynamics(brush.clVr),
-                                hue: (0, descriptor_1.parsePercent)(brush['H   ']),
-                                saturation: (0, descriptor_1.parsePercent)(brush.Strt),
-                                brightness: (0, descriptor_1.parsePercent)(brush.Brgh),
-                                purity: (0, descriptor_1.parsePercent)(brush.purity),
-                                perTip: brush.colorDynamicsPerTip,
-                            };
-                        }
-                        if (brush.usePaintDynamics) {
-                            b.transfer = {
-                                flowDynamics: parseDynamics(brush.prVr),
-                                opacityDynamics: parseDynamics(brush.opVr),
-                                wetnessDynamics: parseDynamics(brush.wtVr),
-                                mixDynamics: parseDynamics(brush.mxVr),
-                            };
-                        }
-                        if (brush.useBrushPose) {
-                            b.brushPose = {
-                                overrideAngle: brush.overridePoseAngle,
-                                overrideTiltX: brush.overridePoseTiltX,
-                                overrideTiltY: brush.overridePoseTiltY,
-                                overridePressure: brush.overridePosePressure,
-                                pressure: (0, descriptor_1.parsePercent)(brush.brushPosePressure),
-                                tiltX: brush.brushPoseTiltX,
-                                tiltY: brush.brushPoseTiltY,
-                                angle: brush.brushPoseAngle,
-                            };
-                        }
-                        const to = brush.toolOptions;
-                        if (to) {
-                            b.toolOptions = {
-                                type: toBrushType[to._classID] || 'brush',
-                                brushPreset: to.brushPreset,
-                                flow: (_a = to.flow) !== null && _a !== void 0 ? _a : 100,
-                                smooth: (_b = to.Smoo) !== null && _b !== void 0 ? _b : 0,
-                                mode: descriptor_1.BlnM.decode(to['Md  '] || 'BlnM.Nrml'), // sometimes mode is missing
-                                opacity: (_c = to.Opct) !== null && _c !== void 0 ? _c : 100,
-                                smoothing: !!to.smoothing,
-                                smoothingValue: to.smoothingValue || 0,
-                                smoothingRadiusMode: !!to.smoothingRadiusMode,
-                                smoothingCatchup: !!to.smoothingCatchup,
-                                smoothingCatchupAtEnd: !!to.smoothingCatchupAtEnd,
-                                smoothingZoomCompensation: !!to.smoothingZoomCompensation,
-                                pressureSmoothing: !!to.pressureSmoothing,
-                                usePressureOverridesSize: !!to.usePressureOverridesSize,
-                                usePressureOverridesOpacity: !!to.usePressureOverridesOpacity,
-                                useLegacy: !!to.useLegacy,
-                            };
-                            if (to.prVr)
-                                b.toolOptions.flowDynamics = parseDynamics(to.prVr);
-                            if (to.opVr)
-                                b.toolOptions.opacityDynamics = parseDynamics(to.opVr);
-                            if (to.szVr)
-                                b.toolOptions.sizeDynamics = parseDynamics(to.szVr);
-                            if ('wetness' in to)
-                                b.toolOptions.wetness = to.wetness;
-                            if ('dryness' in to)
-                                b.toolOptions.dryness = to.dryness;
-                            if ('mix' in to)
-                                b.toolOptions.mix = to.mix;
-                            if ('autoFill' in to)
-                                b.toolOptions.autoFill = to.autoFill;
-                            if ('autoClean' in to)
-                                b.toolOptions.autoClean = to.autoClean;
-                            if ('loadSolidColorOnly' in to)
-                                b.toolOptions.loadSolidColorOnly = to.loadSolidColorOnly;
-                            if ('sampleAllLayers' in to)
-                                b.toolOptions.sampleAllLayers = to.sampleAllLayers;
-                            if ('SmdF' in to)
-                                b.toolOptions.smudgeFingerPainting = to.SmdF;
-                            if ('SmdS' in to)
-                                b.toolOptions.smudgeSampleAllLayers = to.SmdS;
-                            if ('Prs ' in to)
-                                b.toolOptions.strength = to['Prs '];
-                        }
-                        brushes.push(b);
-                    }
-                    break;
-                }
-                case 'patt': {
-                    while (reader.offset < end) {
-                        patterns.push((0, psdReader_1.readPattern)(reader));
+                        break;
                     }
-                    reader.offset = end;
-                    break;
-                }
-                case 'phry': {
-                    // TODO: what is this ?
-                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-                    // example:
-                    // hierarchy: [
-                    // 	{
-                    // 		'Nm  ': 'PRE_EXPORT ',
-                    // 		zuid: '965209f2-6f35-9a40-aa43-485684382172'
-                    // 	},
-                    // 	{},
-                    //  ...
-                    // ]
-                    if (options.logMissingFeatures) {
-                        if ((_d = desc.hierarchy) === null || _d === void 0 ? void 0 : _d.length) {
-                            // console.log('unhandled phry section', desc);
-                        }
+                    case 'phry': { // brush groups (folders in brushes panel)
+                        // flat list of group starts, presets (in the same order as in 'desc' section) and group ends
+                        const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
+                        hierarchy = desc.hierarchy;
+                        break;
                     }
-                    break;
+                    default:
+                        // 'lPdc' (tool presets) and other unknown sections
+                        options.logMissingFeatures && reader.log(`Unhandled brush section: ${type}`);
+                        break;
                 }
-                default:
-                    throw new Error(`Invalid brush type: ${type}`);
+            }
+            catch (e) {
+                skip(e, `brush section ${type}`);
             }
             // skip any unread data in the section and align to 4 bytes
             reader.offset = end;
@@ -364,8 +195,304 @@ function readAbr(buffer, options = {}) {
     else {
         throw new Error(`Unsupported ABR version (${version})`);
     }
+    if (hierarchy) {
+        const groups = [];
+        let presetIndex = 0;
+        for (const item of hierarchy) {
+            if (item._classID === 'Grup') {
+                groups.push(item['Nm  ']);
+            }
+            else if (item._classID === 'groupEnd') {
+                groups.pop();
+            }
+            else if (item._classID === 'preset') {
+                const brush = brushByPreset[presetIndex];
+                if (brush && groups.length)
+                    brush.group = groups.slice();
+                presetIndex++;
+            }
+        }
+    }
     return { samples, patterns, brushes };
 }
+function readSample(reader, brushEnd, minorVersion) {
+    const id = (0, psdReader_1.readPascalString)(reader, 1);
+    // v1 - Skip the Int16 bounds rectangle and the unknown Int16.
+    // v2 - Skip the unknown bytes.
+    (0, psdReader_1.skipBytes)(reader, minorVersion === 1 ? 10 : 264);
+    return readSampleBitmap(reader, brushEnd, id);
+}
+// bounds, bit depth, compression and image data of brush sample
+function readSampleBitmap(reader, brushEnd, id) {
+    const y = (0, psdReader_1.readInt32)(reader);
+    const x = (0, psdReader_1.readInt32)(reader);
+    const h = (0, psdReader_1.readInt32)(reader) - y;
+    const w = (0, psdReader_1.readInt32)(reader) - x;
+    if (w <= 0 || h <= 0)
+        throw new Error('Invalid bounds');
+    if (w > MAX_BRUSH_SIZE || h > MAX_BRUSH_SIZE) {
+        throw new Error(`Brush sample too large (${w}x${h})`);
+    }
+    const bithDepth = (0, psdReader_1.readInt16)(reader);
+    const compression = (0, psdReader_1.readUint8)(reader); // 0 - raw, 1 - RLE
+    if (bithDepth !== 8 && bithDepth !== 16)
+        throw new Error('Invalid depth');
+    if (compression !== 0 && compression !== 1)
+        throw new Error('Invalid compression');
+    const rowSize = w * (bithDepth === 16 ? 2 : 1);
+    // RLE needs at least 2 bytes for row length and 2 bytes per each 128 byte run
+    const minDataSize = compression === 0 ? h * rowSize : h * (2 + Math.ceil(rowSize / 128) * 2);
+    if (minDataSize > brushEnd - reader.offset) {
+        throw new Error('Brush sample data out of bounds');
+    }
+    (0, psdReader_1.consumeMemory)(reader, w * h * (compression === 1 && bithDepth === 16 ? 3 : 1));
+    const alpha = new Uint8Array(w * h);
+    if (bithDepth === 8) {
+        if (compression === 0) {
+            alpha.set((0, psdReader_1.readBytes)(reader, alpha.byteLength));
+        }
+        else if (compression === 1) {
+            (0, psdReader_1.readDataRLE)(reader, { width: w, height: h, data: alpha }, w, h, bithDepth, 1, [0], false);
+        }
+        else {
+            throw new Error('Invalid compression');
+        }
+    }
+    else if (bithDepth === 16) {
+        if (compression === 0) {
+            for (let i = 0; i < alpha.byteLength; i++) {
+                alpha[i] = (0, psdReader_1.readUint16)(reader) >> 8; // convert to 8bit values
+            }
+        }
+        else if (compression === 1) {
+            const data = new Uint16Array(w * h);
+            (0, psdReader_1.readDataRLE)(reader, { width: w, height: h, data }, w, h, bithDepth, 1, [0], false);
+            for (let i = 0; i < alpha.byteLength; i++) {
+                alpha[i] = data[i] >> 8; // convert to 8bit values
+            }
+        }
+        else {
+            throw new Error('Invalid compression');
+        }
+    }
+    else {
+        throw new Error('Invalid depth');
+    }
+    return { id, bounds: { x, y, w, h }, alpha };
+}
+// ABR versions 1 and 2 (Photoshop 6 and earlier) contain a list of brushes with brush tips in them
+function readLegacyBrushes(reader, version, samples, brushes, skip) {
+    const count = (0, psdReader_1.readUint16)(reader);
+    for (let i = 0; i < count; i++) {
+        const type = (0, psdReader_1.readUint16)(reader);
+        const size = (0, psdReader_1.readUint32)(reader);
+        const end = reader.offset + size;
+        if (end > reader.view.byteLength) { // truncated file
+            skip(new Error('Brush data out of bounds'), `brush ${i + 1}`);
+            break;
+        }
+        try {
+            if (type === 1) { // computed brush
+                (0, psdReader_1.skipBytes)(reader, 4); // misc
+                const spacing = (0, psdReader_1.readUint16)(reader);
+                const diameter = (0, psdReader_1.readUint16)(reader);
+                const roundness = (0, psdReader_1.readUint16)(reader);
+                const angle = (0, psdReader_1.readInt16)(reader);
+                const hardness = (0, psdReader_1.readUint16)(reader);
+                if (reader.offset > end)
+                    throw new Error('Brush data out of bounds');
+                brushes.push(createLegacyBrush('', {
+                    type: 'computed',
+                    size: diameter,
+                    angle,
+                    roundness: roundness / 100,
+                    spacingOn: spacing !== 0,
+                    spacing: spacing / 100,
+                    flipX: false,
+                    flipY: false,
+                    hardness: hardness / 100,
+                }));
+            }
+            else if (type === 2) { // sampled brush
+                (0, psdReader_1.skipBytes)(reader, 4); // misc
+                const spacing = (0, psdReader_1.readUint16)(reader);
+                const name = version === 2 ? (0, psdReader_1.readUnicodeString)(reader) : '';
+                (0, psdReader_1.skipBytes)(reader, 1 + 8); // antialiasing, Int16 bounds rectangle (same as Int32 one)
+                // legacy brushes don't have sample ids
+                const sample = readSampleBitmap(reader, end, `brush-${i + 1}`);
+                samples.push(sample);
+                brushes.push(createLegacyBrush(name, {
+                    type: 'sampled',
+                    size: Math.max(sample.bounds.w, sample.bounds.h),
+                    angle: 0,
+                    roundness: 1,
+                    spacingOn: spacing !== 0,
+                    spacing: spacing / 100,
+                    flipX: false,
+                    flipY: false,
+                    name,
+                    sampledData: sample.id,
+                }));
+            }
+            else {
+                throw new Error(`Unknown brush type: ${type}`);
+            }
+        }
+        catch (e) {
+            skip(e, `brush ${i + 1}`);
+        }
+        reader.offset = end;
+    }
+}
+function createLegacyBrush(name, shape) {
+    return { name, shape, spacing: 1, wetEdges: false, noise: false, buildUp: false, useBrushSize: true };
+}
+function parseBrush(brush) {
+    var _a, _b, _c;
+    const b = {
+        name: brush['Nm  '],
+        shape: parseBrushShape(brush.Brsh),
+        spacing: (0, descriptor_1.parsePercent)(brush.Spcn),
+        wetEdges: brush.Wtdg,
+        noise: brush.Nose,
+        buildUp: !!brush['Rpt '],
+        useBrushSize: brush.useBrushSize, // ???
+    };
+    if (brush.interpretation != null)
+        b.interpretation = brush.interpretation;
+    if (brush.protectTexture != null)
+        b.protectTexture = brush.protectTexture;
+    if (brush.useTipDynamics) {
+        b.shapeDynamics = {
+            tiltScale: (0, descriptor_1.parsePercent)(brush.tiltScale),
+            sizeDynamics: parseDynamics(brush.szVr),
+            angleDynamics: parseDynamics(brush.angleDynamics),
+            roundnessDynamics: parseDynamics(brush.roundnessDynamics),
+            flipX: brush.flipX,
+            flipY: brush.flipY,
+            brushProjection: brush.brushProjection,
+            minimumDiameter: (0, descriptor_1.parsePercent)(brush.minimumDiameter),
+            minimumRoundness: (0, descriptor_1.parsePercent)(brush.minimumRoundness),
+        };
+    }
+    if (brush.useScatter) {
+        b.scatter = {
+            count: brush['Cnt '],
+            bothAxes: brush.bothAxes,
+            countDynamics: parseDynamics(brush.countDynamics),
+            scatterDynamics: parseDynamics(brush.scatterDynamics),
+        };
+    }
+    if (brush.useTexture && brush.Txtr) {
+        b.texture = {
+            id: brush.Txtr.Idnt,
+            name: brush.Txtr['Nm  '],
+            blendMode: descriptor_1.BlnM.decode(brush.textureBlendMode),
+            depth: (0, descriptor_1.parsePercent)(brush.textureDepth),
+            depthMinimum: (0, descriptor_1.parsePercent)(brush.minimumDepth),
+            depthDynamics: parseDynamics(brush.textureDepthDynamics),
+            scale: (0, descriptor_1.parsePercent)(brush.textureScale),
+            invert: brush.InvT,
+            brightness: brush.textureBrightness,
+            contrast: brush.textureContrast,
+            textureEachTip: !!brush.TxtC,
+        };
+    }
+    const db = brush.dualBrush;
+    if (db && db.useDualBrush) {
+        b.dualBrush = {
+            flip: db.Flip,
+            shape: parseBrushShape(db.Brsh),
+            blendMode: descriptor_1.BlnM.decode(db.BlnM),
+            useScatter: db.useScatter,
+            spacing: (0, descriptor_1.parsePercent)(db.Spcn),
+            count: db['Cnt '],
+            bothAxes: db.bothAxes,
+            countDynamics: parseDynamics(db.countDynamics),
+            scatterDynamics: parseDynamics(db.scatterDynamics),
+        };
+    }
+    if (brush.useColorDynamics) {
+        b.colorDynamics = {
+            foregroundBackground: parseDynamics(brush.clVr),
+            hue: (0, descriptor_1.parsePercent)(brush['H   ']),
+            saturation: (0, descriptor_1.parsePercent)(brush.Strt),
+            brightness: (0, descriptor_1.parsePercent)(brush.Brgh),
+            purity: (0, descriptor_1.parsePercent)(brush.purity),
+            perTip: brush.colorDynamicsPerTip,
+        };
+    }
+    if (brush.usePaintDynamics) {
+        b.transfer = {
+            flowDynamics: parseDynamics(brush.prVr),
+            opacityDynamics: parseDynamics(brush.opVr),
+        };
+        if (brush.wtVr)
+            b.transfer.wetnessDynamics = parseDynamics(brush.wtVr);
+        if (brush.mxVr)
+            b.transfer.mixDynamics = parseDynamics(brush.mxVr);
+    }
+    if (brush.useBrushPose) {
+        b.brushPose = {
+            overrideAngle: brush.overridePoseAngle,
+            overrideTiltX: brush.overridePoseTiltX,
+            overrideTiltY: brush.overridePoseTiltY,
+            overridePressure: brush.overridePosePressure,
+            pressure: (0, descriptor_1.parsePercent)(brush.brushPosePressure),
+            tiltX: brush.brushPoseTiltX,
+            tiltY: brush.brushPoseTiltY,
+            angle: brush.brushPoseAngle,
+        };
+    }
+    const to = brush.toolOptions;
+    if (to) {
+        b.toolOptions = {
+            type: toBrushType[to._classID] || 'brush',
+            brushPreset: to.brushPreset,
+            flow: (_a = to.flow) !== null && _a !== void 0 ? _a : 100,
+            smooth: (_b = to.Smoo) !== null && _b !== void 0 ? _b : 0,
+            mode: descriptor_1.BlnM.decode(to['Md  '] || 'BlnM.Nrml'), // sometimes mode is missing
+            opacity: (_c = to.Opct) !== null && _c !== void 0 ? _c : 100,
+            smoothing: !!to.smoothing,
+            smoothingValue: to.smoothingValue || 0,
+            smoothingRadiusMode: !!to.smoothingRadiusMode,
+            smoothingCatchup: !!to.smoothingCatchup,
+            smoothingCatchupAtEnd: !!to.smoothingCatchupAtEnd,
+            smoothingZoomCompensation: !!to.smoothingZoomCompensation,
+            pressureSmoothing: !!to.pressureSmoothing,
+            usePressureOverridesSize: !!to.usePressureOverridesSize,
+            usePressureOverridesOpacity: !!to.usePressureOverridesOpacity,
+            useLegacy: !!to.useLegacy,
+        };
+        if (to.prVr)
+            b.toolOptions.flowDynamics = parseDynamics(to.prVr);
+        if (to.opVr)
+            b.toolOptions.opacityDynamics = parseDynamics(to.opVr);
+        if (to.szVr)
+            b.toolOptions.sizeDynamics = parseDynamics(to.szVr);
+        if ('wetness' in to)
+            b.toolOptions.wetness = to.wetness;
+        if ('dryness' in to)
+            b.toolOptions.dryness = to.dryness;
+        if ('mix' in to)
+            b.toolOptions.mix = to.mix;
+        if ('autoFill' in to)
+            b.toolOptions.autoFill = to.autoFill;
+        if ('autoClean' in to)
+            b.toolOptions.autoClean = to.autoClean;
+        if ('loadSolidColorOnly' in to)
+            b.toolOptions.loadSolidColorOnly = to.loadSolidColorOnly;
+        if ('sampleAllLayers' in to)
+            b.toolOptions.sampleAllLayers = to.sampleAllLayers;
+        if ('SmdF' in to)
+            b.toolOptions.smudgeFingerPainting = to.SmdF;
+        if ('SmdS' in to)
+            b.toolOptions.smudgeSampleAllLayers = to.SmdS;
+        if ('Prs ' in to)
+            b.toolOptions.strength = to['Prs '];
+    }
+    return b;
+}
 
 },{"./descriptor":4,"./psdReader":13}],2:[function(require,module,exports){
 "use strict";
@@ -373,6 +500,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");
@@ -403,6 +533,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 = [];
@@ -449,7 +580,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());
@@ -579,25 +711,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);
@@ -614,12 +729,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) {
@@ -627,8 +748,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?
@@ -637,12 +779,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)
@@ -681,15 +819,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)
@@ -740,10 +877,21 @@ 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');
@@ -819,8 +967,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
@@ -893,12 +1045,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);
@@ -909,106 +1064,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.logMissingFeatures);
+                        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.logMissingFeatures);
+                    }
+                    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++;
@@ -1020,6 +1229,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');
@@ -1042,9 +1253,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, false, 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);
@@ -1128,6 +1339,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);
@@ -1207,7 +1427,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),
@@ -1245,9 +1465,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;
@@ -1353,14 +1575,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])
@@ -1405,6 +1628,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);
@@ -1447,7 +1672,7 @@ function pointToHrznVrtc(point) {
         Vrtc: (0, descriptor_1.unitsValue)(point.y, 'y'),
     };
 }
-function parseFilterFXItem(f, options) {
+function parseFilterFXItem(f, reader) {
     const base = {
         name: f['Nm  '],
         opacity: (0, descriptor_1.parsePercent)(f.blendOptions.Opct),
@@ -1495,7 +1720,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: {
@@ -1682,8 +1907,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)),
@@ -1780,7 +2004,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 ']) {
@@ -1804,6 +2028,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: {
@@ -1814,10 +2067,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;
         }
     }
@@ -1837,21 +2091,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) {
@@ -2207,14 +2463,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)),
@@ -2296,7 +2552,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',
@@ -2309,6 +2565,21 @@ 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 'brightness/contrast': return Object.assign(Object.assign({}, base), { Fltr: {
                 _name: 'Brightness/Contrast',
                 _classID: 'BrgC',
@@ -2359,7 +2630,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);
@@ -2416,13 +2688,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 = {
@@ -2436,14 +2713,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));
@@ -2473,7 +2742,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),
@@ -2483,14 +2758,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),
@@ -2514,11 +2812,13 @@ if (helpers_1.MOCK_HANDLERS) {
     }, (writer, target) => false && (0, psdWriter_1.writeBytes)(writer, target._Patt));
 }
 else {
-    addHandler('Patt', // TODO: handle also Pat2 & Pat3
-    // TODO: handle also Pat2 & Pat3
+    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.readPattern)(reader);
+            const pattern = (0, psdReader_1.readPatternSafe)(reader);
+            if (!pattern)
+                continue;
             if (target.patterns === undefined)
                 target.patterns = [];
             target.patterns.push(pattern);
@@ -2706,6 +3006,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;
@@ -2727,8 +3031,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;
@@ -2879,28 +3183,40 @@ 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`);
@@ -2944,6 +3260,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);
@@ -2954,48 +3274,36 @@ 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()) {
+    const channels = [];
+    for (let i = 0; i < 29 && left() >= 10; i++) {
+        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);
-        for (let i = 0; i < (totalChannelRecords - levels.length) && left(); i++) {
-            levels.push(readLevelsChannel(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) {
@@ -3020,17 +3328,16 @@ addHandler('curv', adjustmentType('curves'), (reader, target, left) => {
     if ((0, psdReader_1.readUint16)(reader) !== 1)
         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);
+    const channelsMask = (0, psdReader_1.readUint16)(reader);
+    const channels = [];
+    for (let i = 0; i < 16; i++) {
+        if (channelsMask & (1 << i)) {
+            while (channels.length < i)
+                channels.push([]);
+            channels.push(readCurveChannel(reader));
+        }
+    }
+    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'curves', channels });
     // ignoring, duplicate information
     // checkSignature(reader, 'Crv ');
     // const cVersion = readUint16(reader);
@@ -3046,57 +3353,29 @@ addHandler('curv', adjustmentType('curves'), (reader, target, left) => {
     // }
     (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++;
-    }
-    if (green && green.length) {
-        channels |= 4;
-        channelCount++;
-    }
-    if (blue && blue.length) {
-        channels |= 8;
-        channelCount++;
+    var _a;
+    const channels = (target.adjustment.channels || []).slice(0, 16);
+    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;
+            used.push(i);
+        }
     }
     (0, psdWriter_1.writeUint8)(writer, 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.writeUint16)(writer, channelsMask);
+    for (const i of used)
+        writeCurveChannel(writer, 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.writeUint16)(writer, used.length);
+    for (const i of used) {
+        (0, psdWriter_1.writeUint16)(writer, i);
+        writeCurveChannel(writer, channels[i]);
     }
 });
 addHandler('expA', adjustmentType('exposure'), (reader, target, left) => {
@@ -3153,12 +3432,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);
@@ -3237,16 +3538,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 = {
@@ -3414,7 +3717,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 = [];
@@ -3476,7 +3779,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);
@@ -3798,17 +4101,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;
@@ -3826,17 +4134,19 @@ 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
+    // discard if read in 'lrFX' section ('lmfx' and 'lfx2' are never stored together)
     target.effects = (0, descriptor_1.parseEffects)(desc, !!reader.logMissingFeatures);
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target, _, options) => {
@@ -3893,16 +4203,14 @@ 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));
 });
 addHandler('iOpa', hasKey('fillOpacity'), (reader, target) => {
     target.fillOpacity = (0, psdReader_1.readUint8)(reader) / 0xff;
@@ -3980,14 +4288,13 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntC = exports.IntE = exports.Drct = exports.WndM = exports.CntE = exports.FlCl = exports.ExtR = exports.ExtT = exports.DfsM = exports.blurType = exports.Lns = exports.MztT = exports.Chnl = exports.Dstr = exports.ZZTy = exports.Wvtp = exports.SphM = exports.RplS = exports.Cnvr = exports.UndA = exports.DspM = exports.SmBQ = exports.SmBM = exports.BlrQ = exports.BlrM = exports.strokeStyleLineAlignment = exports.strokeStyleLineJoinType = exports.strokeStyleLineCapType = exports.ESliceBGColorType = exports.ESliceOrigin = exports.ESliceVertAlign = exports.ESliceHorzAlign = exports.ESliceType = exports.FrFl = exports.FStl = exports.ClrS = exports.gradientInterpolationMethodType = exports.stdTrackID = exports.animInterpStyleEnum = exports.GrdT = exports.IGSr = exports.BETE = exports.BESs = exports.bvlT = exports.BESl = exports.BlnM = exports.warpStyle = exports.Annt = exports.Ornt = exports.textGridding = void 0;
-exports.presetKindType = exports.prjM = exports.FlMd = void 0;
+exports.Drct = exports.WndM = exports.CntE = exports.FlCl = exports.ExtR = exports.ExtT = exports.DfsM = exports.blurType = exports.Lns = exports.MztT = exports.Chnl = exports.Dstr = exports.ZZTy = exports.Wvtp = exports.SphM = exports.RplS = exports.Cnvr = exports.UndA = exports.DspM = exports.SmBQ = exports.SmBM = exports.BlrQ = exports.BlrM = exports.strokeStyleLineAlignment = exports.strokeStyleLineJoinType = exports.strokeStyleLineCapType = exports.ESliceBGColorType = exports.ESliceOrigin = exports.ESliceVertAlign = exports.ESliceHorzAlign = exports.ESliceType = exports.FrFl = exports.FStl = exports.ClrS = exports.Clry = exports.gradientInterpolationMethodType = exports.stdTrackID = exports.animInterpStyleEnum = exports.GrdT = exports.IGSr = exports.BETE = exports.BESs = exports.bvlT = exports.BESl = exports.BlnM = exports.warpStyle = exports.Annt = exports.Ornt = exports.textGridding = exports.outputSettingsRoot = void 0;
+exports.presetKindType = exports.prjM = exports.FlMd = exports.IntC = exports.IntE = void 0;
 exports.setLogErrors = setLogErrors;
 exports.readAsciiStringOrClassId = readAsciiStringOrClassId;
 exports.writeAsciiStringOrClassId = writeAsciiStringOrClassId;
 exports.readDescriptorStructure = readDescriptorStructure;
 exports.writeDescriptorStructure = writeDescriptorStructure;
-exports.createDescriptorReference = createDescriptorReference;
 exports.pathSelectionStateToReference = pathSelectionStateToReference;
 exports.writeClassStructure = writeClassStructure;
 exports.readVersionAndDescriptor = readVersionAndDescriptor;
@@ -4136,6 +4443,7 @@ const fieldToArrayExtType = {
     Clrs: makeType('', 'Clrt'),
     Trns: makeType('', 'TrnS'),
     keyDescriptorList: nullType,
+    keyRootDescriptorList: nullType,
     solidFillMulti: makeType('', 'SoFi'),
     gradientFillMulti: makeType('', 'GrFl'),
     dropShadowMulti: makeType('', 'DrSh'),
@@ -4169,17 +4477,23 @@ const fieldToArrayExtType = {
 };
 const typeToField = {
     'TEXT': [
-        'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
+        'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName', 'exportOption', 'scaleSettings',
+        'BackgroundImagePath', 'ImageSubfolderName',
         'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
         'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
-        'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath',
+        'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath', 'Bk  ', 'pathUnicodeName',
     ],
     'tdta': [
         'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
-        'LqMe',
+        'LqMe', 'bookKey',
     ],
     'long': [
-        'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
+        'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ', 'bookID',
+        'cropRectBottom', 'cropRectLeft', 'cropRectRight', 'cropRectTop',
+        // save for web output settings
+        'Version', 'BackgroundColorBlue', 'BackgroundColorGreen', 'BackgroundColorRed', 'BackgroundColorState', 'AttributeCase', 'Encoding',
+        'DuplicateFileNameBehavior', 'ImageMapLocation', 'ImageMapType', 'Indent', 'LineEndings', 'SpacersEmptyCells',
+        'SpacersHorizontal', 'SpacersVertical', 'StylesFormat', 'TDWidthHeight', 'TagCase', 'ColorPolicy', 'MetadataPolicy',
         'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'comp', 'compID', 'originalCompID',
         'curvesPresetKind', 'mixerPresetKind', 'uOrder', 'vOrder', 'PgNm', 'totalPages', 'Crop',
         'numerator', 'denominator', 'frameCount', 'Annt', 'keyOriginType', 'unitValueQuadVersion',
@@ -4201,7 +4515,7 @@ const typeToField = {
         'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
         'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
         'vertAlign', 'bgColorType', 'shapeOperation', 'UndA', 'Wvtp', 'Drct', 'WndM', 'Edg ', 'FlCl', 'IntE',
-        'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod',
+        'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod', 'pathSymmetryMode',
         'interpretAlpha',
     ],
     'bool': [
@@ -4218,7 +4532,7 @@ const typeToField = {
         'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn',
     ],
     'doub': [
-        'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
+        'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght', 'Gmm ',
         'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
         'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
         'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
@@ -4232,7 +4546,7 @@ const typeToField = {
         'topRight', 'topLeft', 'bottomLeft', 'bottomRight', 'ClNs', 'Shrp',
     ],
     'VlLs': [
-        'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
+        'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'keyRootDescriptorList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
         'LaSt', 'Trnf', 'nonAffineTransform', 'keyDescriptorList', 'guideIndeces', 'gradientFillMulti',
         'solidFillMulti', 'frameFXMulti', 'innerShadowMulti', 'dropShadowMulti', 'FrIn', 'FSts', 'FsFr',
         'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
@@ -4251,25 +4565,6 @@ const channels = [
 ];
 // color classes whose channel values are written as doubles ('GRYC' and 'LABC' are kept for backwards compatibility)
 const doubleColorClasses = ['Grsc', 'LbCl', 'GRYC', 'LABC'];
-// Hidden (non-enumerable) markers used to remember how values were stored in the file, so they can be
-// written back the same way. They don't change the shape of the objects returned by the reader.
-const osTypeKey = typeof Symbol !== 'undefined' ? Symbol('agPsdOSType') : '__agPsdOSType';
-const obArInfoKey = typeof Symbol !== 'undefined' ? Symbol('agPsdObAr') : '__agPsdObAr';
-const referenceInfoKey = typeof Symbol !== 'undefined' ? Symbol('agPsdReference') : '__agPsdReference';
-function setHidden(target, key, value) {
-    Object.defineProperty(target, key, { value, enumerable: false, configurable: true, writable: true });
-    return target;
-}
-function getHidden(target, key) {
-    return (target && typeof target === 'object') ? target[key] : undefined;
-}
-const osTypeFamilies = {
-    UntF: 'UntF', UnFl: 'UntF',
-    Objc: 'Objc', GlbO: 'Objc',
-    type: 'type', GlbC: 'type',
-    comp: 'comp',
-};
-// returns the OS type the value was originally read with, if it's compatible with the type we'd write it as
 // fallback for unknown keys, based on the type of the value
 function guessOSType(value) {
     if (typeof value === 'boolean')
@@ -4278,26 +4573,33 @@ function guessOSType(value) {
         return 'doub';
     if (Array.isArray(value))
         return 'VlLs';
-    if (value && typeof value === 'object' && typeof value._classID === 'string')
-        return 'Objc';
+    if (value && typeof value === 'object') {
+        if (typeof value._classID === 'string')
+            return 'Objc';
+        if (typeof value.classID === 'string')
+            return 'type'; // class read from 'type' or 'GlbC'
+        if (typeof value.low === 'number' && typeof value.high === 'number')
+            return 'comp';
+        if (typeof value.units === 'string' && typeof value.value === 'number')
+            return 'UntF';
+    }
     return undefined;
 }
-function getRecordedOSType(value, type) {
-    const recorded = getHidden(value, osTypeKey);
-    if (!recorded)
-        return type;
-    if (!type || recorded === 'comp' || recorded === 'type' || recorded === 'GlbC')
-        return recorded;
-    return osTypeFamilies[recorded] === osTypeFamilies[type] ? recorded : type;
-}
 const fieldToArrayType = {
     'Mnm ': 'long',
     'Mxm ': 'long',
+    HtmlFileNameComponents: 'long', // save for web output settings
+    SavingFileNameComponents: 'long',
+    SliceFileNameComponents: 'long',
+    Inpt: 'long', // levels filter
+    Otpt: 'long', // levels filter
     FrLs: 'long',
     strokeStyleLineDashSet: 'UntF',
     Trnf: 'doub',
     nonAffineTransform: 'doub',
     keyDescriptorList: 'Objc',
+    keyRootDescriptorList: 'Objc',
+    pathList: 'Objc',
     gradientFillMulti: 'Objc',
     solidFillMulti: 'Objc',
     frameFXMulti: 'Objc',
@@ -4388,6 +4690,15 @@ function getTypeByKey(key, value, root, parent) {
     else if ((key === 'Inpt' || key === 'Otpt') && parent._classID === 'HsbP') {
         return 'enum';
     }
+    else if ((key === 'Inpt' || key === 'Otpt') && parent._classID === 'LvlA') {
+        return 'VlLs';
+    }
+    else if (key === 'Intr' && typeof value === 'boolean') {
+        return 'bool'; // interpolation in print style
+    }
+    else if (key === 'PgPs') {
+        return 'enum';
+    }
     else if (key === 'LghD' && parent._classID === 'oilPaint') {
         return 'long';
     }
@@ -4400,7 +4711,7 @@ function readAsciiStringOrClassId(reader) {
     return (0, psdReader_1.readAsciiString)(reader, length || 4);
 }
 function writeAsciiStringOrClassId(writer, value) {
-    if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list') {
+    if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list' && value !== 'json') {
         // write classId
         (0, psdWriter_1.writeInt32)(writer, 0);
         (0, psdWriter_1.writeSignature)(writer, value);
@@ -4428,12 +4739,20 @@ function readDescriptorStructure(reader, includeClass) {
     }
     return object;
 }
+exports.outputSettingsRoot = 'outputSettings';
 function writeDescriptorStructure(writer, name, classId, value, root) {
     if (logErrors && !classId)
         console.log('Missing classId for: ', name, classId, value);
     // write class structure
     (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
-    writeAsciiStringOrClassId(writer, classId);
+    if (root === exports.outputSettingsRoot && classId === 'null') {
+        // Photoshop writes 'null' class id as 4 character string in save for web output settings
+        (0, psdWriter_1.writeInt32)(writer, 4);
+        (0, psdWriter_1.writeSignature)(writer, classId);
+    }
+    else {
+        writeAsciiStringOrClassId(writer, classId);
+    }
     const allKeys = Object.keys(value);
     const keys = allKeys.filter(key => key !== '_name' && key !== '_classID' && value[key] !== undefined);
     (0, psdWriter_1.writeUint32)(writer, keys.length);
@@ -4543,12 +4862,17 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
         else if (key === 'bounds' && root === 'quiltWarp') {
             extType = makeType('', 'classFloatRect');
         }
+        // guess color class from its fields (colors created by serializeColor always have _classID set)
         if (extType && extType.classID === 'RGBC') {
             if ('H   ' in value[key])
                 extType = { classID: 'HSBC', name: '' };
-            // TODO: other color spaces
+            else if ('Cyn ' in value[key])
+                extType = { classID: 'CMYC', name: '' };
+            else if ('Lmnc' in value[key])
+                extType = { classID: 'LbCl', name: '' };
+            else if ('Gry ' in value[key])
+                extType = { classID: 'Grsc', name: '' };
         }
-        type = getRecordedOSType(value[key], type);
         if (!type)
             type = guessOSType(value[key]);
         writeAsciiStringOrClassId(writer, key);
@@ -4563,9 +4887,8 @@ function readOSType(reader, type, includeClass) {
         case 'obj ': // Reference
             return readReferenceStructure(reader);
         case 'Objc': // Descriptor
-            return readDescriptorStructure(reader, includeClass);
         case 'GlbO': // GlobalObject same as Descriptor
-            return setHidden(readDescriptorStructure(reader, includeClass), osTypeKey, type);
+            return readDescriptorStructure(reader, includeClass);
         case 'VlLs': { // List
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
@@ -4590,7 +4913,7 @@ function readOSType(reader, type, includeClass) {
             const value = (0, psdReader_1.readFloat32)(reader);
             if (!unitsMap[units])
                 throw new Error(`Invalid units: ${units}`);
-            return setHidden({ units: unitsMap[units], value }, osTypeKey, type);
+            return { units: unitsMap[units], value };
         }
         case 'TEXT': // String
             return (0, psdReader_1.readUnicodeString)(reader);
@@ -4604,13 +4927,13 @@ function readOSType(reader, type, includeClass) {
         case 'comp': { // Large Integer
             const low = (0, psdReader_1.readUint32)(reader);
             const high = (0, psdReader_1.readUint32)(reader);
-            return setHidden({ low, high }, osTypeKey, type);
+            return { low, high };
         }
         case 'bool': // Boolean
             return !!(0, psdReader_1.readUint8)(reader);
         case 'type': // Class
         case 'GlbC': // Class
-            return setHidden(readClassStructure(reader), osTypeKey, type);
+            return readClassStructure(reader);
         case 'alis': { // Alias
             const length = (0, psdReader_1.readInt32)(reader);
             return (0, psdReader_1.readAsciiString)(reader, length);
@@ -4622,21 +4945,21 @@ function readOSType(reader, type, includeClass) {
         case 'ObAr': { // Object array
             (0, psdReader_1.readInt32)(reader); // version: 16
             (0, psdReader_1.readUnicodeString)(reader); // name: ''
-            const classID = readAsciiStringOrClassId(reader); // 'rationalPoint'
+            readAsciiStringOrClassId(reader); // classID: 'rationalPoint'
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
             for (let i = 0; i < length; i++) {
                 const type1 = readAsciiStringOrClassId(reader); // type Hrzn | Vrtc
-                const valueType = (0, psdReader_1.readSignature)(reader); // UnFl
-                const units = (0, psdReader_1.readSignature)(reader); // units ? '#Pxl'
+                (0, psdReader_1.readSignature)(reader); // UnFl
+                (0, psdReader_1.readSignature)(reader); // units ? '#Pxl'
                 const valuesCount = (0, psdReader_1.readInt32)(reader);
                 const values = [];
                 for (let j = 0; j < valuesCount; j++) {
                     values.push((0, psdReader_1.readFloat64)(reader));
                 }
-                items.push(setHidden({ type: type1, values }, obArInfoKey, { valueType, units }));
+                items.push({ type: type1, values });
             }
-            return setHidden(items, obArInfoKey, { classID });
+            return items;
         }
         case 'Pth ': { // File path
             /*const length =*/ (0, psdReader_1.readInt32)(reader); // total size of all fields below
@@ -4656,7 +4979,7 @@ const ObArTypes = {
     quiltSliceY: 'UntF',
 };
 function writeOSType(writer, type, value, key, extType, root) {
-    var _a, _b, _c, _d, _e;
+    var _a;
     switch (type) {
         case 'obj ': // Reference
             writeReferenceStructure(writer, key, value);
@@ -4677,7 +5000,7 @@ function writeOSType(writer, type, value, key, extType, root) {
                 throw new Error(`Invalid list value: ${JSON.stringify(value)}, key: ${key}`);
             (0, psdWriter_1.writeInt32)(writer, value.length);
             for (let i = 0; i < value.length; i++) {
-                const type = (_a = getRecordedOSType(value[i], fieldToArrayType[key])) !== null && _a !== void 0 ? _a : guessOSType(value[i]);
+                const type = (_a = fieldToArrayType[key]) !== null && _a !== void 0 ? _a : guessOSType(value[i]);
                 (0, psdWriter_1.writeSignature)(writer, type || 'long');
                 writeOSType(writer, type || 'long', value[i], `${key}[]`, fieldToArrayExtType[key], root);
                 if (logErrors && !type)
@@ -4751,16 +5074,15 @@ function writeOSType(writer, type, value, key, extType, root) {
         case 'ObAr': { // Object array
             (0, psdWriter_1.writeInt32)(writer, 16); // version
             (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, ''); // name
-            const type = (_c = (_b = getHidden(value, obArInfoKey)) === null || _b === void 0 ? void 0 : _b.classID) !== null && _c !== void 0 ? _c : ObArTypes[key];
+            const type = ObArTypes[key];
             if (!type)
                 throw new Error(`Not implemented ObArType for: ${key}`);
             writeAsciiStringOrClassId(writer, type);
             (0, psdWriter_1.writeInt32)(writer, value.length);
             for (let i = 0; i < value.length; i++) {
-                const info = getHidden(value[i], obArInfoKey);
                 writeAsciiStringOrClassId(writer, value[i].type); // Hrzn | Vrtc
-                (0, psdWriter_1.writeSignature)(writer, (_d = info === null || info === void 0 ? void 0 : info.valueType) !== null && _d !== void 0 ? _d : 'UnFl');
-                (0, psdWriter_1.writeSignature)(writer, (_e = info === null || info === void 0 ? void 0 : info.units) !== null && _e !== void 0 ? _e : '#Pxl');
+                (0, psdWriter_1.writeSignature)(writer, 'UnFl');
+                (0, psdWriter_1.writeSignature)(writer, '#Pxl');
                 (0, psdWriter_1.writeInt32)(writer, value[i].values.length);
                 for (let j = 0; j < value[i].values.length; j++) {
                     (0, psdWriter_1.writeFloat64)(writer, value[i].values[j]);
@@ -4769,83 +5091,60 @@ function writeOSType(writer, type, value, key, extType, root) {
             break;
         }
         case 'Pth ': { // File path
-            const length = 4 + 4 + 4 + value.path.length * 2;
+            const path = value.path + '\0'; // Photoshop stores trailing null character (stripped when reading)
+            const length = 4 + 4 + 4 + path.length * 2;
             (0, psdWriter_1.writeInt32)(writer, length);
             (0, psdWriter_1.writeSignature)(writer, value.sig);
             (0, psdWriter_1.writeInt32LE)(writer, length);
-            (0, psdWriter_1.writeInt32LE)(writer, value.path.length);
-            (0, psdWriter_1.writeUnicodeStringWithoutLengthLE)(writer, value.path);
+            (0, psdWriter_1.writeInt32LE)(writer, path.length);
+            (0, psdWriter_1.writeUnicodeStringWithoutLengthLE)(writer, path);
             break;
         }
         default:
             throw new Error(`Not implemented descriptor OSType: ${type}`);
     }
 }
-function referenceItemToValue(item) {
-    switch (item.type) {
-        case 'prop': return item.keyID;
-        case 'Clss': return { name: item.name || '', classID: item.classID };
-        case 'Enmr': return `${item.typeID}.${item.enumValue}`;
-        default: return item.value;
-    }
-}
-function referenceItemMatches(item, value) {
-    if (!item)
-        return false;
-    const expected = referenceItemToValue(item);
-    if (expected && typeof expected === 'object') {
-        return !!value && typeof value === 'object' && value.name === expected.name && value.classID === expected.classID;
-    }
-    return expected === value;
-}
-// Attaches information about how each item of reference should be written (class IDs, reference types),
-// the public value of the array stays the same (array of strings/numbers/class objects)
-function createDescriptorReference(items) {
-    return setHidden(items.map(referenceItemToValue), referenceInfoKey, items);
+const referenceTypes = ['prop', 'Clss', 'Enmr', 'rele', 'Idnt', 'indx', 'name'];
+function isReferenceItem(value) {
+    return !!value && typeof value === 'object' && referenceTypes.indexOf(value.type) !== -1;
 }
 function readReferenceStructure(reader) {
     const itemsCount = (0, psdReader_1.readInt32)(reader);
-    const infos = [];
+    const items = [];
     for (let i = 0; i < itemsCount; i++) {
         const type = (0, psdReader_1.readSignature)(reader);
         switch (type) {
-            case 'prop': { // Property
-                const { name, classID } = readClassStructure(reader);
-                const keyID = readAsciiStringOrClassId(reader);
-                infos.push({ type, name, classID, keyID });
+            case 'prop': // Property
+                readClassStructure(reader);
+                items.push(readAsciiStringOrClassId(reader));
                 break;
-            }
-            case 'Clss': { // Class
-                const { name, classID } = readClassStructure(reader);
-                infos.push({ type, name, classID });
+            case 'Clss': // Class
+                items.push(readClassStructure(reader));
                 break;
-            }
             case 'Enmr': { // Enumerated Reference
-                const { name, classID } = readClassStructure(reader);
+                readClassStructure(reader);
                 const typeID = readAsciiStringOrClassId(reader);
                 const enumValue = readAsciiStringOrClassId(reader);
-                infos.push({ type, name, classID, typeID, enumValue });
+                items.push(`${typeID}.${enumValue}`);
                 break;
             }
-            case 'rele': { // Offset
-                const { name, classID } = readClassStructure(reader);
-                infos.push({ type, name, classID, value: (0, psdReader_1.readUint32)(reader) });
+            case 'rele': // Offset
+                readClassStructure(reader);
+                items.push((0, psdReader_1.readUint32)(reader));
                 break;
-            }
             case 'Idnt': // Identifier
             case 'indx': // Index
-                infos.push({ type, value: (0, psdReader_1.readInt32)(reader) });
+                items.push((0, psdReader_1.readInt32)(reader));
                 break;
-            case 'name': { // Name
-                const { name, classID } = readClassStructure(reader);
-                infos.push({ type, name, classID, value: (0, psdReader_1.readUnicodeString)(reader) });
+            case 'name': // Name
+                readClassStructure(reader);
+                items.push((0, psdReader_1.readUnicodeString)(reader));
                 break;
-            }
             default:
                 throw new Error(`Invalid descriptor reference type: ${type}`);
         }
     }
-    return createDescriptorReference(infos);
+    return items;
 }
 function guessReferenceItem(value) {
     if (typeof value === 'string') {
@@ -4853,17 +5152,17 @@ function guessReferenceItem(value) {
         // (values like 'My.Path' or 'Logo.v2' can't be typeID/enum value, so they are written as name references)
         const match = /^([a-z ]{4}|[a-z]{5,})\.([a-z ]+)$/i.exec(value);
         if (match) {
-            return { type: 'Enmr', name: '', classID: match[1], typeID: match[1], enumValue: match[2] };
+            return { type: 'Enmr', _name: '', _classID: match[1], typeID: match[1], enumValue: match[2] };
         }
         else {
-            return { type: 'name', name: '', classID: 'Lyr ', value };
+            return { type: 'name', _name: '', _classID: 'Lyr ', value };
         }
     }
     else if (typeof value === 'number') {
         return { type: 'Idnt', value };
     }
     else if (value && typeof value === 'object' && typeof value.classID === 'string') {
-        return { type: 'Clss', name: value.name || '', classID: value.classID };
+        return { type: 'Clss', _name: value.name || '', _classID: value.classID };
     }
     else {
         throw new Error(`Invalid descriptor reference value: ${JSON.stringify(value)}`);
@@ -4872,41 +5171,35 @@ function guessReferenceItem(value) {
 // path selection state (image resource 1088) is a reference to paths, enumerated references there use 'Path' class
 // (name references use 'Lyr ' class, they reference layer of the vector mask)
 function pathSelectionStateToReference(items) {
-    const infos = getHidden(items, referenceInfoKey);
-    return createDescriptorReference(items.map((value, i) => {
-        if (referenceItemMatches(infos === null || infos === void 0 ? void 0 : infos[i], value))
-            return infos[i]; // keep information read from the file
+    return items.map(value => {
         const item = guessReferenceItem(value);
         if (item.type === 'Enmr')
-            item.classID = 'Path';
+            item._classID = 'Path';
         return item;
-    }));
+    });
 }
 function writeReferenceStructure(writer, _key, items) {
     if (!Array.isArray(items))
         throw new Error(`Invalid reference value: ${JSON.stringify(items)}, key: ${_key}`);
-    const infos = getHidden(items, referenceInfoKey);
     (0, psdWriter_1.writeInt32)(writer, items.length);
-    for (let i = 0; i < items.length; i++) {
-        const value = items[i];
-        const recorded = infos === null || infos === void 0 ? void 0 : infos[i];
-        const item = referenceItemMatches(recorded, value) ? recorded : guessReferenceItem(value);
+    for (const value of items) {
+        const item = isReferenceItem(value) ? value : guessReferenceItem(value);
         (0, psdWriter_1.writeSignature)(writer, item.type);
         switch (item.type) {
             case 'prop': // Property
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 writeAsciiStringOrClassId(writer, item.keyID);
                 break;
             case 'Clss': // Class
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 break;
             case 'Enmr': // Enumerated Reference
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 writeAsciiStringOrClassId(writer, item.typeID);
                 writeAsciiStringOrClassId(writer, item.enumValue);
                 break;
             case 'rele': // Offset
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 (0, psdWriter_1.writeUint32)(writer, item.value);
                 break;
             case 'Idnt': // Identifier
@@ -4914,7 +5207,7 @@ function writeReferenceStructure(writer, _key, items) {
                 (0, psdWriter_1.writeInt32)(writer, item.value);
                 break;
             case 'name': // Name
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, `${item.value}`);
                 break;
             default:
@@ -4973,7 +5266,7 @@ function parseFxObject(fx) {
         fillType: exports.FrFl.decode(fx.PntT),
         blendMode: exports.BlnM.decode(fx['Md  ']),
         opacity: parsePercent(fx.Opct),
-        size: parseUnits(fx['Sz  ']),
+        size: parseUnitsOrNumber(fx['Sz  ']), // stored as number (pixels) in old versions
     };
     if (fx.present !== undefined)
         stroke.present = fx.present;
@@ -5078,11 +5371,11 @@ function serializeEffects(e, log, multi) {
 }
 function parseEffects(info, log) {
     const effects = {};
-    const { masterFXSwitch, DrSh, dropShadowMulti, IrSh, innerShadowMulti, OrGl, IrGl, ebbl, SoFi, solidFillMulti, patternFill, GrFl, gradientFillMulti, ChFX, FrFX, frameFXMulti, numModifyingFX } = info, rest = __rest(info, ["masterFXSwitch", "DrSh", "dropShadowMulti", "IrSh", "innerShadowMulti", "OrGl", "IrGl", "ebbl", "SoFi", "solidFillMulti", "patternFill", "GrFl", "gradientFillMulti", "ChFX", "FrFX", "frameFXMulti", "numModifyingFX"]);
+    const _a = info, { _name, _classID, 'Scl ': scale, masterFXSwitch, DrSh, dropShadowMulti, IrSh, innerShadowMulti, OrGl, IrGl, ebbl, SoFi, solidFillMulti, patternFill, GrFl, gradientFillMulti, ChFX, FrFX, frameFXMulti, numModifyingFX } = _a, rest = __rest(_a, ["_name", "_classID", 'Scl ', "masterFXSwitch", "DrSh", "dropShadowMulti", "IrSh", "innerShadowMulti", "OrGl", "IrGl", "ebbl", "SoFi", "solidFillMulti", "patternFill", "GrFl", "gradientFillMulti", "ChFX", "FrFX", "frameFXMulti", "numModifyingFX"]);
     if (!masterFXSwitch)
         effects.disabled = true;
-    if (info['Scl '])
-        effects.scale = parsePercent(info['Scl ']);
+    if (scale)
+        effects.scale = parsePercent(scale);
     if (DrSh)
         effects.dropShadow = [parseEffectObject(DrSh, log)];
     if (dropShadowMulti)
@@ -5096,7 +5389,7 @@ function parseEffects(info, log) {
     if (IrGl)
         effects.innerGlow = parseEffectObject(IrGl, log);
     if (ebbl)
-        effects.bevel = parseEffectObject(ebbl, log);
+        effects.bevel = parseEffectObject(ebbl, log, 'bevel');
     if (SoFi)
         effects.solidFill = [parseEffectObject(SoFi, log)];
     if (solidFillMulti)
@@ -5113,7 +5406,7 @@ function parseEffects(info, log) {
         effects.stroke = [parseFxObject(FrFX)];
     if (frameFXMulti)
         effects.stroke = frameFXMulti.map(i => parseFxObject(i));
-    if (log && Object.keys(rest).length > 1)
+    if (log && Object.keys(rest).length)
         console.log('Unhandled effect keys:', rest);
     return effects;
 }
@@ -5222,7 +5515,7 @@ function serializeTrackList(tracks) {
     }
     return trackList;
 }
-function parseEffectObject(obj, reportErrors) {
+function parseEffectObject(obj, reportErrors, objName) {
     const result = {};
     for (const key of Object.keys(obj)) {
         const val = obj[key];
@@ -5287,7 +5580,8 @@ function parseEffectObject(obj, reportErrors) {
             case 'Type':
                 result.type = exports.GrdT.decode(val);
                 break;
-            case 'gs99':
+            case 'gs99': // gradient overlay
+            case 'gradientsInterpolationMethod': // glows
                 result.interpolationMethod = exports.gradientInterpolationMethodType.decode(val);
                 break;
             case 'Opct':
@@ -5339,18 +5633,26 @@ function parseEffectObject(obj, reportErrors) {
                 result.pattern = { name: val['Nm  '], id: val.Idnt };
                 break;
             case 'phase':
-                result.phase = { x: val.Hrzn, y: val.Vrtc };
+                result.phase = parsePhase(val);
                 break;
             case 'Ofst':
                 result.offset = { x: parsePercent(val.Hrzn), y: parsePercent(val.Vrtc) };
                 break;
             case 'MpgS':
-            case 'TrnS':
-                result.contour = {
+            case 'TrnS': {
+                const contour = {
                     name: val['Nm  '],
                     curve: val['Crv '].map(p => ({ x: p.Hrzn, y: p.Vrtc })),
                 };
+                // bevel can have both: gloss contour (TrnS) and contour of the shape (MpgS)
+                if (objName === 'bevel' && key === 'MpgS') {
+                    result.shapeContour = contour;
+                }
+                else {
+                    result.contour = contour;
+                }
                 break;
+            }
             case 'Grad':
                 result.gradient = parseGradient(val);
                 break;
@@ -5445,7 +5747,7 @@ function serializeEffectObject(obj, objName, reportErrors) {
                 result.Type = exports.GrdT.encode(val);
                 break;
             case 'interpolationMethod':
-                result.gs99 = exports.gradientInterpolationMethodType.encode(val);
+                result[(objName === 'outerGlow' || objName === 'innerGlow') ? 'gradientsInterpolationMethod' : 'gs99'] = exports.gradientInterpolationMethodType.encode(val);
                 break;
             case 'opacity':
                 result.Opct = unitsPercent(val);
@@ -5501,15 +5803,14 @@ function serializeEffectObject(obj, objName, reportErrors) {
                 result.phase = { Hrzn: val.x, Vrtc: val.y };
                 break;
             case 'offset':
-                result.Ofst = { Hrzn: unitsPercent(val.x), Vrtc: unitsPercent(val.y) };
+                result.Ofst = { Hrzn: unitsPercentF(val.x), Vrtc: unitsPercentF(val.y) };
                 break;
-            case 'contour': {
-                result[objName === 'satin' ? 'MpgS' : 'TrnS'] = {
-                    'Nm  ': val.name,
-                    'Crv ': val.curve.map(p => ({ Hrzn: p.x, Vrtc: p.y })),
-                };
+            case 'contour':
+                result[objName === 'satin' ? 'MpgS' : 'TrnS'] = serializeContour(val);
+                break;
+            case 'shapeContour':
+                result.MpgS = serializeContour(val);
                 break;
-            }
             case 'gradient':
                 result.Grad = serializeGradient(val);
                 break;
@@ -5527,6 +5828,12 @@ function serializeEffectObject(obj, objName, reportErrors) {
     }
     return result;
 }
+function serializeContour(contour) {
+    return {
+        'Nm  ': contour.name,
+        'Crv ': contour.curve.map(p => ({ Hrzn: p.x, Vrtc: p.y })),
+    };
+}
 function parseGradient(grad) {
     if (grad.GrdF === 'GrdF.CstS') {
         // stop locations are always in 0..4096 range, independent of smoothness (Intr)
@@ -5535,11 +5842,22 @@ function parseGradient(grad) {
             type: 'solid',
             name: grad['Nm  '],
             smoothness: grad.Intr / 4096,
-            colorStops: grad.Clrs.map(s => ({
-                color: parseColor(s['Clr ']),
-                location: s.Lctn / samples,
-                midpoint: s.Mdpn / 100,
-            })),
+            colorStops: grad.Clrs.map(s => {
+                const stop = {
+                    color: s['Clr '] ? parseColor(s['Clr ']) : { r: 0, g: 0, b: 0 },
+                    location: s.Lctn / samples,
+                    midpoint: s.Mdpn / 100,
+                };
+                if (s.Type) {
+                    try {
+                        const type = exports.Clry.decode(s.Type);
+                        if (type !== 'user')
+                            stop.type = type;
+                    }
+                    catch (_a) { } // unknown stop type, read as user color
+                }
+                return stop;
+            }),
             opacityStops: grad.Trns.map(s => ({
                 opacity: parsePercent(s.Opct),
                 location: s.Lctn / samples,
@@ -5571,18 +5889,18 @@ function serializeGradient(grad) {
             GrdF: 'GrdF.CstS',
             Intr: Math.round(((_a = grad.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096),
             Clrs: grad.colorStops.map(s => {
-                var _a;
+                var _a, _b;
                 return ({
                     'Clr ': serializeColor(s.color),
-                    Type: 'Clry.UsrS',
+                    Type: exports.Clry.encode((_a = s.type) !== null && _a !== void 0 ? _a : 'user'),
                     Lctn: Math.round(s.location * samples),
-                    Mdpn: Math.round(((_a = s.midpoint) !== null && _a !== void 0 ? _a : 0.5) * 100),
+                    Mdpn: Math.round(((_b = s.midpoint) !== null && _b !== void 0 ? _b : 0.5) * 100),
                 });
             }),
             Trns: grad.opacityStops.map(s => {
                 var _a;
                 return ({
-                    Opct: unitsPercent(s.opacity),
+                    Opct: unitsPercentF(s.opacity),
                     Lctn: Math.round(s.location * samples),
                     Mdpn: Math.round(((_a = s.midpoint) !== null && _a !== void 0 ? _a : 0.5) * 100),
                 });
@@ -5626,6 +5944,13 @@ function parseGradientContent(descriptor) {
     }
     return result;
 }
+// phase is usually stored as plain numbers, but some files store it as unit values
+function parsePhase({ Hrzn, Vrtc }) {
+    return {
+        x: typeof Hrzn === 'number' ? Hrzn : Hrzn.value,
+        y: typeof Vrtc === 'number' ? Vrtc : Vrtc.value,
+    };
+}
 function parsePatternContent(descriptor) {
     const result = {
         name: descriptor.Ptrn['Nm  '],
@@ -5634,7 +5959,11 @@ function parsePatternContent(descriptor) {
     if (descriptor.Lnkd !== undefined)
         result.linked = descriptor.Lnkd;
     if (descriptor.phase !== undefined)
-        result.phase = { x: descriptor.phase.Hrzn, y: descriptor.phase.Vrtc };
+        result.phase = parsePhase(descriptor.phase);
+    if (descriptor['Scl '] !== undefined)
+        result.scale = parsePercent(descriptor['Scl ']);
+    if (descriptor.Angl !== undefined)
+        result.angle = parseAngle(descriptor.Angl);
     return result;
 }
 function parseVectorContent(descriptor) {
@@ -5665,11 +5994,11 @@ function serializeGradientContent(content) {
     if (content.align !== undefined)
         result.Algn = content.align;
     if (content.scale !== undefined)
-        result['Scl '] = unitsPercent(content.scale);
+        result['Scl '] = unitsPercentF(content.scale);
     if (content.offset) {
         result.Ofst = {
-            Hrzn: unitsPercent(content.offset.x),
-            Vrtc: unitsPercent(content.offset.y),
+            Hrzn: unitsPercentF(content.offset.x),
+            Vrtc: unitsPercentF(content.offset.y),
         };
     }
     result.Grad = serializeGradient(content);
@@ -5686,6 +6015,10 @@ function serializePatternContent(content) {
         result.Lnkd = !!content.linked;
     if (content.phase !== undefined)
         result.phase = { Hrzn: content.phase.x, Vrtc: content.phase.y };
+    if (content.scale !== undefined)
+        result['Scl '] = unitsPercentF(content.scale);
+    if (content.angle !== undefined)
+        result.Angl = unitsAngle(content.angle);
     return result;
 }
 function serializeVectorContent(content) {
@@ -5701,9 +6034,9 @@ function serializeVectorContent(content) {
 }
 // Descriptor color values: HSB saturation/brightness 0..100, CMYK 0..100, Gray 0..100, Lab L 0..100, a/b -128..127
 // Color values (see psd.ts): HSB 0..1, CMYK 0..255, Gray 0..255, Lab L 0..1, a/b -1..1 (same as readColor/writeColor)
-const colorSourceKey = typeof Symbol !== 'undefined' ? Symbol('agPsdColorSource') : '__agPsdColorSource';
 const colorConversions = {
     // key: [descriptor -> color, color -> descriptor]
+    'H   ': [x => x / 360, x => x * 360], // angle
     Strt: [x => x / 100, x => x * 100],
     Brgh: [x => x / 100, x => x * 100],
     'Cyn ': [x => x * 255 / 100, x => x * 100 / 255],
@@ -5731,22 +6064,18 @@ function colorToDescriptorValue(key, value) {
     }
     return result;
 }
-function shallowEqual(a, b) {
-    const keys = Object.keys(a);
-    if (keys.length !== Object.keys(b).length)
-        return false;
-    return keys.every(key => a[key] === b[key]);
+function isBookColor(color) {
+    return color._classID === 'BkCl' || 'Bk  ' in color || 'bookID' in color;
 }
 function parseColor(color) {
-    let result;
     if ('H   ' in color) {
-        result = { h: parsePercentOrAngle(color['H   ']), s: color.Strt / 100, b: color.Brgh / 100 };
+        return { h: parsePercentOrAngle(color['H   ']), s: color.Strt / 100, b: color.Brgh / 100 };
     }
     else if ('Rd  ' in color) {
         return { r: color['Rd  '], g: color['Grn '], b: color['Bl  '] };
     }
     else if ('Cyn ' in color) {
-        result = {
+        return {
             c: color['Cyn '] * 255 / 100,
             m: color.Mgnt * 255 / 100,
             y: color['Ylw '] * 255 / 100,
@@ -5754,21 +6083,22 @@ function parseColor(color) {
         };
     }
     else if ('Gry ' in color) {
-        result = { k: color['Gry '] * 255 / 100 };
+        return { k: color['Gry '] * 255 / 100 };
     }
     else if ('Lmnc' in color) {
-        result = { l: color.Lmnc / 100, a: (0, helpers_1.normalizeLabAB)(color['A   ']), b: (0, helpers_1.normalizeLabAB)(color['B   ']) };
+        return { l: color.Lmnc / 100, a: (0, helpers_1.normalizeLabAB)(color['A   ']), b: (0, helpers_1.normalizeLabAB)(color['B   ']) };
     }
     else if ('redFloat' in color) {
         return { fr: color.redFloat, fg: color.greenFloat, fb: color.blueFloat };
     }
+    else if (isBookColor(color)) {
+        return { r: 0, g: 0, b: 0 }; // book (Pantone) colors are not supported
+    }
     else {
         throw new Error('Unsupported color descriptor');
     }
-    // remember original descriptor values, so unmodified colors can be written back without conversion errors
-    return setHidden(result, colorSourceKey, { color: Object.assign({}, result), descriptor: color });
 }
-function serializeColorValues(color) {
+function serializeColor(color) {
     if (!color) {
         return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
     }
@@ -5781,7 +6111,7 @@ function serializeColorValues(color) {
     else if ('h' in color) {
         return {
             _name: '', _classID: 'HSBC',
-            'H   ': unitsAngle((color.h || 0) * 360),
+            'H   ': unitsAngle(colorToDescriptorValue('H   ', color.h || 0)),
             Strt: colorToDescriptorValue('Strt', color.s || 0),
             Brgh: colorToDescriptorValue('Brgh', color.b || 0),
         };
@@ -5807,21 +6137,8 @@ function serializeColorValues(color) {
         return { _name: '', _classID: 'Grsc', 'Gry ': colorToDescriptorValue('Gry ', color.k || 0) };
     }
     else {
-        throw new Error('Invalid color value');
-    }
-}
-function serializeColor(color) {
-    const result = serializeColorValues(color);
-    const source = getHidden(color, colorSourceKey);
-    if (source && shallowEqual(source.color, color)) {
-        // color was not modified since it was read, use exact original values
-        for (const key of Object.keys(result)) {
-            if (colorConversions[key] && typeof source.descriptor[key] === 'number') {
-                result[key] = source.descriptor[key];
-            }
-        }
+        throw new Error('Invalid color value');
     }
-    return result;
 }
 function parseAngle(x) {
     if (x === undefined)
@@ -5848,7 +6165,8 @@ function parsePercentOrAngle(x) {
 }
 function parseUnits({ units, value }) {
     if (units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
-        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density') {
+        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density' &&
+        units !== 'Distance') {
         throw new Error(`Invalid units: ${JSON.stringify({ units, value })}`);
     }
     return { value, units };
@@ -5881,7 +6199,8 @@ function unitsValue(x, key) {
     if (typeof value !== 'number')
         throw new Error(`Invalid value in ${JSON.stringify(x)} (key: ${key})`);
     if (units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
-        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density') {
+        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density' &&
+        units !== 'Distance') {
         throw new Error(`Invalid units in ${JSON.stringify(x)} (key: ${key})`);
     }
     return { units, value };
@@ -6009,6 +6328,11 @@ exports.gradientInterpolationMethodType = (0, helpers_1.createEnum)('gradientInt
     smooth: 'Smoo',
     // TODO: stripes
 });
+exports.Clry = (0, helpers_1.createEnum)('Clry', 'user', {
+    user: 'UsrS',
+    foreground: 'FrgC',
+    background: 'BckC',
+});
 exports.ClrS = (0, helpers_1.createEnum)('ClrS', 'rgb', {
     rgb: 'RGBC',
     hsb: 'HSBl',
@@ -7293,7 +7617,7 @@ function decodeEngineData2(data) {
 },{"./engineData":6}],8:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImageData = exports.createCanvas = exports.MaskParams = exports.LayerMaskFlags = exports.ColorSpace = exports.largeAdditionalInfoKeys = exports.layerColors = exports.toBlendMode = exports.fromBlendMode = exports.RAW_IMAGE_DATA = exports.MOCK_HANDLERS = void 0;
+exports.createImageData = exports.createCanvas = exports.MaskParams = exports.LayerMaskFlags = exports.ColorSpace = exports.largeAdditionalInfoKeys = exports.largeAdditionalInfoKeysObserved = exports.layerColors = exports.toBlendMode = exports.fromBlendMode = exports.MOCK_HANDLERS = void 0;
 exports.revMap = revMap;
 exports.createEnum = createEnum;
 exports.offsetForChannel = offsetForChannel;
@@ -7312,7 +7636,6 @@ exports.initializeCanvas = initializeCanvas;
 const pako_1 = require("pako");
 const jpeg_1 = require("./jpeg");
 exports.MOCK_HANDLERS = false;
-exports.RAW_IMAGE_DATA = false;
 exports.fromBlendMode = {};
 exports.toBlendMode = {
     'pass': 'pass through',
@@ -7348,11 +7671,14 @@ Object.keys(exports.toBlendMode).forEach(key => exports.fromBlendMode[exports.to
 exports.layerColors = [
     'none', 'red', 'orange', 'yellow', 'green', 'blue', 'violet', 'gray'
 ];
+// keys not listed in documentation that Photoshop writes with 64bit length in PSB files (with 8B64 signature)
+exports.largeAdditionalInfoKeysObserved = ['lnk3', 'lnkE', 'pths', 'extd', 'extn', 'FELS', 'artd'];
 exports.largeAdditionalInfoKeys = [
     // from documentation
     'LMsk', 'Lr16', 'Lr32', 'Layr', 'Mt16', 'Mt32', 'Mtrn', 'Alph', 'FMsk', 'lnk2', 'FEid', 'FXid', 'PxSD',
     // from guessing
     'cinf',
+    ...exports.largeAdditionalInfoKeysObserved,
 ];
 function revMap(map) {
     const result = {};
@@ -7664,6 +7990,7 @@ function initializeCanvas(createCanvasMethod, createImageDataMethod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resourceHandlersMap = exports.resourceHandlers = void 0;
 const base64_js_1 = require("base64-js");
+const additionalInfo_1 = require("./additionalInfo");
 const psdReader_1 = require("./psdReader");
 const psdWriter_1 = require("./psdWriter");
 const helpers_1 = require("./helpers");
@@ -7671,10 +7998,12 @@ const utf8_1 = require("./utf8");
 const descriptor_1 = require("./descriptor");
 exports.resourceHandlers = [];
 exports.resourceHandlersMap = {};
-function addHandler(key, has, read, write) {
-    const handler = { key, has, read, write };
+function addHandler(key, has, read, write, options = {}) {
+    var _a;
+    const handler = { key, keyCount: (_a = options.keyCount) !== null && _a !== void 0 ? _a : 1, has, read, write, name: options.name };
     exports.resourceHandlers.push(handler);
-    exports.resourceHandlersMap[handler.key] = handler;
+    for (let i = 0; i < handler.keyCount; i++)
+        exports.resourceHandlersMap[handler.key + i] = handler;
 }
 const LOG_MOCK_HANDLERS = false;
 const RESOLUTION_UNITS = [undefined, 'PPI', 'PPCM'];
@@ -7692,27 +8021,18 @@ function byteAt(value, index) {
 }
 function readUtf8String(reader, length) {
     const buffer = (0, psdReader_1.readBytes)(reader, length);
-    return (0, utf8_1.decodeString)(buffer);
+    return (0, psdReader_1.decodeUtf8)(reader, buffer);
 }
 function writeUtf8String(writer, value) {
     const buffer = (0, utf8_1.encodeString)(value);
     (0, psdWriter_1.writeBytes)(writer, buffer);
 }
-let gbkDecoder;
-function getGbkDecoder() {
-    if (gbkDecoder === undefined) {
-        try {
-            gbkDecoder = new TextDecoder('gbk');
-        }
-        catch (_a) {
-            gbkDecoder = null;
-        }
-    }
-    return gbkDecoder;
-}
 function readEncodedString(reader) {
     const length = (0, psdReader_1.readUint8)(reader);
     const buffer = (0, psdReader_1.readBytes)(reader, length);
+    return decodeEncodedString(reader, buffer);
+}
+function decodeEncodedString(reader, buffer) {
     let notAscii = false;
     for (let i = 0; i < buffer.byteLength; i++) {
         if (buffer[i] & 0x80) {
@@ -7721,17 +8041,20 @@ function readEncodedString(reader) {
         }
     }
     if (notAscii) {
-        const decoder = getGbkDecoder();
-        if (decoder) {
-            try {
-                return decoder.decode(buffer);
+        // encoding is ambiguous, many GBK strings are also valid UTF-8 and vice versa, GBK is preferred,
+        // UTF-8 is only used if the string is not valid GBK
+        for (const decoder of [(0, psdReader_1.getGbkStrictDecoder)(reader), (0, psdReader_1.getUtf8StrictDecoder)(reader)]) {
+            if (decoder) {
+                try {
+                    return decoder.decode(buffer);
+                }
+                catch (_a) { }
             }
-            catch (_a) { }
         }
     }
-    return (0, utf8_1.decodeString)(buffer);
+    return (0, psdReader_1.decodeUtf8)(reader, buffer);
 }
-function writeEncodedString(writer, value) {
+function toShortAsciiString(value) {
     let ascii = '';
     for (let i = 0; i < value.length;) {
         const code = value.codePointAt(i);
@@ -7739,19 +8062,19 @@ function writeEncodedString(writer, value) {
         i += code > 0xffff ? 2 : 1; // skip low surrogate of astral characters
     }
     // length is stored in a single byte
-    if (ascii.length > 255)
-        ascii = ascii.substring(0, 255);
-    const buffer = (0, utf8_1.encodeString)(ascii);
+    return ascii.length > 255 ? ascii.substring(0, 255) : ascii;
+}
+function writeEncodedString(writer, value) {
+    const buffer = (0, utf8_1.encodeString)(toShortAsciiString(value));
     (0, psdWriter_1.writeUint8)(writer, buffer.byteLength);
     (0, psdWriter_1.writeBytes)(writer, buffer);
 }
-helpers_1.MOCK_HANDLERS && addHandler(1028, // IPTC-NAA record
+addHandler(1028, // IPTC-NAA record
 // IPTC-NAA record
-target => target._ir1028 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 1028', left());
-    target._ir1028 = (0, psdReader_1.readBytes)(reader, left());
+target => target.iptcData !== undefined, (reader, target, left) => {
+    target.iptcData = (0, psdReader_1.readBytes)(reader, left());
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1028);
+    (0, psdWriter_1.writeBytes)(writer, target.iptcData);
 });
 addHandler(1061, target => target.captionDigest !== undefined, (reader, target) => {
     let captionDigest = '';
@@ -7777,12 +8100,12 @@ const Inte = (0, helpers_1.createEnum)('Inte', 'perceptual', {
     'relative colorimetric': 'Clrm',
     'absolute colorimetric': 'AClr',
 });
-helpers_1.MOCK_HANDLERS && addHandler(1085, // Windows DEVMODE. Variable OS specific info for Windows.
+addHandler(1085, // Windows DEVMODE. Variable OS specific info for Windows.
 // Windows DEVMODE. Variable OS specific info for Windows.
-target => target._ir1085 !== undefined, (reader, target, left) => {
-    target._ir1085 = (0, psdReader_1.readBytes)(reader, left());
+target => target.windowsDevMode !== undefined, (reader, target, left) => {
+    target.windowsDevMode = (0, psdReader_1.readBytes)(reader, left());
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1085);
+    (0, psdWriter_1.writeBytes)(writer, target.windowsDevMode);
 });
 addHandler(1082, target => target.printInformation !== undefined, (reader, target) => {
     var _a, _b;
@@ -7794,6 +8117,8 @@ addHandler(1082, target => target.printInformation !== undefined, (reader, targe
     const info = target.printInformation;
     if (desc.PstS !== undefined)
         info.printerManagesColors = desc.PstS;
+    if (desc.ClrS === 'ClrS.Grys')
+        info.printerProfileColorSpace = 'grayscale';
     if (desc['Nm  '] !== undefined)
         info.printerProfile = desc['Nm  '];
     if (desc.MpBl !== undefined)
@@ -7816,7 +8141,6 @@ addHandler(1082, target => target.printInformation !== undefined, (reader, targe
         }
     }
 }, (writer, target) => {
-    var _a, _b;
     const info = target.printInformation;
     const desc = {};
     if (info.printerManagesColors) {
@@ -7825,11 +8149,12 @@ addHandler(1082, target => target.printInformation !== undefined, (reader, targe
     else {
         if (info.hardProof !== undefined)
             desc.hardProof = !!info.hardProof;
-        desc.ClrS = 'ClrS.RGBC'; // TODO: ???
-        desc['Nm  '] = (_a = info.printerProfile) !== null && _a !== void 0 ? _a : 'CIE RGB';
+        desc.ClrS = info.printerProfileColorSpace === 'grayscale' ? 'ClrS.Grys' : 'ClrS.RGBC';
+        if (info.printerProfile !== undefined)
+            desc['Nm  '] = info.printerProfile;
     }
     desc.Inte = Inte.encode(info.renderingIntent);
-    if (!info.printerManagesColors)
+    if (!info.printerManagesColors && info.blackPointCompensation !== undefined)
         desc.MpBl = !!info.blackPointCompensation;
     desc.printSixteenBit = !!info.printSixteenBit;
     desc.printerName = info.printerName || '';
@@ -7841,23 +8166,77 @@ addHandler(1082, target => target.printInformation !== undefined, (reader, targe
             paperWhite: !!info.proofSetup.paperWhite,
         };
     }
-    else {
+    else if (info.proofSetup) {
         desc.printProofSetup = {
-            Bltn: ((_b = info.proofSetup) === null || _b === void 0 ? void 0 : _b.builtin) ? `builtinProof.${info.proofSetup.builtin}` : 'builtinProof.proofCMYK',
+            Bltn: `builtinProof.${info.proofSetup.builtin || 'proofCMYK'}`,
         };
     }
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'printOutput', desc);
 });
-helpers_1.MOCK_HANDLERS && addHandler(1083, // Print style
+addHandler(1083, // Print style
 // Print style
-target => target._ir1083 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 1083', left());
-    target._ir1083 = (0, psdReader_1.readBytes)(reader, left());
-    // TODO:
-    // const desc = readVersionAndDescriptor(reader);
-    // console.log('1083', require('util').inspect(desc, false, 99, true));
+target => target.printStyle !== undefined, (reader, target) => {
+    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+    target.printStyle = {
+        caption: desc.Cptn,
+        calibrationBars: desc.Clbr,
+        registrationMarks: desc.RgsM,
+        cornerCropMarks: desc.CrnC,
+        centerCropMarks: desc.CntC,
+        labels: desc.Lbls,
+        negative: desc.Ngtv,
+        emulsionDown: desc.EmlD,
+        interpolate: desc.Intr,
+        backgroundColor: (0, descriptor_1.parseColor)(desc.Bckg),
+        border: (0, descriptor_1.parseUnits)(desc.BrdT),
+        bleed: (0, descriptor_1.parseUnits)(desc['Bld ']),
+        resolution: (0, descriptor_1.parseUnits)(desc.Rslt),
+        vectorData: desc.vectorData,
+        pagePosition: desc.PgPs === 'PgPs.PgPC' ? 'centered' : desc.PgPs,
+        left: (0, descriptor_1.parseUnits)(desc.Left),
+        top: (0, descriptor_1.parseUnits)(desc['Top ']),
+        scale: (0, descriptor_1.parsePercent)(desc['Scl ']),
+    };
+    if (desc.cropWhenPrinting !== undefined) {
+        target.printStyle.cropWhenPrinting = desc.cropWhenPrinting;
+        target.printStyle.cropRect = {
+            top: desc.cropRectTop || 0,
+            left: desc.cropRectLeft || 0,
+            bottom: desc.cropRectBottom || 0,
+            right: desc.cropRectRight || 0,
+        };
+    }
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1083);
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const style = target.printStyle;
+    const desc = {
+        Cptn: !!style.caption,
+        Clbr: !!style.calibrationBars,
+        RgsM: !!style.registrationMarks,
+        CrnC: !!style.cornerCropMarks,
+        CntC: !!style.centerCropMarks,
+        Lbls: !!style.labels,
+        Ngtv: !!style.negative,
+        EmlD: !!style.emulsionDown,
+        Intr: !!style.interpolate,
+        Bckg: (0, descriptor_1.serializeColor)(style.backgroundColor || { r: 255, g: 255, b: 255 }),
+        BrdT: (0, descriptor_1.unitsValue)(style.border || { units: 'Distance', value: 0 }, 'border'),
+        'Bld ': (0, descriptor_1.unitsValue)(style.bleed || { units: 'Distance', value: 0 }, 'bleed'),
+        Rslt: (0, descriptor_1.unitsValue)(style.resolution || { units: 'Pixels', value: 72 }, 'resolution'),
+        vectorData: (_a = style.vectorData) !== null && _a !== void 0 ? _a : true,
+        PgPs: (!style.pagePosition || style.pagePosition === 'centered') ? 'PgPs.PgPC' : style.pagePosition,
+        Left: (0, descriptor_1.unitsValue)(style.left || { units: 'Distance', value: 0 }, 'left'),
+        'Top ': (0, descriptor_1.unitsValue)(style.top || { units: 'Distance', value: 0 }, 'top'),
+        'Scl ': (0, descriptor_1.unitsPercentF)((_b = style.scale) !== null && _b !== void 0 ? _b : 1),
+    };
+    if (style.cropWhenPrinting !== undefined || style.cropRect) {
+        desc.cropWhenPrinting = !!style.cropWhenPrinting;
+        desc.cropRectBottom = (_d = (_c = style.cropRect) === null || _c === void 0 ? void 0 : _c.bottom) !== null && _d !== void 0 ? _d : 0;
+        desc.cropRectLeft = (_f = (_e = style.cropRect) === null || _e === void 0 ? void 0 : _e.left) !== null && _f !== void 0 ? _f : 0;
+        desc.cropRectRight = (_h = (_g = style.cropRect) === null || _g === void 0 ? void 0 : _g.right) !== null && _h !== void 0 ? _h : 0;
+        desc.cropRectTop = (_k = (_j = style.cropRect) === null || _j === void 0 ? void 0 : _j.top) !== null && _k !== void 0 ? _k : 0;
+    }
+    (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'printOutputOptions', desc);
 });
 addHandler(1005, target => target.resolutionInfo !== undefined, (reader, target) => {
     const horizontalResolution = (0, psdReader_1.readFixedPoint32)(reader);
@@ -7926,11 +8305,61 @@ addHandler(1045, target => target.alphaChannelNames !== undefined, (reader, targ
         (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
     }
 });
-helpers_1.MOCK_HANDLERS && addHandler(1077, target => target._ir1077 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 1077', left());
-    target._ir1077 = (0, psdReader_1.readBytes)(reader, left());
+const displayInfoKinds = ['selected', 'protected', 'spot'];
+const supportedColorSpaces = [0 /* ColorSpace.RGB */, 1 /* ColorSpace.HSB */, 2 /* ColorSpace.CMYK */, 7 /* ColorSpace.Lab */, 8 /* ColorSpace.Grayscale */];
+function readDisplayInfo(reader) {
+    const info = { opacity: 0, kind: 'selected' };
+    const colorSpace = reader.view.getUint16(reader.offset);
+    if (supportedColorSpaces.indexOf(colorSpace) !== -1) {
+        info.color = (0, psdReader_1.readColor)(reader);
+    }
+    else {
+        // keep color in unknown color space as it is, so the channel info is not lost or misaligned
+        (0, psdReader_1.skipBytes)(reader, 2);
+        info.rawColor = { colorSpace, values: [(0, psdReader_1.readUint16)(reader), (0, psdReader_1.readUint16)(reader), (0, psdReader_1.readUint16)(reader), (0, psdReader_1.readUint16)(reader)] };
+    }
+    info.opacity = (0, psdReader_1.readUint16)(reader) / 100;
+    const kind = displayInfoKinds[(0, psdReader_1.readUint8)(reader)];
+    if (!kind)
+        throw new Error('Invalid display info kind');
+    info.kind = kind;
+    return info;
+}
+addHandler(1007, // Display info (obsolete, replaced by 1077), written back as 1077
+() => false, (reader, target, left) => {
+    const info = [];
+    while (left() >= 14) {
+        info.push(readDisplayInfo(reader));
+        (0, psdReader_1.skipBytes)(reader, 1); // padding
+    }
+    // 1077 resource has more precise data and is used if present
+    if (!target.alphaChannelDisplayInfo)
+        target.alphaChannelDisplayInfo = info;
+}, () => { });
+addHandler(1077, // Display info (alpha and spot channels)
+// Display info (alpha and spot channels)
+target => target.alphaChannelDisplayInfo !== undefined, (reader, target, left) => {
+    const version = (0, psdReader_1.readUint32)(reader);
+    if (version !== 1)
+        throw new Error(`Invalid display info version: ${version}`);
+    target.alphaChannelDisplayInfo = [];
+    while (left() >= 13) {
+        target.alphaChannelDisplayInfo.push(readDisplayInfo(reader));
+    }
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1077);
+    (0, psdWriter_1.writeUint32)(writer, 1); // version
+    for (const info of target.alphaChannelDisplayInfo) {
+        if (!info.color && info.rawColor) {
+            (0, psdWriter_1.writeUint16)(writer, info.rawColor.colorSpace);
+            for (let i = 0; i < 4; i++)
+                (0, psdWriter_1.writeUint16)(writer, info.rawColor.values[i] | 0);
+        }
+        else {
+            (0, psdWriter_1.writeColor)(writer, info.color || { r: 255, g: 0, b: 0 });
+        }
+        (0, psdWriter_1.writeUint16)(writer, Math.round((0, helpers_1.clamp)(info.opacity, 0, 1) * 100));
+        (0, psdWriter_1.writeUint8)(writer, Math.max(0, displayInfoKinds.indexOf(info.kind)));
+    }
 });
 addHandler(1053, target => target.alphaIdentifiers !== undefined, (reader, target, left) => {
     target.alphaIdentifiers = [];
@@ -7983,30 +8412,101 @@ target => target.url !== undefined, (reader, target, left) => {
 }, (writer, target) => {
     (0, psdWriter_1.writeAsciiString)(writer, target.url);
 });
-helpers_1.MOCK_HANDLERS && addHandler(10000, // Print flags
-// Print flags
-target => target._ir10000 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 10000', left());
-    target._ir10000 = (0, psdReader_1.readBytes)(reader, left());
+addHandler(10000, // Print flags information
+// Print flags information
+target => target.printFlagsInfo !== undefined, (reader, target) => {
+    const version = (0, psdReader_1.readUint16)(reader);
+    if (version !== 1)
+        throw new Error(`Invalid print flags information version: ${version}`);
+    const centerCropMarks = !!(0, psdReader_1.readUint8)(reader);
+    (0, psdReader_1.skipBytes)(reader, 1);
+    const bleedWidth = (0, psdReader_1.readUint32)(reader);
+    const bleedWidthScale = (0, psdReader_1.readUint16)(reader);
+    target.printFlagsInfo = { centerCropMarks, bleedWidth, bleedWidthScale };
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir10000);
+    const info = target.printFlagsInfo;
+    (0, psdWriter_1.writeUint16)(writer, 1); // version
+    (0, psdWriter_1.writeUint8)(writer, info.centerCropMarks ? 1 : 0);
+    (0, psdWriter_1.writeUint8)(writer, 0);
+    (0, psdWriter_1.writeUint32)(writer, info.bleedWidth | 0);
+    (0, psdWriter_1.writeUint16)(writer, info.bleedWidthScale | 0);
 });
-helpers_1.MOCK_HANDLERS && addHandler(1013, // Color halftoning
-// Color halftoning
-target => target._ir1013 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 1013', left());
-    target._ir1013 = (0, psdReader_1.readBytes)(reader, left());
+addHandler(1046, // Indexed color table count
+// Indexed color table count
+target => target.indexedColorCount !== undefined, (reader, target) => {
+    target.indexedColorCount = (0, psdReader_1.readUint16)(reader);
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1013);
+    (0, psdWriter_1.writeUint16)(writer, target.indexedColorCount);
 });
-helpers_1.MOCK_HANDLERS && addHandler(1016, // Color transfer functions
-// Color transfer functions
-target => target._ir1016 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 1016', left());
-    target._ir1016 = (0, psdReader_1.readBytes)(reader, left());
+addHandler(1047, // Transparency index
+// Transparency index
+target => target.transparencyIndex !== undefined, (reader, target) => {
+    target.transparencyIndex = (0, psdReader_1.readUint16)(reader);
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1016);
+    (0, psdWriter_1.writeUint16)(writer, target.transparencyIndex);
 });
+const halftoneFrequencyUnits = ['lines/inch', 'lines/cm']; // 1, 2
+const halftoneShapes = ['round', 'ellipse', 'line', 'square', 'cross', undefined, 'diamond']; // 0 - 6
+function readHalftoneScreens(reader, left) {
+    const screens = [];
+    while (left() >= 18) {
+        const frequency = (0, psdReader_1.readFixedPoint32)(reader);
+        const frequencyUnits = halftoneFrequencyUnits[(0, psdReader_1.readUint16)(reader) - 1];
+        if (!frequencyUnits)
+            throw new Error('Invalid halftone screen frequency units');
+        const angle = (0, psdReader_1.readFixedPoint32)(reader);
+        const shape = halftoneShapes[(0, psdReader_1.readInt16)(reader)];
+        if (!shape)
+            throw new Error('Invalid halftone screen shape');
+        (0, psdReader_1.skipBytes)(reader, 4);
+        const accurateScreens = !!(0, psdReader_1.readUint8)(reader);
+        const printerDefaultScreens = !!(0, psdReader_1.readUint8)(reader);
+        screens.push({ frequency, frequencyUnits, angle, shape, accurateScreens, printerDefaultScreens });
+    }
+    return screens;
+}
+function writeHalftoneScreens(writer, screens) {
+    for (const screen of screens) {
+        (0, psdWriter_1.writeFixedPoint32)(writer, screen.frequency);
+        (0, psdWriter_1.writeUint16)(writer, Math.max(0, halftoneFrequencyUnits.indexOf(screen.frequencyUnits)) + 1);
+        (0, psdWriter_1.writeFixedPoint32)(writer, screen.angle);
+        (0, psdWriter_1.writeInt16)(writer, Math.max(0, halftoneShapes.indexOf(screen.shape)));
+        (0, psdWriter_1.writeZeros)(writer, 4);
+        (0, psdWriter_1.writeUint8)(writer, screen.accurateScreens ? 1 : 0);
+        (0, psdWriter_1.writeUint8)(writer, screen.printerDefaultScreens ? 1 : 0);
+    }
+}
+addHandler(1012, // Grayscale and multichannel halftoning information
+// Grayscale and multichannel halftoning information
+target => target.grayscaleHalftoneScreens !== undefined, (reader, target, left) => target.grayscaleHalftoneScreens = readHalftoneScreens(reader, left), (writer, target) => writeHalftoneScreens(writer, target.grayscaleHalftoneScreens));
+addHandler(1013, // Color halftoning information
+// Color halftoning information
+target => target.colorHalftoneScreens !== undefined, (reader, target, left) => target.colorHalftoneScreens = readHalftoneScreens(reader, left), (writer, target) => writeHalftoneScreens(writer, target.colorHalftoneScreens));
+function readTransferFunctions(reader, left) {
+    const functions = [];
+    while (left() >= 28) {
+        const curve = [];
+        for (let i = 0; i < 13; i++)
+            curve.push((0, psdReader_1.readInt16)(reader));
+        const override = !!(0, psdReader_1.readUint16)(reader);
+        functions.push({ curve, override });
+    }
+    return functions;
+}
+function writeTransferFunctions(writer, functions) {
+    var _a;
+    for (const f of functions) {
+        for (let i = 0; i < 13; i++)
+            (0, psdWriter_1.writeInt16)(writer, (_a = f.curve[i]) !== null && _a !== void 0 ? _a : -1);
+        (0, psdWriter_1.writeUint16)(writer, f.override ? 1 : 0);
+    }
+}
+addHandler(1015, // Grayscale and multichannel transfer function
+// Grayscale and multichannel transfer function
+target => target.grayscaleTransferFunctions !== undefined, (reader, target, left) => target.grayscaleTransferFunctions = readTransferFunctions(reader, left), (writer, target) => writeTransferFunctions(writer, target.grayscaleTransferFunctions));
+addHandler(1016, // Color transfer functions
+// Color transfer functions
+target => target.colorTransferFunctions !== undefined, (reader, target, left) => target.colorTransferFunctions = readTransferFunctions(reader, left), (writer, target) => writeTransferFunctions(writer, target.colorTransferFunctions));
 addHandler(1080, // Count Information
 // Count Information
 target => target.countInformation !== undefined, (reader, target) => {
@@ -8069,22 +8569,27 @@ addHandler(1069, target => target.layerSelectionIds !== undefined, (reader, targ
     }
 });
 addHandler(1032, target => target.gridAndGuidesInformation !== undefined, (reader, target) => {
+    var _a;
     const version = (0, psdReader_1.readUint32)(reader);
     const horizontal = (0, psdReader_1.readUint32)(reader);
     const vertical = (0, psdReader_1.readUint32)(reader);
     const count = (0, psdReader_1.readUint32)(reader);
     if (version !== 1)
         throw new Error(`Invalid 1032 resource version: ${version}`);
-    target.gridAndGuidesInformation = {
-        grid: { horizontal, vertical },
-        guides: [],
-    };
+    const previous = (_a = target.gridAndGuidesInformation) === null || _a === void 0 ? void 0 : _a.guides; // in case guides were already read from 1092
+    const guides = [];
     for (let i = 0; i < count; i++) {
-        target.gridAndGuidesInformation.guides.push({
+        const guide = {
             location: (0, psdReader_1.readInt32)(reader) / 32,
             direction: (0, psdReader_1.readUint8)(reader) ? 'horizontal' : 'vertical'
-        });
+        };
+        if ((previous === null || previous === void 0 ? void 0 : previous.length) === count && previous[i].color)
+            guide.color = previous[i].color;
+        if ((previous === null || previous === void 0 ? void 0 : previous.length) === count && previous[i].id)
+            guide.id = previous[i].id;
+        guides.push(guide);
     }
+    target.gridAndGuidesInformation = { grid: { horizontal, vertical }, guides };
 }, (writer, target) => {
     const info = target.gridAndGuidesInformation;
     const grid = info.grid || { horizontal: 18 * 32, vertical: 18 * 32 };
@@ -8098,6 +8603,76 @@ addHandler(1032, target => target.gridAndGuidesInformation !== undefined, (reade
         (0, psdWriter_1.writeUint8)(writer, g.direction === 'horizontal' ? 1 : 0);
     }
 });
+const defaultGuideColor = { r: 74, g: 255, b: 255 }; // Photoshop default (cyan)
+addHandler(1092, // Grid and guides information with guide colors (same as 1032 with color of each guide)
+// Grid and guides information with guide colors (same as 1032 with color of each guide)
+target => target.gridAndGuidesInformation !== undefined, (reader, target) => {
+    var _a;
+    const version = (0, psdReader_1.readUint32)(reader);
+    if (version !== 2)
+        throw new Error(`Invalid 1092 resource version: ${version}`);
+    const horizontal = (0, psdReader_1.readUint32)(reader);
+    const vertical = (0, psdReader_1.readUint32)(reader);
+    const count = (0, psdReader_1.readUint32)(reader);
+    const guides = [];
+    for (let i = 0; i < count; i++) {
+        const location = (0, psdReader_1.readInt32)(reader) / 32;
+        const direction = (0, psdReader_1.readUint8)(reader) ? 'horizontal' : 'vertical';
+        (0, psdReader_1.skipBytes)(reader, 1);
+        const color = { r: (0, psdReader_1.readUint8)(reader), g: (0, psdReader_1.readUint8)(reader), b: (0, psdReader_1.readUint8)(reader) };
+        guides.push({ location, direction, color });
+    }
+    const existing = (_a = target.gridAndGuidesInformation) === null || _a === void 0 ? void 0 : _a.guides;
+    if (existing && existing.length === count) {
+        existing.forEach((guide, i) => guide.color = guides[i].color);
+    }
+    else {
+        target.gridAndGuidesInformation = { grid: { horizontal, vertical }, guides };
+    }
+}, (writer, target) => {
+    const info = target.gridAndGuidesInformation;
+    const grid = info.grid || { horizontal: 18 * 32, vertical: 18 * 32 };
+    const guides = info.guides || [];
+    (0, psdWriter_1.writeUint32)(writer, 2); // version
+    (0, psdWriter_1.writeUint32)(writer, Math.round(grid.horizontal));
+    (0, psdWriter_1.writeUint32)(writer, Math.round(grid.vertical));
+    (0, psdWriter_1.writeUint32)(writer, guides.length);
+    for (const g of guides) {
+        const color = g.color || defaultGuideColor;
+        (0, psdWriter_1.writeInt32)(writer, Math.round(g.location * 32));
+        (0, psdWriter_1.writeUint8)(writer, g.direction === 'horizontal' ? 1 : 0);
+        (0, psdWriter_1.writeUint8)(writer, 0);
+        (0, psdWriter_1.writeUint8)(writer, Math.round(color.r));
+        (0, psdWriter_1.writeUint8)(writer, Math.round(color.g));
+        (0, psdWriter_1.writeUint8)(writer, Math.round(color.b));
+    }
+});
+const emptyGuid = '00000000-0000-0000-0000-000000000000';
+addHandler(1097, // Guide ids
+// Guide ids
+target => !!target.gridAndGuidesInformation && (target.gridAndGuidesInformation.guides || []).every(g => g.id), (reader, target) => {
+    var _a;
+    const count = (0, psdReader_1.readUint32)(reader);
+    const ids = [];
+    for (let i = 0; i < count; i++) {
+        ids.push((0, psdReader_1.readAsciiString)(reader, (0, psdReader_1.readUint32)(reader)));
+        (0, psdReader_1.readUint32)(reader); // unknown, always 0
+        (0, psdReader_1.readAsciiString)(reader, (0, psdReader_1.readUint32)(reader)); // unknown, always empty guid
+    }
+    const guides = (_a = target.gridAndGuidesInformation) === null || _a === void 0 ? void 0 : _a.guides;
+    if (guides && guides.length === count)
+        guides.forEach((guide, i) => guide.id = ids[i]);
+}, (writer, target) => {
+    const guides = target.gridAndGuidesInformation.guides || [];
+    (0, psdWriter_1.writeUint32)(writer, guides.length);
+    for (const g of guides) {
+        (0, psdWriter_1.writeUint32)(writer, g.id.length);
+        (0, psdWriter_1.writeAsciiString)(writer, g.id);
+        (0, psdWriter_1.writeUint32)(writer, 0);
+        (0, psdWriter_1.writeUint32)(writer, emptyGuid.length);
+        (0, psdWriter_1.writeAsciiString)(writer, emptyGuid);
+    }
+});
 addHandler(1065, // Layer Comps
 // Layer Comps
 target => target.layerComps !== undefined, (reader, target) => {
@@ -8478,27 +9053,78 @@ addHandler(1041, target => target.iccUntaggedProfile !== undefined, (reader, tar
 }, (writer, target) => {
     (0, psdWriter_1.writeUint8)(writer, target.iccUntaggedProfile ? 1 : 0);
 });
-helpers_1.MOCK_HANDLERS && addHandler(1039, // ICC Profile
+addHandler(1039, // ICC Profile
 // ICC Profile
-target => target._ir1039 !== undefined, (reader, target, left) => {
-    // TODO: this is raw bytes, just return as a byte array
-    LOG_MOCK_HANDLERS && console.log('image resource 1039', left());
-    target._ir1039 = (0, psdReader_1.readBytes)(reader, left());
+target => target.iccProfile !== undefined, (reader, target, left) => {
+    target.iccProfile = (0, psdReader_1.readBytes)(reader, left());
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1039);
+    (0, psdWriter_1.writeBytes)(writer, target.iccProfile);
 });
 addHandler(1044, target => target.idsSeedNumber !== undefined, (reader, target) => target.idsSeedNumber = (0, psdReader_1.readUint32)(reader), (writer, target) => (0, psdWriter_1.writeUint32)(writer, target.idsSeedNumber));
+addHandler(1038, // Color samplers (Photoshop 5.0, replaced by 1073 in CS3)
+// Color samplers (Photoshop 5.0, replaced by 1073 in CS3)
+target => target.colorSamplers !== undefined, (reader, target, left) => {
+    const version = (0, psdReader_1.readUint32)(reader);
+    if (version !== 1)
+        throw new Error(`Invalid color samplers version: ${version}`);
+    const count = (0, psdReader_1.readUint32)(reader);
+    target.colorSamplers = [];
+    for (let i = 0; i < count && left() >= 10; i++) {
+        // vertical and horizontal position in 1/16 pixel (inferred from sample files, the specification describes
+        // these values as horizontal and vertical fixed point numbers)
+        const y = (0, psdReader_1.readInt32)(reader) / 16;
+        const x = (0, psdReader_1.readInt32)(reader) / 16;
+        const colorSpace = (0, psdReader_1.readInt16)(reader);
+        target.colorSamplers.push({ x, y, colorSpace });
+    }
+}, (writer, target) => {
+    (0, psdWriter_1.writeUint32)(writer, 1); // version
+    (0, psdWriter_1.writeUint32)(writer, target.colorSamplers.length);
+    for (const sampler of target.colorSamplers) {
+        (0, psdWriter_1.writeInt32)(writer, Math.round(sampler.y * 16));
+        (0, psdWriter_1.writeInt32)(writer, Math.round(sampler.x * 16));
+        (0, psdWriter_1.writeInt16)(writer, sampler.colorSpace);
+    }
+});
+addHandler(1042, // Effects visible (only present when effects are hidden)
+// Effects visible (only present when effects are hidden)
+target => target.effectsVisible !== undefined, (reader, target) => {
+    target.effectsVisible = !!(0, psdReader_1.readUint8)(reader);
+}, (writer, target) => {
+    (0, psdWriter_1.writeUint8)(writer, target.effectsVisible ? 1 : 0);
+});
 addHandler(1036, target => target.thumbnail !== undefined || target.thumbnailRaw !== undefined, (reader, target, left) => {
     const format = (0, psdReader_1.readUint32)(reader); // 1 = kJpegRGB, 0 = kRawRGB
     const width = (0, psdReader_1.readUint32)(reader);
     const height = (0, psdReader_1.readUint32)(reader);
-    (0, psdReader_1.readUint32)(reader); // widthBytes = (width * bits_per_pixel + 31) / 32 * 4.
+    const widthBytes = (0, psdReader_1.readUint32)(reader); // widthBytes = (width * bits_per_pixel + 31) / 32 * 4.
     (0, psdReader_1.readUint32)(reader); // totalSize = widthBytes * height * planes
     (0, psdReader_1.readUint32)(reader); // sizeAfterCompression
     const bitsPerPixel = (0, psdReader_1.readUint16)(reader); // 24
-    const planes = (0, psdReader_1.readUint16)(reader); // 1
-    if (format !== 1 || bitsPerPixel !== 24 || planes !== 1) {
-        reader.logMissingFeatures && reader.log(`Invalid thumbnail data (format: ${format}, bitsPerPixel: ${bitsPerPixel}, planes: ${planes})`);
+    (0, psdReader_1.readUint16)(reader); // planes, should be 1 (some applications write 3)
+    if (format === 0 && bitsPerPixel === 24 && widthBytes >= width * 3 && widthBytes * height <= left()) {
+        // raw RGB data, rows are padded to 4 bytes
+        if (reader.useRawThumbnail) {
+            reader.logMissingFeatures && reader.log('Raw thumbnail data is not supported with useRawThumbnail option');
+            (0, psdReader_1.skipBytes)(reader, left());
+            return;
+        }
+        const data = (0, psdReader_1.readBytes)(reader, widthBytes * height);
+        const imageData = (0, helpers_1.createImageData)(width, height);
+        for (let y = 0, dst = 0; y < height; y++) {
+            for (let x = 0, src = y * widthBytes; x < width; x++, src += 3, dst += 4) {
+                imageData.data[dst + 0] = data[src + 0];
+                imageData.data[dst + 1] = data[src + 1];
+                imageData.data[dst + 2] = data[src + 2];
+                imageData.data[dst + 3] = 255;
+            }
+        }
+        target.thumbnail = (0, helpers_1.imageDataToCanvas)(imageData);
+        (0, psdReader_1.skipBytes)(reader, left());
+        return;
+    }
+    if (format !== 1 || bitsPerPixel !== 24) {
+        reader.logMissingFeatures && reader.log(`Invalid thumbnail data (format: ${format}, bitsPerPixel: ${bitsPerPixel})`);
         (0, psdReader_1.skipBytes)(reader, left());
         return;
     }
@@ -8565,13 +9191,12 @@ addHandler(1057, target => target.versionInfo !== undefined, (reader, target, le
     (0, psdWriter_1.writeUnicodeString)(writer, versionInfo.readerName);
     (0, psdWriter_1.writeUint32)(writer, versionInfo.fileVersion);
 });
-helpers_1.MOCK_HANDLERS && addHandler(1058, // EXIF data 1.
-// EXIF data 1.
-target => target._ir1058 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 1058', left());
-    target._ir1058 = (0, psdReader_1.readBytes)(reader, left());
+addHandler(1058, // EXIF data 1
+// EXIF data 1
+target => target.exifData !== undefined, (reader, target, left) => {
+    target.exifData = (0, psdReader_1.readBytes)(reader, left());
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1058);
+    (0, psdWriter_1.writeBytes)(writer, target.exifData);
 });
 addHandler(7000, target => target.imageReadyVariables !== undefined, (reader, target, left) => {
     target.imageReadyVariables = readUtf8String(reader, left());
@@ -8590,22 +9215,101 @@ addHandler(1088, target => target.pathSelectionState !== undefined, (reader, tar
     const desc = { 'null': (0, descriptor_1.pathSelectionStateToReference)(target.pathSelectionState) };
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
 });
-helpers_1.MOCK_HANDLERS && addHandler(1025, target => target._ir1025 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 1025', left());
-    target._ir1025 = (0, psdReader_1.readBytes)(reader, left());
+addHandler(1025, // Work path
+// Work path
+target => target.workPath !== undefined, (reader, target, left, { width, height }) => {
+    target.workPath = { paths: [] };
+    (0, additionalInfo_1.readVectorMask)(reader, target.workPath, width, height, left());
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target, _index, { width, height }) => {
+    (0, additionalInfo_1.writeVectorMask)(writer, target.workPath, width, height);
+});
+const MAX_SAVED_PATHS = 999; // ids 2000-2998
+addHandler(2000, // Saved paths (one resource for each path, named after the path)
+// Saved paths (one resource for each path, named after the path)
+target => target.savedPaths ? Math.min(target.savedPaths.length, MAX_SAVED_PATHS) : 0, (reader, target, left, { signature, id, name, width, height }) => {
+    var _a, _b;
+    if (signature !== '8BIM') { // ImageReady ('MeSa') resources use the same ids for other data
+        reader.logMissingFeatures && reader.log(`Unhandled image resource: ${signature} ${id}`);
+        (0, psdReader_1.skipBytes)(reader, left());
+        return;
+    }
+    const savedPaths = (_a = target.savedPaths) !== null && _a !== void 0 ? _a : (target.savedPaths = []);
+    const path = { name: decodeEncodedString(reader, name), paths: [] };
+    (0, additionalInfo_1.readVectorMask)(reader, path, width, height, left());
+    (0, psdReader_1.skipBytes)(reader, left());
+    const keyDescriptorList = (_b = target.savedPathsOrigination) === null || _b === void 0 ? void 0 : _b[savedPaths.length];
+    if (keyDescriptorList)
+        path.vectorOrigination = { keyDescriptorList };
+    savedPaths.push(path);
+}, (writer, target, index, { width, height }) => {
+    (0, additionalInfo_1.writeVectorMask)(writer, target.savedPaths[index], width, height);
+}, { keyCount: MAX_SAVED_PATHS, name: (target, index) => toShortAsciiString(target.savedPaths[index].name) });
+addHandler(3000, // Origin path info (origination data of saved paths)
+// Origin path info (origination data of saved paths)
+target => { var _a; return !!((_a = target.savedPaths) === null || _a === void 0 ? void 0 : _a.some(path => path.vectorOrigination)); }, (reader, target, left) => {
+    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+    desc.keyRootDescriptorList.forEach((item, i) => {
+        var _a, _b;
+        const keyDescriptorList = (0, additionalInfo_1.parseKeyDescriptorList)(item);
+        if (!keyDescriptorList.length)
+            return; // written for paths without origination data
+        const path = (_a = target.savedPaths) === null || _a === void 0 ? void 0 : _a[i];
+        if (path) {
+            path.vectorOrigination = { keyDescriptorList };
+        }
+        else { // saved paths are stored after this resource
+            ((_b = target.savedPathsOrigination) !== null && _b !== void 0 ? _b : (target.savedPathsOrigination = []))[i] = keyDescriptorList;
+        }
+    });
+    (0, psdReader_1.skipBytes)(reader, left());
+}, (writer, target) => {
+    const desc = {
+        keyRootDescriptorList: target.savedPaths.slice(0, MAX_SAVED_PATHS)
+            .map(path => { var _a, _b; return (0, additionalInfo_1.serializeKeyDescriptorList)((_b = (_a = path.vectorOrigination) === null || _a === void 0 ? void 0 : _a.keyDescriptorList) !== null && _b !== void 0 ? _b : []); }),
+    };
+    (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
+}, { name: () => 'OriginDataIRB' });
+addHandler(2999, // Clipping path
+// Clipping path
+target => target.clippingPath !== undefined, (reader, target, left) => {
+    const name = readEncodedString(reader);
+    const flatness = (0, psdReader_1.readFixedPoint32)(reader);
+    (0, psdReader_1.skipBytes)(reader, left()); // fill rule (ignored by Photoshop)
+    target.clippingPath = { name, flatness };
 }, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir1025);
+    writeEncodedString(writer, target.clippingPath.name);
+    (0, psdWriter_1.writeFixedPoint32)(writer, target.clippingPath.flatness);
+    (0, psdWriter_1.writeUint16)(writer, 1); // fill rule (ignored by Photoshop)
 });
 const FrmD = (0, helpers_1.createEnum)('FrmD', 'auto', {
     auto: 'Auto',
     none: 'None',
     dispose: 'Disp',
 });
-addHandler(4000, // Plug-In resource(s)
-// Plug-In resource(s)
-target => target.animations !== undefined, (reader, target, left) => {
+// plug-in resources are written with consecutive ids starting at 4000, in the same order as Photoshop writes them
+function pluginResourceKeys(target) {
+    const keys = [];
+    if (target.outputSettings !== undefined)
+        keys.push('mset');
+    if (target.animations !== undefined)
+        keys.push('mani', 'mfri');
+    return keys;
+}
+addHandler(4000, // Plug-In resource(s), identified by key stored in the data (ids 4000-4999)
+// Plug-In resource(s), identified by key stored in the data (ids 4000-4999)
+target => pluginResourceKeys(target).length, (reader, target, left) => {
     const key = (0, psdReader_1.readSignature)(reader);
-    if (key === 'mani') {
+    if (key === 'mset') {
+        // Save for Web output settings
+        target.outputSettings = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
+        (0, psdReader_1.skipBytes)(reader, left());
+    }
+    else if (key === 'mfri') {
+        // frame count, active frame and animation count, same data as in animations (mani)
+        (0, psdReader_1.skipBytes)(reader, left());
+    }
+    else if (key === 'mani') {
         (0, psdReader_1.checkSignature)(reader, 'IRFR');
         (0, psdReader_1.readSection)(reader, 1, left => {
             while (left() > 0) {
@@ -8631,6 +9335,7 @@ target => target.animations !== undefined, (reader, target, left) => {
                         };
                         // console.log('#4000 AnDs', require('util').inspect(desc, false, 99, true));
                         // console.log('#4000 AnDs:result', require('util').inspect(target.animations, false, 99, true));
+                        (0, psdReader_1.skipBytes)(reader, left()); // padding
                     }
                     else if (key === 'Roll') {
                         const bytes = (0, psdReader_1.readBytes)(reader, left());
@@ -8638,20 +9343,39 @@ target => target.animations !== undefined, (reader, target, left) => {
                     }
                     else {
                         reader.logMissingFeatures && reader.log('Unhandled subsection in #4000', key);
+                        (0, psdReader_1.skipBytes)(reader, left());
                     }
                 });
             }
         });
+        (0, psdReader_1.skipBytes)(reader, left()); // unknown data after animations section
     }
     else if (key === 'mopt') {
         const bytes = (0, psdReader_1.readBytes)(reader, left());
         reader.logDevFeatures && reader.log('#4000 mopt', bytes);
     }
     else {
-        reader.logMissingFeatures && reader.log('Unhandled key in #4000:', key);
+        reader.logMissingFeatures && reader.log(`Unhandled plug-in resource key: ${key}`);
+        (0, psdReader_1.skipBytes)(reader, left());
     }
-}, (writer, target) => {
-    if (target.animations) {
+}, (writer, target, index) => {
+    var _a, _b;
+    const key = pluginResourceKeys(target)[index];
+    if (key === 'mset') {
+        (0, psdWriter_1.writeSignature)(writer, 'mset');
+        (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', target.outputSettings, descriptor_1.outputSettingsRoot);
+    }
+    else if (key === 'mfri') {
+        const animations = target.animations;
+        (0, psdWriter_1.writeSignature)(writer, 'mfri');
+        (0, psdWriter_1.writeUint32)(writer, 2); // version
+        (0, psdWriter_1.writeUint32)(writer, 16); // length
+        (0, psdWriter_1.writeUint32)(writer, animations.frames.length);
+        (0, psdWriter_1.writeUint32)(writer, (_b = (_a = animations.animations[0]) === null || _a === void 0 ? void 0 : _a.activeFrame) !== null && _b !== void 0 ? _b : 0);
+        (0, psdWriter_1.writeUint32)(writer, animations.animations.length);
+        (0, psdWriter_1.writeUint32)(writer, 0);
+    }
+    else if (key === 'mani') {
         (0, psdWriter_1.writeSignature)(writer, 'mani');
         (0, psdWriter_1.writeSignature)(writer, 'IRFR');
         (0, psdWriter_1.writeSection)(writer, 1, () => {
@@ -8693,46 +9417,9 @@ target => target.animations !== undefined, (reader, target, left) => {
             // });
         });
     }
-});
-// TODO: Unfinished
-helpers_1.MOCK_HANDLERS && addHandler(4001, // Plug-In resource(s)
-// Plug-In resource(s)
-target => target._ir4001 !== undefined, (reader, target, left) => {
-    if (helpers_1.MOCK_HANDLERS) {
-        LOG_MOCK_HANDLERS && console.log('image resource 4001', left());
-        target._ir4001 = (0, psdReader_1.readBytes)(reader, left());
-        return;
-    }
-    const key = (0, psdReader_1.readSignature)(reader);
-    if (key === 'mfri') {
-        const version = (0, psdReader_1.readUint32)(reader);
-        if (version !== 2)
-            throw new Error('Invalid mfri version');
-        const length = (0, psdReader_1.readUint32)(reader);
-        const bytes = (0, psdReader_1.readBytes)(reader, length);
-        reader.logDevFeatures && reader.log('mfri', bytes);
-    }
-    else if (key === 'mset') {
-        const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-        reader.logDevFeatures && reader.log('mset', desc);
-    }
-    else {
-        reader.logMissingFeatures && reader.log('Unhandled key in #4001', key);
-    }
-}, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir4001);
-});
-// TODO: Unfinished
-helpers_1.MOCK_HANDLERS && addHandler(4002, // Plug-In resource(s)
-// Plug-In resource(s)
-target => target._ir4002 !== undefined, (reader, target, left) => {
-    LOG_MOCK_HANDLERS && console.log('image resource 4002', left());
-    target._ir4002 = (0, psdReader_1.readBytes)(reader, left());
-}, (writer, target) => {
-    (0, psdWriter_1.writeBytes)(writer, target._ir4002);
-});
+}, { keyCount: 1000 });
 
-},{"./descriptor":4,"./helpers":8,"./psdReader":13,"./psdWriter":14,"./utf8":16,"base64-js":17}],10:[function(require,module,exports){
+},{"./additionalInfo":2,"./descriptor":4,"./helpers":8,"./psdReader":13,"./psdWriter":14,"./utf8":16,"base64-js":17}],10:[function(require,module,exports){
 (function (Buffer){(function (){
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -9458,7 +10145,7 @@ function parse(data) {
                         };
                     }
                 }
-                // TODO APP1 - Exif
+                // APP1 - Exif
                 if (fileMarker === 0xFFE1) {
                     if (appData[0] === 0x45 &&
                         appData[1] === 0x78 &&
@@ -9641,12 +10328,12 @@ function parse(data) {
     // set each frame's components quantization table
     for (let i = 0; i < frames.length; i++) {
         const cp = frames[i].components;
-        for (let j in cp) { // TODO: don't use `in`
-            const table = quantizationTables[cp[j].quantizationIdx];
+        for (const key of Object.keys(cp)) {
+            const component = cp[+key];
+            const table = quantizationTables[component.quantizationIdx];
             if (!table)
-                throw new Error(`Missing quantization table ${cp[j].quantizationIdx}`);
-            cp[j].quantizationTable = table;
-            delete cp[j].quantizationIdx; // TODO: why ???
+                throw new Error(`Missing quantization table ${component.quantizationIdx}`);
+            component.quantizationTable = table;
         }
     }
     self.width = frame.samplesPerLine;
@@ -9701,8 +10388,8 @@ function getData(decoded) {
             break;
         }
         case 3: {
-            // The default transform for three components is true, the adobe transform marker overrides it
-            colorTransform = decoded.adobe ? !!decoded.adobe.transformCode : true;
+            // The default transform for three components is true, JFIF marker implies YCbCr, otherwise the adobe transform marker overrides it
+            colorTransform = decoded.jfif ? true : decoded.adobe ? !!decoded.adobe.transformCode : true;
             const component1 = decoded.components[0];
             const component2 = decoded.components[1];
             const component3 = decoded.components[2];
@@ -9916,6 +10603,10 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.supportedColorModes = void 0;
+exports.getUtf8Decoder = getUtf8Decoder;
+exports.getUtf8StrictDecoder = getUtf8StrictDecoder;
+exports.getGbkStrictDecoder = getGbkStrictDecoder;
+exports.decodeUtf8 = decodeUtf8;
 exports.createReader = createReader;
 exports.warnOrThrow = warnOrThrow;
 exports.readUint8 = readUint8;
@@ -9957,12 +10648,15 @@ exports.readDataZip = readDataZip;
 exports.readDataRLE = readDataRLE;
 exports.readSection = readSection;
 exports.readColor = readColor;
+exports.readPatternSafe = readPatternSafe;
 exports.readPattern = readPattern;
+exports.consumeMemory = consumeMemory;
 const pako_1 = require("pako");
 const helpers_1 = require("./helpers");
 const additionalInfo_1 = require("./additionalInfo");
+const utf8_1 = require("./utf8");
 const imageResources_1 = require("./imageResources");
-exports.supportedColorModes = [0 /* ColorMode.Bitmap */, 1 /* ColorMode.Grayscale */, 3 /* ColorMode.RGB */, 2 /* ColorMode.Indexed */];
+exports.supportedColorModes = [0 /* ColorMode.Bitmap */, 1 /* ColorMode.Grayscale */, 3 /* ColorMode.RGB */, 2 /* ColorMode.Indexed */, 4 /* ColorMode.CMYK */];
 const colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', '', '', 'multichannel', 'duotone', 'lab'];
 function setupGrayscale(data) {
     const size = data.width * data.height * 4;
@@ -9972,6 +10666,37 @@ function setupGrayscale(data) {
         data.data[i + 2] = c;
     }
 }
+function createTextDecoder(label, options) {
+    try {
+        return typeof TextDecoder !== 'undefined' ? new TextDecoder(label, options) : null;
+    }
+    catch (_a) {
+        return null; // encoding not supported
+    }
+}
+// non-fatal UTF-8 decoder, malformed byte sequences are replaced with U+FFFD
+function getUtf8Decoder(reader) {
+    if (reader.utf8Decoder === undefined)
+        reader.utf8Decoder = createTextDecoder('utf-8', { ignoreBOM: true });
+    return reader.utf8Decoder;
+}
+// UTF-8 decoder that throws on malformed byte sequences
+function getUtf8StrictDecoder(reader) {
+    if (reader.utf8StrictDecoder === undefined)
+        reader.utf8StrictDecoder = createTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+    return reader.utf8StrictDecoder;
+}
+// GBK decoder that throws on malformed byte sequences
+function getGbkStrictDecoder(reader) {
+    if (reader.gbkDecoder === undefined)
+        reader.gbkDecoder = createTextDecoder('gbk', { fatal: true });
+    return reader.gbkDecoder;
+}
+function decodeUtf8(reader, buffer) {
+    // native decoder is faster only for longer strings
+    const decoder = buffer.byteLength > 1000 ? getUtf8Decoder(reader) : null;
+    return decoder ? decoder.decode(buffer) : (0, utf8_1.decodeString)(buffer);
+}
 function createReader(buffer, offset, length) {
     const view = new DataView(buffer, offset, length);
     return { view, offset: 0, strict: false, debug: false, large: false, globalAlpha: false, log: console.log };
@@ -10151,7 +10876,8 @@ function readPsd(reader, readOptions = {}) {
     const maxSize = version === 1 ? 30000 : 300000;
     if (width > maxSize || height > maxSize)
         throw new Error(`Invalid size: ${width}x${height}`);
-    if (channels < 1 || channels > 56)
+    // up to 56 channels plus transparency of composite image (Photoshop CS3 writes 57 channels for 53 alpha channels)
+    if (channels < 1 || channels > 57)
         throw new Error(`Invalid channel count: ${channels}`);
     if (![1, 8, 16, 32].includes(bitsPerChannel))
         throw new Error(`Invalid bitsPerChannel: ${bitsPerChannel}`);
@@ -10161,6 +10887,7 @@ function readPsd(reader, readOptions = {}) {
     Object.assign(reader, readOptions);
     reader.large = version === 2;
     reader.globalAlpha = false;
+    reader.layersInGlobalInfo = false;
     if (!('totalMemoryLimit' in reader)) { // setting totalMemoryLimit to undefined explicitly disables memory limit
         reader.totalMemoryLimit = 2 * 1024 * 1024 * 1024; // default 2GB memory limit
     }
@@ -10188,17 +10915,21 @@ function readPsd(reader, readOptions = {}) {
     });
     // image resources
     const imageResources = {};
+    let unreadResourceBytes = 0;
     readSection(reader, 1, left => {
-        while (left() > 0) {
-            realignWithSignature(reader, isValidSignature);
+        // stop if there's not enough data left for resource header (some files have few trailing bytes in this section)
+        while (left() >= 12) {
+            const signature = realignWithSignature(reader, isValidSignature);
             const id = readUint16(reader);
-            readPascalString(reader, 2); // name
+            const nameLength = readUint8(reader);
+            const name = readBytes(reader, nameLength);
+            skipBytes(reader, (nameLength + 1) % 2); // pad to even size
             readSection(reader, 2, left => {
                 const handler = imageResources_1.resourceHandlersMap[id];
                 const skip = id === 1036 && !!reader.skipThumbnail;
                 if (handler && !skip) {
                     try {
-                        handler.read(reader, imageResources, left);
+                        handler.read(reader, imageResources, left, { signature, id, name, width, height });
                     }
                     catch (e) {
                         if (reader.throwForMissingFeatures)
@@ -10207,13 +10938,20 @@ function readPsd(reader, readOptions = {}) {
                     }
                 }
                 else {
-                    // options.logMissingFeatures && console.log(`Unhandled image resource: ${id} (${left()})`);
+                    reader.logMissingFeatures && reader.log(`Unhandled image resource: ${id} (${left()})`);
                     skipBytes(reader, left());
                 }
             });
         }
+        unreadResourceBytes = left();
+        skipBytes(reader, left());
     });
-    const { layersGroup, layerGroupsEnabledId } = imageResources, rest = __rest(imageResources, ["layersGroup", "layerGroupsEnabledId"]);
+    // some files have image resources section length few bytes larger than the data, layer and mask info section
+    // starts right after the last resource in that case
+    if (unreadResourceBytes && !sectionFits(reader, reader.offset) && sectionFits(reader, reader.offset - unreadResourceBytes)) {
+        reader.offset -= unreadResourceBytes;
+    }
+    const { layersGroup, layerGroupsEnabledId, savedPathsOrigination } = imageResources, rest = __rest(imageResources, ["layersGroup", "layerGroupsEnabledId", "savedPathsOrigination"]);
     if (Object.keys(rest).length) {
         psd.imageResources = rest;
     }
@@ -10257,6 +10995,8 @@ function readPsd(reader, readOptions = {}) {
             const rawCompositeData = new Uint8Array(reader.view.buffer, reader.view.byteOffset + rawOffset, reader.view.byteLength - rawOffset);
             psd.rawCompositeData = rawCompositeData;
             psd.rawCompositeDataInfo = { large: reader.large, globalAlpha: reader.globalAlpha };
+            if (reader.layersInGlobalInfo)
+                psd.rawCompositeDataInfo.layersInGlobalInfo = true;
         }
         else {
             const imageData = readImageData(reader, psd);
@@ -10268,9 +11008,6 @@ function readPsd(reader, readOptions = {}) {
             }
         }
     }
-    // TODO: show converted color mode instead of original PSD file color mode
-    //       but add option to preserve file color mode (need to return image data instead of canvas in that case)
-    // psd.colorMode = ColorMode.RGB; // we convert all color modes to RGB
     return psd;
 }
 function readLayerInfo(reader, psd, imageResources) {
@@ -10346,9 +11083,12 @@ function readLayerRecord(reader, psd, imageResources) {
     }
     checkSignature(reader, '8BIM');
     const blendMode = readSignature(reader);
-    if (!helpers_1.toBlendMode[blendMode])
-        throw new Error(`Invalid blend mode: '${blendMode}'`);
-    layer.blendMode = helpers_1.toBlendMode[blendMode];
+    if (!helpers_1.toBlendMode[blendMode]) {
+        if (reader.throwForMissingFeatures)
+            throw new Error(`Invalid blend mode: '${blendMode}'`);
+        reader.logMissingFeatures && reader.log(`Unknown blend mode: '${blendMode}', using normal blend mode`);
+    }
+    layer.blendMode = helpers_1.toBlendMode[blendMode] || 'normal';
     layer.opacity = readUint8(reader) / 0xff;
     layer.clipping = readUint8(reader) === 1;
     const flags = readUint8(reader);
@@ -10376,11 +11116,20 @@ function readLayerRecord(reader, psd, imageResources) {
     });
     return { layer, channels };
 }
+// negative sizes are treated as empty (Photoshop writes them for some empty layers, like 0,0,-1,0 bounds of fill layer)
+// checks if length of section (layer and mask info) at given offset fits in the file
+function sectionFits(reader, offset) {
+    const lengthSize = reader.large ? 8 : 4;
+    if (offset < 0 || offset + lengthSize > reader.view.byteLength)
+        return false;
+    const length = reader.large ? reader.view.getUint32(offset) * 0x100000000 + reader.view.getUint32(offset + 4) : reader.view.getUint32(offset);
+    return offset + lengthSize + length <= reader.view.byteLength;
+}
 function isValidBoxSize(box, reader) {
     const width = (box.right || 0) - (box.left || 0);
     const height = (box.bottom || 0) - (box.top || 0);
     const maxSize = reader.large ? 300000 : 30000;
-    return width >= 0 && height >= 0 && width <= maxSize && height <= maxSize;
+    return width <= maxSize && height <= maxSize;
 }
 function readLayerMaskData(reader, layer) {
     return readSection(reader, 1, left => {
@@ -10499,9 +11248,9 @@ function readLayerChannelImageData(reader, psd, layer, channels) {
                 reader.offset -= 1;
                 compression = readUint16(reader);
             }
-            // try to fix broken files where there's 1 byte shift of channel
+            // try to fix broken files where there's 1 byte shift of channel (in the other direction)
             if (compression > 3) {
-                reader.offset -= 3;
+                reader.offset -= 4;
                 compression = readUint16(reader);
             }
             if (compression > 3)
@@ -10535,6 +11284,7 @@ function getCompositeImageData(psd) {
     if (info) {
         reader.large = info.large;
         reader.globalAlpha = info.globalAlpha;
+        reader.layersInGlobalInfo = !!info.layersInGlobalInfo;
     }
     return readImageData(reader, psd);
 }
@@ -10615,18 +11365,14 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit, log
     let initializedAlpha = false;
     if (layerWidth && layerHeight && read === LayerDataType.Layer) {
         if (cmyk) {
-            if (bitsPerChannel !== 8)
+            if (bitsPerChannel !== 8 && bitsPerChannel !== 16)
                 throw new Error('bitsPerChannel not supported');
-            imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) };
+            imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel, 5, memoryLimit);
         }
         else {
             imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel, 4, memoryLimit);
         }
     }
-    if (helpers_1.RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-        layer.imageDataRaw = [];
-        layer.imageDataRawCompression = [];
-    }
     for (const { id, compression, data } of channels) {
         if (!data)
             continue;
@@ -10651,16 +11397,6 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit, log
                 if (memoryLimit !== undefined)
                     dataReader.totalMemoryLimit = Math.max(0, dataReader.totalMemoryLimit - maskData.data.byteLength);
                 readData(dataReader, data.byteLength, maskData, compression, maskWidth, maskHeight, bitsPerChannel, 0, large, 4);
-                if (helpers_1.RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-                    if (id === -2 /* ChannelID.UserMask */) {
-                        layer.maskDataRawCompression = compression;
-                        layer.maskDataRaw = data;
-                    }
-                    else {
-                        layer.realMaskDataRawCompression = compression;
-                        layer.realMaskDataRaw = data;
-                    }
-                }
                 setupGrayscale(maskData);
                 resetAlpha(maskData, false);
             }
@@ -10677,10 +11413,6 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit, log
                 }
             }
             readData(dataReader, data.byteLength, targetData, compression, layerWidth, layerHeight, bitsPerChannel, offset, large, cmyk ? 5 : 4);
-            if (helpers_1.RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-                layer.imageDataRawCompression[id] = compression;
-                layer.imageDataRaw[id] = data;
-            }
         }
         if (id === -1 /* ChannelID.Transparency */) {
             initializedAlpha = true;
@@ -10693,7 +11425,8 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit, log
             resetAlpha(imageData, cmyk);
         if (cmyk) {
             const cmykData = imageData;
-            imageData = (0, helpers_1.createImageData)(cmykData.width, cmykData.height);
+            const rgbMemoryLimit = memoryLimit === undefined ? undefined : Math.max(0, memoryLimit - cmykData.data.byteLength);
+            imageData = createImageDataBitDepth(cmykData.width, cmykData.height, bitsPerChannel, 4, rgbMemoryLimit);
             cmykToRgb(cmykData, imageData, false);
         }
     }
@@ -10766,7 +11499,15 @@ function readAdditionalLayerInfo(reader, target, psd, imageResources) {
     const sig = realignWithSignature(reader, isValidAdditionalInfoSignature);
     const key = readSignature(reader);
     // `largeAdditionalInfoKeys` fallback, because some keys don't have 8B64 signature even when they are 64bit
-    const u64 = sig === '8B64' || (reader.large && helpers_1.largeAdditionalInfoKeys.indexOf(key) !== -1);
+    let u64 = sig === '8B64' || (reader.large && helpers_1.largeAdditionalInfoKeys.indexOf(key) !== -1);
+    // these keys were written by older versions of this library with 32bit length and 8BIM signature,
+    // 64bit length always has high 32bits set to 0 (lengths over 4GB are not supported)
+    if (reader.large && sig === '8BIM' && helpers_1.largeAdditionalInfoKeysObserved.indexOf(key) !== -1) {
+        // 32bit length of 0 is followed by signature of the next block, 64bit length would continue with its low 32bits
+        const next = reader.offset + 8 <= reader.view.byteLength ? reader.view.getUint32(reader.offset + 4) : 0;
+        const nextIsSignature = next === 0x3842494d /* 8BIM */ || next === 0x38423634 /* 8B64 */;
+        u64 = reader.view.getUint32(reader.offset) === 0 && !nextIsSignature;
+    }
     readSection(reader, 2, left => {
         const handler = additionalInfo_1.infoHandlersMap[key];
         if (handler) {
@@ -10779,7 +11520,7 @@ function readAdditionalLayerInfo(reader, target, psd, imageResources) {
             }
         }
         else {
-            reader.logMissingFeatures && reader.log(`Unhandled additional info: ${key}`);
+            reader.logMissingFeatures && key !== 'GenI' && key !== 'OCIO' && key !== 'CAI ' && reader.log(`Unhandled additional info: ${key}`);
             skipBytes(reader, left());
         }
         if (left()) {
@@ -10811,7 +11552,7 @@ function createImageDataBitDepth(width, height, bitDepth, channels, memoryLimit)
     }
 }
 function readImageData(reader, psd) {
-    var _a;
+    var _a, _b, _c;
     const compression = readUint16(reader);
     const bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
     const { width, height } = psd;
@@ -10843,11 +11584,7 @@ function readImageData(reader, psd) {
         case 1 /* ColorMode.Grayscale */: {
             const colorChannels = psd.colorMode === 1 /* ColorMode.Grayscale */ ? 1 : 3;
             const offsets = compositeChannelOffsets(reader, psd, colorChannels, 3);
-            const start = reader.offset;
             readCompositeChannels(reader, compression, imageData, bitsPerChannel, 4, offsets);
-            if (helpers_1.RAW_IMAGE_DATA && compression === 1 /* Compression.RleCompressed */) {
-                psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
-            }
             if (psd.colorMode === 1 /* ColorMode.Grayscale */) {
                 setupGrayscale(imageData);
             }
@@ -10861,41 +11598,42 @@ function readImageData(reader, psd) {
             const offsets = compositeChannelOffsets(reader, psd, 1, -1);
             const indexedImageData = { width, height, data: new Uint8Array(width * height) };
             readCompositeChannels(reader, compression, indexedImageData, 8, 1, offsets);
-            indexedToRgb(indexedImageData, imageData, psd.palette);
+            indexedToRgb(indexedImageData, imageData, psd.palette, (_c = (_b = psd.imageResources) === null || _b === void 0 ? void 0 : _b.transparencyIndex) !== null && _c !== void 0 ? _c : -1);
             break;
         }
         case 4 /* ColorMode.CMYK */: {
-            if (bitsPerChannel !== 8)
+            if (bitsPerChannel !== 8 && bitsPerChannel !== 16)
                 throw new Error('bitsPerChannel not supported');
             const offsets = compositeChannelOffsets(reader, psd, 4, 4);
-            const cmykImageData = { width, height, data: new Uint8Array(width * height * 5) };
-            const start = reader.offset;
-            readCompositeChannels(reader, compression, cmykImageData, 8, 5, offsets);
-            cmykToRgb(cmykImageData, imageData, true);
-            if (helpers_1.RAW_IMAGE_DATA && compression === 1 /* Compression.RleCompressed */) {
-                psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
-            }
+            const cmykImageData = createImageDataBitDepth(width, height, bitsPerChannel, 5, reader.totalMemoryLimit);
+            resetAlpha(cmykImageData, true);
+            readCompositeChannels(reader, compression, cmykImageData, bitsPerChannel, 5, offsets);
+            cmykToRgb(cmykImageData, imageData, !!reader.globalAlpha);
             break;
         }
         default: throw new Error(`Color mode not supported: ${psd.colorMode}`);
     }
-    // remove weird white matte
-    if (reader.globalAlpha) {
+    // remove weird white matte (already removed when converting from CMYK)
+    if (reader.globalAlpha && psd.colorMode !== 4 /* ColorMode.CMYK */) {
         removeWhiteMatte(imageData);
     }
     return imageData;
 }
 // returns target offset for each of the composite image channels stored in the file, -1 for channels that are skipped
 function compositeChannelOffsets(reader, psd, colorChannels, alphaOffset) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     const channelCount = (_a = psd.channels) !== null && _a !== void 0 ? _a : (colorChannels + (reader.globalAlpha ? 1 : 0));
     if (channelCount < colorChannels)
         throw new Error(`Invalid channel count: ${channelCount}`);
     // First extra channel is transparency if document has global alpha (negative layer count). Some non-Photoshop
     // applications write transparency channel without setting global alpha, in that case extra channel is not
     // listed in alpha channel names (Photoshop names all user alpha channels / saved selections).
-    const namedChannels = (_d = (_c = (_b = psd.imageResources) === null || _b === void 0 ? void 0 : _b.alphaChannelNames) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
-    const hasTransparency = reader.globalAlpha || (channelCount - colorChannels) > namedChannels;
+    // Photoshop also lists merged transparency as first alpha channel named "Transparency" (in documents marked with
+    // Mtrn/Mt16/Mt32 additional info, or in some 16bit documents with layers stored in Lr16 without any other mark)
+    const alphaNames = (_c = (_b = psd.imageResources) === null || _b === void 0 ? void 0 : _b.alphaChannelNames) !== null && _c !== void 0 ? _c : [];
+    const namedChannels = alphaNames.length;
+    const namedTransparency = !!reader.layersInGlobalInfo && alphaNames[0] === 'Transparency' && namedChannels === channelCount - colorChannels;
+    const hasTransparency = reader.globalAlpha || namedTransparency || (channelCount - colorChannels) > namedChannels;
     const offsets = [];
     for (let i = 0; i < channelCount; i++) {
         if (i < colorChannels) {
@@ -10974,41 +11712,67 @@ function removeWhiteMatte({ data, width, height }) {
         }
     }
 }
-function cmykToRgb(cmyk, rgb, reverseAlpha) {
+// converts value in 0-255 range to target range, rounding and clamping it
+function toRange(value, max) {
+    value = Math.round(value * (max / 255));
+    return value <= 0 ? 0 : (value >= max ? max : value);
+}
+// Polynomial approximation of U.S. Web Coated (SWOP) v2 CMYK to RGB conversion (default CMYK profile of Photoshop).
+// Coefficients are taken from pdf.js (DeviceCmykCS in src/core/colorspace.js, https://github.com/mozilla/pdf.js),
+// Copyright 2012 Mozilla Foundation, licensed under the Apache License, Version 2.0
+// (http://www.apache.org/licenses/LICENSE-2.0)
+// cmyk - 8 or 16 bit data with 5 channels (cmyka), rgb - 8 or 16 bit data with 4 channels (rgba)
+// removeMatte - colors are blended with white (no ink), used for composite image of documents with global alpha
+function cmykToRgb(cmyk, rgb, removeMatte) {
     const size = rgb.width * rgb.height * 4;
     const srcData = cmyk.data;
     const dstData = rgb.data;
+    const srcMax = srcData instanceof Uint16Array ? 0xffff : 0xff;
+    const dstMax = dstData instanceof Uint16Array ? 0xffff : 0xff;
     for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
-        const c = srcData[src];
-        const m = srcData[src + 1];
-        const y = srcData[src + 2];
-        const k = srcData[src + 3];
-        dstData[dst] = ((((c * k) | 0) / 255) | 0);
-        dstData[dst + 1] = ((((m * k) | 0) / 255) | 0);
-        dstData[dst + 2] = ((((y * k) | 0) / 255) | 0);
-        dstData[dst + 3] = reverseAlpha ? 255 - srcData[src + 4] : srcData[src + 4];
-    }
-    // for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
-    // 	const c = 1 - (srcData[src + 0] / 255);
-    // 	const m = 1 - (srcData[src + 1] / 255);
-    // 	const y = 1 - (srcData[src + 2] / 255);
-    // 	// const k = srcData[src + 3] / 255;
-    // 	dstData[dst + 0] = ((1 - c * 0.8) * 255) | 0;
-    // 	dstData[dst + 1] = ((1 - m * 0.8) * 255) | 0;
-    // 	dstData[dst + 2] = ((1 - y * 0.8) * 255) | 0;
-    // 	dstData[dst + 3] = reverseAlpha ? 255 - srcData[src + 4] : srcData[src + 4];
-    // }
-}
-function indexedToRgb(indexed, rgb, palette) {
+        const a = srcData[src + 4];
+        // image data stores inverted values (0 = 100% ink)
+        let c = 1 - srcData[src] / srcMax;
+        let m = 1 - srcData[src + 1] / srcMax;
+        let y = 1 - srcData[src + 2] / srcMax;
+        let k = 1 - srcData[src + 3] / srcMax;
+        if (removeMatte && a > 0 && a < srcMax) {
+            const ra = srcMax / a;
+            c = Math.min(1, c * ra);
+            m = Math.min(1, m * ra);
+            y = Math.min(1, y * ra);
+            k = Math.min(1, k * ra);
+        }
+        dstData[dst] = toRange(255 +
+            c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k - 285.2331026137004) +
+            m * (1.7149763477362134 * m - 5.6096736904047315 * y - 17.873870861415444 * k - 5.497006427196366) +
+            y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) +
+            k * (-21.86122147463605 * k - 189.48180835922747), dstMax);
+        dstData[dst + 1] = toRange(255 +
+            c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k - 79.2970844816548) +
+            m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) +
+            y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) +
+            k * (-20.737325471181034 * k - 187.80453709719578), dstMax);
+        dstData[dst + 2] = toRange(255 +
+            c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k - 14.183576799673286) +
+            m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) +
+            y * (0.03296041114873217 * y + 115.60384449646641 * k - 193.58209356861505) +
+            k * (-22.33816807309886 * k - 180.12613974708367), dstMax);
+        dstData[dst + 3] = srcMax === dstMax ? a : Math.round(a * dstMax / srcMax);
+    }
+}
+// transparencyIndex - palette index of transparent color (-1 if there's none)
+function indexedToRgb(indexed, rgb, palette, transparencyIndex) {
     const size = indexed.width * indexed.height;
     const srcData = indexed.data;
     const dstData = rgb.data;
     for (let src = 0, dst = 0; src < size; src++, dst += 4) {
-        const c = palette[srcData[src]];
+        const index = srcData[src];
+        const c = palette[index];
         dstData[dst + 0] = c.r;
         dstData[dst + 1] = c.g;
         dstData[dst + 2] = c.b;
-        dstData[dst + 3] = 255;
+        dstData[dst + 3] = index === transparencyIndex ? 0 : 255;
     }
 }
 // number of bytes used to store single channel value, 1-bit data is handled as bytes
@@ -11319,11 +12083,11 @@ function readColor(reader) {
             skipBytes(reader, 2);
             return { h, s, b };
         }
-        case 2 /* ColorSpace.CMYK */: {
-            const c = readUint16(reader) / 257;
-            const m = readUint16(reader) / 257;
-            const y = readUint16(reader) / 257;
-            const k = readUint16(reader) / 257;
+        case 2 /* ColorSpace.CMYK */: { // 0 = 100% ink
+            const c = (0xffff - readUint16(reader)) / 257;
+            const m = (0xffff - readUint16(reader)) / 257;
+            const y = (0xffff - readUint16(reader)) / 257;
+            const k = (0xffff - readUint16(reader)) / 257;
             return { c, m, y, k };
         }
         case 7 /* ColorSpace.Lab */: {
@@ -11344,6 +12108,24 @@ function readColor(reader) {
             throw new Error('Invalid color space');
     }
 }
+const MAX_PATTERN_SIZE = 30000;
+// reads pattern, unsupported or invalid patterns are skipped (returns undefined) unless throwForMissingFeatures is set
+function readPatternSafe(reader) {
+    let length = reader.view.getUint32(reader.offset);
+    while (length % 4)
+        length++;
+    const end = reader.offset + 4 + length;
+    try {
+        return readPattern(reader);
+    }
+    catch (e) {
+        if (reader.throwForMissingFeatures)
+            throw e;
+        reader.logMissingFeatures && reader.log(`Skipped pattern: ${e.message}`);
+        reader.offset = end;
+        return undefined;
+    }
+}
 function readPattern(reader) {
     let length = readUint32(reader);
     while (length % 4)
@@ -11355,8 +12137,8 @@ function readPattern(reader) {
     const colorMode = readUint32(reader);
     const x = readInt16(reader);
     const y = readInt16(reader);
-    // we only support RGB and grayscale for now
-    if (colorMode !== 3 /* ColorMode.RGB */ && colorMode !== 1 /* ColorMode.Grayscale */ && colorMode !== 2 /* ColorMode.Indexed */) {
+    // we only support RGB, grayscale, indexed and CMYK for now
+    if (colorMode !== 3 /* ColorMode.RGB */ && colorMode !== 1 /* ColorMode.Grayscale */ && colorMode !== 2 /* ColorMode.Indexed */ && colorMode !== 4 /* ColorMode.CMYK */) {
         throw new Error(`Unsupported pattern color mode: ${colorMode}`);
     }
     let name = readUnicodeString(reader);
@@ -11370,7 +12152,9 @@ function readPattern(reader) {
                 b: readUint8(reader),
             });
         }
-        skipBytes(reader, 4); // no idea what this is
+        // some writers follow the palette with 4 extra bytes (unknown)
+        if (reader.view.getUint32(reader.offset) !== 3)
+            skipBytes(reader, 4);
     }
     // virtual memory array list
     const version2 = readUint32(reader);
@@ -11384,17 +12168,37 @@ function readPattern(reader) {
     const channelsCount = readUint32(reader);
     const width = right - left;
     const height = bottom - top;
+    if (width < 0 || height < 0)
+        throw new Error('Invalid pattern bounds');
+    if (width > MAX_PATTERN_SIZE || height > MAX_PATTERN_SIZE)
+        throw new Error(`Pattern too large (${width}x${height})`);
+    if (channelsCount > 64)
+        throw new Error(`Invalid pattern channel count: ${channelsCount}`);
+    // channels cover whole pattern, each 2 bytes of RLE data can produce at most 128 bytes
+    if (width * height > (Math.min(end, reader.view.byteLength) - reader.offset) * 64)
+        throw new Error('Pattern data out of bounds');
     const size = width * height * 4;
     consumeMemory(reader, size);
     const data = new Uint8Array(size);
     for (let i = 3; i < data.byteLength; i += 4) {
         data[i] = 255;
     }
-    for (let i = 0, ch = 0; i < (channelsCount + 2); i++) {
+    // first written arrays are color channels, next one is transparency (Photoshop stores it in the last, sheet mask, array)
+    const colorChannels = colorMode === 3 /* ColorMode.RGB */ ? 3 : (colorMode === 4 /* ColorMode.CMYK */ ? 4 : 1);
+    // CMYK channels are decoded into separate buffer (5 values per pixel, inverted, 0 = 100% ink) and converted to RGB at the end
+    const cmyk = colorMode === 4 /* ColorMode.CMYK */ ? new Uint8Array(width * height * 5).fill(255) : undefined;
+    if (cmyk)
+        consumeMemory(reader, cmyk.byteLength);
+    const alphaTarget = cmyk ? 4 : 3;
+    for (let i = 0, ch = 0; i < (channelsCount + 2) && reader.offset + 4 <= end; i++) {
         const has = readUint32(reader);
         if (!has)
             continue;
         const length = readUint32(reader);
+        if (!length)
+            continue;
+        if (length < 23)
+            throw new Error('Invalid pattern channel length');
         const pixelDepth = readUint32(reader);
         const ctop = readUint32(reader);
         const cleft = readUint32(reader);
@@ -11402,97 +12206,92 @@ function readPattern(reader) {
         const cright = readUint32(reader);
         const pixelDepth2 = readUint16(reader);
         const compressionMode = readUint8(reader); // 0 - raw, 1 - rle
-        const dataLength = length - (4 + 16 + 2 + 1);
-        const cdata = readBytes(reader, dataLength);
-        if (pixelDepth !== 8 || pixelDepth2 !== 8) {
-            throw new Error('16bit pixel depth not supported for patterns');
-        }
+        const cdata = readBytes(reader, length - 23);
+        const depth = (pixelDepth2 === 8 || pixelDepth2 === 16 || pixelDepth2 === 32) ? pixelDepth2 : pixelDepth;
+        if (depth !== 8 && depth !== 16 && depth !== 32)
+            throw new Error(`Unsupported pattern pixel depth: ${depth}`);
+        if (ctop < top || cleft < left || cbottom > bottom || cright > right || cbottom < ctop || cright < cleft) {
+            throw new Error('Pattern channel bounds outside of pattern bounds');
+        }
+        const target = ch < colorChannels ? ch : (ch === colorChannels ? alphaTarget : -1);
+        ch++;
+        if (target === -1)
+            continue;
         const w = cright - cleft;
         const h = cbottom - ctop;
-        const ox = cleft - left;
-        const oy = ctop - top;
+        const rowBytes = w * (depth / 8);
+        const channelSize = rowBytes * h;
+        let bytes;
         if (compressionMode === 0) {
-            if (colorMode === 3 /* ColorMode.RGB */ && ch < 3) {
-                for (let y = 0; y < h; y++) {
-                    for (let x = 0; x < w; x++) {
-                        const src = x + y * w;
-                        const dst = (ox + x + (y + oy) * width) * 4;
-                        data[dst + ch] = cdata[src];
-                    }
-                }
-            }
-            else if (colorMode === 1 /* ColorMode.Grayscale */ && ch < 1) {
-                for (let y = 0; y < h; y++) {
-                    for (let x = 0; x < w; x++) {
-                        const src = x + y * w;
-                        const dst = (ox + x + (y + oy) * width) * 4;
-                        const value = cdata[src];
-                        data[dst + 0] = value;
-                        data[dst + 1] = value;
-                        data[dst + 2] = value;
-                    }
-                }
-            }
-            else if (colorMode === 2 /* ColorMode.Indexed */) {
-                for (let y = 0; y < h; y++) {
-                    for (let x = 0; x < w; x++) {
-                        const src = x + y * w;
-                        const dst = (ox + x + (y + oy) * width) * 4;
-                        const index = cdata[src];
-                        const color = palette[index];
-                        data[dst + 0] = color.r;
-                        data[dst + 1] = color.g;
-                        data[dst + 2] = color.b;
-                    }
-                }
-            }
-            else {
-                if (reader.throwForMissingFeatures)
-                    throw new Error('Invalid color pattern');
-            }
+            if (cdata.byteLength < channelSize)
+                throw new Error('Pattern channel data out of bounds');
+            bytes = cdata;
         }
         else if (compressionMode === 1) {
-            consumeMemory(reader, w * h);
-            const pixelData = { data, width, height };
-            const tempData = { data: new Uint8Array(w * h), width: w, height: h };
+            // each 2 bytes of RLE data can produce at most 128 bytes
+            if (channelSize > cdata.byteLength * 64)
+                throw new Error('Pattern channel data out of bounds');
+            consumeMemory(reader, channelSize);
+            bytes = new Uint8Array(channelSize);
             const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
-            if (colorMode === 3 /* ColorMode.RGB */ && ch < 3) {
-                readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
-                copyChannelToRGBA(tempData, pixelData, ox, oy, ch);
-            }
-            if (colorMode === 1 /* ColorMode.Grayscale */ && ch < 1) {
-                readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
-                copyChannelToRGBA(tempData, pixelData, ox, oy, 0);
-                setupGrayscale(pixelData);
-            }
-            if (colorMode === 2 /* ColorMode.Indexed */) {
-                // TODO:
-                throw new Error('Indexed pattern color mode not implemented');
-            }
-            recoverMemory(reader, w * h);
+            readDataRLE(cdataReader, { data: bytes, width: rowBytes, height: h }, rowBytes, h, 8, 1, [0], false);
         }
         else {
             throw new Error('Invalid pattern compression mode');
         }
-        ch++;
+        const ox = cleft - left;
+        const oy = ctop - top;
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                const src = x + y * w;
+                const dst = (ox + x + (y + oy) * width) * 4;
+                const value = depth === 8 ? bytes[src] : patternValueTo8bit(bytes, src, depth);
+                if (cmyk) {
+                    cmyk[(ox + x + (y + oy) * width) * 5 + target] = value;
+                }
+                else if (target === 3) {
+                    data[dst + 3] = value;
+                }
+                else if (colorMode === 2 /* ColorMode.Indexed */) {
+                    const color = palette[value];
+                    data[dst + 0] = color.r;
+                    data[dst + 1] = color.g;
+                    data[dst + 2] = color.b;
+                }
+                else if (colorMode === 1 /* ColorMode.Grayscale */) {
+                    data[dst + 0] = value;
+                    data[dst + 1] = value;
+                    data[dst + 2] = value;
+                }
+                else {
+                    data[dst + target] = value;
+                }
+            }
+        }
+        if (compressionMode === 1)
+            recoverMemory(reader, channelSize);
+    }
+    if (cmyk) {
+        cmykToRgb({ width, height, data: cmyk }, { width, height, data }, false);
+        recoverMemory(reader, cmyk.byteLength);
     }
     reader.offset = end;
     return { id, name, x, y, bounds: { x: left, y: top, w: width, h: height }, data };
 }
-function copyChannelToRGBA(srcData, dstData, ox, oy, offset) {
-    const w = srcData.width;
-    const h = srcData.height;
-    const width = dstData.width;
-    for (let y = 0; y < h; y++) {
-        for (let x = 0; x < w; x++) {
-            const src = x + y * w;
-            const dst = (ox + x + (y + oy) * width) * 4;
-            const value = srcData.data[src];
-            dstData.data[dst + offset] = value;
-        }
+// converts big-endian 16bit or 32bit (float) value at given index to 8bit value
+function patternValueTo8bit(bytes, index, depth) {
+    if (depth === 16) {
+        return Math.round(((bytes[index * 2] << 8) | bytes[index * 2 + 1]) / 257);
+    }
+    else {
+        const view = new DataView(bytes.buffer, bytes.byteOffset + index * 4, 4);
+        const value = view.getFloat32(0, false);
+        return value > 0 ? (value < 1 ? Math.round(value * 255) : 255) : 0;
     }
 }
 function consumeMemory(reader, size) {
+    if (!(size >= 0))
+        throw new Error('Invalid size');
     if (reader.totalMemoryLimit !== undefined) {
         if (reader.totalMemoryLimit < size)
             throw new Error('Exceeded memory limit');
@@ -11505,7 +12304,7 @@ function recoverMemory(reader, size) {
     }
 }
 
-},{"./additionalInfo":2,"./helpers":8,"./imageResources":9,"pako":20}],14:[function(require,module,exports){
+},{"./additionalInfo":2,"./helpers":8,"./imageResources":9,"./utf8":16,"pako":20}],14:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWriter = createWriter;
@@ -11540,11 +12339,12 @@ exports.writePattern = writePattern;
 const helpers_1 = require("./helpers");
 const additionalInfo_1 = require("./additionalInfo");
 const imageResources_1 = require("./imageResources");
+const psdReader_1 = require("./psdReader");
 function createWriter(size = 4096) {
     const buffer = new ArrayBuffer(size);
     const view = new DataView(buffer);
     const offset = 0;
-    return { buffer, view, offset, tempBuffer: undefined };
+    return { buffer, view, offset, tempBuffer: undefined, log: console.log };
 }
 function getWriterBuffer(writer) {
     return writer.buffer.slice(0, writer.offset);
@@ -11731,6 +12531,8 @@ function writePsd(writer, psd, options = {}) {
     const bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
     if (bitsPerChannel !== 8)
         throw new Error('bitsPerChannel other than 8 are not supported for writing');
+    if (options.log)
+        writer.log = options.log;
     const layers = [];
     addChildren(layers, psd.children);
     if (!layers.length)
@@ -11738,6 +12540,17 @@ function writePsd(writer, psd, options = {}) {
     verifyBitCount(psd);
     const imageResources = Object.assign({}, psd.imageResources);
     const opt = Object.assign(Object.assign({}, options), { layerIds: new Set(), layerToId: new Map() });
+    // document is always written in RGB color mode, skip resources specific to original color mode
+    if (psd.colorMode !== undefined && psd.colorMode !== 3 /* ColorMode.RGB */) {
+        delete imageResources.iccProfile;
+        delete imageResources.indexedColorCount;
+        delete imageResources.transparencyIndex;
+        delete imageResources.alphaChannelDisplayInfo;
+        delete imageResources.colorHalftoneScreens;
+        delete imageResources.grayscaleHalftoneScreens;
+        delete imageResources.colorTransferFunctions;
+        delete imageResources.grayscaleTransferFunctions;
+    }
     if (opt.generateThumbnail) {
         imageResources.thumbnail = createThumbnail(psd);
     }
@@ -11745,6 +12558,9 @@ function writePsd(writer, psd, options = {}) {
     if (!imageData && psd.canvas) {
         imageData = psd.canvas.getContext('2d').getImageData(0, 0, psd.canvas.width, psd.canvas.height);
     }
+    if (!imageData && psd.rawCompositeData) { // read with `useRawData` option
+        imageData = (0, psdReader_1.getCompositeImageData)(psd);
+    }
     if (imageData && (psd.width !== imageData.width || psd.height !== imageData.height))
         throw new Error('Document canvas must have the same size as document');
     const globalAlpha = !!imageData && (0, helpers_1.hasAlpha)(imageData);
@@ -11759,19 +12575,8 @@ function writePsd(writer, psd, options = {}) {
     writeUint32(writer, psd.width);
     writeUint16(writer, bitsPerChannel); // bits per channel
     writeUint16(writer, 3 /* ColorMode.RGB */); // we only support saving RGB right now
-    // color mode data
-    writeSection(writer, 1, () => {
-        var _a, _b, _c;
-        if (psd.palette) {
-            for (let i = 0; i < 256; i++)
-                writeUint8(writer, ((_a = psd.palette[i]) === null || _a === void 0 ? void 0 : _a.r) || 0);
-            for (let i = 0; i < 256; i++)
-                writeUint8(writer, ((_b = psd.palette[i]) === null || _b === void 0 ? void 0 : _b.g) || 0);
-            for (let i = 0; i < 256; i++)
-                writeUint8(writer, ((_c = psd.palette[i]) === null || _c === void 0 ? void 0 : _c.b) || 0);
-        }
-        // TODO: other data?
-    });
+    // color mode data (empty for RGB color mode)
+    writeUint32(writer, 0);
     // image resources
     imageResources.layersGroup = layers.map(l => l.linkGroup || 0);
     imageResources.layerGroupsEnabledId = layers.map(l => l.linkGroupEnabled == false ? 0 : 1);
@@ -11780,10 +12585,12 @@ function writePsd(writer, psd, options = {}) {
             const has = handler.has(imageResources);
             const count = has === false ? 0 : (has === true ? 1 : has);
             for (let i = 0; i < count; i++) {
+                const id = handler.keyCount > 1 ? handler.key + i : handler.key;
+                const name = handler.name ? handler.name(imageResources, i) : '';
                 writeSignature(writer, '8BIM');
-                writeUint16(writer, handler.key);
-                writePascalString(writer, '', 2);
-                writeSection(writer, 2, () => handler.write(writer, imageResources, i));
+                writeUint16(writer, id);
+                writePascalString(writer, name, 2);
+                writeSection(writer, 2, () => handler.write(writer, imageResources, i, psd));
             }
         }
     });
@@ -11796,19 +12603,13 @@ function writePsd(writer, psd, options = {}) {
     writer.tempBuffer = undefined;
     // image data
     writeUint16(writer, 1 /* Compression.RleCompressed */); // Photoshop doesn't support zip compression of composite image data
-    if (helpers_1.RAW_IMAGE_DATA && psd.imageDataRaw) {
-        console.log('writing raw image data');
-        writeBytes(writer, psd.imageDataRaw);
-    }
-    else {
-        const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
-        const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
-        // encode directly into the writer buffer
-        const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
-        ensureSize(writer, writer.offset + maxSize);
-        const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
-        writer.offset += (0, helpers_1.writeDataRLE)(buffer, data, channels, !!options.psb).length;
-    }
+    const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
+    const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
+    // encode directly into the writer buffer
+    const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
+    ensureSize(writer, writer.offset + maxSize);
+    const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
+    writer.offset += (0, helpers_1.writeDataRLE)(buffer, data, channels, !!options.psb).length;
 }
 function getCompositeData(imageData, width, height, globalAlpha) {
     if (!imageData)
@@ -11837,7 +12638,7 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
     writeSection(writer, 4, () => {
         var _a;
         writeInt16(writer, globalAlpha ? -layers.length : layers.length);
-        const layersData = layers.map((l, i) => getChannels(writer.tempBuffer, l, i === 0, options));
+        const layersData = layers.map((l, i) => getChannels(writer, l, i === 0, options));
         // layer records
         for (const layerData of layersData) {
             const { layer, top, left, bottom, right, channels } = layerData;
@@ -11889,7 +12690,12 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
         }
     }, true, options.psb);
 }
-function writeLayerMaskData(writer, { mask, realMask }, layerData) {
+// real mask is only stored separately if layer has both vector and pixel masks, otherwise it's stored as the main mask
+function getMasks(layer) {
+    return layer.mask ? { mask: layer.mask, realMask: layer.realMask } : { mask: layer.realMask, realMask: undefined };
+}
+function writeLayerMaskData(writer, layer, layerData) {
+    const { mask, realMask } = getMasks(layer);
     writeSection(writer, 4, () => {
         if (!mask && !realMask)
             return;
@@ -11985,13 +12791,13 @@ function writeAdditionalLayerInfo(writer, target, psd, options) {
         let key = handler.key;
         if (key === 'Txt2' && options.invalidateTextLayers)
             continue;
-        if (key === 'vmsk' && options.psb)
-            key = 'vsms';
+        if (key === 'vmsk' && additionalInfo_1.infoHandlersMap['vscg'].has(target))
+            key = 'vsms'; // Photoshop uses 'vsms' for layers with vector stroke
         if (handler.has(target)) {
             const large = options.psb && helpers_1.largeAdditionalInfoKeys.indexOf(key) !== -1;
             const writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn' && key !== 'CAI ' && key !== 'OCIO';
             const fourBytes = key === 'levl' || key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
-                key === 'vogk' || key === 'SoLd' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
+                key === 'vogk' || key === 'SoLd' || key === 'SoLE' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
                 key === 'lmfx' || key === 'lrFX' || key === 'cinf' || key === 'PlLd' || key === 'Anno' || key === 'CAI ' || key === 'OCIO' || key === 'GenI' || key === 'FEid' || key === 'curv' || key === 'CgEd' || key === 'vibA' || key === 'blwh' || key === 'grdm';
             writeSignature(writer, large ? '8B64' : '8BIM');
             writeSignature(writer, key);
@@ -12084,7 +12890,7 @@ function createThumbnail(psd) {
     }
     return canvas;
 }
-function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask) {
+function getMaskChannels(tempBuffer, layerData, mask, options, realMask) {
     let top = mask.top | 0;
     let left = mask.left | 0;
     let right = mask.right | 0;
@@ -12101,11 +12907,7 @@ function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask)
     bottom = top + height;
     let buffer;
     let compression;
-    if (helpers_1.RAW_IMAGE_DATA && layer[realMask ? 'realMaskDataRaw' : 'maskDataRaw']) {
-        buffer = layer[realMask ? 'realMaskDataRaw' : 'maskDataRaw'];
-        compression = layer[realMask ? 'realMaskDataRawCompression' : 'maskDataRawCompression'];
-    }
-    else if (!imageData) {
+    if (!imageData) {
         buffer = new Uint8Array(0);
         compression = 1 /* Compression.RleCompressed */;
     }
@@ -12128,15 +12930,32 @@ function bounds(obj) {
         bottom: obj.bottom || 0,
     } : undefined;
 }
-function getChannels(tempBuffer, layer, background, options) {
+function getChannels(writer, layer, background, options) {
+    let source = layer;
     if (layer.rawData) {
-        return Object.assign(Object.assign({ layer, channels: layer.rawData.channels.map(c => { var _a, _b; return (Object.assign(Object.assign({}, c), { length: 2 + ((_b = (_a = c.data) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0) })); }) }, bounds(layer)), { mask: bounds(layer.mask), realMask: bounds(layer.realMask) });
-    }
-    const layerData = getLayerChannels(tempBuffer, layer, background, options);
-    if (layer.mask)
-        getMaskChannels(tempBuffer, layerData, layer, layer.mask, options, false);
-    if (layer.realMask)
-        getMaskChannels(tempBuffer, layerData, layer, layer.realMask, options, true);
+        const { colorMode, bitsPerChannel, large } = layer.rawData;
+        if (large === !!options.psb && colorMode === 3 /* ColorMode.RGB */ && bitsPerChannel === 8) {
+            // same mask mapping as in writeLayerMaskData
+            const { mask, realMask } = getMasks(layer);
+            return Object.assign(Object.assign({ layer, channels: layer.rawData.channels.map(c => { var _a, _b; return (Object.assign(Object.assign({}, c), { length: 2 + ((_b = (_a = c.data) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0) })); }) }, bounds(layer)), { mask: bounds(mask), realMask: bounds(realMask) });
+        }
+        if (bitsPerChannel !== 8)
+            throw new Error('Layer raw data with bitsPerChannel other than 8 is not supported for writing');
+        // raw data is in different format than the one we're writing, decode it so it can be re-encoded
+        source = Object.assign(Object.assign({}, layer), { rawData: undefined, canvas: undefined, imageData: (0, psdReader_1.getLayerImageData)(layer), mask: layer.mask && Object.assign(Object.assign({}, layer.mask), { canvas: undefined, imageData: (0, psdReader_1.getLayerMaskImageData)(layer) }), realMask: layer.realMask && Object.assign(Object.assign({}, layer.realMask), { canvas: undefined, imageData: (0, psdReader_1.getLayerRealMaskImageData)(layer) }) });
+        // temp buffer is sized only for layers with image data, grow it and keep it for following layers
+        const size = getLargestLayerSize([Object.assign(Object.assign({}, source), { children: undefined })], !!options.psb);
+        if (writer.tempBuffer.byteLength < size)
+            writer.tempBuffer = new Uint8Array(size);
+    }
+    const tempBuffer = writer.tempBuffer;
+    const { mask, realMask } = getMasks(source);
+    const layerData = getLayerChannels(tempBuffer, source, background, options);
+    if (mask)
+        getMaskChannels(tempBuffer, layerData, mask, options, false);
+    if (realMask)
+        getMaskChannels(tempBuffer, layerData, realMask, options, true);
+    layerData.layer = layer;
     return layerData;
 }
 function getLayerDimentions({ canvas, imageData }) {
@@ -12166,7 +12985,6 @@ function cropImageData(data, left, top, width, height) {
     return croppedData;
 }
 function getLayerChannels(tempBuffer, layer, background, options) {
-    var _a;
     let top = layer.top | 0;
     let left = layer.left | 0;
     let right = layer.right | 0;
@@ -12205,19 +13023,14 @@ function getLayerChannels(tempBuffer, layer, background, options) {
         1 /* ChannelID.Color1 */,
         2 /* ChannelID.Color2 */,
     ];
-    if (!background || options.noBackground || layer.mask || (0, helpers_1.hasAlpha)(imageData) || (helpers_1.RAW_IMAGE_DATA && ((_a = layer.imageDataRaw) === null || _a === void 0 ? void 0 : _a['-1']))) {
+    if (!background || options.noBackground || layer.mask || (0, helpers_1.hasAlpha)(imageData)) {
         channelIds.unshift(-1 /* ChannelID.Transparency */);
     }
     channels = channelIds.map(id => {
-        const offset = (0, helpers_1.offsetForChannel)(id, false); // TODO: psd.colorMode === ColorMode.CMYK);
+        const offset = (0, helpers_1.offsetForChannel)(id, false); // image data is always RGBA
         let data;
         let compression;
-        if (helpers_1.RAW_IMAGE_DATA && layer.imageDataRaw) {
-            // console.log('written raw layer image data');
-            data = layer.imageDataRaw[id];
-            compression = layer.imageDataRawCompression[id];
-        }
-        else if (options.compress) {
+        if (options.compress) {
             data = (0, helpers_1.writeDataZipWithoutPrediction)(imageData, [offset]);
             compression = 2 /* Compression.ZipWithoutPrediction */;
         }
@@ -12298,11 +13111,12 @@ function writeColor(writer, color) {
         writeUint16(writer, 0);
     }
     else if ('c' in color) {
+        // 0 = 100% ink
         writeUint16(writer, 2 /* ColorSpace.CMYK */);
-        writeUint16(writer, Math.round(color.c * 257));
-        writeUint16(writer, Math.round(color.m * 257));
-        writeUint16(writer, Math.round(color.y * 257));
-        writeUint16(writer, Math.round(color.k * 257));
+        writeUint16(writer, 0xffff - Math.round((0, helpers_1.clamp)(color.c, 0, 255) * 257));
+        writeUint16(writer, 0xffff - Math.round((0, helpers_1.clamp)(color.m, 0, 255) * 257));
+        writeUint16(writer, 0xffff - Math.round((0, helpers_1.clamp)(color.y, 0, 255) * 257));
+        writeUint16(writer, 0xffff - Math.round((0, helpers_1.clamp)(color.k, 0, 255) * 257));
     }
     else {
         writeUint16(writer, 8 /* ColorSpace.Grayscale */);
@@ -12369,7 +13183,7 @@ function writePattern(writer, pattern) {
     writer.view.setUint32(pattsOffset - 4, pattsLength, false);
 }
 
-},{"./additionalInfo":2,"./helpers":8,"./imageResources":9}],15:[function(require,module,exports){
+},{"./additionalInfo":2,"./helpers":8,"./imageResources":9,"./psdReader":13}],15:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeEngineData = decodeEngineData;
@@ -12463,7 +13277,16 @@ const styleKeys = [
     'strokeFlag', 'fillFirst', 'yUnderline', 'outlineWidth', 'characterDirection', 'hindiNumbers',
     'kashida', 'diacriticPos',
 ];
-const antialias = ['none', 'crisp', 'strong', 'smooth', 'sharp'];
+const antialias = [
+    'none', // 0
+    'crisp', // 1
+    'strong', // 2
+    'smooth', // 3
+    'sharp', // 4
+    undefined, // 5 - unknown
+    'platformLCD', // 6
+    'platform', // 7
+];
 const justification = [
     'left', // 0
     'right', // 1
@@ -12556,8 +13379,9 @@ function objectsEqual(a, b) {
     return true;
 }
 function findOrAddFont(fonts, font) {
+    // Photoshop writes separate entries for the same font with different synthetic (faux bold/italic) styles
     for (let i = 0; i < fonts.length; i++) {
-        if (fonts[i].name === font.name)
+        if (fonts[i].name === font.name && (fonts[i].synthetic || 0) === (font.synthetic || 0))
             return i;
     }
     fonts.push(font);
@@ -12753,7 +13577,8 @@ function decodeEngineData(engineData) {
         result.paragraphStyleRuns.push({ length, style /*, adjustments*/ });
     }
     for (let counter = removedCharacters; result.paragraphStyleRuns.length && counter > 0; counter--) {
-        if (--result.paragraphStyleRuns[result.paragraphStyleRuns.length - 1].length === 0) {
+        // keep 0 length run if it's for empty last paragraph, otherwise we lose its style
+        if (--result.paragraphStyleRuns[result.paragraphStyleRuns.length - 1].length === 0 && result.paragraphStyleRuns.length === 1) {
             result.paragraphStyleRuns.pop();
         }
     }
@@ -12829,13 +13654,13 @@ function encodeEngineData(data) {
         for (const run of paragraphRuns) {
             let runLength = Math.min(run.length, leftLength);
             leftLength -= runLength;
-            if (!runLength)
-                continue; // ignore 0 size runs
-            // extend last run if it's only for trailing \r
+            // extend last run if it's only for trailing \r (last run has 0 length if it's for empty last paragraph)
             if (leftLength === 1 && run === paragraphRuns[paragraphRuns.length - 1]) {
                 runLength++;
                 leftLength--;
             }
+            if (!runLength)
+                continue; // ignore 0 size runs
             paragraphRunLengthArray.push(runLength);
             paragraphRunArray.push({
                 ParagraphSheet: {
@@ -13138,9 +13963,6 @@ function encodeString(value) {
 // UTF-8 decoder implementing the WHATWG Encoding Standard's non-fatal error handling,
 // so malformed byte sequences are replaced with U+FFFD instead of throwing, matching TextDecoder.
 function decodeString(value) {
-    if (value.byteLength > 1000 && typeof TextDecoder !== 'undefined') {
-        return (new TextDecoder()).decode(value);
-    }
     const result = [];
     function pushCodePoint(code) {
         if (code > 0xffff) {