ag-psd 31.0.2 → 32.0.0

package/dist/bundle.js

@@ -7,6 +7,8 @@ const psdReader_1 = require("./psdReader");
 const dynamicsControl = ['off', 'fade', 'pen pressure', 'pen tilt', 'stylus wheel', 'initial direction', 'direction', 'initial rotation', 'rotation'];
 const dynamicBrushShapeShapes = ['round point', 'round blunt', 'round curve', 'round angle', 'round fan', 'flat point', 'flat blunt', 'flat curve', 'flat angle', 'flat fan'];
 const tipsBrushShapeShapes = ['erodible point', 'erodible flat', 'erodible round', 'erodible square', 'erodible triangle', 'custom'];
+// sanity limits for brush sample dimensions (Photoshop brushes are limited to 5000px)
+const MAX_BRUSH_SIZE = 10000;
 const toBrushType = {
     _: 'brush',
     MixB: 'mixer brush',
@@ -113,7 +115,7 @@ function readAbr(buffer, options = {}) {
         while (reader.offset < reader.view.byteLength) {
             (0, psdReader_1.checkSignature)(reader, '8BIM');
             const type = (0, psdReader_1.readSignature)(reader);
-            let size = (0, psdReader_1.readUint32)(reader);
+            const size = (0, psdReader_1.readUint32)(reader);
             const end = reader.offset + size;
             switch (type) {
                 case 'samp': {
@@ -132,8 +134,14 @@ function readAbr(buffer, options = {}) {
                         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) {
@@ -347,11 +355,10 @@ function readAbr(buffer, options = {}) {
                 default:
                     throw new Error(`Invalid brush type: ${type}`);
             }
-            // align to 4 bytes
-            while (size % 4) {
+            // skip any unread data in the section and align to 4 bytes
+            reader.offset = end;
+            while (reader.offset % 4)
                 reader.offset++;
-                size++;
-            }
         }
     }
     else {
@@ -395,10 +402,6 @@ function readLength64(reader) {
         throw new Error(`Resource size above 4 GB limit at ${reader.offset.toString(16)}`);
     return (0, psdReader_1.readUint32)(reader);
 }
-function writeLength64(writer, length) {
-    (0, psdWriter_1.writeUint32)(writer, 0);
-    (0, psdWriter_1.writeUint32)(writer, length);
-}
 addHandler('TySh', hasKey('text'), (reader, target, leftBytes) => {
     if ((0, psdReader_1.readInt16)(reader) !== 1)
         throw new Error(`Invalid TySh version`);
@@ -437,7 +440,7 @@ addHandler('TySh', hasKey('text'), (reader, target, leftBytes) => {
     if (text.boundingBox)
         target.text.boundingBox = (0, descriptor_1.descBoundsToBounds)(text.boundingBox);
     if (text.EngineData) {
-        const engineData = (0, engineData_1.parseEngineData)(text.EngineData);
+        const engineData = (0, engineData_1.parseEngineData)(text.EngineData, reader);
         const textData = (0, text_1.decodeEngineData)(engineData);
         // console.log(require('util').inspect(engineData, false, 99, false), 'utf8');
         // require('fs').writeFileSync(`layer-${target.name}.txt`, require('util').inspect(engineData, false, 99, false), 'utf8');
@@ -451,6 +454,7 @@ addHandler('TySh', hasKey('text'), (reader, target, leftBytes) => {
     }
     (0, psdReader_1.skipBytes)(reader, leftBytes());
 }, (writer, target) => {
+    var _a, _b, _c, _d;
     const text = target.text;
     const warp = text.warp || {};
     const transform = text.transform || [1, 0, 0, 1, 0, 0];
@@ -463,10 +467,10 @@ addHandler('TySh', hasKey('text'), (reader, target, leftBytes) => {
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'TxLr', textDescriptor, 'text');
     (0, psdWriter_1.writeInt16)(writer, 1); // warp version
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'warp', encodeWarp(warp));
-    (0, psdWriter_1.writeFloat32)(writer, text.left);
-    (0, psdWriter_1.writeFloat32)(writer, text.top);
-    (0, psdWriter_1.writeFloat32)(writer, text.right);
-    (0, psdWriter_1.writeFloat32)(writer, text.bottom);
+    (0, psdWriter_1.writeFloat32)(writer, (_a = text.left) !== null && _a !== void 0 ? _a : 0);
+    (0, psdWriter_1.writeFloat32)(writer, (_b = text.top) !== null && _b !== void 0 ? _b : 0);
+    (0, psdWriter_1.writeFloat32)(writer, (_c = text.right) !== null && _c !== void 0 ? _c : 0);
+    (0, psdWriter_1.writeFloat32)(writer, (_d = text.bottom) !== null && _d !== void 0 ? _d : 0);
     // writeZeros(writer, 2);
 });
 // vector fills
@@ -782,12 +786,50 @@ addHandler('luni', hasKey('name'), (reader, target, left) => {
     // writeUint16(writer, 0); // padding (but not extending string length)
 });
 addHandler('lnsr', hasKey('nameSource'), (reader, target) => target.nameSource = (0, psdReader_1.readSignature)(reader), (writer, target) => (0, psdWriter_1.writeSignature)(writer, target.nameSource));
-addHandler('lyid', hasKey('id'), (reader, target) => {
+// these sections reference layer id
+function layerNeedsId(target) {
+    return !!(target.animationFrames || target.timeline || target.comps);
+}
+function getExplicitLayerIds(psd, options) {
+    if (!options.explicitLayerIds) {
+        const ids = new Set();
+        const addIds = (layers) => {
+            for (const layer of layers !== null && layers !== void 0 ? layers : []) {
+                if (layer.id !== undefined)
+                    ids.add(layer.id);
+                addIds(layer.children);
+            }
+        };
+        addIds(psd.children);
+        options.explicitLayerIds = ids;
+    }
+    return options.explicitLayerIds;
+}
+function getLayerId(target, options) {
+    var _a;
+    const id = (_a = options.layerToId.get(target)) !== null && _a !== void 0 ? _a : target.id;
+    if (id === undefined)
+        throw new Error('Missing layer id');
+    return id;
+}
+addHandler('lyid', target => target.id !== undefined || layerNeedsId(target), (reader, target) => {
     target.id = (0, psdReader_1.readUint32)(reader);
-}, (writer, target, _psd, options) => {
-    let id = target.id;
-    while (options.layerIds.has(id))
-        id += 100; // make sure we don't have duplicate layer ids
+}, (writer, target, psd, options) => {
+    var _a;
+    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
+    }
+    else {
+        // generate id for layers that don't have it, if it's referenced by other sections
+        const explicitIds = getExplicitLayerIds(psd, options);
+        id = (_a = options.nextGeneratedLayerId) !== null && _a !== void 0 ? _a : 1;
+        while (options.layerIds.has(id) || explicitIds.has(id))
+            id++;
+        options.nextGeneratedLayerId = id + 1;
+    }
     (0, psdWriter_1.writeUint32)(writer, id);
     options.layerIds.add(id);
     options.layerToId.set(target, id);
@@ -985,9 +1027,8 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
         (0, psdWriter_1.writeUint8)(writer, 0); // copy (always false)
         (0, psdWriter_1.writeZeros)(writer, 3);
         (0, psdWriter_1.writeSection)(writer, 2, () => {
-            var _a;
             const desc = {
-                LaID: (_a = target.id) !== null && _a !== void 0 ? _a : 0,
+                LaID: getLayerId(target, options),
                 LaSt: [],
             };
             for (let i = 0; i < animationFrames.length; i++) {
@@ -1043,10 +1084,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
             if (timeline.tracks) {
                 desc.trackList = (0, descriptor_1.serializeTrackList)(timeline.tracks);
             }
-            const id = options.layerToId.get(target) || target.id;
-            if (!id)
-                throw new Error('You need to provide layer.id value whan writing document with animations');
-            desc.LyrI = id;
+            desc.LyrI = getLayerId(target, options);
             // console.log('WRITE:tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
             (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc, 'anim');
         }, true);
@@ -1069,14 +1107,11 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
         (0, psdWriter_1.writeUint8)(writer, 0); // copy (always false)
         (0, psdWriter_1.writeZeros)(writer, 3);
         (0, psdWriter_1.writeSection)(writer, 2, () => {
-            const id = options.layerToId.get(target) || target.id;
-            if (!id)
-                throw new Error('You need to provide layer.id value whan writing document with layer comps');
             const desc = {};
             if (comps.originalEffectsReferencePoint) {
                 desc.origFXRefPoint = { Hrzn: comps.originalEffectsReferencePoint.x, Vrtc: comps.originalEffectsReferencePoint.y };
             }
-            desc.LyrI = id;
+            desc.LyrI = getLayerId(target, options);
             desc.layerSettings = [];
             for (const item of comps.settings) {
                 const t = {};
@@ -1094,7 +1129,7 @@ target => target.timestamp !== undefined || target.animationFrames !== undefined
         }, true);
     }
 });
-addHandler('PxSc', () => false, (reader, target) => {
+addHandler('PxSc', hasKey('pixelSource'), (reader, target) => {
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
     // console.log('PxSc', require('util').inspect(desc, false, 99, true));
     if (desc.pixelSourceType === 1986285651) {
@@ -1129,7 +1164,7 @@ addHandler('PxSc', () => false, (reader, target) => {
         _classID: 'PixelSource',
         pixelSourceType: 1986285651, // vdP
         descVersion: 1,
-        origin: { Hrzn: source.origin.x, Vrtc: source.origin.y },
+        origin: { Hrzn: source.origin.x, Vrtc: source.origin.y }, // written as 'null' class with 'long' values (see writeDescriptorStructure)
         interpretation: {
             _name: '',
             _classID: 'footageInterpretation',
@@ -1371,10 +1406,12 @@ addHandler('PlLd', hasKey('placedLayer'), (reader, target, left) => {
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', type, encodeWarp(warp), type);
 });
 function uint8ToFloat32(array) {
-    return new Float32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+    const length = Math.floor(array.byteLength / 4);
+    return new Float32Array(array.buffer.slice(array.byteOffset, array.byteOffset + length * 4), 0, length);
 }
 function uint8ToUint32(array) {
-    return new Uint32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+    const length = Math.floor(array.byteLength / 4);
+    return new Uint32Array(array.buffer.slice(array.byteOffset, array.byteOffset + length * 4), 0, length);
 }
 function toUint8(array) {
     return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
@@ -1643,7 +1680,7 @@ function parseFilterFXItem(f, options) {
                         { x: f.Fltr.PuX2, y: f.Fltr.PuY2, },
                         { x: f.Fltr.PuX3, y: f.Fltr.PuY3, },
                     ],
-                    puppetShapeList: f.Fltr.puppetShapeList.map(p => ({
+                    puppetShapeList: (f.Fltr.puppetShapeList || []).map(p => ({
                         rigidType: p.rigidType,
                         // TODO: VrsM
                         // TODO: VrsN
@@ -2172,7 +2209,7 @@ function serializeFilterFXItem(f) {
                 _classID: 'rigidTransform',
                 'null': ['Ordn.Trgt'], // TODO: ???
                 rigidType: f.filter.rigidType,
-                puppetShapeList: f.filter.puppetShapeList.map(p => ({
+                puppetShapeList: (f.filter.puppetShapeList || []).map(p => ({
                     _name: '',
                     _classID: 'puppetShape',
                     rigidType: p.rigidType,
@@ -2257,7 +2294,7 @@ function serializeFilterFXItem(f) {
                 _classID: 'perspectiveWarpTransform',
                 vertices: f.filter.vertices.map(pointToHrznVrtc),
                 warpedVertices: f.filter.warpedVertices.map(pointToHrznVrtc),
-                quads: f.filter.quads.map(indices => ({ indices })),
+                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 ? {
                 Adjs: f.filter.adjustments.map(a => 'curve' in a ? {
@@ -2279,10 +2316,13 @@ function serializeFilterFXItem(f) {
                 Cntr: f.filter.contrast,
                 useLegacy: !!f.filter.useLegacy,
             }, filterID: 1114793795 });
-        // case 'hsb/hsl': return {
-        // TODO: ...
-        // };
-        default: throw new Error(`Unknow filter type: ${f.type}`);
+        case 'hsb/hsl': return Object.assign(Object.assign({}, base), { Fltr: {
+                _name: 'HSB/HSL',
+                _classID: 'HsbP',
+                Inpt: descriptor_1.ClrS.encode(f.filter.inputMode),
+                Otpt: descriptor_1.ClrS.encode(f.filter.rowOrder),
+            }, filterID: 1215521360 });
+        default: throw new Error(`Unknown filter type: ${f.type}`);
     }
 }
 // let t: any;
@@ -2373,7 +2413,10 @@ addHandler('SoLd', hasKey('placedLayer'), (reader, target, left) => {
     if (!placed.id || typeof placed.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(placed.id)) {
         throw new Error('Placed layer ID must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)');
     }
-    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: placedLayerTypes.indexOf(placed.type), Trnf: placed.transform, nonAffineTransform: (_b = placed.nonAffineTransform) !== null && _b !== void 0 ? _b : placed.transform, 
+    const placedType = placedLayerTypes.indexOf(placed.type);
+    if (placedType === -1)
+        throw new Error('Invalid placedLayer type');
+    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  ': {
             _name: '',
@@ -2451,7 +2494,7 @@ addHandler('Lr32', () => false, (reader, _target, _left, psd, imageResources) =>
 addHandler('LMsk', hasKey('userMask'), (reader, target) => {
     target.userMask = {
         colorSpace: (0, psdReader_1.readColor)(reader),
-        opacity: (0, psdReader_1.readUint16)(reader) / 0xff,
+        opacity: (0, psdReader_1.readUint16)(reader) / 100,
     };
     const flag = (0, psdReader_1.readUint8)(reader);
     if (flag !== 128)
@@ -2460,7 +2503,7 @@ addHandler('LMsk', hasKey('userMask'), (reader, target) => {
 }, (writer, target) => {
     const userMask = target.userMask;
     (0, psdWriter_1.writeColor)(writer, userMask.colorSpace);
-    (0, psdWriter_1.writeUint16)(writer, (0, helpers_1.clamp)(userMask.opacity, 0, 1) * 0xff);
+    (0, psdWriter_1.writeUint16)(writer, Math.round((0, helpers_1.clamp)(userMask.opacity, 0, 1) * 100));
     (0, psdWriter_1.writeUint8)(writer, 128);
     (0, psdWriter_1.writeZeros)(writer, 1);
 });
@@ -2498,7 +2541,7 @@ interface CAIDesc {
 }
 
 addHandler(
-    'CAI ', // content credentials ? something to do with generative tech
+    'CAI ', // Content Authenticity Initiative
     () => false,
     (reader, _target, left) => {
         const version = readUint32(reader); // 3
@@ -2512,7 +2555,9 @@ addHandler(
 );
 // */
 if (helpers_1.MOCK_HANDLERS) {
-    addHandler('CAI ', target => target._CAI_ !== undefined, (reader, target, left) => {
+    addHandler('CAI ', // Content Authenticity Initiative / C2PA provenance metadata
+    // Content Authenticity Initiative / C2PA provenance metadata
+    target => target._CAI_ !== undefined, (reader, target, left) => {
         target._CAI_ = (0, psdReader_1.readBytes)(reader, left());
     }, (writer, target) => {
         (0, psdWriter_1.writeBytes)(writer, target._CAI_);
@@ -2530,8 +2575,8 @@ if (helpers_1.MOCK_HANDLERS) {
 // 	};
 // }
 if (helpers_1.MOCK_HANDLERS) {
-    addHandler('OCIO', // document color management info
-    // document color management info
+    addHandler('OCIO', // Document color management info
+    // Document color management info
     target => target._OCIO !== undefined, (reader, target, left) => {
         // const desc = readVersionAndDescriptor(reader, true) as OCIODescriptor;
         // console.log('OCIO', require('util').inspect(desc, false, 99, true));
@@ -2547,8 +2592,8 @@ if (helpers_1.MOCK_HANDLERS) {
 //  externalModelList?: [];
 // }
 if (helpers_1.MOCK_HANDLERS) {
-    addHandler('GenI', // generative tech
-    // generative tech
+    addHandler('GenI', // Generative Fill / generative AI (Firefly) features
+    // Generative Fill / generative AI (Firefly) features
     target => target._GenI !== undefined, (reader, target, left) => {
         // const desc = readVersionAndDescriptor(reader, true); // as GenIDescriptor;
         // console.log('GenI', require('util').inspect(desc, false, 99, true));
@@ -2578,7 +2623,8 @@ addHandler('Anno', target => target.annotations !== undefined, (reader, target,
     const count = (0, psdReader_1.readUint32)(reader);
     const annotations = [];
     for (let i = 0; i < count; i++) {
-        /*const length =*/ (0, psdReader_1.readUint32)(reader);
+        const recordStart = reader.offset;
+        const length = (0, psdReader_1.readUint32)(reader); // includes the length field itself
         const type = (0, psdReader_1.readSignature)(reader);
         const open = !!(0, psdReader_1.readUint8)(reader);
         /*const flags =*/ (0, psdReader_1.readUint8)(reader); // always 28
@@ -2594,11 +2640,12 @@ addHandler('Anno', target => target.annotations !== undefined, (reader, target,
         const dataLength = (0, psdReader_1.readUint32)(reader);
         let data;
         if (type === 'txtA') {
+            const dataStart = reader.offset;
             if (dataLength >= 2 && (0, psdReader_1.readUint16)(reader) === 0xfeff) {
-                data = (0, psdReader_1.readUnicodeStringWithLength)(reader, (dataLength - 2) / 2);
+                data = (0, psdReader_1.readUnicodeStringWithLength)(reader, Math.floor((dataLength - 2) / 2));
             }
             else {
-                reader.offset -= 2;
+                reader.offset = dataStart;
                 data = (0, psdReader_1.readAsciiString)(reader, dataLength);
             }
             data = data.replace(/\r/g, '\n');
@@ -2612,6 +2659,8 @@ addHandler('Anno', target => target.annotations !== undefined, (reader, target,
         annotations.push({
             type: type === 'txtA' ? 'text' : 'sound', open, iconLocation, popupLocation, color, author, name, date, data,
         });
+        if (length >= (reader.offset - recordStart))
+            reader.offset = recordStart + length;
     }
     target.annotations = annotations;
     (0, psdReader_1.skipBytes)(reader, left());
@@ -2739,11 +2788,12 @@ function createLnkHandler(tag) {
         }
         (0, psdReader_1.skipBytes)(reader, left()); // ?
     }, (writer, target) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const psd = target;
         for (const file of psd.linkedFiles) {
             if ((tag === 'lnkE') !== !!file.linkedFile)
                 continue;
+            const external = tag === 'lnkE';
             let version = 2;
             if (file.assetLockedState != null)
                 version = 7;
@@ -2751,11 +2801,13 @@ function createLnkHandler(tag) {
                 version = 6;
             else if (file.childDocumentID != null)
                 version = 5;
-            else if (tag === 'lnkE')
-                version = 3;
-            writeLength64(writer, 0);
+            // liFE version 2 is the only one with embedded data, it has no date and its file size is the size of the data,
+            // versions 5+ can't store the data, so it's not written in that case
+            else if (external && !file.data)
+                version = 4;
+            (0, psdWriter_1.writeUint64)(writer, 0);
             const sizeOffset = writer.offset;
-            (0, psdWriter_1.writeSignature)(writer, (tag === 'lnkE') ? 'liFE' : (file.data ? 'liFD' : 'liFA'));
+            (0, psdWriter_1.writeSignature)(writer, external ? 'liFE' : (file.data ? 'liFD' : 'liFA'));
             (0, psdWriter_1.writeInt32)(writer, version);
             if (!file.id || typeof file.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(file.id)) {
                 throw new Error('Linked file ID must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)');
@@ -2764,7 +2816,7 @@ function createLnkHandler(tag) {
             (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, file.name || '');
             (0, psdWriter_1.writeSignature)(writer, file.type ? `${file.type}    `.substring(0, 4) : '    ');
             (0, psdWriter_1.writeSignature)(writer, file.creator ? `${file.creator}    `.substring(0, 4) : '\0\0\0\0');
-            writeLength64(writer, file.data ? file.data.byteLength : 0);
+            (0, psdWriter_1.writeUint64)(writer, (!external && file.data) ? file.data.byteLength : 0);
             if (file.descriptor && file.descriptor.compInfo) {
                 const desc = {
                     compInfo: {
@@ -2778,7 +2830,7 @@ function createLnkHandler(tag) {
             else {
                 (0, psdWriter_1.writeUint8)(writer, 0);
             }
-            if (tag === 'lnkE') {
+            if (external) {
                 const desc = {
                     descVersion: 2,
                     'Nm  ': (_b = (_a = file.linkedFile) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '',
@@ -2787,6 +2839,8 @@ function createLnkHandler(tag) {
                     relPath: (_h = (_g = file.linkedFile) === null || _g === void 0 ? void 0 : _g.relativePath) !== null && _h !== void 0 ? _h : '',
                 };
                 (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'ExternalFileLink', desc);
+            }
+            if (external && version > 3) {
                 const time = file.time ? new Date(file.time) : new Date();
                 (0, psdWriter_1.writeInt32)(writer, time.getUTCFullYear());
                 (0, psdWriter_1.writeUint8)(writer, time.getUTCMonth());
@@ -2795,11 +2849,14 @@ function createLnkHandler(tag) {
                 (0, psdWriter_1.writeUint8)(writer, time.getUTCMinutes());
                 (0, psdWriter_1.writeFloat64)(writer, time.getUTCSeconds() + time.getUTCMilliseconds() / 1000);
             }
-            if (file.data) {
-                (0, psdWriter_1.writeBytes)(writer, file.data);
+            if (external) {
+                (0, psdWriter_1.writeUint64)(writer, (version === 2 ? (_j = file.data) === null || _j === void 0 ? void 0 : _j.byteLength : (_k = file.linkedFile) === null || _k === void 0 ? void 0 : _k.fileSize) || 0); // file size
+            }
+            else if (file.data) {
+                (0, psdWriter_1.writeBytes)(writer, file.data); // liFD
             }
             else {
-                writeLength64(writer, ((_j = file.linkedFile) === null || _j === void 0 ? void 0 : _j.fileSize) || 0);
+                (0, psdWriter_1.writeZeros)(writer, 8); // liFA
             }
             if (version >= 5)
                 (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, file.childDocumentID || '');
@@ -2807,6 +2864,8 @@ function createLnkHandler(tag) {
                 (0, psdWriter_1.writeFloat64)(writer, file.assetModTime || 0);
             if (version >= 7)
                 (0, psdWriter_1.writeUint8)(writer, file.assetLockedState || 0);
+            if (external && version === 2 && file.data)
+                (0, psdWriter_1.writeBytes)(writer, file.data);
             let size = writer.offset - sizeOffset;
             writer.view.setUint32(sizeOffset - 4, size, false); // write size
             while (size % 4) {
@@ -2895,7 +2954,25 @@ function writeLevelsChannel(writer, channel) {
 addHandler('levl', adjustmentType('levels'), (reader, target, left) => {
     if ((0, psdReader_1.readUint16)(reader) !== 2)
         throw new Error('Invalid levl version');
-    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'levels', rgb: readLevelsChannel(reader), red: readLevelsChannel(reader), green: readLevelsChannel(reader), blue: readLevelsChannel(reader) });
+    const levels = [];
+    for (let i = 0; i < 29 && left(); i++) {
+        levels.push(readLevelsChannel(reader));
+    }
+    const [rgb, red, green, blue] = levels;
+    target.adjustment = Object.assign(Object.assign({}, target.adjustment), { type: 'levels', rgb,
+        red,
+        green,
+        blue });
+    if (left()) {
+        if ((0, psdReader_1.readSignature)(reader) !== 'Lvls')
+            throw new Error(`Invalid levl signature`);
+        if ((0, psdReader_1.readUint16)(reader) !== 3)
+            throw new Error(`Invalid levl version`);
+        const totalChannelRecords = (0, psdReader_1.readUint16)(reader);
+        for (let i = 0; i < (totalChannelRecords - levels.length) && left(); i++) {
+            levels.push(readLevelsChannel(reader));
+        }
+    }
     (0, psdReader_1.skipBytes)(reader, left());
 }, (writer, target) => {
     const info = target.adjustment;
@@ -2911,8 +2988,15 @@ addHandler('levl', adjustmentType('levels'), (reader, target, left) => {
     writeLevelsChannel(writer, info.red || defaultChannel);
     writeLevelsChannel(writer, info.green || defaultChannel);
     writeLevelsChannel(writer, info.blue || defaultChannel);
-    for (let i = 0; i < 59; i++)
+    for (let i = 0; i < (29 - 4); i++) {
+        writeLevelsChannel(writer, defaultChannel);
+    }
+    (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);
+    }
 });
 function readCurveChannel(reader) {
     const nodes = (0, psdReader_1.readUint16)(reader);
@@ -3154,10 +3238,15 @@ addHandler('phfl', adjustmentType('photo filter'), (reader, target, left) => {
     }
     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;
         color = {
-            l: (0, psdReader_1.readInt32)(reader) / 100,
-            a: (0, psdReader_1.readInt32)(reader) / 100,
-            b: (0, psdReader_1.readInt32)(reader) / 100,
+            l: l / 100,
+            a: (0, helpers_1.normalizeLabAB)(a),
+            b: (0, helpers_1.normalizeLabAB)(b),
         };
     }
     target.adjustment = {
@@ -3171,7 +3260,7 @@ addHandler('phfl', adjustmentType('photo filter'), (reader, target, left) => {
     const info = target.adjustment;
     (0, psdWriter_1.writeUint16)(writer, 2); // version
     (0, psdWriter_1.writeColor)(writer, info.color || { l: 0, a: 0, b: 0 });
-    (0, psdWriter_1.writeUint32)(writer, (info.density || 0) * 100);
+    (0, psdWriter_1.writeUint32)(writer, Math.round(Math.max(0, info.density || 0) * 100));
     (0, psdWriter_1.writeUint8)(writer, info.preserveLuminosity ? 1 : 0);
     (0, psdWriter_1.writeZeros)(writer, 3);
 });
@@ -3374,10 +3463,11 @@ addHandler('grdm', adjustmentType('gradient map'), (reader, target, left) => {
         (0, psdReader_1.readUint16)(reader) / 0x8000,
     ];
     (0, psdReader_1.skipBytes)(reader, left());
+    // stop locations are always in 0..4096 range, independent of smoothness
     for (const s of info.colorStops)
-        s.location /= interpolation;
+        s.location /= 4096;
     for (const s of info.opacityStops)
-        s.location /= interpolation;
+        s.location /= 4096;
     target.adjustment = info;
 }, (writer, target) => {
     var _a, _b, _c;
@@ -3390,18 +3480,18 @@ addHandler('grdm', adjustmentType('gradient map'), (reader, target, left) => {
     }
     (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, info.name || '');
     (0, psdWriter_1.writeUint16)(writer, info.colorStops && info.colorStops.length || 0);
-    const interpolation = Math.round(((_a = info.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096);
+    const interpolation = Math.round((0, helpers_1.clamp)((_a = info.smoothness) !== null && _a !== void 0 ? _a : 1, 0, 1) * 4096);
     for (const s of info.colorStops || []) {
-        (0, psdWriter_1.writeUint32)(writer, Math.round(s.location * interpolation));
+        (0, psdWriter_1.writeUint32)(writer, Math.round((0, helpers_1.clamp)(s.location, 0, 1) * 4096));
         (0, psdWriter_1.writeUint32)(writer, Math.round(s.midpoint * 100));
         (0, psdWriter_1.writeColor)(writer, s.color);
         (0, psdWriter_1.writeZeros)(writer, 2);
     }
     (0, psdWriter_1.writeUint16)(writer, info.opacityStops && info.opacityStops.length || 0);
     for (const s of info.opacityStops || []) {
-        (0, psdWriter_1.writeUint32)(writer, Math.round(s.location * interpolation));
+        (0, psdWriter_1.writeUint32)(writer, Math.round((0, helpers_1.clamp)(s.location, 0, 1) * 4096));
         (0, psdWriter_1.writeUint32)(writer, Math.round(s.midpoint * 100));
-        (0, psdWriter_1.writeUint16)(writer, Math.round(s.opacity * 0xff));
+        (0, psdWriter_1.writeUint16)(writer, Math.round((0, helpers_1.clamp)(s.opacity, 0, 1) * 0xff));
     }
     (0, psdWriter_1.writeUint16)(writer, 2); // expansion count
     (0, psdWriter_1.writeUint16)(writer, interpolation);
@@ -3563,7 +3653,7 @@ addHandler('Txt2', hasKey('engineData'), (reader, target, left, psd) => {
     const data = (0, psdReader_1.readBytes)(reader, left());
     target.engineData = (0, base64_js_1.fromByteArray)(data);
     const layersByIndex = getTextLayersSortedByIndex(psd);
-    const engineData = (0, engineData_1.parseEngineData)(data);
+    const engineData = (0, engineData_1.parseEngineData)(data, reader);
     const engineData2 = (0, engineData2_1.decodeEngineData2)(engineData);
     const TextFrameSet = engineData2.ResourceDict.TextFrameSet;
     if (TextFrameSet) {
@@ -3645,7 +3735,6 @@ addHandler('FEid', hasKey('filterEffectsMasks'), (reader, target, leftBytes) =>
         }
     }
 }, (writer, target) => {
-    var _a;
     (0, psdWriter_1.writeInt32)(writer, 3); // version
     for (const mask of target.filterEffectsMasks) {
         (0, psdWriter_1.writeUint32)(writer, 0);
@@ -3674,7 +3763,7 @@ addHandler('FEid', hasKey('filterEffectsMasks'), (reader, target, leftBytes) =>
             }
         }
         writer.view.setUint32(length2Offset - 4, writer.offset - length2Offset, false);
-        const extra = (_a = target.filterEffectsMasks[target.filterEffectsMasks.length - 1]) === null || _a === void 0 ? void 0 : _a.extra;
+        const extra = mask.extra;
         if (extra) {
             (0, psdWriter_1.writeUint8)(writer, 1);
             (0, psdWriter_1.writeInt32)(writer, extra.top);
@@ -3698,12 +3787,12 @@ addHandlerAlias('FXid', 'FEid');
 addHandler('FMsk', hasKey('filterMask'), (reader, target) => {
     target.filterMask = {
         colorSpace: (0, psdReader_1.readColor)(reader),
-        opacity: (0, psdReader_1.readUint16)(reader) / 0xff,
+        opacity: (0, psdReader_1.readUint16)(reader) / 100,
     };
 }, (writer, target) => {
     var _a;
     (0, psdWriter_1.writeColor)(writer, target.filterMask.colorSpace);
-    (0, psdWriter_1.writeUint16)(writer, (0, helpers_1.clamp)((_a = target.filterMask.opacity) !== null && _a !== void 0 ? _a : 1, 0, 1) * 0xff);
+    (0, psdWriter_1.writeUint16)(writer, Math.round((0, helpers_1.clamp)((_a = target.filterMask.opacity) !== null && _a !== void 0 ? _a : 1, 0, 1) * 100));
 });
 addHandler('artd', // document-wide artboard info
 // document-wide artboard info
@@ -3819,12 +3908,12 @@ addHandler('iOpa', hasKey('fillOpacity'), (reader, target) => {
     target.fillOpacity = (0, psdReader_1.readUint8)(reader) / 0xff;
     (0, psdReader_1.skipBytes)(reader, 3);
 }, (writer, target) => {
-    (0, psdWriter_1.writeUint8)(writer, target.fillOpacity * 0xff);
+    (0, psdWriter_1.writeUint8)(writer, Math.round((0, helpers_1.clamp)(target.fillOpacity, 0, 1) * 0xff));
     (0, psdWriter_1.writeZeros)(writer, 3);
 });
 addHandler('brst', hasKey('channelBlendingRestrictions'), (reader, target, left) => {
     target.channelBlendingRestrictions = [];
-    while (left() > 4) {
+    while (left() >= 4) {
         target.channelBlendingRestrictions.push((0, psdReader_1.readInt32)(reader));
     }
 }, (writer, target) => {
@@ -3895,8 +3984,12 @@ exports.IntC = exports.IntE = exports.Drct = exports.WndM = exports.CntE = expor
 exports.presetKindType = exports.prjM = exports.FlMd = 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;
 exports.writeVersionAndDescriptor = writeVersionAndDescriptor;
 exports.horzVrtcToXY = horzVrtcToXY;
@@ -4035,6 +4128,8 @@ const fieldToExtType = {
     origFXRefPoint: nullType,
     FXRefPoint: nullType,
     ClMg: makeType('', 'ClMg'),
+    interpretation: makeType('', 'footageInterpretation'),
+    bgColor: makeType('', 'NativeQuad'),
 };
 const fieldToArrayExtType = {
     'Crv ': makeType('', 'CrPt'),
@@ -4068,6 +4163,9 @@ const fieldToArrayExtType = {
     layerSettings: nullType,
     list: nullType,
     Adjs: makeType('', 'CrvA'),
+    vertices: makeType('', 'Pnt '),
+    warpedVertices: makeType('', 'Pnt '),
+    quads: makeType('', 'quadIndices'),
 };
 const typeToField = {
     'TEXT': [
@@ -4093,6 +4191,7 @@ const typeToField = {
         'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN', 'NmbG', 'WLMn', 'WLMx', 'AmMn', 'AmMx', 'SclH', 'SclV',
         'Lvl ', 'TlNm', 'TlOf', 'FlRs', 'Thsh', 'ShrS', 'ShrE', 'FlRs', 'Vrnc', 'Strg', 'ExtS', 'ExtD',
         'HrzS', 'VrtS', 'NmbR', 'EdgF', 'Ang1', 'Ang2', 'Ang3', 'Ang4', 'lastAppliedComp', 'capturedInfo',
+        'pixelSourceType',
     ],
     'enum': [
         'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
@@ -4103,6 +4202,7 @@ const typeToField = {
         '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',
+        'interpretAlpha',
     ],
     'bool': [
         'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -4115,14 +4215,15 @@ const typeToField = {
         'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
         'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
         'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
-        'moreAccurate', 'GpuY', 'LIWy', 'Cnty',
+        'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn',
     ],
     'doub': [
         'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
         'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
         'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
         'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
-        'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
+        'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3',
+        'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity',
     ],
     'UntF': [
         'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -4138,14 +4239,57 @@ const typeToField = {
         'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
         'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
         'channelDenoise', 'Mtrx', 'layerSettings', 'list', 'compList', 'Adjs',
+        'vertices', 'warpedVertices', 'quads', 'indices', 'Mpng',
     ],
     'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
     'obj ': ['null', 'Chnl'],
     'Pth ': ['DspF'],
+    'alis': ['alis'],
 };
 const channels = [
     'Rd  ', 'Grn ', 'Bl  ', 'Yllw', 'Ylw ', 'Cyn ', 'Mgnt', 'Blck', 'Gry ', 'Lmnc', 'A   ', 'B   ',
 ];
+// 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')
+        return 'bool';
+    if (typeof value === 'number' && !Number.isInteger(value))
+        return 'doub';
+    if (Array.isArray(value))
+        return 'VlLs';
+    if (value && typeof value === 'object' && typeof value._classID === 'string')
+        return 'Objc';
+    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',
@@ -4185,6 +4329,8 @@ const fieldToArrayType = {
     Mtrx: 'long',
     compList: 'long',
     Chnl: 'enum',
+    indices: 'long',
+    Mpng: 'long',
 };
 const fieldToType = {};
 for (const type of Object.keys(typeToField)) {
@@ -4199,6 +4345,7 @@ for (const field of Object.keys(fieldToExtType)) {
 for (const field of Object.keys(fieldToArrayExtType)) {
     fieldToArrayType[field] = 'Objc';
 }
+const pixelSourceOriginRoot = 'PixelSource.origin';
 function getTypeByKey(key, value, root, parent) {
     if (key === 'presetKind') {
         return typeof value === 'string' ? 'enum' : 'long';
@@ -4218,7 +4365,7 @@ function getTypeByKey(key, value, root, parent) {
     else if (key === 'AntA') {
         return typeof value === 'string' ? 'enum' : 'bool';
     }
-    else if ((key === 'Hrzn' || key === 'Vrtc') && (parent.Type === 'keyType.Pstn' || parent._classID === 'Ofst')) {
+    else if ((key === 'Hrzn' || key === 'Vrtc') && (parent.Type === 'keyType.Pstn' || parent._classID === 'Ofst' || root === pixelSourceOriginRoot)) {
         return 'long';
     }
     else if (key === 'Hrzn' || key === 'Vrtc' || key === 'Top ' || key === 'Left' || key === 'Btom' || key === 'Rght') {
@@ -4235,6 +4382,15 @@ function getTypeByKey(key, value, root, parent) {
     else if (key === 'Trnf') {
         return Array.isArray(value) ? 'VlLs' : 'Objc';
     }
+    else if (key === 'alpha' && root === 'slices') {
+        return 'long';
+    }
+    else if ((key === 'Inpt' || key === 'Otpt') && parent._classID === 'HsbP') {
+        return 'enum';
+    }
+    else if (key === 'LghD' && parent._classID === 'oilPaint') {
+        return 'long';
+    }
     else {
         return fieldToType[key];
     }
@@ -4278,23 +4434,22 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
     // write class structure
     (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
     writeAsciiStringOrClassId(writer, classId);
-    const keys = Object.keys(value);
-    let keyCount = keys.length;
-    if ('_name' in value)
-        keyCount--;
-    if ('_classID' in value)
-        keyCount--;
-    (0, psdWriter_1.writeUint32)(writer, keyCount);
+    const allKeys = Object.keys(value);
+    const keys = allKeys.filter(key => key !== '_name' && key !== '_classID' && value[key] !== undefined);
+    (0, psdWriter_1.writeUint32)(writer, keys.length);
     for (const key of keys) {
-        if (key === '_name' || key === '_classID')
-            continue;
         let type = getTypeByKey(key, value[key], root, value);
+        let childRoot = root;
         let extType = fieldToExtType[key];
         if (key === 'bounds' && root === 'text') {
             extType = makeType('', 'bounds');
         }
         else if (key === 'origin') {
             type = root === 'slices' ? 'enum' : 'Objc';
+            if (classId === 'PixelSource') {
+                extType = nullType; // stored as 'null' class with integer Hrzn/Vrtc
+                childRoot = pixelSourceOriginRoot;
+            }
         }
         else if ((key === 'Cyn ' || key === 'Mgnt' || key === 'Ylw ' || key === 'Blck') && value._classID === 'CMYC') {
             type = 'doub';
@@ -4362,10 +4517,14 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
             extType = nullType;
         }
         else if (channels.indexOf(key) !== -1) {
-            type = (classId === 'RGBC' && root !== 'artd') ? 'doub' : 'long';
+            type = ((classId === 'RGBC' && root !== 'artd') || doubleColorClasses.indexOf(classId) !== -1) ? 'doub' : 'long';
         }
         else if (key === 'profile') {
-            type = classId === 'printOutput' ? 'TEXT' : 'tdta';
+            type = (classId === 'printOutput' || classId === 'proofSetup') ? 'TEXT' : 'tdta';
+        }
+        else if (key === 'alis' && typeof value[key] === 'string') {
+            // 'alis' is read as a binary string (one char per byte), strings with wider chars can only be stored as TEXT
+            type = /[^\x00-\xff]/.test(value[key]) ? 'TEXT' : 'alis';
         }
         else if (key === 'strokeStyleContent') {
             if (value[key]['Clr ']) {
@@ -4389,9 +4548,12 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
                 extType = { classID: 'HSBC', name: '' };
             // TODO: other color spaces
         }
+        type = getRecordedOSType(value[key], type);
+        if (!type)
+            type = guessOSType(value[key]);
         writeAsciiStringOrClassId(writer, key);
         (0, psdWriter_1.writeSignature)(writer, type || 'long');
-        writeOSType(writer, type || 'long', value[key], key, extType, root);
+        writeOSType(writer, type || 'long', value[key], key, extType, childRoot);
         if (logErrors && !type)
             console.log(`Missing descriptor field type for: '${key}' in`, value);
     }
@@ -4401,8 +4563,9 @@ function readOSType(reader, type, includeClass) {
         case 'obj ': // Reference
             return readReferenceStructure(reader);
         case 'Objc': // Descriptor
-        case 'GlbO': // GlobalObject same as Descriptor
             return readDescriptorStructure(reader, includeClass);
+        case 'GlbO': // GlobalObject same as Descriptor
+            return setHidden(readDescriptorStructure(reader, includeClass), osTypeKey, type);
         case 'VlLs': { // List
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
@@ -4427,7 +4590,7 @@ function readOSType(reader, type, includeClass) {
             const value = (0, psdReader_1.readFloat32)(reader);
             if (!unitsMap[units])
                 throw new Error(`Invalid units: ${units}`);
-            return { units: unitsMap[units], value };
+            return setHidden({ units: unitsMap[units], value }, osTypeKey, type);
         }
         case 'TEXT': // String
             return (0, psdReader_1.readUnicodeString)(reader);
@@ -4441,13 +4604,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 { low, high };
+            return setHidden({ low, high }, osTypeKey, type);
         }
         case 'bool': // Boolean
             return !!(0, psdReader_1.readUint8)(reader);
         case 'type': // Class
         case 'GlbC': // Class
-            return readClassStructure(reader);
+            return setHidden(readClassStructure(reader), osTypeKey, type);
         case 'alis': { // Alias
             const length = (0, psdReader_1.readInt32)(reader);
             return (0, psdReader_1.readAsciiString)(reader, length);
@@ -4459,21 +4622,21 @@ function readOSType(reader, type, includeClass) {
         case 'ObAr': { // Object array
             (0, psdReader_1.readInt32)(reader); // version: 16
             (0, psdReader_1.readUnicodeString)(reader); // name: ''
-            readAsciiStringOrClassId(reader); // 'rationalPoint'
+            const classID = readAsciiStringOrClassId(reader); // 'rationalPoint'
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
             for (let i = 0; i < length; i++) {
                 const type1 = readAsciiStringOrClassId(reader); // type Hrzn | Vrtc
-                (0, psdReader_1.readSignature)(reader); // UnFl
-                (0, psdReader_1.readSignature)(reader); // units ? '#Pxl'
+                const valueType = (0, psdReader_1.readSignature)(reader); // UnFl
+                const units = (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({ type: type1, values });
+                items.push(setHidden({ type: type1, values }, obArInfoKey, { valueType, units }));
             }
-            return items;
+            return setHidden(items, obArInfoKey, { classID });
         }
         case 'Pth ': { // File path
             /*const length =*/ (0, psdReader_1.readInt32)(reader); // total size of all fields below
@@ -4493,6 +4656,7 @@ const ObArTypes = {
     quiltSliceY: 'UntF',
 };
 function writeOSType(writer, type, value, key, extType, root) {
+    var _a, _b, _c, _d, _e;
     switch (type) {
         case 'obj ': // Reference
             writeReferenceStructure(writer, key, value);
@@ -4501,9 +4665,9 @@ function writeOSType(writer, type, value, key, extType, root) {
         case 'GlbO': { // GlobalObject same as Descriptor
             if (typeof value !== 'object')
                 throw new Error(`Invalid struct value: ${JSON.stringify(value)}, key: ${key}`);
-            if (!extType)
+            if (!extType && !value._classID)
                 throw new Error(`Missing ext type for: '${key}' (${JSON.stringify(value)})`);
-            const name = value._name || extType.name;
+            const name = value._name || (extType === null || extType === void 0 ? void 0 : extType.name) || '';
             const classID = value._classID || extType.classID;
             writeDescriptorStructure(writer, name, classID, value, root);
             break;
@@ -4513,7 +4677,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 = fieldToArrayType[key];
+                const type = (_a = getRecordedOSType(value[i], 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)
@@ -4551,20 +4715,35 @@ function writeOSType(writer, type, value, key, extType, root) {
         case 'long': // Integer
             if (typeof value !== 'number')
                 throw new Error(`Invalid integer value: ${JSON.stringify(value)}, key: ${key}`);
-            (0, psdWriter_1.writeInt32)(writer, value);
+            (0, psdWriter_1.writeInt32)(writer, Math.round(value)); // round instead of truncating fractional values
+            break;
+        case 'comp': // Large Integer
+            if (!value || typeof value !== 'object')
+                throw new Error(`Invalid large integer value: ${JSON.stringify(value)}, key: ${key}`);
+            (0, psdWriter_1.writeUint32)(writer, value.low >>> 0);
+            (0, psdWriter_1.writeUint32)(writer, value.high >>> 0);
             break;
-        // case 'comp': // Large Integer
-        // 	writeLargeInteger(reader);
         case 'bool': // Boolean
             if (typeof value !== 'boolean')
                 throw new Error(`Invalid boolean value: ${JSON.stringify(value)}, key: ${key}`);
             (0, psdWriter_1.writeUint8)(writer, value ? 1 : 0);
             break;
-        // case 'type': // Class
-        // case 'GlbC': // Class
-        // 	writeClassStructure(reader);
-        // case 'alis': // Alias
-        // 	writeAliasStructure(reader);
+        case 'type': // Class
+        case 'GlbC': // Class
+            if (!value || typeof value !== 'object')
+                throw new Error(`Invalid class value: ${JSON.stringify(value)}, key: ${key}`);
+            (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, value.name || '');
+            writeAsciiStringOrClassId(writer, value.classID);
+            break;
+        case 'alis': { // Alias (read as a binary string, one char per byte)
+            if (typeof value !== 'string')
+                throw new Error(`Invalid alias value: ${JSON.stringify(value)}, key: ${key}`);
+            (0, psdWriter_1.writeInt32)(writer, value.length);
+            for (let i = 0; i < value.length; i++) {
+                (0, psdWriter_1.writeUint8)(writer, value.charCodeAt(i) & 0xff);
+            }
+            break;
+        }
         case 'tdta': // Raw Data
             (0, psdWriter_1.writeInt32)(writer, value.byteLength);
             (0, psdWriter_1.writeBytes)(writer, value);
@@ -4572,15 +4751,16 @@ 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 = ObArTypes[key];
+            const type = (_c = (_b = getHidden(value, obArInfoKey)) === null || _b === void 0 ? void 0 : _b.classID) !== null && _c !== void 0 ? _c : 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, 'UnFl');
-                (0, psdWriter_1.writeSignature)(writer, '#Pxl');
+                (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.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]);
@@ -4601,85 +4781,144 @@ function writeOSType(writer, type, value, key, extType, root) {
             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);
+}
 function readReferenceStructure(reader) {
     const itemsCount = (0, psdReader_1.readInt32)(reader);
-    const items = [];
+    const infos = [];
     for (let i = 0; i < itemsCount; i++) {
         const type = (0, psdReader_1.readSignature)(reader);
         switch (type) {
             case 'prop': { // Property
-                readClassStructure(reader);
+                const { name, classID } = readClassStructure(reader);
                 const keyID = readAsciiStringOrClassId(reader);
-                items.push(keyID);
+                infos.push({ type, name, classID, keyID });
                 break;
             }
-            case 'Clss': // Class
-                items.push(readClassStructure(reader));
+            case 'Clss': { // Class
+                const { name, classID } = readClassStructure(reader);
+                infos.push({ type, name, classID });
                 break;
+            }
             case 'Enmr': { // Enumerated Reference
-                readClassStructure(reader);
+                const { name, classID } = readClassStructure(reader);
                 const typeID = readAsciiStringOrClassId(reader);
-                const value = readAsciiStringOrClassId(reader);
-                items.push(`${typeID}.${value}`);
+                const enumValue = readAsciiStringOrClassId(reader);
+                infos.push({ type, name, classID, typeID, enumValue });
                 break;
             }
             case 'rele': { // Offset
-                // const { name, classID } =
-                readClassStructure(reader);
-                items.push((0, psdReader_1.readUint32)(reader));
+                const { name, classID } = readClassStructure(reader);
+                infos.push({ type, name, classID, value: (0, psdReader_1.readUint32)(reader) });
                 break;
             }
             case 'Idnt': // Identifier
-                items.push((0, psdReader_1.readInt32)(reader));
-                break;
             case 'indx': // Index
-                items.push((0, psdReader_1.readInt32)(reader));
+                infos.push({ type, value: (0, psdReader_1.readInt32)(reader) });
                 break;
             case 'name': { // Name
-                readClassStructure(reader);
-                items.push((0, psdReader_1.readUnicodeString)(reader));
+                const { name, classID } = readClassStructure(reader);
+                infos.push({ type, name, classID, value: (0, psdReader_1.readUnicodeString)(reader) });
                 break;
             }
             default:
                 throw new Error(`Invalid descriptor reference type: ${type}`);
         }
     }
-    return items;
+    return createDescriptorReference(infos);
+}
+function guessReferenceItem(value) {
+    if (typeof value === 'string') {
+        // enumerated references are read as `${typeID}.${enumValue}` where typeID is a 4 character ID or a string ID
+        // (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] };
+        }
+        else {
+            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 };
+    }
+    else {
+        throw new Error(`Invalid descriptor reference value: ${JSON.stringify(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
+        const item = guessReferenceItem(value);
+        if (item.type === 'Enmr')
+            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];
-        let type = 'unknown';
-        if (typeof value === 'string') {
-            if (/^[a-z ]+\.[a-z ]+$/i.test(value)) {
-                type = 'Enmr';
-            }
-            else {
-                type = 'name';
-            }
-        }
-        (0, psdWriter_1.writeSignature)(writer, type);
-        switch (type) {
-            // case 'prop': // Property
-            // case 'Clss': // Class
-            case 'Enmr': { // Enumerated Reference
-                const [typeID, enumValue] = value.split('.');
-                writeClassStructure(writer, '\0', typeID);
-                writeAsciiStringOrClassId(writer, typeID);
-                writeAsciiStringOrClassId(writer, enumValue);
+        const recorded = infos === null || infos === void 0 ? void 0 : infos[i];
+        const item = referenceItemMatches(recorded, value) ? recorded : guessReferenceItem(value);
+        (0, psdWriter_1.writeSignature)(writer, item.type);
+        switch (item.type) {
+            case 'prop': // Property
+                writeClassStructure(writer, item.name || '', item.classID);
+                writeAsciiStringOrClassId(writer, item.keyID);
                 break;
-            }
-            // case 'rele': // Offset
-            // case 'Idnt': // Identifier
-            // case 'indx': // Index
-            case 'name': { // Name
-                writeClassStructure(writer, '\0', 'Lyr ');
-                (0, psdWriter_1.writeUnicodeString)(writer, value + '\0');
+            case 'Clss': // Class
+                writeClassStructure(writer, item.name || '', item.classID);
+                break;
+            case 'Enmr': // Enumerated Reference
+                writeClassStructure(writer, item.name || '', item.classID);
+                writeAsciiStringOrClassId(writer, item.typeID);
+                writeAsciiStringOrClassId(writer, item.enumValue);
+                break;
+            case 'rele': // Offset
+                writeClassStructure(writer, item.name || '', item.classID);
+                (0, psdWriter_1.writeUint32)(writer, item.value);
+                break;
+            case 'Idnt': // Identifier
+            case 'indx': // Index
+                (0, psdWriter_1.writeInt32)(writer, item.value);
+                break;
+            case 'name': // Name
+                writeClassStructure(writer, item.name || '', item.classID);
+                (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, `${item.value}`);
                 break;
-            }
             default:
-                throw new Error(`Invalid descriptor reference type: ${type}`);
+                throw new Error(`Invalid descriptor reference type: ${item.type}`);
         }
     }
     return items;
@@ -4690,7 +4929,7 @@ function readClassStructure(reader) {
     return { name, classID };
 }
 function writeClassStructure(writer, name, classID) {
-    (0, psdWriter_1.writeUnicodeString)(writer, name);
+    (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
     writeAsciiStringOrClassId(writer, classID);
 }
 function readVersionAndDescriptor(reader, includeClass = false) {
@@ -4822,9 +5061,11 @@ function serializeEffects(e, log, multi) {
         info.numModifyingFX = 0;
         for (const key of Object.keys(e)) {
             const value = e[key];
+            if (value == null || typeof value !== 'object')
+                continue;
             if (Array.isArray(value)) {
                 for (const effect of value) {
-                    if (effect.enabled)
+                    if (effect === null || effect === void 0 ? void 0 : effect.enabled)
                         info.numModifyingFX++;
                 }
             }
@@ -4973,7 +5214,7 @@ function serializeTrackList(tracks) {
         const t = tracks[i];
         trackList.push(Object.assign(Object.assign({ trackID: exports.stdTrackID.encode(t.type), Vrsn: 1, enab: !!t.enabled, Effc: !!t.effectParams }, (t.effectParams ? {
             effectParams: {
-                keyList: serializeKeyList(t.keys),
+                keyList: serializeKeyList(t.effectParams.keys),
                 fillCanvas: t.effectParams.fillCanvas,
                 zoomOrigin: t.effectParams.zoomOrigin,
             }
@@ -5216,7 +5457,7 @@ function serializeEffectObject(obj, objName, reportErrors) {
                 result.sdwO = unitsPercent(val);
                 break;
             case 'angle':
-                if (objName === 'gradientOverlay' || objName === 'patternFill') {
+                if (objName === 'gradientOverlay' || objName === 'patternOverlay') {
                     result.Angl = unitsAngle(val);
                 }
                 else {
@@ -5288,7 +5529,8 @@ function serializeEffectObject(obj, objName, reportErrors) {
 }
 function parseGradient(grad) {
     if (grad.GrdF === 'GrdF.CstS') {
-        const samples = grad.Intr || 4096;
+        // stop locations are always in 0..4096 range, independent of smoothness (Intr)
+        const samples = 4096;
         return {
             type: 'solid',
             name: grad['Nm  '],
@@ -5322,11 +5564,12 @@ function parseGradient(grad) {
 function serializeGradient(grad) {
     var _a, _b;
     if (grad.type === 'solid') {
-        const samples = Math.round(((_a = grad.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096);
+        // stop locations are always in 0..4096 range, independent of smoothness (Intr)
+        const samples = 4096;
         return {
             'Nm  ': grad.name || '',
             GrdF: 'GrdF.CstS',
-            Intr: samples,
+            Intr: Math.round(((_a = grad.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096),
             Clrs: grad.colorStops.map(s => {
                 var _a;
                 return ({
@@ -5355,8 +5598,8 @@ function serializeGradient(grad) {
             ClrS: exports.ClrS.encode(grad.colorModel),
             RndS: grad.randomSeed || 0,
             Smth: Math.round(((_b = grad.roughness) !== null && _b !== void 0 ? _b : 1) * 4096),
-            'Mnm ': (grad.min || [0, 0, 0, 0]).map(x => x * 100),
-            'Mxm ': (grad.max || [1, 1, 1, 1]).map(x => x * 100),
+            'Mnm ': (grad.min || [0, 0, 0, 0]).map(x => Math.round(x * 100)),
+            'Mxm ': (grad.max || [1, 1, 1, 1]).map(x => Math.round(x * 100)),
         };
     }
 }
@@ -5456,21 +5699,65 @@ function serializeVectorContent(content) {
         return { key: 'GdFl', descriptor: serializeGradientContent(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]
+    Strt: [x => x / 100, x => x * 100],
+    Brgh: [x => x / 100, x => x * 100],
+    'Cyn ': [x => x * 255 / 100, x => x * 100 / 255],
+    Mgnt: [x => x * 255 / 100, x => x * 100 / 255],
+    'Ylw ': [x => x * 255 / 100, x => x * 100 / 255],
+    Blck: [x => x * 255 / 100, x => x * 100 / 255],
+    'Gry ': [x => x * 255 / 100, x => x * 100 / 255],
+    Lmnc: [x => x / 100, x => x * 100],
+    'A   ': [helpers_1.normalizeLabAB, helpers_1.denormalizeLabAB],
+    'B   ': [helpers_1.normalizeLabAB, helpers_1.denormalizeLabAB],
+};
+function colorToDescriptorValue(key, value) {
+    const conversion = colorConversions[key];
+    if (!conversion)
+        return value;
+    const [from, to] = conversion;
+    const result = to(value);
+    if (!isFinite(result))
+        return result;
+    // prefer shortest number that converts back to the same value (avoids values like 30.200000000000003)
+    for (let precision = 1; precision < 17; precision++) {
+        const candidate = +result.toPrecision(precision);
+        if (from(candidate) === value)
+            return candidate;
+    }
+    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 parseColor(color) {
+    let result;
     if ('H   ' in color) {
-        return { h: parsePercentOrAngle(color['H   ']), s: color.Strt, b: color.Brgh };
+        result = { 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) {
-        return { c: color['Cyn '], m: color.Mgnt, y: color['Ylw '], k: color.Blck };
+        result = {
+            c: color['Cyn '] * 255 / 100,
+            m: color.Mgnt * 255 / 100,
+            y: color['Ylw '] * 255 / 100,
+            k: color.Blck * 255 / 100,
+        };
     }
     else if ('Gry ' in color) {
-        return { k: color['Gry '] };
+        result = { k: color['Gry '] * 255 / 100 };
     }
     else if ('Lmnc' in color) {
-        return { l: color.Lmnc, a: color['A   '], b: color['B   '] };
+        result = { 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 };
@@ -5478,8 +5765,10 @@ function parseColor(color) {
     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 serializeColor(color) {
+function serializeColorValues(color) {
     if (!color) {
         return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
     }
@@ -5490,21 +5779,50 @@ function serializeColor(color) {
         return { _name: '', _classID: 'RGBC', redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
     }
     else if ('h' in color) {
-        return { _name: '', _classID: 'HSBC', 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
+        return {
+            _name: '', _classID: 'HSBC',
+            'H   ': unitsAngle((color.h || 0) * 360),
+            Strt: colorToDescriptorValue('Strt', color.s || 0),
+            Brgh: colorToDescriptorValue('Brgh', color.b || 0),
+        };
     }
     else if ('c' in color) {
-        return { _name: '', _classID: 'CMYC', 'Cyn ': color.c || 0, Mgnt: color.m || 0, 'Ylw ': color.y || 0, Blck: color.k || 0 };
+        return {
+            _name: '', _classID: 'CMYC',
+            'Cyn ': colorToDescriptorValue('Cyn ', color.c || 0),
+            Mgnt: colorToDescriptorValue('Mgnt', color.m || 0),
+            'Ylw ': colorToDescriptorValue('Ylw ', color.y || 0),
+            Blck: colorToDescriptorValue('Blck', color.k || 0),
+        };
     }
     else if ('l' in color) {
-        return { _name: '', _classID: 'LABC', Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
+        return {
+            _name: '', _classID: 'LbCl',
+            Lmnc: colorToDescriptorValue('Lmnc', color.l || 0),
+            'A   ': colorToDescriptorValue('A   ', color.a || 0),
+            'B   ': colorToDescriptorValue('B   ', color.b || 0),
+        };
     }
     else if ('k' in color) {
-        return { _name: '', _classID: 'GRYC', 'Gry ': color.k };
+        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];
+            }
+        }
+    }
+    return result;
+}
 function parseAngle(x) {
     if (x === undefined)
         return 0;
@@ -5921,9 +6239,9 @@ function readEffects(reader) {
             case 'cmnS': { // common state (see See Effects layer, common state info)
                 const size = (0, psdReader_1.readUint32)(reader);
                 const version = (0, psdReader_1.readUint32)(reader);
-                const visible = !!(0, psdReader_1.readUint8)(reader);
+                (0, psdReader_1.readUint8)(reader); // visible (not reliable, Photoshop writes 1 even if effects are disabled)
                 (0, psdReader_1.skipBytes)(reader, 2);
-                if (size !== 7 || version !== 0 || !visible)
+                if (size !== 7 || version !== 0)
                     throw new Error(`Invalid effects common state`);
                 break;
             }
@@ -6071,7 +6389,7 @@ function writeShadowInfo(writer, shadow) {
     (0, psdWriter_1.writeColor)(writer, shadow.color); // native color
 }
 function writeEffects(writer, effects) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     const dropShadow = (_a = effects.dropShadow) === null || _a === void 0 ? void 0 : _a[0];
     const innerShadow = (_b = effects.innerShadow) === null || _b === void 0 ? void 0 : _b[0];
     const outerGlow = effects.outerGlow;
@@ -6097,7 +6415,7 @@ function writeEffects(writer, effects) {
     (0, psdWriter_1.writeSignature)(writer, 'cmnS');
     (0, psdWriter_1.writeUint32)(writer, 7); // size
     (0, psdWriter_1.writeUint32)(writer, 0); // version
-    (0, psdWriter_1.writeUint8)(writer, 1); // visible
+    (0, psdWriter_1.writeUint8)(writer, 1); // visible (Photoshop writes 1 here even if effects are disabled)
     (0, psdWriter_1.writeZeros)(writer, 2);
     if (dropShadow) {
         (0, psdWriter_1.writeSignature)(writer, '8BIM');
@@ -6119,7 +6437,7 @@ function writeEffects(writer, effects) {
         (0, psdWriter_1.writeColor)(writer, outerGlow.color);
         writeBlendMode(writer, outerGlow.blendMode);
         (0, psdWriter_1.writeUint8)(writer, outerGlow.enabled ? 1 : 0);
-        writeFixedPoint8(writer, outerGlow.opacity || 0);
+        writeFixedPoint8(writer, (_e = outerGlow.opacity) !== null && _e !== void 0 ? _e : 1);
         (0, psdWriter_1.writeColor)(writer, outerGlow.color);
     }
     if (innerGlow) {
@@ -6127,12 +6445,12 @@ function writeEffects(writer, effects) {
         (0, psdWriter_1.writeSignature)(writer, 'iglw');
         (0, psdWriter_1.writeUint32)(writer, 43);
         (0, psdWriter_1.writeUint32)(writer, 2);
-        (0, psdWriter_1.writeFixedPoint32)(writer, ((_e = innerGlow.size) === null || _e === void 0 ? void 0 : _e.value) || 0);
+        (0, psdWriter_1.writeFixedPoint32)(writer, ((_f = innerGlow.size) === null || _f === void 0 ? void 0 : _f.value) || 0);
         (0, psdWriter_1.writeFixedPoint32)(writer, 0); // intensity
         (0, psdWriter_1.writeColor)(writer, innerGlow.color);
         writeBlendMode(writer, innerGlow.blendMode);
         (0, psdWriter_1.writeUint8)(writer, innerGlow.enabled ? 1 : 0);
-        writeFixedPoint8(writer, innerGlow.opacity || 0);
+        writeFixedPoint8(writer, (_g = innerGlow.opacity) !== null && _g !== void 0 ? _g : 1);
         (0, psdWriter_1.writeUint8)(writer, 0); // inverted
         (0, psdWriter_1.writeColor)(writer, innerGlow.color);
     }
@@ -6143,15 +6461,15 @@ function writeEffects(writer, effects) {
         (0, psdWriter_1.writeUint32)(writer, 2);
         (0, psdWriter_1.writeFixedPoint32)(writer, bevel.angle || 0);
         (0, psdWriter_1.writeFixedPoint32)(writer, bevel.strength || 0);
-        (0, psdWriter_1.writeFixedPoint32)(writer, ((_f = bevel.size) === null || _f === void 0 ? void 0 : _f.value) || 0);
+        (0, psdWriter_1.writeFixedPoint32)(writer, ((_h = bevel.size) === null || _h === void 0 ? void 0 : _h.value) || 0);
         writeBlendMode(writer, bevel.highlightBlendMode);
         writeBlendMode(writer, bevel.shadowBlendMode);
         (0, psdWriter_1.writeColor)(writer, bevel.highlightColor);
         (0, psdWriter_1.writeColor)(writer, bevel.shadowColor);
         const style = bevelStyles.indexOf(bevel.style);
-        (0, psdWriter_1.writeUint8)(writer, style <= 0 ? 1 : style);
-        writeFixedPoint8(writer, bevel.highlightOpacity || 0);
-        writeFixedPoint8(writer, bevel.shadowOpacity || 0);
+        (0, psdWriter_1.writeUint8)(writer, style <= 0 ? bevelStyles.indexOf('inner bevel') : style); // reader defaults to inner bevel
+        writeFixedPoint8(writer, (_j = bevel.highlightOpacity) !== null && _j !== void 0 ? _j : 1);
+        writeFixedPoint8(writer, (_k = bevel.shadowOpacity) !== null && _k !== void 0 ? _k : 1);
         (0, psdWriter_1.writeUint8)(writer, bevel.enabled ? 1 : 0);
         (0, psdWriter_1.writeUint8)(writer, bevel.useGlobalLight ? 1 : 0);
         (0, psdWriter_1.writeUint8)(writer, bevel.direction === 'down' ? 1 : 0);
@@ -6165,7 +6483,7 @@ function writeEffects(writer, effects) {
         (0, psdWriter_1.writeUint32)(writer, 2);
         writeBlendMode(writer, solidFill.blendMode);
         (0, psdWriter_1.writeColor)(writer, solidFill.color);
-        writeFixedPoint8(writer, solidFill.opacity || 0);
+        writeFixedPoint8(writer, (_l = solidFill.opacity) !== null && _l !== void 0 ? _l : 1);
         (0, psdWriter_1.writeUint8)(writer, solidFill.enabled ? 1 : 0);
         (0, psdWriter_1.writeColor)(writer, solidFill.color);
     }
@@ -6174,6 +6492,7 @@ function writeEffects(writer, effects) {
 },{"./helpers":8,"./psdReader":13,"./psdWriter":14}],6:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setProperty = setProperty;
 exports.parseEngineData = parseEngineData;
 exports.serializeEngineData = serializeEngineData;
 function isWhitespace(char) {
@@ -6184,7 +6503,15 @@ function isNumber(char) {
     // 0123456789.-
     return (char >= 48 && char <= 57) || char === 46 || char === 45;
 }
-function parseEngineData(data) {
+function setProperty(target, key, value) {
+    if (key === '__proto__') { // avoid changing prototype of the object
+        Object.defineProperty(target, key, { value, enumerable: true, configurable: true, writable: true });
+    }
+    else {
+        target[key] = value;
+    }
+}
+function parseEngineData(data, reader) {
     let index = 0;
     function skipWhitespace() {
         while (index < data.length && isWhitespace(data[index])) {
@@ -6206,9 +6533,13 @@ function parseEngineData(data) {
             index++;
             return result;
         }
-        // Strings start with utf-16 BOM
+        // Strings usually start with utf-16 BOM, strings without it are single-byte (e.g. "(01110)" in Txt2)
         if (data[index] !== 0xFE || data[index + 1] !== 0xFF) {
-            throw new Error('Invalid utf-16 BOM');
+            while (index < data.length && data[index] !== 41) { // )
+                result += String.fromCharCode(getTextByte());
+            }
+            index++;
+            return result;
         }
         index += 2;
         // ), ( and \ characters are escaped in ascii manner, remove the escapes before interpreting
@@ -6239,7 +6570,8 @@ function parseEngineData(data) {
             throw new Error('Invalid data');
         const top = stack[stack.length - 1];
         if (typeof top === 'string') {
-            stack[stack.length - 2][top] = value;
+            const target = stack[stack.length - 2];
+            setProperty(target, top, value);
             pop();
         }
         else if (Array.isArray(top)) {
@@ -6253,7 +6585,8 @@ function parseEngineData(data) {
         if (!stack.length)
             pushContainer({});
         const top = stack[stack.length - 1];
-        if (top && typeof top === 'string') {
+        if (typeof top === 'string' || Array.isArray(top)) {
+            // name used as a value (either property value or array item)
             if (name === 'nil') {
                 pushValue(null);
             }
@@ -6275,6 +6608,8 @@ function parseEngineData(data) {
     }
     skipWhitespace();
     let dataLength = data.length;
+    let invalidTokens = 0;
+    let firstInvalidToken = '';
     while (dataLength > 0 && data[dataLength - 1] === 0)
         dataLength--; // trim 0 bytes from end
     while (index < dataLength) {
@@ -6334,14 +6669,16 @@ function parseEngineData(data) {
         }
         else {
             index += 1;
-            console.log(`Invalid token '${String.fromCharCode(char)}' (${char}) at ${index}`
-            // + ` near '${String.fromCharCode.apply(null, data.slice(index - 10, index + 20) as any)}'`
-            // + ` data [${Array.from(data.slice(index - 10, index + 20)).join(', ')}]`
-            );
+            if (!invalidTokens)
+                firstInvalidToken = `'${String.fromCharCode(char)}' (${char}) at ${index}`;
+            invalidTokens++;
             // throw new Error(`Invalid token ${String.fromCharCode(char)} at ${index}`);
         }
         skipWhitespace();
     }
+    if (invalidTokens) {
+        reader.log(`Invalid tokens in engine data (${invalidTokens} in total, first: ${firstInvalidToken})`);
+    }
     return root;
 }
 const floatKeys = [
@@ -6351,7 +6688,6 @@ const floatKeys = [
     'OutlineWidth', 'AutoLeading',
 ];
 const intArrays = ['RunLengthArray'];
-// TODO: handle /nil
 function serializeEngineData(data, condensed = false) {
     let buffer = new Uint8Array(1024);
     let offset = 0;
@@ -6387,16 +6723,21 @@ function serializeEngineData(data, condensed = false) {
         if (!condensed)
             writeString('\n');
     }
+    // NaN and Infinity can't be represented in engine data, write them as 0
+    function finite(value) {
+        return Number.isFinite(value) ? value : 0;
+    }
     function serializeInt(value) {
-        return value.toString();
+        return finite(value).toString();
     }
     function serializeFloat(value) {
-        return value.toFixed(5)
+        return finite(value).toFixed(5)
             .replace(/(\d)0+$/g, '$1')
             .replace(/^0+\.([1-9])/g, '.$1')
             .replace(/^-0+\.0(\d)/g, '-.0$1');
     }
     function serializeNumber(value, key) {
+        value = finite(value);
         const isFloat = (key && floatKeys.indexOf(key) !== -1) || (value | 0) !== value;
         return isFloat ? serializeFloat(value) : serializeInt(value);
     }
@@ -6423,7 +6764,7 @@ function serializeEngineData(data, condensed = false) {
                 writeIndent();
             }
         }
-        if (value === null) {
+        if (value === null || value === undefined) { // undefined is only written for array items, properties are skipped
             writePrefix();
             writeString(condensed ? '/nil' : 'null');
         }
@@ -6485,7 +6826,8 @@ function serializeEngineData(data, condensed = false) {
                 writeString('\n');
             indent++;
             for (const key of getKeys(value)) {
-                writeProperty(key, value[key]);
+                if (value[key] !== undefined)
+                    writeProperty(key, value[key]);
             }
             indent--;
             writeIndent();
@@ -6496,7 +6838,8 @@ function serializeEngineData(data, condensed = false) {
     if (condensed) {
         if (typeof data === 'object') {
             for (const key of getKeys(data)) {
-                writeProperty(key, data[key]);
+                if (data[key] !== undefined)
+                    writeProperty(key, data[key]);
             }
         }
     }
@@ -6513,6 +6856,7 @@ function serializeEngineData(data, condensed = false) {
 // /test/engineData2.json:1109 is character codes
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeEngineData2 = decodeEngineData2;
+const engineData_1 = require("./engineData");
 const keysColor = {
     '0': {
         uproot: true,
@@ -6883,48 +7227,78 @@ const keysRoot = {
         },
     },
 };
-function decodeObj(obj, keys) {
+const MAX_DEPTH = 256;
+function getKey(keys, key) {
+    return Object.prototype.hasOwnProperty.call(keys, key) ? keys[key] : undefined;
+}
+function decodeObj(obj, keys, depth) {
     var _a, _b;
-    if (obj === null)
+    if (depth > MAX_DEPTH)
+        throw new Error(`Engine data is nested too deeply (more than ${MAX_DEPTH} levels)`);
+    if (obj === null || obj === undefined)
         return obj;
     if (Array.isArray(obj))
-        return obj.map(x => decodeObj(x, keys));
+        return obj.map(x => decodeObj(x, keys, depth + 1));
     if (typeof obj !== 'object')
         return obj;
-    let result = {};
-    for (const key of Object.keys(obj)) {
-        if (keys[key]) {
-            if (keys[key].uproot) {
-                if (key !== '99')
-                    result = decodeObj(obj[key], (_a = keys[key].children) !== null && _a !== void 0 ? _a : {});
-                if (obj['99'])
-                    result._type = obj['99'];
-                break;
-            }
-            else {
-                result[keys[key].name || key] = decodeObj(obj[key], (_b = keys[key].children) !== null && _b !== void 0 ? _b : {});
-            }
-        }
-        else if (key === '99') {
-            result._type = obj[key];
+    const objKeys = Object.keys(obj);
+    const uprootKey = objKeys.find(key => { var _a; return key !== '99' && ((_a = getKey(keys, key)) === null || _a === void 0 ? void 0 : _a.uproot); });
+    let result;
+    if (uprootKey !== undefined) {
+        // replace the object with the value of the uprooted key
+        result = decodeObj(obj[uprootKey], (_a = getKey(keys, uprootKey).children) !== null && _a !== void 0 ? _a : {}, depth + 1);
+        // primitive values can't hold extra properties (type and sibling keys are dropped)
+        if (result === null || typeof result !== 'object')
+            return result;
+        if (obj['99'])
+            result._type = obj['99'];
+        if (Array.isArray(result))
+            return result;
+    }
+    else {
+        result = {};
+    }
+    for (const key of objKeys) {
+        if (key === uprootKey)
+            continue;
+        const info = getKey(keys, key);
+        if (key === '99') {
+            if (uprootKey === undefined)
+                result._type = obj[key];
         }
         else {
-            result[key] = decodeObj(obj[key], {});
+            const name = (info === null || info === void 0 ? void 0 : info.name) || key;
+            // don't overwrite fields of uprooted object with sibling keys
+            if (uprootKey === undefined || !(name in result)) {
+                (0, engineData_1.setProperty)(result, name, decodeObj(obj[key], (_b = info === null || info === void 0 ? void 0 : info.children) !== null && _b !== void 0 ? _b : {}, depth + 1));
+            }
         }
     }
     return result;
 }
+function emptyResourceDict() {
+    return { FontSet: [], StyleSheetSet: [], ParagraphSheetSet: [] };
+}
 function decodeEngineData2(data) {
-    return decodeObj(data, keysRoot);
+    const result = decodeObj(data, keysRoot, 0);
+    if (!result || typeof result !== 'object' || Array.isArray(result)) {
+        return { ResourceDict: emptyResourceDict(), EngineDict: {} };
+    }
+    if (!result.ResourceDict || typeof result.ResourceDict !== 'object') {
+        result.ResourceDict = emptyResourceDict();
+    }
+    return result;
 }
 
-},{}],8:[function(require,module,exports){
+},{"./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.revMap = revMap;
 exports.createEnum = createEnum;
 exports.offsetForChannel = offsetForChannel;
+exports.normalizeLabAB = normalizeLabAB;
+exports.denormalizeLabAB = denormalizeLabAB;
 exports.clamp = clamp;
 exports.hasAlpha = hasAlpha;
 exports.resetImageData = resetImageData;
@@ -7044,6 +7418,13 @@ function offsetForChannel(channelId, cmyk) {
         default: return channelId + 1;
     }
 }
+// Lab a/b components are stored in -128..127 range (multiplied by scale), normalized values are in -1..1 range
+function normalizeLabAB(value, scale = 1) {
+    return value < 0 ? (value / (128 * scale)) : (value / (127 * scale));
+}
+function denormalizeLabAB(value, scale = 1) {
+    return value < 0 ? (value * (128 * scale)) : (value * (127 * scale));
+}
 function clamp(value, min, max) {
     return value < min ? min : (value > max ? max : value);
 }
@@ -7119,9 +7500,10 @@ function writeDataRaw(data, offset, width, height) {
     }
     return array;
 }
+// returns view into the buffer, the buffer has to fit worst case size (see getRLEChannelBound), throws if it doesn't
 function writeDataRLE(buffer, { data, width, height }, offsets, large) {
     if (!width || !height)
-        return undefined;
+        return buffer.subarray(0, 0);
     const stride = (4 * width) | 0;
     let ol = 0;
     let o = (offsets.length * (large ? 4 : 2) * height) | 0;
@@ -7198,6 +7580,9 @@ function writeDataRLE(buffer, { data, width, height }, offsets, large) {
                     buffer[o++] = data[p];
                 }
             }
+            // writes past the end of typed array are ignored, so it's enough to check the size after each row
+            if (o > buffer.length)
+                throw new Error(`RLE buffer too small (${buffer.length})`);
             const length = o - startOffset;
             if (large) {
                 buffer[ol++] = (length >> 24) & 0xff;
@@ -7207,7 +7592,8 @@ function writeDataRLE(buffer, { data, width, height }, offsets, large) {
             buffer[ol++] = length & 0xff;
         }
     }
-    return buffer.slice(0, o);
+    // returns view of the buffer, copy the data if the buffer is going to be reused
+    return buffer.subarray(0, o);
 }
 function writeDataZipWithoutPrediction({ data, width, height }, offsets) {
     const size = width * height;
@@ -7235,7 +7621,7 @@ function writeDataZipWithoutPrediction({ data, width, height }, offsets) {
         return buffers[0];
     }
 }
-function createCanvasFromData(data) {
+function createCanvasFromData(data, reader) {
     const canvas = (0, exports.createCanvas)(100, 100);
     try {
         const context = canvas.getContext('2d');
@@ -7245,7 +7631,7 @@ function createCanvasFromData(data) {
         context.putImageData(imageData, 0, 0);
     }
     catch (e) {
-        console.error('JPEG decompression error', e.message);
+        reader.log('JPEG decompression error', e.message);
     }
     return canvas;
 }
@@ -7312,6 +7698,18 @@ 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);
@@ -7323,19 +7721,26 @@ function readEncodedString(reader) {
         }
     }
     if (notAscii) {
-        try {
-            const decoder = new TextDecoder('gbk');
-            return decoder.decode(buffer);
+        const decoder = getGbkDecoder();
+        if (decoder) {
+            try {
+                return decoder.decode(buffer);
+            }
+            catch (_a) { }
         }
-        catch (_a) { }
     }
     return (0, utf8_1.decodeString)(buffer);
 }
 function writeEncodedString(writer, value) {
     let ascii = '';
-    for (let i = 0, code = value.codePointAt(i++); code !== undefined; code = value.codePointAt(i++)) {
-        ascii += code > 0x7f ? '?' : String.fromCodePoint(code);
+    for (let i = 0; i < value.length;) {
+        const code = value.codePointAt(i);
+        ascii += code > 0x7f ? '?' : String.fromCharCode(code);
+        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);
     (0, psdWriter_1.writeUint8)(writer, buffer.byteLength);
     (0, psdWriter_1.writeBytes)(writer, buffer);
@@ -7540,7 +7945,7 @@ addHandler(1053, target => target.alphaIdentifiers !== undefined, (reader, targe
 addHandler(1010, target => target.backgroundColor !== undefined, (reader, target) => target.backgroundColor = (0, psdReader_1.readColor)(reader), (writer, target) => (0, psdWriter_1.writeColor)(writer, target.backgroundColor));
 addHandler(1037, target => target.globalAngle !== undefined, (reader, target) => target.globalAngle = (0, psdReader_1.readInt32)(reader), (writer, target) => (0, psdWriter_1.writeInt32)(writer, target.globalAngle));
 addHandler(1049, target => target.globalAltitude !== undefined, (reader, target) => target.globalAltitude = (0, psdReader_1.readUint32)(reader), (writer, target) => (0, psdWriter_1.writeUint32)(writer, target.globalAltitude));
-addHandler(1011, target => target.printFlags !== undefined, (reader, target) => {
+addHandler(1011, target => target.printFlags !== undefined, (reader, target, left) => {
     target.printFlags = {
         labels: !!(0, psdReader_1.readUint8)(reader),
         cropMarks: !!(0, psdReader_1.readUint8)(reader),
@@ -7550,7 +7955,7 @@ addHandler(1011, target => target.printFlags !== undefined, (reader, target) =>
         flip: !!(0, psdReader_1.readUint8)(reader),
         interpolate: !!(0, psdReader_1.readUint8)(reader),
         caption: !!(0, psdReader_1.readUint8)(reader),
-        printFlags: !!(0, psdReader_1.readUint8)(reader),
+        printFlags: left() ? !!(0, psdReader_1.readUint8)(reader) : false,
     };
 }, (writer, target) => {
     const flags = target.printFlags;
@@ -7676,7 +8081,7 @@ addHandler(1032, target => target.gridAndGuidesInformation !== undefined, (reade
     };
     for (let i = 0; i < count; i++) {
         target.gridAndGuidesInformation.guides.push({
-            location: (0, psdReader_1.readUint32)(reader) / 32,
+            location: (0, psdReader_1.readInt32)(reader) / 32,
             direction: (0, psdReader_1.readUint8)(reader) ? 'horizontal' : 'vertical'
         });
     }
@@ -7685,11 +8090,11 @@ addHandler(1032, target => target.gridAndGuidesInformation !== undefined, (reade
     const grid = info.grid || { horizontal: 18 * 32, vertical: 18 * 32 };
     const guides = info.guides || [];
     (0, psdWriter_1.writeUint32)(writer, 1);
-    (0, psdWriter_1.writeUint32)(writer, grid.horizontal);
-    (0, psdWriter_1.writeUint32)(writer, grid.vertical);
+    (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) {
-        (0, psdWriter_1.writeUint32)(writer, g.location * 32);
+        (0, psdWriter_1.writeInt32)(writer, Math.round(g.location * 32));
         (0, psdWriter_1.writeUint8)(writer, g.direction === 'horizontal' ? 1 : 0);
     }
 });
@@ -7705,10 +8110,10 @@ target => target.layerComps !== undefined, (reader, target) => {
             name: item['Nm  '],
             capturedInfo: item.capturedInfo,
         });
-        if ('comment' in item)
+        if (item.comment !== undefined)
             target.layerComps.list[target.layerComps.list.length - 1].comment = item.comment;
     }
-    if ('lastAppliedComp' in desc)
+    if (desc.lastAppliedComp !== undefined)
         target.layerComps.lastApplied = desc.lastAppliedComp;
 }, (writer, target) => {
     const layerComps = target.layerComps;
@@ -7717,13 +8122,13 @@ target => target.layerComps !== undefined, (reader, target) => {
         const t = {};
         t._classID = 'Comp';
         t['Nm  '] = item.name;
-        if ('comment' in item)
+        if (item.comment !== undefined)
             t.comment = item.comment;
         t.compID = item.id;
         t.capturedInfo = item.capturedInfo;
         desc.list.push(t);
     }
-    if ('lastApplied' in layerComps)
+    if (layerComps.lastApplied !== undefined)
         desc.lastAppliedComp = layerComps.lastApplied;
     // console.log('CompList', require('util').inspect(desc, false, 99, true));
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'CompList', desc);
@@ -7765,8 +8170,8 @@ target => target.onionSkins !== undefined, (reader, target) => {
         numBefore: onionSkins.framesBefore,
         numAfter: onionSkins.framesAfter,
         Spcn: onionSkins.frameSpacing,
-        minOpacity: (onionSkins.minOpacity * 100) | 0,
-        maxOpacity: (onionSkins.maxOpacity * 100) | 0,
+        minOpacity: Math.round(onionSkins.minOpacity * 100),
+        maxOpacity: Math.round(onionSkins.maxOpacity * 100),
         BlnM: Math.max(0, onionSkinsBlendModes.indexOf(onionSkins.blendMode)),
     };
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
@@ -7827,7 +8232,7 @@ target => target.timelineInformation !== undefined, (reader, target) => {
         LCnt: timeline.repeats,
         globalTrackList: (0, descriptor_1.serializeTrackList)(timeline.globalTracks),
         audioClipGroupList: {
-            audioClipGroupList: (_a = timeline.audioClipGroups) === null || _a === void 0 ? void 0 : _a.map(a => ({
+            audioClipGroupList: ((_a = timeline.audioClipGroups) !== null && _a !== void 0 ? _a : []).map(a => ({
                 groupID: a.id,
                 muted: a.muted,
                 audioClipList: a.audioClips.map(c => ({
@@ -7924,7 +8329,7 @@ const sliceTypes = ['noImage', 'image'];
 const sliceAlignments = ['default'];
 addHandler(1050, // Slices
 // Slices
-target => target.slices ? target.slices.length : 0, (reader, target) => {
+target => target.slices ? target.slices.length : 0, (reader, target, leftBytes) => {
     const version = (0, psdReader_1.readUint32)(reader);
     if (version === 6) {
         if (!target.slices)
@@ -7968,16 +8373,23 @@ target => target.slices ? target.slices.length : 0, (reader, target) => {
                 backgroundColorType, backgroundColor: { r, g, b, a },
             });
         }
-        const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-        desc.slices.forEach(d => {
-            const slice = slices.find(s => d.sliceID == s.id);
-            if (slice) {
-                slice.topOutset = d.topOutset;
-                slice.leftOutset = d.leftOutset;
-                slice.bottomOutset = d.bottomOutset;
-                slice.rightOutset = d.rightOutset;
+        if (leftBytes()) {
+            const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
+            const slicesById = new Map();
+            for (const s of slices) {
+                if (!slicesById.has(s.id))
+                    slicesById.set(s.id, s);
             }
-        });
+            desc.slices.forEach(d => {
+                const slice = slicesById.get(d.sliceID);
+                if (slice) {
+                    slice.topOutset = d.topOutset;
+                    slice.leftOutset = d.leftOutset;
+                    slice.bottomOutset = d.bottomOutset;
+                    slice.rightOutset = d.rightOutset;
+                }
+            });
+        }
     }
     else if (version === 7 || version === 8) {
         const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
@@ -8096,7 +8508,7 @@ addHandler(1036, target => target.thumbnail !== undefined || target.thumbnailRaw
         target.thumbnailRaw = { width, height, data };
     }
     else if (data.byteLength) {
-        target.thumbnail = (0, helpers_1.createCanvasFromData)(data);
+        target.thumbnail = (0, helpers_1.createCanvasFromData)(data, reader);
     }
 }, (writer, target) => {
     var _a;
@@ -8175,7 +8587,7 @@ addHandler(1088, target => target.pathSelectionState !== undefined, (reader, tar
     const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
     target.pathSelectionState = desc['null'];
 }, (writer, target) => {
-    const desc = { 'null': target.pathSelectionState };
+    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) => {
@@ -8257,7 +8669,7 @@ target => target.animations !== undefined, (reader, target, left) => {
                         FrID: f.id,
                     };
                     if (f.delay)
-                        frame.FrDl = (f.delay * 100) | 0;
+                        frame.FrDl = Math.round(f.delay * 100);
                     frame.FrDs = FrmD.encode(f.dispose);
                     // if (i === 0) frame.FrGA = 30; // ???
                     desc.FrIn.push(frame);
@@ -8381,6 +8793,7 @@ function writePsdBuffer(psd, options) {
     if (typeof Buffer === 'undefined') {
         throw new Error('Buffer not supported on this platform');
     }
+    // copy, so the buffer doesn't hold on to the unused part of the writer's buffer
     return Buffer.from(writePsdUint8Array(psd, options));
 }
 
@@ -8434,6 +8847,8 @@ const maxResolutionInMP = 100; // Don't decode more than 100 megapixels
 const maxMemoryUsageBytes = 64 * 1024 * 1024; // Don't decode if memory footprint is more than 64MB
 let totalBytesAllocated = 0; // avoid unexpected OOMs from untrusted content.
 function requestMemoryAllocation(increaseAmount) {
+    if (!isFinite(increaseAmount) || increaseAmount < 0)
+        throw new Error(`Invalid memory allocation size (${increaseAmount})`);
     const totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
     if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
         const exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
@@ -8499,6 +8914,8 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
         return bitsData >>> 7;
     }
     function decodeHuffman(tree) {
+        if (!tree)
+            throw new Error('Missing Huffman table');
         let node = tree;
         while (true) {
             node = node[readBit()];
@@ -8681,6 +9098,8 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
     else {
         mcuExpected = mcusPerLine * frame.mcusPerColumn;
     }
+    if (!isFinite(mcuExpected) || mcuExpected < 0)
+        throw new Error('Invalid number of MCUs');
     if (!resetInterval)
         resetInterval = mcuExpected;
     let h;
@@ -8696,6 +9115,9 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
             for (let n = 0; n < resetInterval; n++) {
                 decodeBlock(component, decodeFn, mcu);
                 mcu++;
+                // If we've reached our expected MCU's, stop decoding
+                if (mcu === mcuExpected)
+                    break;
             }
         }
         else {
@@ -8756,6 +9178,8 @@ function buildComponentData(component) {
     //   988-991.
     function quantizeAndInverse(zz, dataOut, dataIn) {
         const qt = component.quantizationTable;
+        if (!qt)
+            throw new Error('Missing quantization table');
         const p = dataIn;
         // dequant
         for (let i = 0; i < 64; i++) {
@@ -9105,10 +9529,14 @@ function parse(data) {
                     throw new Error(`maxResolutionInMP limit exceeded by ${exceededAmount}MP`);
                 }
                 const componentsCount = data[offset++];
+                if (!componentsCount)
+                    throw new Error('SOF: no components in frame');
                 for (let i = 0; i < componentsCount; i++) {
                     const componentId = data[offset];
                     const h = data[offset + 1] >> 4;
                     const v = data[offset + 1] & 15;
+                    if (h < 1 || h > 4 || v < 1 || v > 4)
+                        throw new Error(`SOF: invalid sampling factors (${h}x${v})`);
                     const qId = data[offset + 2];
                     frame.componentsOrder.push(componentId);
                     frame.components[componentId] = {
@@ -9156,11 +9584,16 @@ function parse(data) {
                 readUint16(); // Ignore this data since it represents the image height
                 break;
             case 0xFFDA: { // SOS (Start of Scan)
+                if (!frame)
+                    throw new Error('SOS: scan before frame header (SOF)');
                 readUint16(); // skip data length
                 const selectorsCount = data[offset++];
                 const components = [];
                 for (let i = 0; i < selectorsCount; i++) {
-                    const component = frame.components[data[offset++]];
+                    const componentId = data[offset++];
+                    const component = frame.components[componentId];
+                    if (!component)
+                        throw new Error(`SOS: component ${componentId} not found in frame`);
                     const tableSpec = data[offset++];
                     component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
                     component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
@@ -9209,7 +9642,10 @@ function parse(data) {
     for (let i = 0; i < frames.length; i++) {
         const cp = frames[i].components;
         for (let j in cp) { // TODO: don't use `in`
-            cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx];
+            const table = quantizationTables[cp[j].quantizationIdx];
+            if (!table)
+                throw new Error(`Missing quantization table ${cp[j].quantizationIdx}`);
+            cp[j].quantizationTable = table;
             delete cp[j].quantizationIdx; // TODO: why ???
         }
     }
@@ -9265,11 +9701,8 @@ function getData(decoded) {
             break;
         }
         case 3: {
-            // The default transform for three components is true
-            colorTransform = true;
-            // The adobe transform marker overrides any previous setting
-            if (decoded.adobe && decoded.adobe.transformCode)
-                colorTransform = true;
+            // The default transform for three components is true, the adobe transform marker overrides it
+            colorTransform = decoded.adobe ? !!decoded.adobe.transformCode : true;
             const component1 = decoded.components[0];
             const component2 = decoded.components[1];
             const component3 = decoded.components[2];
@@ -9596,22 +10029,24 @@ function readFixedPoint32(reader) {
 function readFixedPointPath32(reader) {
     return readInt32(reader) / (1 << 24);
 }
+// NOTE: returned array may alias the reader's underlying buffer, never write into it
 function readBytes(reader, length) {
-    const start = reader.view.byteOffset + reader.offset;
+    const start = reader.offset;
+    const viewLength = reader.view.byteLength;
     reader.offset += length;
-    if ((start + length) > reader.view.buffer.byteLength) {
+    if ((start + length) > viewLength) {
         // fix for broken PSD files that are missing part of file at the end
         warnOrThrow(reader, 'Reading bytes exceeding buffer length');
         if (length > (100 * 1024 * 1024))
             throw new Error('Reading past end of file'); // limit to 100MB
         const result = new Uint8Array(length);
-        const len = Math.min(length, reader.view.byteLength - start);
+        const len = Math.min(length, viewLength - start);
         if (len > 0)
-            result.set(new Uint8Array(reader.view.buffer, start, len));
+            result.set(new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, len));
         return result;
     }
     else {
-        return new Uint8Array(reader.view.buffer, start, length);
+        return new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, length);
     }
 }
 function readSignature(reader) {
@@ -9636,31 +10071,52 @@ function readUnicodeString(reader) {
     const length = readUint32(reader);
     return readUnicodeStringWithLength(reader, length);
 }
-function readUnicodeStringWithLength(reader, length) {
+const STRING_CHUNK_SIZE = 0x2000;
+function checkReadBounds(reader, size) {
+    if (reader.offset < 0 || (reader.offset + size) > reader.view.byteLength) {
+        throw new RangeError('Offset is outside the bounds of the DataView');
+    }
+}
+function readUtf16String(reader, length, littleEndian) {
+    if (!(length > 0))
+        return '';
+    checkReadBounds(reader, length * 2);
+    const view = reader.view;
+    const codes = new Uint16Array(Math.min(length, STRING_CHUNK_SIZE));
+    let offset = reader.offset;
     let text = '';
-    while (length--) {
-        const value = readUint16(reader);
-        if (value || length > 0) { // remove trailing \0
-            text += String.fromCharCode(value);
+    for (let i = 0; i < length; i += STRING_CHUNK_SIZE) {
+        const count = Math.min(STRING_CHUNK_SIZE, length - i);
+        for (let j = 0; j < count; j++, offset += 2) {
+            codes[j] = view.getUint16(offset, littleEndian);
         }
+        text += String.fromCharCode.apply(null, (count === codes.length ? codes : codes.subarray(0, count)));
     }
+    reader.offset = offset;
+    // remove trailing \0
+    if (text.charCodeAt(text.length - 1) === 0)
+        text = text.substring(0, text.length - 1);
     return text;
 }
-function readUnicodeStringWithLengthLE(reader, length) {
+function bytesToString(bytes) {
     let text = '';
-    while (length--) {
-        const value = readUint16LE(reader);
-        if (value || length > 0) { // remove trailing \0
-            text += String.fromCharCode(value);
-        }
+    for (let i = 0; i < bytes.length; i += STRING_CHUNK_SIZE) {
+        text += String.fromCharCode.apply(null, bytes.subarray(i, i + STRING_CHUNK_SIZE));
     }
     return text;
 }
+function readUnicodeStringWithLength(reader, length) {
+    return readUtf16String(reader, length, false);
+}
+function readUnicodeStringWithLengthLE(reader, length) {
+    return readUtf16String(reader, length, true);
+}
 function readAsciiString(reader, length) {
-    let text = '';
-    while (length--) {
-        text += String.fromCharCode(readUint8(reader));
-    }
+    if (!(length > 0))
+        return '';
+    checkReadBounds(reader, length);
+    const text = bytesToString(new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length));
+    reader.offset += length;
     return text;
 }
 function skipBytes(reader, count) {
@@ -9674,12 +10130,7 @@ function checkSignature(reader, a, b) {
     }
 }
 function readShortString(reader, length) {
-    const buffer = readBytes(reader, length);
-    let result = '';
-    for (let i = 0; i < buffer.length; i++) {
-        result += String.fromCharCode(buffer[i]);
-    }
-    return result;
+    return bytesToString(readBytes(reader, length));
 }
 function isValidSignature(sig) {
     return sig === '8BIM' || sig === 'MeSa' || sig === 'AgHg' || sig === 'PHUT' || sig === 'DCSR';
@@ -9700,7 +10151,7 @@ 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 > 16)
+    if (channels < 1 || channels > 56)
         throw new Error(`Invalid channel count: ${channels}`);
     if (![1, 8, 16, 32].includes(bitsPerChannel))
         throw new Error(`Invalid bitsPerChannel: ${bitsPerChannel}`);
@@ -9802,7 +10253,10 @@ function readPsd(reader, readOptions = {}) {
     const skipComposite = reader.skipCompositeImageData && (reader.skipLayerImageData || hasChildren);
     if (!skipComposite) {
         if (reader.useRawData) {
-            psd.rawCompositeData = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset);
+            const rawOffset = Math.min(reader.offset, reader.view.byteLength);
+            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 };
         }
         else {
             const imageData = readImageData(reader, psd);
@@ -9857,7 +10311,9 @@ function readLayerInfo(reader, psd, imageResources) {
             stack.push(l);
         }
         else if (type === 3 /* SectionDividerType.BoundingSectionDivider */) {
-            stack.pop();
+            // ignore unmatched section dividers, never pop the root
+            if (stack.length > 1)
+                stack.pop();
             // this was workaround because I didn't know what `lsdk` section was, now it's probably not needed anymore
             // } else if (l.name === '</Layer group>' && !l.sectionDivider && !l.top && !l.left && !l.bottom && !l.right) {
             // 	// sometimes layer group terminator doesn't have sectionDivider, so we just guess here (PS bug ?)
@@ -9943,7 +10399,7 @@ function readLayerMaskData(reader, layer) {
         mask.positionRelativeToLayer = (flags & 1 /* LayerMaskFlags.PositionRelativeToLayer */) !== 0;
         mask.disabled = (flags & 2 /* LayerMaskFlags.LayerMaskDisabled */) !== 0;
         mask.fromVectorData = (flags & 8 /* LayerMaskFlags.LayerMaskFromRenderingOtherData */) !== 0;
-        if (left() >= 18) {
+        if (hasRealMaskData(reader, flags, left())) {
             const realMask = {};
             layer.realMask = realMask;
             const realFlags = readUint8(reader);
@@ -9972,6 +10428,43 @@ function readLayerMaskData(reader, layer) {
         skipBytes(reader, left());
     });
 }
+function maskParamsSize(params) {
+    return 1 +
+        ((params & 1 /* MaskParams.UserMaskDensity */) ? 1 : 0) +
+        ((params & 2 /* MaskParams.UserMaskFeather */) ? 8 : 0) +
+        ((params & 4 /* MaskParams.VectorMaskDensity */) ? 1 : 0) +
+        ((params & 8 /* MaskParams.VectorMaskFeather */) ? 8 : 0);
+}
+// checks if data at offset is mask parameters followed by up to 3 bytes of zero padding, ending exactly at offset + left
+function isMaskParamsLayout(view, offset, left) {
+    if (left < 1)
+        return false;
+    const params = view.getUint8(offset);
+    if (params === 0 || (params & ~0x0f))
+        return false; // only 4 parameter flags exist
+    const size = maskParamsSize(params);
+    if (left < size || left - size > 3)
+        return false;
+    for (let i = size; i < left; i++) {
+        if (view.getUint8(offset + i) !== 0)
+            return false;
+    }
+    return true;
+}
+// real mask data (18 bytes) is followed by mask parameters (if flag is set) and padding
+function hasRealMaskData(reader, flags, left) {
+    if (left < 18)
+        return false;
+    if (!(flags & 16 /* LayerMaskFlags.MaskHasParametersAppliedToIt */))
+        return true;
+    const { view, offset } = reader;
+    if (isMaskParamsLayout(view, offset, left))
+        return false;
+    if (isMaskParamsLayout(view, offset + 18, left - 18))
+        return true;
+    // unknown layout, assume real mask if there's enough data for it (and mask parameters)
+    return left === 18 || left - 18 >= maskParamsSize(view.getUint8(offset + 18));
+}
 function readBlendingRange(reader) {
     return [readUint8(reader), readUint8(reader), readUint8(reader), readUint8(reader)];
 }
@@ -10038,8 +10531,12 @@ function getCompositeImageData(psd) {
     if (!data)
         return undefined;
     const reader = createReader(data.buffer, data.byteOffset, data.byteLength);
-    const imageData = readImageData(reader, psd);
-    return imageData;
+    const info = psd.rawCompositeDataInfo;
+    if (info) {
+        reader.large = info.large;
+        reader.globalAlpha = info.globalAlpha;
+    }
+    return readImageData(reader, psd);
 }
 function getCompositeCanvas(psd) {
     return imageDataToCanvasSafe(getCompositeImageData(psd));
@@ -10081,18 +10578,18 @@ function decodeLayerPixels(layer, useImageData) {
 function decodeLayerImageData(layer, options) {
     var _a, _b, _c;
     let { throwForMissingFeatures, useImageData } = options;
-    const imageData = getDataFromLayer(layer, LayerDataType.Layer, throwForMissingFeatures, options.totalMemoryLimit);
+    const imageData = getDataFromLayer(layer, LayerDataType.Layer, throwForMissingFeatures, options.totalMemoryLimit, options);
     setImageDataOrCanvas(layer, imageData, useImageData);
     if (options.totalMemoryLimit !== undefined)
         options.totalMemoryLimit -= (_a = imageData === null || imageData === void 0 ? void 0 : imageData.data.byteLength) !== null && _a !== void 0 ? _a : 0;
     if (layer.mask) {
-        const maskData = getDataFromLayer(layer, LayerDataType.Mask, throwForMissingFeatures, options.totalMemoryLimit);
+        const maskData = getDataFromLayer(layer, LayerDataType.Mask, throwForMissingFeatures, options.totalMemoryLimit, options);
         setImageDataOrCanvas(layer.mask, maskData, useImageData);
         if (options.totalMemoryLimit !== undefined)
             options.totalMemoryLimit -= (_b = maskData === null || maskData === void 0 ? void 0 : maskData.data.byteLength) !== null && _b !== void 0 ? _b : 0;
     }
     if (layer.realMask) {
-        const maskData = getDataFromLayer(layer, LayerDataType.RealMask, throwForMissingFeatures, options.totalMemoryLimit);
+        const maskData = getDataFromLayer(layer, LayerDataType.RealMask, throwForMissingFeatures, options.totalMemoryLimit, options);
         setImageDataOrCanvas(layer.realMask, maskData, useImageData);
         if (options.totalMemoryLimit !== undefined)
             options.totalMemoryLimit -= (_c = maskData === null || maskData === void 0 ? void 0 : maskData.data.byteLength) !== null && _c !== void 0 ? _c : 0;
@@ -10105,7 +10602,8 @@ var LayerDataType;
     LayerDataType[LayerDataType["Mask"] = 1] = "Mask";
     LayerDataType[LayerDataType["RealMask"] = 2] = "RealMask";
 })(LayerDataType || (LayerDataType = {}));
-function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
+function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit, logOptions) {
+    var _a;
     if (!layer.rawData)
         return undefined;
     const { colorMode, bitsPerChannel, channels, large } = layer.rawData;
@@ -10118,7 +10616,7 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
     if (layerWidth && layerHeight && read === LayerDataType.Layer) {
         if (cmyk) {
             if (bitsPerChannel !== 8)
-                throw new Error('bitsPerChannel Not supproted');
+                throw new Error('bitsPerChannel not supported');
             imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) };
         }
         else {
@@ -10133,6 +10631,11 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
         if (!data)
             continue;
         const dataReader = createReader(data.buffer, data.byteOffset, data.byteLength);
+        dataReader.debug = !!(logOptions === null || logOptions === void 0 ? void 0 : logOptions.debug);
+        if (logOptions === null || logOptions === void 0 ? void 0 : logOptions.log)
+            dataReader.log = logOptions.log;
+        if (memoryLimit !== undefined)
+            dataReader.totalMemoryLimit = Math.max(0, memoryLimit - ((_a = imageData === null || imageData === void 0 ? void 0 : imageData.data.byteLength) !== null && _a !== void 0 ? _a : 0));
         if (id === -2 /* ChannelID.UserMask */ || id === -3 /* ChannelID.RealUserMask */) {
             if (id === -2 /* ChannelID.UserMask */ && read !== LayerDataType.Mask)
                 continue;
@@ -10145,6 +10648,8 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
             const maskHeight = Math.max(0, (mask.bottom || 0) - (mask.top || 0));
             if (maskWidth && maskHeight) {
                 maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel, 4, memoryLimit);
+                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 */) {
@@ -10176,15 +10681,14 @@ function getDataFromLayer(layer, read, throwForMissingFeatures, memoryLimit) {
                 layer.imageDataRawCompression[id] = compression;
                 layer.imageDataRaw[id] = data;
             }
-            if (targetData && colorMode === 1 /* ColorMode.Grayscale */) {
-                setupGrayscale(targetData);
-            }
         }
         if (id === -1 /* ChannelID.Transparency */) {
             initializedAlpha = true;
         }
     }
     if (imageData) {
+        if (colorMode === 1 /* ColorMode.Grayscale */)
+            setupGrayscale(imageData);
         if (!initializedAlpha)
             resetAlpha(imageData, cmyk);
         if (cmyk) {
@@ -10200,7 +10704,7 @@ function readData(reader, length, pixels, compression, width, height, bitDepth,
         return;
     if (compression === 0 /* Compression.RawData */) {
         if (length !== (width * height * Math.floor(bitDepth / 8))) {
-            reader.log(`Invalid length (${length}, ${width * height * Math.floor(bitDepth / 8)})`);
+            warnOrThrow(reader, `Invalid length (${length}, ${width * height * Math.floor(bitDepth / 8)})`);
         }
         const data = readBytes(reader, length);
         readDataRaw(data, pixels, bitDepth, step, offset);
@@ -10211,11 +10715,11 @@ function readData(reader, length, pixels, compression, width, height, bitDepth,
     }
     else if (compression === 2 /* Compression.ZipWithoutPrediction */) {
         const data = readBytes(reader, length);
-        readDataZip(data, pixels, width, height, bitDepth, step, offset, false);
+        readDataZip(data, pixels, width, height, bitDepth, step, offset, false, reader);
     }
     else if (compression === 3 /* Compression.ZipWithPrediction */) {
         const data = readBytes(reader, length);
-        readDataZip(data, pixels, width, height, bitDepth, step, offset, true);
+        readDataZip(data, pixels, width, height, bitDepth, step, offset, true, reader);
     }
     else {
         throw new Error(`Invalid Compression type: ${compression}`);
@@ -10230,7 +10734,7 @@ function readGlobalLayerMaskInfo(reader) {
         const colorSpace2 = readUint16(reader);
         const colorSpace3 = readUint16(reader);
         const colorSpace4 = readUint16(reader);
-        const opacity = readUint16(reader) / 0xff;
+        const opacity = readUint16(reader) / 100; // 0 - 100
         const kind = readUint8(reader);
         skipBytes(reader, left()); // 3 bytes of padding ?
         return { overlayColorSpace, colorSpace1, colorSpace2, colorSpace3, colorSpace4, opacity, kind };
@@ -10310,11 +10814,12 @@ function readImageData(reader, psd) {
     var _a;
     const compression = readUint16(reader);
     const bitsPerChannel = (_a = psd.bitsPerChannel) !== null && _a !== void 0 ? _a : 8;
+    const { width, height } = psd;
     if (exports.supportedColorModes.indexOf(psd.colorMode) === -1)
         throw new Error(`Color mode not supported: ${psd.colorMode}`);
     if (compression !== 0 /* Compression.RawData */ && compression !== 1 /* Compression.RleCompressed */)
         throw new Error(`Compression type not supported: ${compression}`);
-    const imageData = createImageDataBitDepth(psd.width, psd.height, bitsPerChannel, 4, reader.totalMemoryLimit);
+    const imageData = createImageDataBitDepth(width, height, bitsPerChannel, 4, reader.totalMemoryLimit);
     if (reader.totalMemoryLimit !== undefined)
         reader.totalMemoryLimit -= imageData.data.byteLength;
     (0, helpers_1.resetImageData)(imageData);
@@ -10322,46 +10827,26 @@ function readImageData(reader, psd) {
         case 0 /* ColorMode.Bitmap */: {
             if (bitsPerChannel !== 1)
                 throw new Error('Invalid bitsPerChannel for bitmap color mode');
+            const rowBytes = Math.ceil(width / 8);
             let bytes;
             if (compression === 0 /* Compression.RawData */) {
-                bytes = readBytes(reader, Math.ceil(psd.width / 8) * psd.height);
-            }
-            else if (compression === 1 /* Compression.RleCompressed */) {
-                bytes = new Uint8Array(psd.width * psd.height);
-                readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, 8, 1, [0], reader.large);
+                bytes = readBytes(reader, rowBytes * height);
             }
             else {
-                throw new Error(`Compression not supported: ${compression}`);
+                bytes = new Uint8Array(rowBytes * height);
+                readDataRLE(reader, { data: bytes, width: rowBytes, height }, rowBytes, height, 8, 1, [0], reader.large);
             }
-            (0, helpers_1.decodeBitmap)(bytes, imageData.data, psd.width, psd.height);
+            (0, helpers_1.decodeBitmap)(bytes, imageData.data, width, height);
             break;
         }
         case 3 /* ColorMode.RGB */:
         case 1 /* ColorMode.Grayscale */: {
-            const channels = psd.colorMode === 1 /* ColorMode.Grayscale */ ? [0] : [0, 1, 2];
-            if (psd.channels && psd.channels > 3) {
-                for (let i = 3; i < psd.channels; i++) {
-                    // TODO: store these channels in additional image data
-                    channels.push(i);
-                }
-            }
-            else if (reader.globalAlpha) {
-                channels.push(3);
-            }
-            if (compression === 0 /* Compression.RawData */) {
-                for (let i = 0; i < channels.length; i++) {
-                    const data = readBytes(reader, psd.width * psd.height * Math.floor(bitsPerChannel / 8));
-                    readDataRaw(data, imageData, bitsPerChannel, 4, channels[i]);
-                }
-            }
-            else if (compression === 1 /* Compression.RleCompressed */) {
-                const start = reader.offset;
-                readDataRLE(reader, imageData, psd.width, psd.height, bitsPerChannel, 4, channels, reader.large);
-                if (helpers_1.RAW_IMAGE_DATA)
-                    psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
-            }
-            else {
-                throw new Error(`Compression not supported: ${compression}`);
+            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);
@@ -10370,57 +10855,25 @@ function readImageData(reader, psd) {
         }
         case 2 /* ColorMode.Indexed */: {
             if (bitsPerChannel !== 8)
-                throw new Error('bitsPerChannel Not supproted');
-            if (psd.channels !== 1)
-                throw new Error('Invalid channel count');
+                throw new Error('bitsPerChannel not supported');
             if (!psd.palette)
                 throw new Error('Missing color palette');
-            if (compression === 0 /* Compression.RawData */) {
-                throw new Error(`Compression not supported: ${compression}`);
-            }
-            else if (compression === 1 /* Compression.RleCompressed */) {
-                const indexedImageData = {
-                    width: imageData.width,
-                    height: imageData.height,
-                    data: new Uint8Array(imageData.width * imageData.height),
-                };
-                readDataRLE(reader, indexedImageData, psd.width, psd.height, bitsPerChannel, 1, [0], reader.large);
-                indexedToRgb(indexedImageData, imageData, psd.palette);
-            }
-            else {
-                throw new Error(`Compression not supported: ${compression}`);
-            }
+            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);
             break;
         }
         case 4 /* ColorMode.CMYK */: {
             if (bitsPerChannel !== 8)
-                throw new Error('bitsPerChannel Not supproted');
-            if (psd.channels !== 4)
-                throw new Error(`Invalid channel count`);
-            const channels = [0, 1, 2, 3];
-            if (reader.globalAlpha)
-                channels.push(4);
-            if (compression === 0 /* Compression.RawData */) {
-                throw new Error(`Compression not supported: ${compression}`);
-                // TODO: ...
-                // for (let i = 0; i < channels.length; i++) {
-                // 	readDataRaw(reader, imageData, channels[i], psd.width, psd.height);
-                // }
-            }
-            else if (compression === 1 /* Compression.RleCompressed */) {
-                const cmykImageData = {
-                    width: imageData.width,
-                    height: imageData.height,
-                    data: new Uint8Array(imageData.width * imageData.height * 5),
-                };
-                const start = reader.offset;
-                readDataRLE(reader, cmykImageData, psd.width, psd.height, bitsPerChannel, 5, channels, reader.large);
-                cmykToRgb(cmykImageData, imageData, true);
-                if (helpers_1.RAW_IMAGE_DATA)
-                    psd.imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
-            }
-            else {
-                throw new Error(`Compression not supported: ${compression}`);
+                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);
             }
             break;
         }
@@ -10428,23 +10881,98 @@ function readImageData(reader, psd) {
     }
     // remove weird white matte
     if (reader.globalAlpha) {
-        if (psd.bitsPerChannel !== 8)
-            throw new Error('bitsPerChannel Not supproted');
-        const p = imageData.data;
-        const size = imageData.width * imageData.height * 4;
+        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;
+    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;
+    const offsets = [];
+    for (let i = 0; i < channelCount; i++) {
+        if (i < colorChannels) {
+            offsets.push(i);
+        }
+        else if (i === colorChannels && hasTransparency && alphaOffset >= 0) {
+            offsets.push(alphaOffset);
+        }
+        else {
+            // TODO: store these channels (alpha channels / saved selections, spot colors) in additional image data
+            offsets.push(-1);
+        }
+    }
+    return offsets;
+}
+function readCompositeChannels(reader, compression, pixelData, bitsPerChannel, step, offsets) {
+    if (compression === 0 /* Compression.RawData */) {
+        const channelSize = pixelData.width * pixelData.height * bytesPerValue(bitsPerChannel);
+        for (const offset of offsets) {
+            if (offset < 0) {
+                skipBytes(reader, channelSize);
+            }
+            else {
+                readDataRaw(readBytes(reader, channelSize), pixelData, bitsPerChannel, step, offset);
+            }
+        }
+    }
+    else if (compression === 1 /* Compression.RleCompressed */) {
+        readDataRLE(reader, pixelData, pixelData.width, pixelData.height, bitsPerChannel, step, offsets, reader.large);
+    }
+    else {
+        throw new Error(`Compression not supported: ${compression}`);
+    }
+}
+// un-premultiplies colors from white matte, used for composite image of documents with global alpha
+function removeWhiteMatte({ data, width, height }) {
+    const size = width * height * 4;
+    if (data instanceof Float32Array) {
+        for (let i = 0; i < size; i += 4) {
+            const a = data[i + 3];
+            if (a > 0 && a < 1) {
+                const ra = 1 / a;
+                const invA = 1 - ra;
+                for (let j = 0; j < 3; j++) {
+                    const v = data[i + j] * ra + invA;
+                    data[i + j] = v < 0 ? 0 : v;
+                }
+            }
+        }
+    }
+    else if (data instanceof Uint16Array) {
         for (let i = 0; i < size; i += 4) {
-            const pa = p[i + 3];
+            const pa = data[i + 3];
+            if (pa !== 0 && pa !== 0xffff) {
+                const ra = 0xffff / pa;
+                const invA = 0xffff * (1 - ra);
+                for (let j = 0; j < 3; j++) {
+                    const v = Math.round(data[i + j] * ra + invA);
+                    data[i + j] = v < 0 ? 0 : (v > 0xffff ? 0xffff : v);
+                }
+            }
+        }
+    }
+    else {
+        // Uint8ClampedArray clamps and rounds values on assignment
+        for (let i = 0; i < size; i += 4) {
+            const pa = data[i + 3];
             if (pa != 0 && pa != 255) {
                 const a = pa / 255;
                 const ra = 1 / a;
                 const invA = 255 * (1 - ra);
-                p[i + 0] = p[i + 0] * ra + invA;
-                p[i + 1] = p[i + 1] * ra + invA;
-                p[i + 2] = p[i + 2] * ra + invA;
+                data[i + 0] = data[i + 0] * ra + invA;
+                data[i + 1] = data[i + 1] * ra + invA;
+                data[i + 2] = data[i + 2] * ra + invA;
             }
         }
     }
-    return imageData;
 }
 function cmykToRgb(cmyk, rgb, reverseAlpha) {
     const size = rgb.width * rgb.height * 4;
@@ -10483,175 +11011,267 @@ function indexedToRgb(indexed, rgb, palette) {
         dstData[dst + 3] = 255;
     }
 }
-function verifyCompatible(a, b) {
-    if ((a.byteLength / a.length) !== (b.byteLength / b.length)) {
-        throw new Error('Invalid array types');
+// number of bytes used to store single channel value, 1-bit data is handled as bytes
+function bytesPerValue(bitDepth) {
+    switch (bitDepth) {
+        case 1:
+        case 8: return 1;
+        case 16: return 2;
+        case 32: return 4;
+        default: throw new Error(`Invalid bitDepth (${bitDepth})`);
     }
 }
-function bytesToArray(bytes, bitDepth) {
-    if (bitDepth === 8) {
-        return bytes;
+function verifyArrayType(data, bytesPerValue) {
+    if (data.BYTES_PER_ELEMENT !== bytesPerValue) {
+        throw new Error('Invalid array types');
     }
-    else if (bitDepth === 16) {
-        // PSD files store 16-bit channel data in big-endian byte order.
-        // Swap each pair of bytes so that Uint16Array (native-endian) reads the correct values.
-        for (let i = 0; i < bytes.byteLength; i += 2) {
-            const tmp = bytes[i];
-            bytes[i] = bytes[i + 1];
-            bytes[i + 1] = tmp;
-        }
-        if (bytes.byteOffset % 2) {
-            const result = new Uint16Array(bytes.byteLength / 2);
-            new Uint8Array(result.buffer, result.byteOffset, result.byteLength).set(bytes);
-            return result;
-        }
-        else {
-            return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
+}
+// NOTE: `buffer` may alias input file data, it must not be modified here
+function readDataRaw(buffer, pixelData, bitDepth, step, offset) {
+    const bpv = bytesPerValue(bitDepth);
+    if (!pixelData || offset < 0 || offset >= step)
+        return;
+    const data = pixelData.data;
+    verifyArrayType(data, bpv);
+    const size = Math.min(pixelData.width * pixelData.height, Math.floor(buffer.byteLength / bpv)) | 0;
+    if (bpv === 1) {
+        for (let i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
+            data[p] = buffer[i];
         }
     }
-    else if (bitDepth === 32) {
-        if (bytes.byteOffset % 4) {
-            const result = new Float32Array(bytes.byteLength / 4);
-            new Uint8Array(result.buffer, result.byteOffset, result.byteLength).set(bytes);
-            return result;
-        }
-        else {
-            return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+    else if (bpv === 2) {
+        for (let i = 0, j = 0, p = offset | 0; i < size; i++, j += 2, p = (p + step) | 0) {
+            data[p] = (buffer[j] << 8) | buffer[j + 1];
         }
     }
     else {
-        throw new Error(`Invalid bitDepth (${bitDepth})`);
-    }
-}
-function copyChannelToPixelData(pixelData, channel, offset, step) {
-    verifyCompatible(pixelData.data, channel);
-    const size = pixelData.width * pixelData.height;
-    const data = pixelData.data;
-    for (let i = 0, p = offset | 0; i < size; i++, p = (p + step) | 0) {
-        data[p] = channel[i];
-    }
-}
-function readDataRaw(buffer, pixelData, bitDepth, step, offset) {
-    if (bitDepth == 32) {
-        for (let i = 0; i < buffer.byteLength; i += 4) {
-            const a = buffer[i + 0];
-            const b = buffer[i + 1];
-            const c = buffer[i + 2];
-            const d = buffer[i + 3];
-            buffer[i + 0] = d;
-            buffer[i + 1] = c;
-            buffer[i + 2] = b;
-            buffer[i + 3] = a;
+        const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        for (let i = 0, j = 0, p = offset | 0; i < size; i++, j += 4, p = (p + step) | 0) {
+            data[p] = view.getFloat32(j, false);
         }
     }
-    const array = bytesToArray(buffer, bitDepth);
-    if (pixelData && offset < step) {
-        copyChannelToPixelData(pixelData, array, offset, step);
-    }
 }
-function decodePredicted(data, width, height, mod) {
+function decodePredicted(data, width, height) {
     for (let y = 0; y < height; y++) {
         const offset = y * width;
         for (let x = 1, o = offset + 1; x < width; x++, o++) {
-            data[o] = (data[o - 1] + data[o]) % mod;
+            data[o] = data[o - 1] + data[o]; // Uint8Array wraps values on assignment
+        }
+    }
+}
+const zipOverflow = new Error('Decompressed data exceeds expected size');
+// inflates data, stopping when output exceeds expected size (protects against zip bombs)
+function inflateLimited(compressed, expectedSize, reader) {
+    const output = new Uint8Array(expectedSize);
+    let position = 0;
+    let overflow = false;
+    const inflator = new pako_1.Inflate({ chunkSize: Math.max(1024, Math.min(expectedSize, 0x10000)) });
+    inflator.onData = (chunk) => {
+        const data = chunk;
+        const count = Math.min(data.length, expectedSize - position);
+        if (count > 0)
+            output.set(count === data.length ? data : data.subarray(0, count), position);
+        position += count;
+        if (count < data.length) {
+            overflow = true;
+            throw zipOverflow;
         }
+    };
+    inflator.onEnd = (status) => {
+        var _a;
+        // default handler collects all the chunks into result, we only need the error status
+        inflator.err = status;
+        inflator.msg = ((_a = inflator.strm) === null || _a === void 0 ? void 0 : _a.msg) || '';
+    };
+    try {
+        inflator.push(compressed, true);
     }
+    catch (e) {
+        if (e !== zipOverflow)
+            throw e;
+    }
+    if (overflow) {
+        if (reader)
+            warnOrThrow(reader, zipOverflow.message);
+    }
+    else if (inflator.err) {
+        throw new Error(`Invalid zip data: ${inflator.msg}`);
+    }
+    return output;
 }
-function readDataZip(compressed, pixelData, width, height, bitDepth, step, offset, prediction) {
-    const decompressed = (0, pako_1.inflate)(compressed);
-    if (pixelData && offset < step) {
-        const array = bytesToArray(decompressed, bitDepth);
-        if (bitDepth === 8) {
-            if (prediction)
-                decodePredicted(decompressed, width, height, 0x100);
-            copyChannelToPixelData(pixelData, decompressed, offset, step);
-        }
-        else if (bitDepth === 16) {
-            if (prediction)
-                decodePredicted(array, width, height, 0x10000);
-            copyChannelToPixelData(pixelData, array, offset, step);
+function readDataZip(compressed, pixelData, width, height, bitDepth, step, offset, prediction, reader) {
+    const bpv = bytesPerValue(bitDepth);
+    if (!pixelData || offset < 0 || offset >= step)
+        return;
+    const data = pixelData.data;
+    verifyArrayType(data, bpv);
+    const expectedSize = width * height * bpv;
+    if (reader)
+        consumeMemory(reader, expectedSize);
+    try {
+        const decompressed = inflateLimited(compressed, expectedSize, reader);
+        if (bpv === 1) {
+            for (let y = 0, i = 0; y < height; y++) {
+                let prev = 0;
+                for (let x = 0, p = offset + y * width * step; x < width; x++, i++, p += step) {
+                    let v = decompressed[i];
+                    if (prediction)
+                        v = prev = (prev + v) & 0xff;
+                    data[p] = v;
+                }
+            }
         }
-        else if (bitDepth === 32) {
-            if (prediction)
-                decodePredicted(decompressed, width * 4, height, 0x100);
-            let di = offset;
-            const dst = new Uint32Array(pixelData.data.buffer, pixelData.data.byteOffset, pixelData.data.length);
-            for (let y = 0; y < height; y++) {
-                let a = width * 4 * y;
-                for (let x = 0; x < width; x++, a++, di += step) {
-                    const b = a + width;
-                    const c = b + width;
-                    const d = c + width;
-                    dst[di] = ((decompressed[a] << 24) | (decompressed[b] << 16) | (decompressed[c] << 8) | decompressed[d]) >>> 0;
+        else if (bpv === 2) {
+            for (let y = 0, i = 0; y < height; y++) {
+                let prev = 0;
+                for (let x = 0, p = offset + y * width * step; x < width; x++, i += 2, p += step) {
+                    let v = (decompressed[i] << 8) | decompressed[i + 1];
+                    if (prediction)
+                        v = prev = (prev + v) & 0xffff;
+                    data[p] = v;
                 }
             }
         }
         else {
-            throw new Error('Invalid bitDepth');
+            const dst = new Uint32Array(data.buffer, data.byteOffset, data.length);
+            if (prediction) {
+                // bytes are delta encoded per row and stored in planar order (all 1st bytes, all 2nd bytes, ...)
+                decodePredicted(decompressed, width * 4, height);
+                for (let y = 0, di = offset; y < height; y++) {
+                    let a = width * 4 * y;
+                    for (let x = 0; x < width; x++, a++, di += step) {
+                        const b = a + width;
+                        const c = b + width;
+                        const d = c + width;
+                        dst[di] = ((decompressed[a] << 24) | (decompressed[b] << 16) | (decompressed[c] << 8) | decompressed[d]) >>> 0;
+                    }
+                }
+            }
+            else {
+                const view = new DataView(decompressed.buffer, decompressed.byteOffset, decompressed.byteLength);
+                for (let i = 0, j = 0, di = offset, size = width * height; i < size; i++, j += 4, di += step) {
+                    dst[di] = view.getUint32(j, false);
+                }
+            }
         }
     }
+    finally {
+        if (reader)
+            recoverMemory(reader, expectedSize);
+    }
 }
-function readDataRLE(reader, pixelData, width, height, _bitDepth, step, offsets, large) {
-    const data = pixelData && pixelData.data;
-    let lengths;
-    if (large) {
-        consumeMemory(reader, offsets.length * height * 4);
-        lengths = new Uint32Array(offsets.length * height);
-        for (let o = 0, li = 0; o < offsets.length; o++) {
-            for (let y = 0; y < height; y++, li++) {
-                lengths[li] = readUint32(reader);
+// decodes single PackBits row, returns number of decoded values
+function decodeRLERow(src, i, end, dst, p, step, count) {
+    let x = 0;
+    while (i < end && x < count) {
+        const header = src[i++];
+        if (header > 128) {
+            if (i >= end)
+                break;
+            const value = src[i++];
+            let n = 257 - header;
+            if (n > count - x)
+                n = count - x;
+            x += n;
+            for (; n > 0; n--, p += step) {
+                dst[p] = value;
+            }
+        }
+        else if (header < 128) {
+            let n = header + 1;
+            if (n > count - x)
+                n = count - x;
+            if (n > end - i)
+                n = end - i;
+            x += n;
+            for (; n > 0; n--, p += step) {
+                dst[p] = src[i++];
             }
         }
+        else {
+            // ignore 128
+        }
+    }
+    return x;
+}
+// converts big-endian 16/32-bit values from bytes and writes them to `data` starting at `p` with `step`
+function scatterValues(bytes, count, bpv, data, p, step) {
+    if (bpv === 2) {
+        for (let x = 0, i = 0; x < count; x++, i += 2, p += step) {
+            data[p] = (bytes[i] << 8) | bytes[i + 1];
+        }
     }
     else {
-        consumeMemory(reader, offsets.length * height * 2);
-        lengths = new Uint16Array(offsets.length * height);
-        for (let o = 0, li = 0; o < offsets.length; o++) {
-            for (let y = 0; y < height; y++, li++) {
-                lengths[li] = readUint16(reader);
-            }
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        for (let x = 0, i = 0; x < count; x++, i += 4, p += step) {
+            data[p] = view.getFloat32(i, false);
         }
     }
-    // if (bitDepth !== 1 && bitDepth !== 8) throw new Error(`Invalid bit depth (${bitDepth})`);
-    const extraLimit = (step - 1) | 0; // 3 for rgb, 4 for cmyk
-    for (let c = 0, li = 0; c < offsets.length; c++) {
-        const offset = offsets[c] | 0;
-        const extra = c > extraLimit || offset > extraLimit;
-        if (!data || extra) {
-            for (let y = 0; y < height; y++, li++) {
-                skipBytes(reader, lengths[li]);
-            }
+}
+// decodes RLE rows of single channel, each row starts at the beginning of the image row
+function decodeRLEChannel(src, lengths, li, pos, width, height, data, offset, step, bpv, row) {
+    const srcEnd = src.length;
+    const rowSize = width * bpv;
+    for (let y = 0; y < height; y++, li++) {
+        const rowStart = pos < srcEnd ? pos : srcEnd;
+        pos += lengths[li];
+        const rowEnd = pos < srcEnd ? pos : srcEnd;
+        if (rowStart >= rowEnd)
+            continue;
+        if (bpv === 1) {
+            decodeRLERow(src, rowStart, rowEnd, data, offset + y * width * step, step, width);
         }
         else {
-            for (let y = 0, p = offset | 0; y < height; y++, li++) {
-                const length = lengths[li];
-                const buffer = readBytes(reader, length);
-                for (let i = 0, x = 0; i < length; i++) {
-                    let header = buffer[i];
-                    if (header > 128) {
-                        const value = buffer[++i];
-                        header = (256 - header) | 0;
-                        for (let j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
-                            data[p] = value;
-                            p = (p + step) | 0;
-                        }
-                    }
-                    else if (header < 128) {
-                        for (let j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
-                            data[p] = buffer[++i];
-                            p = (p + step) | 0;
-                        }
-                    }
-                    else {
-                        // ignore 128
-                    }
-                    // This showed up on some images from non-photoshop programs, ignoring it seems to work just fine.
-                    // if (i >= length) throw new Error(`Invalid RLE data: exceeded buffer size ${i}/${length}`);
-                }
+            const decoded = decodeRLERow(src, rowStart, rowEnd, row, 0, 1, rowSize);
+            scatterValues(row, Math.floor(decoded / bpv), bpv, data, offset + y * width * step, step);
+        }
+    }
+}
+function readDataRLE(reader, pixelData, width, height, bitDepth, step, offsets, large) {
+    const data = pixelData && pixelData.data;
+    const rows = offsets.length * height;
+    const lengthSize = large ? 4 : 2;
+    consumeMemory(reader, rows * lengthSize);
+    try {
+        if ((reader.offset + rows * lengthSize) > reader.view.byteLength) {
+            throw new Error('RLE row lengths exceed buffer length');
+        }
+        const lengths = large ? new Uint32Array(rows) : new Uint16Array(rows);
+        let total = 0;
+        if (large) {
+            for (let i = 0; i < rows; i++)
+                total += (lengths[i] = readUint32(reader));
+        }
+        else {
+            for (let i = 0; i < rows; i++)
+                total += (lengths[i] = readUint16(reader));
+        }
+        const start = reader.offset;
+        const srcEnd = reader.view.byteLength;
+        if (total > (srcEnd - start)) {
+            // broken or truncated file, decode only data that is available
+            warnOrThrow(reader, 'RLE data exceeds buffer length');
+        }
+        const bpv = bytesPerValue(bitDepth);
+        if (data)
+            verifyArrayType(data, bpv);
+        const src = new Uint8Array(reader.view.buffer, reader.view.byteOffset, srcEnd);
+        const row = (data && bpv > 1) ? new Uint8Array(width * bpv) : undefined;
+        let pos = start;
+        for (let c = 0, li = 0; c < offsets.length; c++, li += height) {
+            const offset = offsets[c] | 0;
+            const channelStart = pos;
+            for (let y = 0; y < height; y++)
+                pos += lengths[li + y];
+            if (data && offset >= 0 && offset < step) {
+                decodeRLEChannel(src, lengths, li, channelStart, width, height, data, offset, step, bpv, row);
             }
         }
+        reader.offset = pos;
+    }
+    finally {
+        recoverMemory(reader, rows * lengthSize);
     }
-    recoverMemory(reader, lengths.byteLength);
 }
 function readSection(reader, round, func, skipEmpty = true, eightBytes = false) {
     let length = readUint32(reader);
@@ -10710,8 +11330,8 @@ function readColor(reader) {
             const l = readInt16(reader) / 10000;
             const ta = readInt16(reader);
             const tb = readInt16(reader);
-            const a = ta < 0 ? (ta / 12800) : (ta / 12700);
-            const b = tb < 0 ? (tb / 12800) : (tb / 12700);
+            const a = (0, helpers_1.normalizeLabAB)(ta, 100);
+            const b = (0, helpers_1.normalizeLabAB)(tb, 100);
             skipBytes(reader, 2);
             return { l, a, b };
         }
@@ -10911,6 +11531,8 @@ exports.writeUnicodeStringWithoutLength = writeUnicodeStringWithoutLength;
 exports.writeUnicodeStringWithoutLengthLE = writeUnicodeStringWithoutLengthLE;
 exports.writeUnicodeString = writeUnicodeString;
 exports.writeUnicodeStringWithPadding = writeUnicodeStringWithPadding;
+exports.getRLEChannelBound = getRLEChannelBound;
+exports.writeUint64 = writeUint64;
 exports.writeSection = writeSection;
 exports.writePsd = writePsd;
 exports.writeColor = writeColor;
@@ -11034,59 +11656,71 @@ function writeUnicodeStringWithPadding(writer, text) {
     }
     writeUint16(writer, 0);
 }
-function getLargestLayerSize(layers = []) {
+// Worst-case size of writeDataRLE output for a single channel: per row the byte count (2 bytes, 4 for PSB)
+// plus PackBits data, which in the worst case is all literal runs of up to 128 bytes, each with 1 header byte.
+function getRLEChannelBound(width, height, large) {
+    return height * ((large ? 4 : 2) + width + Math.ceil(width / 128));
+}
+function getLargestLayerSize(layers = [], large) {
     let max = 0;
     for (const layer of layers) {
-        const { width, height } = getLayerDimentions(layer);
-        max = Math.max(max, 2 * height + 2 * width * height);
-        if (layer.mask) {
-            const { width, height } = getLayerDimentions(layer.mask);
-            max = Math.max(max, 2 * height + 2 * width * height);
-        }
-        if (layer.realMask) {
-            const { width, height } = getLayerDimentions(layer.realMask);
-            max = Math.max(max, 2 * height + 2 * width * height);
+        for (const target of [layer, layer.mask, layer.realMask]) {
+            if (target) {
+                const { width, height } = getLayerDimentions(target);
+                max = Math.max(max, getRLEChannelBound(width, height, large));
+            }
         }
         if (layer.children) {
-            max = Math.max(max, getLargestLayerSize(layer.children));
+            max = Math.max(max, getLargestLayerSize(layer.children, large));
         }
     }
     return max;
 }
+function writeUint64(writer, value) {
+    writeUint32(writer, Math.floor(value / 0x100000000));
+    writeUint32(writer, value >>> 0);
+}
 function writeSection(writer, round, func, writeTotalLength = false, large = false) {
+    const offset = writer.offset;
     if (large)
         writeUint32(writer, 0);
-    const offset = writer.offset;
     writeUint32(writer, 0);
+    const start = writer.offset;
     func();
-    let length = writer.offset - offset - 4;
+    let length = writer.offset - start;
     let len = length;
     while (len % round) {
         writeUint8(writer, 0);
         len++;
     }
-    // while (writer.offset % round) {
-    // 	writeUint8(writer, 0);
-    // 	len++;
-    // }
     if (writeTotalLength) {
         length = len;
     }
-    writer.view.setUint32(offset, length, false);
+    if (large) {
+        writer.view.setUint32(offset, Math.floor(length / 0x100000000), false);
+        writer.view.setUint32(offset + 4, length >>> 0, false);
+    }
+    else {
+        if (length > 0xffffffff)
+            throw new Error('Section too large, use PSB format instead');
+        writer.view.setUint32(offset, length, false);
+    }
+}
+function verifyPixelData(data, name) {
+    // check element size instead of instanceof, so arrays from other realms (iframes, workers, vm) are accepted
+    const bytesPerElement = data && data.data.BYTES_PER_ELEMENT;
+    if (bytesPerElement !== undefined && bytesPerElement !== 1) {
+        throw new Error(`${name} has incorrect bitDepth (only 8-bit Uint8Array or Uint8ClampedArray data is supported for writing)`);
+    }
 }
 function verifyBitCount(target) {
-    var _a;
+    var _a, _b, _c;
     (_a = target.children) === null || _a === void 0 ? void 0 : _a.forEach(verifyBitCount);
-    const data = target.imageData;
-    if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
-        throw new Error('imageData has incorrect bitDepth');
-    }
-    if ('mask' in target && target.mask) {
-        const data = target.mask.imageData;
-        if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
-            throw new Error('mask imageData has incorrect bitDepth');
-        }
-    }
+    verifyPixelData(target.imageData, 'imageData');
+    if ('mask' in target)
+        verifyPixelData((_b = target.mask) === null || _b === void 0 ? void 0 : _b.imageData, 'mask imageData');
+    if ('realMask' in target)
+        verifyPixelData((_c = target.realMask) === null || _c === void 0 ? void 0 : _c.imageData, 'realMask imageData');
 }
 function writePsd(writer, psd, options = {}) {
     var _a;
@@ -11097,6 +11731,10 @@ 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');
+    const layers = [];
+    addChildren(layers, psd.children);
+    if (!layers.length)
+        layers.push({});
     verifyBitCount(psd);
     const imageResources = Object.assign({}, psd.imageResources);
     const opt = Object.assign(Object.assign({}, options), { layerIds: new Set(), layerToId: new Map() });
@@ -11110,8 +11748,8 @@ function writePsd(writer, psd, options = {}) {
     if (imageData && (psd.width !== imageData.width || psd.height !== imageData.height))
         throw new Error('Document canvas must have the same size as document');
     const globalAlpha = !!imageData && (0, helpers_1.hasAlpha)(imageData);
-    const maxBufferSize = Math.max(getLargestLayerSize(psd.children), 4 * 2 * psd.width * psd.height + 2 * psd.height);
-    writer.tempBuffer = new Uint8Array(maxBufferSize);
+    // only used for encoding a single layer channel at a time, composite image is encoded directly into the writer buffer
+    writer.tempBuffer = new Uint8Array(getLargestLayerSize(psd.children, !!options.psb));
     // header
     writeSignature(writer, '8BPS');
     writeUint16(writer, options.psb ? 2 : 1); // version
@@ -11134,10 +11772,6 @@ function writePsd(writer, psd, options = {}) {
         }
         // TODO: other data?
     });
-    const layers = [];
-    addChildren(layers, psd.children);
-    if (!layers.length)
-        layers.push({});
     // image resources
     imageResources.layersGroup = layers.map(l => l.linkGroup || 0);
     imageResources.layerGroupsEnabledId = layers.map(l => l.linkGroupEnabled == false ? 0 : 1);
@@ -11159,36 +11793,45 @@ function writePsd(writer, psd, options = {}) {
         writeGlobalLayerMaskInfo(writer, psd.globalLayerMaskInfo);
         writeAdditionalLayerInfo(writer, psd, psd, opt);
     }, undefined, !!opt.psb);
+    writer.tempBuffer = undefined;
     // image data
-    const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
-    const width = imageData ? imageData.width : psd.width;
-    const height = imageData ? imageData.height : psd.height;
-    const data = { data: new Uint8Array(width * height * 4), width, height };
     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 {
-        if (imageData)
-            data.data.set(new Uint8Array(imageData.data.buffer, imageData.data.byteOffset, imageData.data.byteLength));
-        // add weird white matte
-        if (globalAlpha) {
-            const size = data.width * data.height * 4;
-            const p = data.data;
-            for (let i = 0; i < size; i += 4) {
-                const pa = p[i + 3];
-                if (pa != 0 && pa != 255) {
-                    const a = pa / 255;
-                    const ra = 255 * (1 - a);
-                    p[i + 0] = p[i + 0] * a + ra;
-                    p[i + 1] = p[i + 1] * a + ra;
-                    p[i + 2] = p[i + 2] * a + ra;
-                }
+        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)
+        return { data: new Uint8Array(width * height * 4), width, height };
+    const size = width * height * 4;
+    const src = imageData.data;
+    let dst = undefined;
+    // add weird white matte (copy the data only if there are semi-transparent pixels)
+    if (globalAlpha) {
+        for (let i = 0; i < size; i += 4) {
+            const pa = src[i + 3];
+            if (pa != 0 && pa != 255) {
+                if (!dst)
+                    dst = new Uint8Array(src.buffer, src.byteOffset, size).slice();
+                const a = pa / 255;
+                const ra = 255 * (1 - a);
+                dst[i + 0] = src[i + 0] * a + ra;
+                dst[i + 1] = src[i + 1] * a + ra;
+                dst[i + 2] = src[i + 2] * a + ra;
             }
         }
-        writeBytes(writer, (0, helpers_1.writeDataRLE)(writer.tempBuffer, data, channels, !!options.psb));
     }
+    return dst ? { data: dst, width, height } : imageData;
 }
 function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
     writeSection(writer, 4, () => {
@@ -11205,9 +11848,12 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
             writeUint16(writer, channels.length);
             for (const c of channels) {
                 writeInt16(writer, c.id);
-                if (options.psb)
-                    writeUint32(writer, 0);
-                writeUint32(writer, c.length);
+                if (options.psb) {
+                    writeUint64(writer, c.length);
+                }
+                else {
+                    writeUint32(writer, c.length);
+                }
             }
             writeSignature(writer, '8BIM');
             writeSignature(writer, helpers_1.fromBlendMode[layer.blendMode] || 'norm');
@@ -11244,7 +11890,7 @@ function writeLayerInfo(writer, layers, psd, globalAlpha, options) {
     }, true, options.psb);
 }
 function writeLayerMaskData(writer, { mask, realMask }, layerData) {
-    writeSection(writer, 1, () => {
+    writeSection(writer, 4, () => {
         if (!mask && !realMask)
             return;
         let params = 0, flags = 0, realFlags = 0;
@@ -11299,8 +11945,7 @@ function writeLayerMaskData(writer, { mask, realMask }, layerData) {
             if (mask.vectorMaskFeather !== undefined)
                 writeFloat64(writer, mask.vectorMaskFeather);
         }
-        writeZeros(writer, 2);
-    });
+    }, true); // photoshop pads mask data to multiple of 4 bytes and includes padding in the length
 }
 function writerBlendingRange(writer, range) {
     writeUint8(writer, range[0]);
@@ -11329,7 +11974,7 @@ function writeGlobalLayerMaskInfo(writer, info) {
             writeUint16(writer, info.colorSpace2);
             writeUint16(writer, info.colorSpace3);
             writeUint16(writer, info.colorSpace4);
-            writeUint16(writer, Math.round(info.opacity * 0xff));
+            writeUint16(writer, Math.round((0, helpers_1.clamp)(info.opacity, 0, 1) * 100)); // 0-100
             writeUint8(writer, info.kind);
             writeZeros(writer, 3);
         }
@@ -11345,7 +11990,7 @@ function writeAdditionalLayerInfo(writer, target, psd, options) {
         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 === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
+            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 === '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');
@@ -11397,10 +12042,8 @@ function addChildren(layers, children) {
     }
 }
 function resizeBuffer(writer, size) {
-    let newLength = writer.buffer.byteLength;
-    do {
-        newLength *= 2;
-    } while (size > newLength);
+    // grow at least 2x to keep small writes fast, but don't overshoot large reservations (like composite image data)
+    const newLength = Math.max(writer.buffer.byteLength * 2, size);
     const newBuffer = new ArrayBuffer(newLength);
     const newBytes = new Uint8Array(newBuffer);
     const oldBytes = new Uint8Array(writer.buffer);
@@ -11423,12 +12066,12 @@ function createThumbnail(psd) {
     let scale = 1;
     if (psd.width > psd.height) {
         canvas.width = 160;
-        canvas.height = Math.floor(psd.height * (canvas.width / psd.width));
+        canvas.height = Math.max(1, Math.floor(psd.height * (canvas.width / psd.width)));
         scale = canvas.width / psd.width;
     }
     else {
         canvas.height = 160;
-        canvas.width = Math.floor(psd.width * (canvas.height / psd.height));
+        canvas.width = Math.max(1, Math.floor(psd.width * (canvas.height / psd.height)));
         scale = canvas.height / psd.height;
     }
     const context = canvas.getContext('2d');
@@ -11471,7 +12114,7 @@ function getMaskChannels(tempBuffer, layerData, layer, mask, options, realMask)
         compression = 2 /* Compression.ZipWithoutPrediction */;
     }
     else {
-        buffer = (0, helpers_1.writeDataRLE)(tempBuffer, imageData, [0], !!options.psb);
+        buffer = (0, helpers_1.writeDataRLE)(tempBuffer, imageData, [0], !!options.psb).slice(); // copy, temp buffer is reused
         compression = 1 /* Compression.RleCompressed */;
     }
     layerData.channels.push({ id: realMask ? -3 /* ChannelID.RealUserMask */ : -2 /* ChannelID.UserMask */, compression, data: buffer, length: 2 + buffer.length });
@@ -11579,7 +12222,7 @@ function getLayerChannels(tempBuffer, layer, background, options) {
             compression = 2 /* Compression.ZipWithoutPrediction */;
         }
         else {
-            data = (0, helpers_1.writeDataRLE)(tempBuffer, imageData, [offset], !!options.psb);
+            data = (0, helpers_1.writeDataRLE)(tempBuffer, imageData, [offset], !!options.psb).slice(); // copy, temp buffer is reused
             compression = 1 /* Compression.RleCompressed */;
         }
         return { id, compression, data, length: 2 + data.length };
@@ -11643,8 +12286,8 @@ function writeColor(writer, color) {
     else if ('l' in color) {
         writeUint16(writer, 7 /* ColorSpace.Lab */);
         writeInt16(writer, Math.round(color.l * 10000));
-        writeInt16(writer, Math.round(color.a < 0 ? (color.a * 12800) : (color.a * 12700)));
-        writeInt16(writer, Math.round(color.b < 0 ? (color.b * 12800) : (color.b * 12700)));
+        writeInt16(writer, Math.round((0, helpers_1.denormalizeLabAB)(color.a, 100)));
+        writeInt16(writer, Math.round((0, helpers_1.denormalizeLabAB)(color.b, 100)));
         writeUint16(writer, 0);
     }
     else if ('h' in color) {
@@ -11694,6 +12337,9 @@ function writePattern(writer, pattern) {
     writeUint32(writer, bottom);
     writeUint32(writer, right);
     writeUint32(writer, 24); // channels count
+    // ponytail: pattern channels always use small (2-byte) RLE scanline headers, matching
+    // readPattern which reads them as non-large
+    const buffer = new Uint8Array(getRLEChannelBound(width, height, false));
     // channels: RGB at indices 0,1,2 and alpha at index 25
     for (let i = 0; i < 24 + 2; i++) {
         const offset = i < 3 ? i : (i === 25 ? 3 : -1);
@@ -11701,10 +12347,6 @@ function writePattern(writer, pattern) {
             writeUint32(writer, 0); // has
             continue;
         }
-        // worst-case RLE size for a single channel: width + 1 per scanline, plus scanline length headers
-        const buffer = new Uint8Array(width * height + 2 * height + 2 * width + 16);
-        // ponytail: pattern channels always use small (2-byte) RLE scanline headers, matching
-        // readPattern which reads them as non-large; `large` here only affects the header width.
         const data = (0, helpers_1.writeDataRLE)(buffer, pixelData, [offset], false);
         writeUint32(writer, 1); // has
         writeUint32(writer, data.length + 4 + 16 + 2 + 1); // length
@@ -11732,6 +12374,7 @@ function writePattern(writer, pattern) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeEngineData = decodeEngineData;
 exports.encodeEngineData = encodeEngineData;
+const helpers_1 = require("./helpers");
 const defaultFont = {
     name: 'MyriadPro-Regular',
     script: 0,
@@ -11844,6 +12487,26 @@ function decodeColor(color) {
         default: throw new Error('Unknown color type in text layer');
     }
 }
+// h, s, b in 0..1 range, returns r, g, b in 0..1 range
+function hsbToRgb(h, s, v) {
+    h = (0, helpers_1.clamp)(h || 0, 0, 1);
+    s = (0, helpers_1.clamp)(s || 0, 0, 1);
+    v = (0, helpers_1.clamp)(v || 0, 0, 1);
+    const h6 = (h * 6) % 6;
+    const i = Math.floor(h6);
+    const f = h6 - i;
+    const p = v * (1 - s);
+    const q = v * (1 - s * f);
+    const t = v * (1 - s * (1 - f));
+    switch (i) {
+        case 0: return [v, t, p];
+        case 1: return [q, v, p];
+        case 2: return [p, v, t];
+        case 3: return [p, q, v];
+        case 4: return [t, p, v];
+        default: return [v, p, q];
+    }
+}
 function encodeColor(color) {
     if (!color) {
         return { Type: 1, Values: [0, 0, 0, 0] };
@@ -11851,9 +12514,19 @@ function encodeColor(color) {
     else if ('r' in color) {
         return { Type: 1, Values: ['a' in color ? color.a / 255 : 1, color.r / 255, color.g / 255, color.b / 255] };
     }
+    else if ('fr' in color) {
+        return { Type: 1, Values: [1, (0, helpers_1.clamp)(color.fr || 0, 0, 1), (0, helpers_1.clamp)(color.fg || 0, 0, 1), (0, helpers_1.clamp)(color.fb || 0, 0, 1)] };
+    }
+    else if ('h' in color) {
+        const [r, g, b] = hsbToRgb(color.h, color.s, color.b);
+        return { Type: 1, Values: [1, r, g, b] };
+    }
     else if ('c' in color) {
         return { Type: 2, Values: [1, color.c / 255, color.m / 255, color.y / 255, color.k / 255] };
     }
+    else if ('l' in color) {
+        throw new Error('LAB colors are not supported in text layers, use RGB, CMYK or grayscale color instead');
+    }
     else if ('k' in color) {
         return { Type: 0, Values: [1, color.k / 255] };
     }
@@ -11891,16 +12564,19 @@ function findOrAddFont(fonts, font) {
     return fonts.length - 1;
 }
 function decodeObject(obj, keys, fonts) {
+    var _a;
     const result = {};
     for (const key of keys) {
         const Key = upperFirst(key);
         if (obj[Key] === undefined)
             continue;
         if (key === 'justification') {
-            result[key] = justification[obj[Key]];
+            result[key] = (_a = justification[obj[Key]]) !== null && _a !== void 0 ? _a : 'left';
         }
         else if (key === 'font') {
-            result[key] = fonts[obj[Key]];
+            const font = fonts[obj[Key]];
+            if (font)
+                result[key] = font; // invalid font index, leave the font unset so it falls back to default
         }
         else if (key === 'fillColor' || key === 'strokeColor') {
             result[key] = decodeColor(obj[Key]);
@@ -11919,7 +12595,7 @@ function encodeObject(obj, keys, fonts) {
         if (obj[key] === undefined)
             continue;
         if (key === 'justification') {
-            result[Key] = justification.indexOf((_a = obj[key]) !== null && _a !== void 0 ? _a : 'left');
+            result[Key] = Math.max(0, justification.indexOf((_a = obj[key]) !== null && _a !== void 0 ? _a : 'left')); // default to 'left' for unknown values
         }
         else if (key === 'font') {
             result[Key] = findOrAddFont(fonts, obj[key]);
@@ -11987,8 +12663,38 @@ function deduplicateValues(base, runs, keys) {
         runs.length = 0;
     }
 }
+function isDefaultGridColor(color) {
+    // Photoshop writes default grid colors as blue with 0 alpha, ignore alpha when comparing
+    return !!color && 'r' in color && color.r === 0 && color.g === 0 && color.b === 255;
+}
+function decodeGridColor(color, defaultColor) {
+    try {
+        return color ? decodeColor(color) : defaultColor;
+    }
+    catch (_a) {
+        return defaultColor; // don't fail whole text layer because of invalid grid color
+    }
+}
+function decodeGridInfo(grid) {
+    var _a, _b;
+    if (!grid || typeof grid !== 'object')
+        return undefined;
+    const result = {
+        isOn: !!grid.GridIsOn,
+        show: !!grid.ShowGrid,
+        size: (_a = grid.GridSize) !== null && _a !== void 0 ? _a : defaultGridInfo.size,
+        leading: (_b = grid.GridLeading) !== null && _b !== void 0 ? _b : defaultGridInfo.leading,
+        color: decodeGridColor(grid.GridColor, defaultGridInfo.color),
+        leadingFillColor: decodeGridColor(grid.GridLeadingFillColor, defaultGridInfo.leadingFillColor),
+        alignLineHeightToGridFlags: !!grid.AlignLineHeightToGridFlags,
+    };
+    const isDefault = !result.isOn && !result.show && result.size === defaultGridInfo.size &&
+        result.leading === defaultGridInfo.leading && !result.alignLineHeightToGridFlags &&
+        isDefaultGridColor(result.color) && isDefaultGridColor(result.leadingFillColor);
+    return isDefault ? undefined : result;
+}
 function decodeEngineData(engineData) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     // console.log('engineData', require('util').inspect(engineData, false, 99, true));
     const engineDict = engineData.EngineDict;
     const resourceDict = engineData.ResourceDict;
@@ -12000,9 +12706,11 @@ function decodeEngineData(engineData) {
     }));
     let text = engineDict.Editor.Text.replace(/\r/g, '\n');
     let removedCharacters = 0;
-    while (/\n$/.test(text)) {
+    // Photoshop always appends exactly one trailing \r (and encoder adds one back), any additional
+    // trailing new lines are empty paragraphs that are part of the text
+    if (/\n$/.test(text)) {
         text = text.substring(0, text.length - 1);
-        removedCharacters++;
+        removedCharacters = 1;
     }
     const result = {
         text,
@@ -12023,6 +12731,10 @@ function decodeEngineData(engineData) {
         if (photoshop.BoxBounds)
             result.boxBounds = photoshop.BoxBounds;
     }
+    // grid info (only included when it differs from defaults, to avoid noise in common case)
+    const gridInfo = decodeGridInfo(engineDict.GridInfo);
+    if (gridInfo)
+        result.gridInfo = gridInfo;
     // paragraph style
     // const theNormalParagraphSheet = resourceDict.TheNormalParagraphSheet;
     // const paragraphSheetSet = resourceDict.ParagraphSheetSet;
@@ -12053,13 +12765,17 @@ function decodeEngineData(engineData) {
     // const styleSheetSet = resourceDict.StyleSheetSet;
     // const styleSheetData = styleSheetSet[theNormalStyleSheet].StyleSheetData;
     const styleRun = engineDict.StyleRun;
+    // style runs without a font use the font of the normal style sheet
+    const normalStyleSheet = (_j = (_g = resourceDict.StyleSheetSet) === null || _g === void 0 ? void 0 : _g[(_h = resourceDict.TheNormalStyleSheet) !== null && _h !== void 0 ? _h : 0]) === null || _j === void 0 ? void 0 : _j.StyleSheetData;
+    const normalFontIndex = normalStyleSheet === null || normalStyleSheet === void 0 ? void 0 : normalStyleSheet.Font;
+    const normalFont = (_k = (normalFontIndex !== undefined ? fonts[normalFontIndex] : undefined)) !== null && _k !== void 0 ? _k : fonts[0];
     result.style = {}; // decodeStyle(styleSheetData, fonts);
     result.styleRuns = [];
     for (let i = 0; i < styleRun.RunArray.length; i++) {
         const length = styleRun.RunLengthArray[i];
         const style = decodeStyle(styleRun.RunArray[i].StyleSheet.StyleSheetData, fonts);
-        if (!style.font)
-            style.font = fonts[0];
+        if (!style.font && normalFont)
+            style.font = normalFont;
         result.styleRuns.push({ length, style });
     }
     for (let counter = removedCharacters; result.styleRuns.length && counter > 0; counter--) {
@@ -12072,16 +12788,42 @@ function decodeEngineData(engineData) {
         delete result.styleRuns;
     return result;
 }
+// Adjusts run lengths (specified in terms of the original text) for characters removed from the text
+// (\r characters of \r\n pairs that are collapsed into single \r)
+function adjustRunLengths(runs, removed) {
+    if (!runs || !removed.length)
+        return runs;
+    let start = 0;
+    let removedIndex = 0;
+    return runs.map(run => {
+        const length = Math.max(0, run.length || 0);
+        const end = start + length;
+        let count = 0;
+        while (removedIndex < removed.length && removed[removedIndex] < end) {
+            if (removed[removedIndex] >= start)
+                count++;
+            removedIndex++;
+        }
+        start = end;
+        return Object.assign(Object.assign({}, run), { length: length - count });
+    });
+}
 function encodeEngineData(data) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-    const text = `${(data.text || '').replace(/\r?\n/g, '\r')}\r`;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    const sourceText = data.text || '';
+    const removedIndices = []; // indices of \r characters removed from \r\n pairs
+    for (let i = 0; i < sourceText.length - 1; i++) {
+        if (sourceText.charCodeAt(i) === 13 && sourceText.charCodeAt(i + 1) === 10)
+            removedIndices.push(i);
+    }
+    const text = `${sourceText.replace(/\r?\n/g, '\r')}\r`;
     const fonts = [
         { name: 'AdobeInvisFont', script: 0, type: 0, synthetic: 0 },
     ];
     const defFont = ((_a = data.style) === null || _a === void 0 ? void 0 : _a.font) || ((_c = (_b = data.styleRuns) === null || _b === void 0 ? void 0 : _b.find(s => s.style.font)) === null || _c === void 0 ? void 0 : _c.style.font) || defaultFont;
     const paragraphRunArray = [];
     const paragraphRunLengthArray = [];
-    const paragraphRuns = data.paragraphStyleRuns;
+    const paragraphRuns = adjustRunLengths(data.paragraphStyleRuns, removedIndices);
     if (paragraphRuns && paragraphRuns.length) {
         let leftLength = text.length;
         for (const run of paragraphRuns) {
@@ -12130,7 +12872,9 @@ function encodeEngineData(data) {
         }
     }
     const styleSheetData = encodeStyle(Object.assign(Object.assign({}, defaultStyle), { font: defFont }), fonts);
-    const styleRuns = data.styleRuns || [{ length: text.length, style: data.style || {} }];
+    const styleRuns = ((_d = data.styleRuns) === null || _d === void 0 ? void 0 : _d.length) ?
+        adjustRunLengths(data.styleRuns, removedIndices) :
+        [{ length: text.length, style: data.style || {} }];
     const styleRunArray = [];
     const styleRunLengthArray = [];
     let leftLength = text.length;
@@ -12152,7 +12896,7 @@ function encodeEngineData(data) {
         });
     }
     // add extra run to the end if existing ones didn't fill it up
-    if (leftLength && styleRuns.length) {
+    if (leftLength) {
         styleRunLengthArray.push(leftLength);
         styleRunArray.push({
             StyleSheet: {
@@ -12161,6 +12905,7 @@ function encodeEngineData(data) {
         });
     }
     const gridInfo = Object.assign(Object.assign({}, defaultGridInfo), data.gridInfo);
+    const antiAliasIndex = antialias.indexOf((_e = data.antiAlias) !== null && _e !== void 0 ? _e : 'sharp');
     const WritingDirection = data.orientation === 'vertical' ? 2 : 0;
     const Procession = data.orientation === 'vertical' ? 1 : 0;
     const ShapeType = data.shapeType === 'box' ? 1 : 0;
@@ -12224,11 +12969,11 @@ function encodeEngineData(data) {
             FontType: f.type || 0,
             Synthetic: f.synthetic || 0,
         })),
-        SuperscriptSize: (_d = data.superscriptSize) !== null && _d !== void 0 ? _d : 0.583,
-        SuperscriptPosition: (_e = data.superscriptPosition) !== null && _e !== void 0 ? _e : 0.333,
-        SubscriptSize: (_f = data.subscriptSize) !== null && _f !== void 0 ? _f : 0.583,
-        SubscriptPosition: (_g = data.subscriptPosition) !== null && _g !== void 0 ? _g : 0.333,
-        SmallCapSize: (_h = data.smallCapSize) !== null && _h !== void 0 ? _h : 0.7,
+        SuperscriptSize: (_f = data.superscriptSize) !== null && _f !== void 0 ? _f : 0.583,
+        SuperscriptPosition: (_g = data.superscriptPosition) !== null && _g !== void 0 ? _g : 0.333,
+        SubscriptSize: (_h = data.subscriptSize) !== null && _h !== void 0 ? _h : 0.583,
+        SubscriptPosition: (_j = data.subscriptPosition) !== null && _j !== void 0 ? _j : 0.333,
+        SmallCapSize: (_k = data.smallCapSize) !== null && _k !== void 0 ? _k : 0.7,
     };
     const engineData = {
         EngineDict: {
@@ -12251,14 +12996,14 @@ function encodeEngineData(data) {
             GridInfo: {
                 GridIsOn: !!gridInfo.isOn,
                 ShowGrid: !!gridInfo.show,
-                GridSize: (_j = gridInfo.size) !== null && _j !== void 0 ? _j : 18,
-                GridLeading: (_k = gridInfo.leading) !== null && _k !== void 0 ? _k : 22,
+                GridSize: (_l = gridInfo.size) !== null && _l !== void 0 ? _l : 18,
+                GridLeading: (_m = gridInfo.leading) !== null && _m !== void 0 ? _m : 22,
                 GridColor: encodeColor(gridInfo.color),
-                GridLeadingFillColor: encodeColor(gridInfo.color),
+                GridLeadingFillColor: encodeColor(gridInfo.leadingFillColor),
                 AlignLineHeightToGridFlags: !!gridInfo.alignLineHeightToGridFlags,
             },
-            AntiAlias: antialias.indexOf((_l = data.antiAlias) !== null && _l !== void 0 ? _l : 'sharp'),
-            UseFractionalGlyphWidths: (_m = data.useFractionalGlyphWidths) !== null && _m !== void 0 ? _m : true,
+            AntiAlias: antiAliasIndex === -1 ? antialias.indexOf('sharp') : antiAliasIndex,
+            UseFractionalGlyphWidths: (_o = data.useFractionalGlyphWidths) !== null && _o !== void 0 ? _o : true,
             Rendered: {
                 Version: 1,
                 Shapes: {
@@ -12281,7 +13026,7 @@ function encodeEngineData(data) {
     return engineData;
 }
 
-},{}],16:[function(require,module,exports){
+},{"./helpers":8}],16:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringLengthInBytes = stringLengthInBytes;
@@ -12302,30 +13047,44 @@ function charLengthInBytes(code) {
         return 4;
     }
 }
-// Reads a scalar value at index `i`, replacing unpaired surrogates with U+FFFD,
+// Returns scalar value at index `i` (combining surrogate pairs), replacing unpaired surrogates with U+FFFD,
 // matching how TextEncoder converts a string to a sequence of Unicode scalar values.
+// Values above 0xffff always take 2 UTF-16 code units.
 function codePointAt(value, i) {
     const code = value.charCodeAt(i);
+    if (code < 0xd800 || code > 0xdfff)
+        return code;
     // high surrogate
-    if (code >= 0xd800 && code <= 0xdbff && (i + 1) < value.length) {
+    if (code <= 0xdbff && (i + 1) < value.length) {
         const extra = value.charCodeAt(i + 1);
         // low surrogate
         if (extra >= 0xdc00 && extra <= 0xdfff) {
-            return { code: ((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000, size: 2 };
+            return ((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
         }
     }
     // unpaired surrogate (lone high or lone low)
-    if (code >= 0xd800 && code <= 0xdfff) {
-        return { code: 0xfffd, size: 1 };
-    }
-    return { code, size: 1 };
+    return 0xfffd;
 }
 function stringLengthInBytes(value) {
     let result = 0;
-    for (let i = 0; i < value.length;) {
-        const { code, size } = codePointAt(value, i);
-        result += charLengthInBytes(code);
-        i += size;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80) {
+            result += 1;
+        }
+        else if (code < 0x800) {
+            result += 2;
+        }
+        else {
+            const scalar = codePointAt(value, i);
+            if (scalar > 0xffff) {
+                result += 4;
+                i++;
+            }
+            else {
+                result += 3;
+            }
+        }
     }
     return result;
 }
@@ -12354,10 +13113,17 @@ function writeCharacter(buffer, offset, code) {
     return length;
 }
 function encodeStringTo(buffer, offset, value) {
-    for (let i = 0; i < value.length;) {
-        const { code, size } = codePointAt(value, i);
-        offset += writeCharacter(buffer, offset, code);
-        i += size;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80) {
+            buffer[offset++] = code;
+        }
+        else {
+            const scalar = codePointAt(value, i);
+            if (scalar > 0xffff)
+                i++;
+            offset += writeCharacter(buffer, offset, scalar);
+        }
     }
     return offset;
 }