ag-psd 16.0.0 → 17.0.1

package/dist/bundle.js

@@ -292,6 +292,7 @@ var psdWriter_1 = require("./psdWriter");
 var descriptor_1 = require("./descriptor");
 var engineData_1 = require("./engineData");
 var text_1 = require("./text");
+var fromAtoZ = 'abcdefghijklmnopqrstuvwxyz';
 exports.infoHandlers = [];
 exports.infoHandlersMap = {};
 function addHandler(key, has, read, write) {
@@ -345,6 +346,10 @@ addHandler('TySh', hasKey('text'), function (reader, target, leftBytes) {
             rotate: descriptor_1.Ornt.decode(warp.warpRotate),
         },
     };
+    if (text.bounds)
+        target.text.bounds = (0, descriptor_1.descBoundsToBounds)(text.bounds);
+    if (text.boundingBox)
+        target.text.boundingBox = (0, descriptor_1.descBoundsToBounds)(text.boundingBox);
     if (text.EngineData) {
         var engineData = (0, engineData_1.parseEngineData)(text.EngineData);
         var textData = (0, text_1.decodeEngineData)(engineData);
@@ -362,20 +367,13 @@ addHandler('TySh', hasKey('text'), function (reader, target, leftBytes) {
     var text = target.text;
     var warp = text.warp || {};
     var transform = text.transform || [1, 0, 0, 1, 0, 0];
-    var textDescriptor = {
-        'Txt ': (text.text || '').replace(/\r?\n/g, '\r'),
-        textGridding: descriptor_1.textGridding.encode(text.gridding),
-        Ornt: descriptor_1.Ornt.encode(text.orientation),
-        AntA: descriptor_1.Annt.encode(text.antiAlias),
-        TextIndex: text.index || 0,
-        EngineData: (0, engineData_1.serializeEngineData)((0, text_1.encodeEngineData)(text)),
-    };
+    var textDescriptor = __assign(__assign(__assign({ 'Txt ': (text.text || '').replace(/\r?\n/g, '\r'), textGridding: descriptor_1.textGridding.encode(text.gridding), Ornt: descriptor_1.Ornt.encode(text.orientation), AntA: descriptor_1.Annt.encode(text.antiAlias) }, (text.bounds ? { bounds: (0, descriptor_1.boundsToDescBounds)(text.bounds) } : {})), (text.boundingBox ? { boundingBox: (0, descriptor_1.boundsToDescBounds)(text.boundingBox) } : {})), { TextIndex: text.index || 0, EngineData: (0, engineData_1.serializeEngineData)((0, text_1.encodeEngineData)(text)) });
     (0, psdWriter_1.writeInt16)(writer, 1); // version
     for (var i = 0; i < 6; i++) {
         (0, psdWriter_1.writeFloat64)(writer, transform[i]);
     }
     (0, psdWriter_1.writeInt16)(writer, 50); // text version
-    (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'TxLr', textDescriptor);
+    (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);
@@ -818,10 +816,10 @@ addHandler('shmd', function (target) { return target.timestamp !== undefined ||
                 var timeScope = desc.timeScope;
                 // console.log('tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
                 var timeline = {
-                    start: timeScope.Strt,
-                    duration: timeScope.duration,
-                    inTime: timeScope.inTime,
-                    outTime: timeScope.outTime,
+                    start: (0, descriptor_1.frac)(timeScope.Strt),
+                    duration: (0, descriptor_1.frac)(timeScope.duration),
+                    inTime: (0, descriptor_1.frac)(timeScope.inTime),
+                    outTime: (0, descriptor_1.frac)(timeScope.outTime),
                     autoScope: desc.autoScope,
                     audioLevel: desc.audioLevel,
                 };
@@ -962,7 +960,7 @@ addHandler('vstk', hasKey('vectorStroke'), function (reader, target, left) {
 }, function (writer, target) {
     var _a, _b, _c;
     var stroke = target.vectorStroke;
-    var descriptor = {
+    var desc = {
         strokeStyleVersion: 2,
         strokeEnabled: !!stroke.strokeEnabled,
         fillEnabled: !!stroke.fillEnabled,
@@ -980,7 +978,7 @@ addHandler('vstk', hasKey('vectorStroke'), function (reader, target, left) {
         strokeStyleContent: (0, descriptor_1.serializeVectorContent)(stroke.content || { type: 'color', color: { r: 0, g: 0, b: 0 } }).descriptor,
         strokeStyleResolution: (_c = stroke.resolution) !== null && _c !== void 0 ? _c : 72,
     };
-    (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'strokeStyle', descriptor);
+    (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'strokeStyle', desc);
 });
 addHandler('artb', // per-layer arboard info
 hasKey('artboard'), function (reader, target, left) {
@@ -1045,7 +1043,7 @@ function isQuiltWarp(warp) {
 }
 function encodeWarp(warp) {
     var bounds = warp.bounds;
-    var desc = __assign(__assign({ warpStyle: descriptor_1.warpStyle.encode(warp.style) }, (warp.values ? { warpValues: warp.values } : { warpValue: warp.value })), { warpPerspective: warp.perspective || 0, warpPerspectiveOther: warp.perspectiveOther || 0, warpRotate: descriptor_1.Ornt.encode(warp.rotate), bounds: {
+    var desc = __assign(__assign({ warpStyle: descriptor_1.warpStyle.encode(warp.style) }, (warp.values ? { warpValues: warp.values } : { warpValue: warp.value || 0 })), { warpPerspective: warp.perspective || 0, warpPerspectiveOther: warp.perspectiveOther || 0, warpRotate: descriptor_1.Ornt.encode(warp.rotate), bounds: {
             'Top ': (0, descriptor_1.unitsValue)(bounds && bounds.top || { units: 'Pixels', value: 0 }, 'bounds.top'),
             Left: (0, descriptor_1.unitsValue)(bounds && bounds.left || { units: 'Pixels', value: 0 }, 'bounds.left'),
             Btom: (0, descriptor_1.unitsValue)(bounds && bounds.bottom || { units: 'Pixels', value: 0 }, 'bounds.bottom'),
@@ -1063,6 +1061,8 @@ function encodeWarp(warp) {
         if (isQuilt) {
             var desc2 = desc;
             desc2.customEnvelopeWarp = {
+                _name: '',
+                _classID: 'customEnvelopeWarp',
                 quiltSliceX: [{
                         type: 'quiltSliceX',
                         values: customEnvelopeWarp.quiltSliceX || [],
@@ -1079,6 +1079,8 @@ function encodeWarp(warp) {
         }
         else {
             desc.customEnvelopeWarp = {
+                _name: '',
+                _classID: 'customEnvelopeWarp',
                 meshPoints: [
                     { type: 'Hrzn', values: meshPoints.map(function (p) { return p.x; }) },
                     { type: 'Vrtc', values: meshPoints.map(function (p) { return p.y; }) },
@@ -1170,58 +1172,345 @@ function hrznVrtcToPoint(desc) {
 }
 function pointToHrznVrtc(point) {
     return {
+        _name: '',
+        _classID: 'Pnt ',
         Hrzn: (0, descriptor_1.unitsValue)(point.x, 'x'),
         Vrtc: (0, descriptor_1.unitsValue)(point.y, 'y'),
     };
 }
-function parseFilterFXFilter(Fltr) {
-    if ('puppetShapeList' in Fltr) {
-        return {
-            rigidType: Fltr.rigidType,
-            bounds: [
-                { x: Fltr.PuX0, y: Fltr.PuY0, },
-                { x: Fltr.PuX1, y: Fltr.PuY1, },
-                { x: Fltr.PuX2, y: Fltr.PuY2, },
-                { x: Fltr.PuX3, y: Fltr.PuY3, },
-            ],
-            puppetShapeList: Fltr.puppetShapeList.map(function (p) { return ({
-                rigidType: p.rigidType,
-                // TODO: VrsM
-                // TODO: VrsN
-                originalVertexArray: uint8ToPoints(p.originalVertexArray),
-                deformedVertexArray: uint8ToPoints(p.deformedVertexArray),
-                indexArray: Array.from(uint8ToUint32(p.indexArray)),
-                pinOffsets: arrayToPoints(p.pinOffsets),
-                posFinalPins: arrayToPoints(p.posFinalPins),
-                pinVertexIndices: p.pinVertexIndices,
-                selectedPin: p.selectedPin,
-                pinPosition: arrayToPoints(p.PinP),
-                pinRotation: p.PnRt,
-                pinOverlay: p.PnOv,
-                pinDepth: p.PnDp,
-                meshQuality: p.meshQuality,
-                meshExpansion: p.meshExpansion,
-                meshRigidity: p.meshRigidity,
-                imageResolution: p.imageResolution,
-                meshBoundaryPath: {
-                    pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
-                        shapeOperation: c.shapeOperation.split('.')[1],
-                        paths: c.SbpL.map(function (t) { return ({
-                            closed: t.Clsp,
-                            points: t['Pts '].map(function (pt) { return ({
-                                anchor: hrznVrtcToPoint(pt.Anch),
-                                forward: hrznVrtcToPoint(pt['Fwd ']),
-                                backward: hrznVrtcToPoint(pt['Bwd ']),
-                                smooth: pt.Smoo,
+function parseFilterFXItem(f) {
+    var base = {
+        name: f['Nm  '],
+        opacity: (0, descriptor_1.parsePercent)(f.blendOptions.Opct),
+        blendMode: descriptor_1.BlnM.decode(f.blendOptions['Md  ']),
+        enabled: f.enab,
+        hasOptions: f.hasoptions,
+        foregroundColor: (0, descriptor_1.parseColor)(f.FrgC),
+        backgroundColor: (0, descriptor_1.parseColor)(f.BckC),
+    };
+    switch (f.filterID) {
+        case 1098281575: return __assign(__assign({}, base), { type: 'average' });
+        case 1114403360: return __assign(__assign({}, base), { type: 'blur' });
+        case 1114403405: return __assign(__assign({}, base), { type: 'blur more' });
+        case 697: return __assign(__assign({}, base), { type: 'box blur', filter: {
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+            } });
+        case 1198747202: return __assign(__assign({}, base), { type: 'gaussian blur', filter: {
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+            } });
+        case 1299476034: return __assign(__assign({}, base), { type: 'motion blur', filter: {
+                angle: f.Fltr.Angl,
+                distance: (0, descriptor_1.parseUnits)(f.Fltr.Dstn),
+            } });
+        case 1382313026: return __assign(__assign({}, base), { type: 'radial blur', filter: {
+                amount: f.Fltr.Amnt,
+                method: descriptor_1.BlrM.decode(f.Fltr.BlrM),
+                quality: descriptor_1.BlrQ.decode(f.Fltr.BlrQ),
+            } });
+        case 702: return __assign(__assign({}, base), { type: 'shape blur', filter: {
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+                customShape: { name: f.Fltr.customShape['Nm  '], id: f.Fltr.customShape.Idnt },
+            } });
+        case 1399681602: return __assign(__assign({}, base), { type: 'smart blur', filter: {
+                radius: f.Fltr['Rds '],
+                threshold: f.Fltr.Thsh,
+                quality: descriptor_1.SmBQ.decode(f.Fltr.SmBQ),
+                mode: descriptor_1.SmBM.decode(f.Fltr.SmBM),
+            } });
+        case 701: return __assign(__assign({}, base), { type: 'surface blur', filter: {
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+                threshold: f.Fltr.Thsh,
+            } });
+        case 1148416108: return __assign(__assign({}, base), { type: 'displace', filter: {
+                horizontalScale: f.Fltr.HrzS,
+                verticalScale: f.Fltr.VrtS,
+                displacementMap: descriptor_1.DspM.decode(f.Fltr.DspM),
+                undefinedAreas: descriptor_1.UndA.decode(f.Fltr.UndA),
+                displacementFile: {
+                    signature: f.Fltr.DspF.sig,
+                    path: f.Fltr.DspF.path, // TODO: this is decoded incorrectly ???
+                },
+            } });
+        case 1349411688: return __assign(__assign({}, base), { type: 'pinch', filter: {
+                amount: f.Fltr.Amnt,
+            } });
+        case 1349284384: return __assign(__assign({}, base), { type: 'polar coordinates', filter: {
+                conversion: descriptor_1.Cnvr.decode(f.Fltr.Cnvr),
+            } });
+        case 1383099493: return __assign(__assign({}, base), { type: 'ripple', filter: {
+                amount: f.Fltr.Amnt,
+                size: descriptor_1.RplS.decode(f.Fltr.RplS),
+            } });
+        case 1399353888: return __assign(__assign({}, base), { type: 'shear', filter: {
+                shearPoints: f.Fltr.ShrP.map(function (p) { return ({ x: p.Hrzn, y: p.Vrtc }); }),
+                shearStart: f.Fltr.ShrS,
+                shearEnd: f.Fltr.ShrE,
+                undefinedAreas: descriptor_1.UndA.decode(f.Fltr.UndA),
+            } });
+        case 1399875698: return __assign(__assign({}, base), { type: 'spherize', filter: {
+                amount: f.Fltr.Amnt,
+                mode: descriptor_1.SphM.decode(f.Fltr.SphM),
+            } });
+        case 1417114220: return __assign(__assign({}, base), { type: 'twirl', filter: {
+                angle: f.Fltr.Angl,
+            } });
+        case 1466005093: return __assign(__assign({}, base), { type: 'wave', filter: {
+                numberOfGenerators: f.Fltr.NmbG,
+                type: descriptor_1.Wvtp.decode(f.Fltr.Wvtp),
+                wavelength: { min: f.Fltr.WLMn, max: f.Fltr.WLMx },
+                amplitude: { min: f.Fltr.AmMn, max: f.Fltr.AmMx },
+                scale: { x: f.Fltr.SclH, y: f.Fltr.SclV },
+                randomSeed: f.Fltr.RndS,
+                undefinedAreas: descriptor_1.UndA.decode(f.Fltr.UndA),
+            } });
+        case 1516722791: return __assign(__assign({}, base), { type: 'zigzag', filter: {
+                amount: f.Fltr.Amnt,
+                ridges: f.Fltr.NmbR,
+                style: descriptor_1.ZZTy.decode(f.Fltr.ZZTy),
+            } });
+        case 1097092723: return __assign(__assign({}, base), { type: 'add noise', filter: {
+                amount: (0, descriptor_1.parsePercent)(f.Fltr.Nose),
+                distribution: descriptor_1.Dstr.decode(f.Fltr.Dstr),
+                monochromatic: f.Fltr.Mnch,
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1148416099: return __assign(__assign({}, base), { type: 'despeckle' });
+        case 1148417107: return __assign(__assign({}, base), { type: 'dust and scratches', filter: {
+                radius: f.Fltr['Rds '],
+                threshold: f.Fltr.Thsh,
+            } });
+        case 1298427424: return __assign(__assign({}, base), { type: 'median', filter: {
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+            } });
+        case 633: return __assign(__assign({}, base), { type: 'reduce noise', filter: {
+                preset: f.Fltr.preset,
+                removeJpegArtifact: f.Fltr.removeJPEGArtifact,
+                reduceColorNoise: (0, descriptor_1.parsePercent)(f.Fltr.ClNs),
+                sharpenDetails: (0, descriptor_1.parsePercent)(f.Fltr.Shrp),
+                channelDenoise: f.Fltr.channelDenoise.map(function (c) { return (__assign({ channels: c.Chnl.map(function (i) { return descriptor_1.Chnl.decode(i); }), amount: c.Amnt }, (c.EdgF ? { preserveDetails: c.EdgF } : {}))); }),
+            } });
+        case 1131180616: return __assign(__assign({}, base), { type: 'color halftone', filter: {
+                radius: f.Fltr['Rds '],
+                angle1: f.Fltr.Ang1,
+                angle2: f.Fltr.Ang2,
+                angle3: f.Fltr.Ang3,
+                angle4: f.Fltr.Ang4,
+            } });
+        case 1131574132: return __assign(__assign({}, base), { type: 'crystallize', filter: {
+                cellSize: f.Fltr.ClSz,
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1180922912: return __assign(__assign({}, base), { type: 'facet' });
+        case 1181902701: return __assign(__assign({}, base), { type: 'fragment' });
+        case 1299870830: return __assign(__assign({}, base), { type: 'mezzotint', filter: {
+                type: descriptor_1.MztT.decode(f.Fltr.MztT),
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1299407648: return __assign(__assign({}, base), { type: 'mosaic', filter: {
+                cellSize: (0, descriptor_1.parseUnits)(f.Fltr.ClSz),
+            } });
+        case 1349416044: return __assign(__assign({}, base), { type: 'pointillize', filter: {
+                cellSize: f.Fltr.ClSz,
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1131177075: return __assign(__assign({}, base), { type: 'clouds', filter: {
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1147564611: return __assign(__assign({}, base), { type: 'difference clouds', filter: {
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1180856947: return __assign(__assign({}, base), { type: 'fibers', filter: {
+                variance: f.Fltr.Vrnc,
+                strength: f.Fltr.Strg,
+                randomSeed: f.Fltr.RndS,
+            } });
+        case 1282306886: return __assign(__assign({}, base), { type: 'lens flare', filter: {
+                brightness: f.Fltr.Brgh,
+                position: { x: f.Fltr.FlrC.Hrzn, y: f.Fltr.FlrC.Vrtc },
+                lensType: descriptor_1.Lns.decode(f.Fltr['Lns ']),
+            } });
+        case 1399353968: return __assign(__assign({}, base), { type: 'sharpen' });
+        case 1399353925: return __assign(__assign({}, base), { type: 'sharpen edges' });
+        case 1399353933: return __assign(__assign({}, base), { type: 'sharpen more' });
+        case 698: return __assign(__assign({}, base), { type: 'smart sharpen', filter: {
+                amount: (0, descriptor_1.parsePercent)(f.Fltr.Amnt),
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+                threshold: f.Fltr.Thsh,
+                angle: f.Fltr.Angl,
+                moreAccurate: f.Fltr.moreAccurate,
+                blur: descriptor_1.blurType.decode(f.Fltr.blur),
+                preset: f.Fltr.preset,
+                shadow: {
+                    fadeAmount: (0, descriptor_1.parsePercent)(f.Fltr.sdwM.Amnt),
+                    tonalWidth: (0, descriptor_1.parsePercent)(f.Fltr.sdwM.Wdth),
+                    radius: f.Fltr.sdwM['Rds '],
+                },
+                highlight: {
+                    fadeAmount: (0, descriptor_1.parsePercent)(f.Fltr.hglM.Amnt),
+                    tonalWidth: (0, descriptor_1.parsePercent)(f.Fltr.hglM.Wdth),
+                    radius: f.Fltr.hglM['Rds '],
+                },
+            } });
+        case 1433301837: return __assign(__assign({}, base), { type: 'unsharp mask', filter: {
+                amount: (0, descriptor_1.parsePercent)(f.Fltr.Amnt),
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+                threshold: f.Fltr.Thsh,
+            } });
+        case 1147564832: return __assign(__assign({}, base), { type: 'diffuse', filter: {
+                mode: descriptor_1.DfsM.decode(f.Fltr['Md  ']),
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1164796531: return __assign(__assign({}, base), { type: 'emboss', filter: {
+                angle: f.Fltr.Angl,
+                height: f.Fltr.Hght,
+                amount: f.Fltr.Amnt,
+            } });
+        case 1165522034: return __assign(__assign({}, base), { type: 'extrude', filter: {
+                type: descriptor_1.ExtT.decode(f.Fltr.ExtT),
+                size: f.Fltr.ExtS,
+                depth: f.Fltr.ExtD,
+                depthMode: descriptor_1.ExtR.decode(f.Fltr.ExtR),
+                randomSeed: f.Fltr.FlRs,
+                solidFrontFaces: f.Fltr.ExtF,
+                maskIncompleteBlocks: f.Fltr.ExtM,
+            } });
+        case 1181639749: return __assign(__assign({}, base), { type: 'find edges' });
+        case 1399616122: return __assign(__assign({}, base), { type: 'solarize' });
+        case 1416393504: return __assign(__assign({}, base), { type: 'tiles', filter: {
+                numberOfTiles: f.Fltr.TlNm,
+                maximumOffset: f.Fltr.TlOf,
+                fillEmptyAreaWith: descriptor_1.FlCl.decode(f.Fltr.FlCl),
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1416782659: return __assign(__assign({}, base), { type: 'trace contour', filter: {
+                level: f.Fltr['Lvl '],
+                edge: descriptor_1.CntE.decode(f.Fltr['Edg ']),
+            } });
+        case 1466852384: return __assign(__assign({}, base), { type: 'wind', filter: {
+                method: descriptor_1.WndM.decode(f.Fltr.WndM),
+                direction: descriptor_1.Drct.decode(f.Fltr.Drct),
+            } });
+        case 1148089458: return __assign(__assign({}, base), { type: 'de-interlace', filter: {
+                eliminate: descriptor_1.IntE.decode(f.Fltr.IntE),
+                newFieldsBy: descriptor_1.IntC.decode(f.Fltr.IntC),
+            } });
+        case 1314149187: return __assign(__assign({}, base), { type: 'ntsc colors' });
+        case 1131639917: return __assign(__assign({}, base), { type: 'custom', filter: {
+                scale: f.Fltr['Scl '],
+                offset: f.Fltr.Ofst,
+                matrix: f.Fltr.Mtrx,
+            } });
+        case 1214736464: return __assign(__assign({}, base), { type: 'high pass', filter: {
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+            } });
+        case 1299737888: return __assign(__assign({}, base), { type: 'maximum', filter: {
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+            } });
+        case 1299082528: return __assign(__assign({}, base), { type: 'minimum', filter: {
+                radius: (0, descriptor_1.parseUnits)(f.Fltr['Rds ']),
+            } });
+        case 1332114292: return __assign(__assign({}, base), { type: 'offset', filter: {
+                horizontal: f.Fltr.Hrzn,
+                vertical: f.Fltr.Vrtc,
+                undefinedAreas: descriptor_1.FlMd.decode(f.Fltr['Fl  ']),
+            } });
+        case 991: return __assign(__assign({}, base), { type: 'puppet', filter: {
+                rigidType: f.Fltr.rigidType,
+                bounds: [
+                    { x: f.Fltr.PuX0, y: f.Fltr.PuY0, },
+                    { x: f.Fltr.PuX1, y: f.Fltr.PuY1, },
+                    { x: f.Fltr.PuX2, y: f.Fltr.PuY2, },
+                    { x: f.Fltr.PuX3, y: f.Fltr.PuY3, },
+                ],
+                puppetShapeList: f.Fltr.puppetShapeList.map(function (p) { return ({
+                    rigidType: p.rigidType,
+                    // TODO: VrsM
+                    // TODO: VrsN
+                    originalVertexArray: uint8ToPoints(p.originalVertexArray),
+                    deformedVertexArray: uint8ToPoints(p.deformedVertexArray),
+                    indexArray: Array.from(uint8ToUint32(p.indexArray)),
+                    pinOffsets: arrayToPoints(p.pinOffsets),
+                    posFinalPins: arrayToPoints(p.posFinalPins),
+                    pinVertexIndices: p.pinVertexIndices,
+                    selectedPin: p.selectedPin,
+                    pinPosition: arrayToPoints(p.PinP),
+                    pinRotation: p.PnRt,
+                    pinOverlay: p.PnOv,
+                    pinDepth: p.PnDp,
+                    meshQuality: p.meshQuality,
+                    meshExpansion: p.meshExpansion,
+                    meshRigidity: p.meshRigidity,
+                    imageResolution: p.imageResolution,
+                    meshBoundaryPath: {
+                        pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
+                            shapeOperation: c.shapeOperation.split('.')[1],
+                            paths: c.SbpL.map(function (t) { return ({
+                                closed: t.Clsp,
+                                points: t['Pts '].map(function (pt) { return ({
+                                    anchor: hrznVrtcToPoint(pt.Anch),
+                                    forward: hrznVrtcToPoint(pt['Fwd ']),
+                                    backward: hrznVrtcToPoint(pt['Bwd ']),
+                                    smooth: pt.Smoo,
+                                }); }),
                             }); }),
                         }); }),
-                    }); }),
-                },
-            }); }),
-        };
-    }
-    else {
-        return {};
+                    },
+                }); }),
+            } });
+        case 1348620396: {
+            var parameters = [];
+            var Flrt = f.Fltr;
+            for (var i = 0; i < fromAtoZ.length; i++) {
+                if (!Flrt["PN".concat(fromAtoZ[i], "a")])
+                    break;
+                for (var j = 0; j < fromAtoZ.length; j++) {
+                    if (!Flrt["PN".concat(fromAtoZ[i]).concat(fromAtoZ[j])])
+                        break;
+                    parameters.push({
+                        name: Flrt["PN".concat(fromAtoZ[i]).concat(fromAtoZ[j])],
+                        value: Flrt["PF".concat(fromAtoZ[i]).concat(fromAtoZ[j])]
+                    });
+                }
+            }
+            return __assign(__assign({}, base), { type: 'oil paint plugin', filter: {
+                    name: f.Fltr.KnNm,
+                    gpu: f.Fltr.GpuY,
+                    lighting: f.Fltr.LIWy,
+                    parameters: parameters,
+                } });
+        }
+        // case 2089: return {
+        // 	...base,
+        // 	type: 'adaptive wide angle',
+        // 	params: {
+        // 		correction: prjM.decode(f.Fltr.prjM),
+        // 		focalLength: f.Fltr.focL,
+        // 		cropFactor: f.Fltr.CrpF,
+        // 		imageScale: f.Fltr.imgS,
+        // 		imageX: f.Fltr.imgX,
+        // 		imageY: f.Fltr.imgY,
+        // 	},
+        // };
+        case 1215521360: return __assign(__assign({}, base), { type: 'hsb/hsl', filter: {
+                inputMode: descriptor_1.ClrS.decode(f.Fltr.Inpt),
+                rowOrder: descriptor_1.ClrS.decode(f.Fltr.Otpt),
+            } });
+        case 1122: return __assign(__assign({}, base), { type: 'oil paint', filter: {
+                lightingOn: f.Fltr.lightingOn,
+                stylization: f.Fltr.stylization,
+                cleanliness: f.Fltr.cleanliness,
+                brushScale: f.Fltr.brushScale,
+                microBrush: f.Fltr.microBrush,
+                lightDirection: f.Fltr.LghD,
+                specularity: f.Fltr.specularity,
+            } });
+        case 1282492025: {
+            return __assign(__assign({}, base), { type: 'liquify', filter: {
+                    liquifyMesh: f.Fltr.LqMe,
+                } });
+        }
+        default:
+            throw new Error("Unknown filterID: ".concat(f.filterID));
     }
 }
 function parseFilterFX(desc) {
@@ -1231,96 +1520,446 @@ function parseFilterFX(desc) {
         maskEnabled: desc.filterMaskEnable,
         maskLinked: desc.filterMaskLinked,
         maskExtendWithWhite: desc.filterMaskExtendWithWhite,
-        list: desc.filterFXList.map(function (f) { return ({
-            id: f.filterID,
-            name: f['Nm  '],
-            opacity: (0, descriptor_1.parsePercent)(f.blendOptions.Opct),
-            blendMode: descriptor_1.BlnM.decode(f.blendOptions['Md  ']),
-            enabled: f.enab,
-            hasOptions: f.hasoptions,
-            foregroundColor: (0, descriptor_1.parseColor)(f.FrgC),
-            backgroundColor: (0, descriptor_1.parseColor)(f.BckC),
-            filter: parseFilterFXFilter(f.Fltr),
-        }); }),
+        list: desc.filterFXList.map(parseFilterFXItem),
     };
 }
-function serializeFltr(filter) {
-    if ('puppetShapeList' in filter) {
-        return {
-            'null': ['Ordn.Trgt'],
-            rigidType: filter.rigidType,
-            puppetShapeList: filter.puppetShapeList.map(function (p) { return ({
-                rigidType: p.rigidType,
-                VrsM: 1,
-                VrsN: 0,
-                originalVertexArray: toUint8(new Float32Array(pointsToArray(p.originalVertexArray))),
-                deformedVertexArray: toUint8(new Float32Array(pointsToArray(p.deformedVertexArray))),
-                indexArray: toUint8(new Uint32Array(p.indexArray)),
-                pinOffsets: pointsToArray(p.pinOffsets),
-                posFinalPins: pointsToArray(p.posFinalPins),
-                selectedPin: p.selectedPin,
-                pinVertexIndices: p.pinVertexIndices,
-                PinP: pointsToArray(p.pinPosition),
-                PnRt: p.pinRotation,
-                PnOv: p.pinOverlay,
-                PnDp: p.pinDepth,
-                meshQuality: p.meshQuality,
-                meshExpansion: p.meshExpansion,
-                meshRigidity: p.meshRigidity,
-                imageResolution: p.imageResolution,
-                meshBoundaryPath: {
-                    pathComponents: (p.meshBoundaryPath.pathComponents || []).map(function (c) { return ({
-                        shapeOperation: "shapeOperation.".concat(c.shapeOperation),
-                        SbpL: (c.paths || []).map(function (path) { return ({
-                            Clsp: path.closed,
-                            'Pts ': (path.points || []).map(function (pt) { return ({
-                                Anch: pointToHrznVrtc(pt.anchor),
-                                'Fwd ': pointToHrznVrtc(pt.forward),
-                                'Bwd ': pointToHrznVrtc(pt.backward),
-                                Smoo: pt.smooth,
+function uvRadius(t) {
+    return (0, descriptor_1.unitsValue)(t.radius, 'radius');
+}
+function serializeFilterFXItem(f) {
+    var base = {
+        _name: '',
+        _classID: 'filterFX',
+        'Nm  ': f.name,
+        blendOptions: {
+            _name: '',
+            _classID: 'blendOptions',
+            Opct: (0, descriptor_1.unitsPercentF)(f.opacity),
+            'Md  ': descriptor_1.BlnM.encode(f.blendMode),
+        },
+        enab: f.enabled,
+        hasoptions: f.hasOptions,
+        FrgC: (0, descriptor_1.serializeColor)(f.foregroundColor),
+        BckC: (0, descriptor_1.serializeColor)(f.backgroundColor),
+    };
+    switch (f.type) {
+        case 'average': return __assign(__assign({}, base), { filterID: 1098281575 });
+        case 'blur': return __assign(__assign({}, base), { filterID: 1114403360 });
+        case 'blur more': return __assign(__assign({}, base), { filterID: 1114403405 });
+        case 'box blur': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Box Blur',
+                _classID: 'boxblur',
+                'Rds ': uvRadius(f.filter),
+            }, filterID: 697 });
+        case 'gaussian blur': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Gaussian Blur',
+                _classID: 'GsnB',
+                'Rds ': uvRadius(f.filter),
+            }, filterID: 1198747202 });
+        case 'motion blur': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Motion Blur',
+                _classID: 'MtnB',
+                Angl: f.filter.angle,
+                Dstn: (0, descriptor_1.unitsValue)(f.filter.distance, 'distance'),
+            }, filterID: 1299476034 });
+        case 'radial blur': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Radial Blur',
+                _classID: 'RdlB',
+                Amnt: f.filter.amount,
+                BlrM: descriptor_1.BlrM.encode(f.filter.method),
+                BlrQ: descriptor_1.BlrQ.encode(f.filter.quality),
+            }, filterID: 1382313026 });
+        case 'shape blur': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Shape Blur',
+                _classID: 'shapeBlur',
+                'Rds ': uvRadius(f.filter),
+                customShape: {
+                    _name: '',
+                    _classID: 'customShape',
+                    'Nm  ': f.filter.customShape.name,
+                    Idnt: f.filter.customShape.id,
+                }
+            }, filterID: 702 });
+        case 'smart blur': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Smart Blur',
+                _classID: 'SmrB',
+                'Rds ': f.filter.radius,
+                Thsh: f.filter.threshold,
+                SmBQ: descriptor_1.SmBQ.encode(f.filter.quality),
+                SmBM: descriptor_1.SmBM.encode(f.filter.mode),
+            }, filterID: 1399681602 });
+        case 'surface blur': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Surface Blur',
+                _classID: 'surfaceBlur',
+                'Rds ': uvRadius(f.filter),
+                Thsh: f.filter.threshold,
+            }, filterID: 701 });
+        case 'displace': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Displace',
+                _classID: 'Dspl',
+                HrzS: f.filter.horizontalScale,
+                VrtS: f.filter.verticalScale,
+                DspM: descriptor_1.DspM.encode(f.filter.displacementMap),
+                UndA: descriptor_1.UndA.encode(f.filter.undefinedAreas),
+                DspF: {
+                    sig: f.filter.displacementFile.signature,
+                    path: f.filter.displacementFile.path,
+                },
+            }, filterID: 1148416108 });
+        case 'pinch': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Pinch',
+                _classID: 'Pnch',
+                Amnt: f.filter.amount,
+            }, filterID: 1349411688 });
+        case 'polar coordinates': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Polar Coordinates',
+                _classID: 'Plr ',
+                Cnvr: descriptor_1.Cnvr.encode(f.filter.conversion),
+            }, filterID: 1349284384 });
+        case 'ripple': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Ripple',
+                _classID: 'Rple',
+                Amnt: f.filter.amount,
+                RplS: descriptor_1.RplS.encode(f.filter.size),
+            }, filterID: 1383099493 });
+        case 'shear': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Shear',
+                _classID: 'Shr ',
+                ShrP: f.filter.shearPoints.map(function (p) { return ({ _name: '', _classID: 'Pnt ', Hrzn: p.x, Vrtc: p.y }); }),
+                UndA: descriptor_1.UndA.encode(f.filter.undefinedAreas),
+                ShrS: f.filter.shearStart,
+                ShrE: f.filter.shearEnd,
+            }, filterID: 1399353888 });
+        case 'spherize': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Spherize',
+                _classID: 'Sphr',
+                Amnt: f.filter.amount,
+                SphM: descriptor_1.SphM.encode(f.filter.mode),
+            }, filterID: 1399875698 });
+        case 'twirl': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Twirl',
+                _classID: 'Twrl',
+                Angl: f.filter.angle,
+            }, filterID: 1417114220 });
+        case 'wave': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Wave',
+                _classID: 'Wave',
+                Wvtp: descriptor_1.Wvtp.encode(f.filter.type),
+                NmbG: f.filter.numberOfGenerators,
+                WLMn: f.filter.wavelength.min,
+                WLMx: f.filter.wavelength.max,
+                AmMn: f.filter.amplitude.min,
+                AmMx: f.filter.amplitude.max,
+                SclH: f.filter.scale.x,
+                SclV: f.filter.scale.y,
+                UndA: descriptor_1.UndA.encode(f.filter.undefinedAreas),
+                RndS: f.filter.randomSeed,
+            }, filterID: 1466005093 });
+        case 'zigzag': return __assign(__assign({}, base), { Fltr: {
+                _name: 'ZigZag',
+                _classID: 'ZgZg',
+                Amnt: f.filter.amount,
+                NmbR: f.filter.ridges,
+                ZZTy: descriptor_1.ZZTy.encode(f.filter.style),
+            }, filterID: 1516722791 });
+        case 'add noise': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Add Noise',
+                _classID: 'AdNs',
+                Dstr: descriptor_1.Dstr.encode(f.filter.distribution),
+                Nose: (0, descriptor_1.unitsPercentF)(f.filter.amount),
+                Mnch: f.filter.monochromatic,
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1097092723 });
+        case 'despeckle': return __assign(__assign({}, base), { filterID: 1148416099 });
+        case 'dust and scratches': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Dust & Scratches',
+                _classID: 'DstS',
+                'Rds ': f.filter.radius,
+                Thsh: f.filter.threshold,
+            }, filterID: 1148417107 });
+        case 'median': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Median',
+                _classID: 'Mdn ',
+                'Rds ': uvRadius(f.filter),
+            }, filterID: 1298427424 });
+        case 'reduce noise': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Reduce Noise',
+                _classID: 'denoise',
+                ClNs: (0, descriptor_1.unitsPercentF)(f.filter.reduceColorNoise),
+                Shrp: (0, descriptor_1.unitsPercentF)(f.filter.sharpenDetails),
+                removeJPEGArtifact: f.filter.removeJpegArtifact,
+                channelDenoise: f.filter.channelDenoise.map(function (c) { return (__assign({ _name: '', _classID: 'channelDenoiseParams', Chnl: c.channels.map(function (i) { return descriptor_1.Chnl.encode(i); }), Amnt: c.amount }, (c.preserveDetails ? { EdgF: c.preserveDetails } : {}))); }),
+                preset: f.filter.preset,
+            }, filterID: 633 });
+        case 'color halftone': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Color Halftone',
+                _classID: 'ClrH',
+                'Rds ': f.filter.radius,
+                Ang1: f.filter.angle1,
+                Ang2: f.filter.angle2,
+                Ang3: f.filter.angle3,
+                Ang4: f.filter.angle4,
+            }, filterID: 1131180616 });
+        case 'crystallize': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Crystallize',
+                _classID: 'Crst',
+                ClSz: f.filter.cellSize,
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1131574132 });
+        case 'facet': return __assign(__assign({}, base), { filterID: 1180922912 });
+        case 'fragment': return __assign(__assign({}, base), { filterID: 1181902701 });
+        case 'mezzotint': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Mezzotint',
+                _classID: 'Mztn',
+                MztT: descriptor_1.MztT.encode(f.filter.type),
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1299870830 });
+        case 'mosaic': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Mosaic',
+                _classID: 'Msc ',
+                ClSz: (0, descriptor_1.unitsValue)(f.filter.cellSize, 'cellSize'),
+            }, filterID: 1299407648 });
+        case 'pointillize': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Pointillize',
+                _classID: 'Pntl',
+                ClSz: f.filter.cellSize,
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1349416044 });
+        case 'clouds': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Clouds',
+                _classID: 'Clds',
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1131177075 });
+        case 'difference clouds': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Difference Clouds',
+                _classID: 'DfrC',
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1147564611 });
+        case 'fibers': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Fibers',
+                _classID: 'Fbrs',
+                Vrnc: f.filter.variance,
+                Strg: f.filter.strength,
+                RndS: f.filter.randomSeed,
+            }, filterID: 1180856947 });
+        case 'lens flare': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Lens Flare',
+                _classID: 'LnsF',
+                Brgh: f.filter.brightness,
+                FlrC: {
+                    _name: '',
+                    _classID: 'Pnt ',
+                    Hrzn: f.filter.position.x,
+                    Vrtc: f.filter.position.y,
+                },
+                'Lns ': descriptor_1.Lns.encode(f.filter.lensType),
+            }, filterID: 1282306886 });
+        case 'sharpen': return __assign(__assign({}, base), { filterID: 1399353968 });
+        case 'sharpen edges': return __assign(__assign({}, base), { filterID: 1399353925 });
+        case 'sharpen more': return __assign(__assign({}, base), { filterID: 1399353933 });
+        case 'smart sharpen': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Smart Sharpen',
+                _classID: 'smartSharpen',
+                Amnt: (0, descriptor_1.unitsPercentF)(f.filter.amount),
+                'Rds ': uvRadius(f.filter),
+                Thsh: f.filter.threshold,
+                Angl: f.filter.angle,
+                moreAccurate: f.filter.moreAccurate,
+                blur: descriptor_1.blurType.encode(f.filter.blur),
+                preset: f.filter.preset,
+                sdwM: {
+                    _name: 'Parameters',
+                    _classID: 'adaptCorrectTones',
+                    Amnt: (0, descriptor_1.unitsPercentF)(f.filter.shadow.fadeAmount),
+                    Wdth: (0, descriptor_1.unitsPercentF)(f.filter.shadow.tonalWidth),
+                    'Rds ': f.filter.shadow.radius,
+                },
+                hglM: {
+                    _name: 'Parameters',
+                    _classID: 'adaptCorrectTones',
+                    Amnt: (0, descriptor_1.unitsPercentF)(f.filter.highlight.fadeAmount),
+                    Wdth: (0, descriptor_1.unitsPercentF)(f.filter.highlight.tonalWidth),
+                    'Rds ': f.filter.highlight.radius,
+                },
+            }, filterID: 698 });
+        case 'unsharp mask': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Unsharp Mask',
+                _classID: 'UnsM',
+                Amnt: (0, descriptor_1.unitsPercentF)(f.filter.amount),
+                'Rds ': uvRadius(f.filter),
+                Thsh: f.filter.threshold,
+            }, filterID: 1433301837 });
+        case 'diffuse': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Diffuse',
+                _classID: 'Dfs ',
+                'Md  ': descriptor_1.DfsM.encode(f.filter.mode),
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1147564832 });
+        case 'emboss': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Emboss',
+                _classID: 'Embs',
+                Angl: f.filter.angle,
+                Hght: f.filter.height,
+                Amnt: f.filter.amount,
+            }, filterID: 1164796531 });
+        case 'extrude': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Extrude',
+                _classID: 'Extr',
+                ExtS: f.filter.size,
+                ExtD: f.filter.depth,
+                ExtF: f.filter.solidFrontFaces,
+                ExtM: f.filter.maskIncompleteBlocks,
+                ExtT: descriptor_1.ExtT.encode(f.filter.type),
+                ExtR: descriptor_1.ExtR.encode(f.filter.depthMode),
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1165522034 });
+        case 'find edges': return __assign(__assign({}, base), { filterID: 1181639749 });
+        case 'solarize': return __assign(__assign({}, base), { filterID: 1399616122 });
+        case 'tiles': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Tiles',
+                _classID: 'Tls ',
+                TlNm: f.filter.numberOfTiles,
+                TlOf: f.filter.maximumOffset,
+                FlCl: descriptor_1.FlCl.encode(f.filter.fillEmptyAreaWith),
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1416393504 });
+        case 'trace contour': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Trace Contour',
+                _classID: 'TrcC',
+                'Lvl ': f.filter.level,
+                'Edg ': descriptor_1.CntE.encode(f.filter.edge),
+            }, filterID: 1416782659 });
+        case 'wind': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Wind',
+                _classID: 'Wnd ',
+                WndM: descriptor_1.WndM.encode(f.filter.method),
+                Drct: descriptor_1.Drct.encode(f.filter.direction),
+            }, filterID: 1466852384 });
+        case 'de-interlace': return __assign(__assign({}, base), { Fltr: {
+                _name: 'De-Interlace',
+                _classID: 'Dntr',
+                IntE: descriptor_1.IntE.encode(f.filter.eliminate),
+                IntC: descriptor_1.IntC.encode(f.filter.newFieldsBy),
+            }, filterID: 1148089458 });
+        case 'ntsc colors': return __assign(__assign({}, base), { filterID: 1314149187 });
+        case 'custom': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Custom',
+                _classID: 'Cstm',
+                'Scl ': f.filter.scale,
+                Ofst: f.filter.offset,
+                Mtrx: f.filter.matrix,
+            }, filterID: 1131639917 });
+        case 'high pass': return __assign(__assign({}, base), { Fltr: {
+                _name: 'High Pass',
+                _classID: 'HghP',
+                'Rds ': uvRadius(f.filter),
+            }, filterID: 1214736464 });
+        case 'maximum': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Maximum',
+                _classID: 'Mxm ',
+                'Rds ': uvRadius(f.filter),
+            }, filterID: 1299737888 });
+        case 'minimum': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Minimum',
+                _classID: 'Mnm ',
+                'Rds ': uvRadius(f.filter),
+            }, filterID: 1299082528 });
+        case 'offset': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Offset',
+                _classID: 'Ofst',
+                Hrzn: f.filter.horizontal,
+                Vrtc: f.filter.vertical,
+                'Fl  ': descriptor_1.FlMd.encode(f.filter.undefinedAreas),
+            }, filterID: 1332114292 });
+        case 'puppet': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Rigid Transform',
+                _classID: 'rigidTransform',
+                'null': ['Ordn.Trgt'],
+                rigidType: f.filter.rigidType,
+                puppetShapeList: f.filter.puppetShapeList.map(function (p) { return ({
+                    _name: '',
+                    _classID: 'puppetShape',
+                    rigidType: p.rigidType,
+                    VrsM: 1,
+                    VrsN: 0,
+                    originalVertexArray: toUint8(new Float32Array(pointsToArray(p.originalVertexArray))),
+                    deformedVertexArray: toUint8(new Float32Array(pointsToArray(p.deformedVertexArray))),
+                    indexArray: toUint8(new Uint32Array(p.indexArray)),
+                    pinOffsets: pointsToArray(p.pinOffsets),
+                    posFinalPins: pointsToArray(p.posFinalPins),
+                    pinVertexIndices: p.pinVertexIndices,
+                    PinP: pointsToArray(p.pinPosition),
+                    PnRt: p.pinRotation,
+                    PnOv: p.pinOverlay,
+                    PnDp: p.pinDepth,
+                    meshQuality: p.meshQuality,
+                    meshExpansion: p.meshExpansion,
+                    meshRigidity: p.meshRigidity,
+                    imageResolution: p.imageResolution,
+                    meshBoundaryPath: {
+                        _name: '',
+                        _classID: 'pathClass',
+                        pathComponents: p.meshBoundaryPath.pathComponents.map(function (c) { return ({
+                            _name: '',
+                            _classID: 'PaCm',
+                            shapeOperation: "shapeOperation.".concat(c.shapeOperation),
+                            SbpL: c.paths.map(function (path) { return ({
+                                _name: '',
+                                _classID: 'Sbpl',
+                                Clsp: path.closed,
+                                'Pts ': path.points.map(function (pt) { return ({
+                                    _name: '',
+                                    _classID: 'Pthp',
+                                    Anch: pointToHrznVrtc(pt.anchor),
+                                    'Fwd ': pointToHrznVrtc(pt.forward),
+                                    'Bwd ': pointToHrznVrtc(pt.backward),
+                                    Smoo: pt.smooth,
+                                }); }),
                             }); }),
                         }); }),
-                    }); }),
-                },
-            }); }),
-            PuX0: filter.bounds[0].x,
-            PuX1: filter.bounds[1].x,
-            PuX2: filter.bounds[2].x,
-            PuX3: filter.bounds[3].x,
-            PuY0: filter.bounds[0].y,
-            PuY1: filter.bounds[1].y,
-            PuY2: filter.bounds[2].y,
-            PuY3: filter.bounds[3].y,
-        };
-    }
-    else {
-        return {
-            LqMe: new Uint8Array(),
-        };
+                    },
+                    selectedPin: p.selectedPin,
+                }); }),
+                PuX0: f.filter.bounds[0].x,
+                PuX1: f.filter.bounds[1].x,
+                PuX2: f.filter.bounds[2].x,
+                PuX3: f.filter.bounds[3].x,
+                PuY0: f.filter.bounds[0].y,
+                PuY1: f.filter.bounds[1].y,
+                PuY2: f.filter.bounds[2].y,
+                PuY3: f.filter.bounds[3].y,
+            }, filterID: 991 });
+        case 'oil paint plugin': {
+            var params = {};
+            for (var i = 0; i < f.filter.parameters.length; i++) {
+                var _a = f.filter.parameters[i], name_1 = _a.name, value = _a.value;
+                var suffix = "".concat(fromAtoZ[Math.floor(i / fromAtoZ.length)]).concat(fromAtoZ[i % fromAtoZ.length]);
+                params["PN".concat(suffix)] = name_1;
+                params["PT".concat(suffix)] = 0;
+                params["PF".concat(suffix)] = value;
+            }
+            return __assign(__assign({}, base), { Fltr: __assign({ _name: 'Oil Paint Plugin', _classID: 'PbPl', KnNm: f.filter.name, GpuY: f.filter.gpu, LIWy: f.filter.lighting, FPth: '1' }, params), filterID: 1348620396 });
+        }
+        case 'oil paint': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Oil Paint',
+                _classID: 'oilPaint',
+                lightingOn: f.filter.lightingOn,
+                stylization: f.filter.stylization,
+                cleanliness: f.filter.cleanliness,
+                brushScale: f.filter.brushScale,
+                microBrush: f.filter.microBrush,
+                LghD: f.filter.lightDirection,
+                specularity: f.filter.specularity,
+            }, filterID: 1122 });
+        case 'liquify': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Liquify',
+                _classID: 'LqFy',
+                LqMe: f.filter.liquifyMesh,
+            }, filterID: 1282492025 });
+        default: throw new Error("Unknow filter type: ".concat(f.type));
     }
 }
-function serializeFilterFX(filter) {
-    return {
-        enab: filter.enabled,
-        validAtPosition: filter.validAtPosition,
-        filterMaskEnable: filter.maskEnabled,
-        filterMaskLinked: filter.maskLinked,
-        filterMaskExtendWithWhite: filter.maskExtendWithWhite,
-        filterFXList: (filter.list || []).map(function (f) { return ({
-            'Nm  ': f.name,
-            blendOptions: {
-                Opct: (0, descriptor_1.unitsPercent)(f.opacity),
-                'Md  ': descriptor_1.BlnM.encode(f.blendMode),
-            },
-            enab: f.enabled,
-            hasoptions: f.hasOptions,
-            FrgC: (0, descriptor_1.serializeColor)(f.foregroundColor),
-            BckC: (0, descriptor_1.serializeColor)(f.backgroundColor),
-            Fltr: serializeFltr(f.filter),
-            filterID: f.id,
-        }); }),
-    };
-}
+// let t: any;
 addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     if ((0, psdReader_1.readSignature)(reader) !== 'soLD')
         throw new Error("Invalid SoLd type");
@@ -1332,15 +1971,17 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     // console.log('SoLd.warp', require('util').inspect(desc.warp, false, 99, true));
     // console.log('SoLd.quiltWarp', require('util').inspect(desc.quiltWarp, false, 99, true));
     // desc.filterFX!.filterFXList[0].Fltr.puppetShapeList[0].meshBoundaryPath.pathComponents[0].SbpL[0]['Pts '] = [];
-    // console.log('filterFX', require('util').inspect(desc.filterFX, false, 99, true));
+    // console.log('read', require('util').inspect(desc.filterFX, false, 99, true));
+    // console.log('filterFXList[0]', require('util').inspect((desc as any).filterFX.filterFXList[0], false, 99, true));
+    // t = desc;
     target.placedLayer = {
         id: desc.Idnt,
         placed: desc.placed,
         type: placedLayerTypes[desc.Type],
         pageNumber: desc.PgNm,
         totalPages: desc.totalPages,
-        frameStep: desc.frameStep,
-        duration: desc.duration,
+        frameStep: (0, descriptor_1.frac)(desc.frameStep),
+        duration: (0, descriptor_1.frac)(desc.duration),
         frameCount: desc.frameCount,
         transform: desc.Trnf,
         width: desc['Sz  '].Wdth,
@@ -1355,22 +1996,48 @@ addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
         target.placedLayer.crop = desc.Crop;
     if (desc.comp)
         target.placedLayer.comp = desc.comp;
-    if (desc.compInfo)
-        target.placedLayer.compInfo = desc.compInfo;
+    if (desc.compInfo) {
+        target.placedLayer.compInfo = {
+            compID: desc.compInfo.compID,
+            originalCompID: desc.compInfo.originalCompID,
+        };
+    }
     if (desc.filterFX)
         target.placedLayer.filter = parseFilterFX(desc.filterFX);
+    // console.log('filter', require('util').inspect(target.placedLayer.filter, false, 99, true));
     (0, psdReader_1.skipBytes)(reader, left()); // HACK
 }, function (writer, target) {
     var _a, _b;
     (0, psdWriter_1.writeSignature)(writer, 'soLD');
     (0, psdWriter_1.writeInt32)(writer, 4); // version
     var placed = target.placedLayer;
-    var desc = __assign(__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, quiltWarp: {}, warp: encodeWarp(placed.warp || {}), 'Sz  ': {
+    var desc = __assign(__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, 
+        // quiltWarp: {} as any,
+        warp: encodeWarp(placed.warp || {}), 'Sz  ': {
+            _name: '',
+            _classID: 'Pnt ',
             Wdth: placed.width || 0,
             Hght: placed.height || 0, // TODO: find size ?
         }, Rslt: placed.resolution ? (0, descriptor_1.unitsValue)(placed.resolution, 'resolution') : { units: 'Density', value: 72 } });
-    if (placed.filter)
-        desc.filterFX = serializeFilterFX(placed.filter);
+    if (placed.filter) {
+        desc.filterFX = {
+            _name: '',
+            _classID: 'filterFXStyle',
+            enab: placed.filter.enabled,
+            validAtPosition: placed.filter.validAtPosition,
+            filterMaskEnable: placed.filter.maskEnabled,
+            filterMaskLinked: placed.filter.maskLinked,
+            filterMaskExtendWithWhite: placed.filter.maskExtendWithWhite,
+            filterFXList: placed.filter.list.map(function (f) { return serializeFilterFXItem(f); }),
+        };
+    }
+    // console.log('write', require('util').inspect(desc.filterFX, false, 99, true)); ///
+    // if (JSON.stringify(t) !== JSON.stringify(desc)) {
+    // 	console.log('read', require('util').inspect(t, false, 99, true));
+    // 	console.log('write', require('util').inspect(desc, false, 99, true));
+    // 	console.error('DIFFERENT');
+    // 	// throw new Error('DIFFERENT');
+    // }
     if (placed.warp && isQuiltWarp(placed.warp)) {
         var quiltWarp = encodeWarp(placed.warp);
         desc.quiltWarp = quiltWarp;
@@ -1456,7 +2123,7 @@ addHandler('Anno', function (target) { return target.annotations !== undefined;
         var popupLocation = readRect(reader);
         var color = (0, psdReader_1.readColor)(reader);
         var author = (0, psdReader_1.readPascalString)(reader, 2);
-        var name_1 = (0, psdReader_1.readPascalString)(reader, 2);
+        var name_2 = (0, psdReader_1.readPascalString)(reader, 2);
         var date = (0, psdReader_1.readPascalString)(reader, 2);
         /*const contentLength =*/ (0, psdReader_1.readUint32)(reader);
         /*const dataType =*/ (0, psdReader_1.readSignature)(reader);
@@ -1485,7 +2152,7 @@ addHandler('Anno', function (target) { return target.annotations !== undefined;
             popupLocation: popupLocation,
             color: color,
             author: author,
-            name: name_1,
+            name: name_2,
             date: date,
             data: data,
         });
@@ -1544,20 +2211,26 @@ addHandler('lnk2', function (target) { return !!target.linkedFiles && target.lin
         var type = (0, psdReader_1.readSignature)(reader);
         var version = (0, psdReader_1.readInt32)(reader);
         var id = (0, psdReader_1.readPascalString)(reader, 1);
-        var name_2 = (0, psdReader_1.readUnicodeString)(reader);
+        var name_3 = (0, psdReader_1.readUnicodeString)(reader);
         var fileType = (0, psdReader_1.readSignature)(reader).trim(); // '    ' if empty
         var fileCreator = (0, psdReader_1.readSignature)(reader).trim(); // '    ' or '\0\0\0\0' if empty
         var dataSize = readLength64(reader);
         var hasFileOpenDescriptor = (0, psdReader_1.readUint8)(reader);
         var fileOpenDescriptor = hasFileOpenDescriptor ? (0, descriptor_1.readVersionAndDescriptor)(reader) : undefined;
         var linkedFileDescriptor = type === 'liFE' ? (0, descriptor_1.readVersionAndDescriptor)(reader) : undefined;
-        var file = { id: id, name: name_2, data: undefined };
+        var file = { id: id, name: name_3, data: undefined };
         if (fileType)
             file.type = fileType;
         if (fileCreator)
             file.creator = fileCreator;
-        if (fileOpenDescriptor)
-            file.descriptor = fileOpenDescriptor;
+        if (fileOpenDescriptor) {
+            file.descriptor = {
+                compInfo: {
+                    compID: fileOpenDescriptor.compInfo.compID,
+                    originalCompID: fileOpenDescriptor.compInfo.originalCompID,
+                }
+            };
+        }
         if (type === 'liFE' && version > 3) {
             var year = (0, psdReader_1.readInt32)(reader);
             var month = (0, psdReader_1.readUint8)(reader);
@@ -1615,7 +2288,10 @@ addHandler('lnk2', function (target) { return !!target.linkedFiles && target.lin
         writeLength64(writer, file.data ? file.data.byteLength : 0);
         if (file.descriptor && file.descriptor.compInfo) {
             var desc = {
-                compInfo: file.descriptor.compInfo,
+                compInfo: {
+                    compID: file.descriptor.compInfo.compID,
+                    originalCompID: file.descriptor.compInfo.originalCompID,
+                }
             };
             (0, psdWriter_1.writeUint8)(writer, 1);
             (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc);
@@ -2355,6 +3031,94 @@ addHandler('Txt2', hasKey('engineData'), function (reader, target, left) {
     var buffer = (0, base64_js_1.toByteArray)(target.engineData);
     (0, psdWriter_1.writeBytes)(writer, buffer);
 });
+addHandler('FEid', hasKey('filterEffectsMasks'), function (reader, target, leftBytes) {
+    var version = (0, psdReader_1.readInt32)(reader);
+    if (version < 1 || version > 3)
+        throw new Error("Invalid filterEffects version ".concat(version));
+    if ((0, psdReader_1.readUint32)(reader))
+        throw new Error('filterEffects: 64 bit length is not supported');
+    var length = (0, psdReader_1.readUint32)(reader);
+    var end = reader.offset + length;
+    target.filterEffectsMasks = [];
+    while (reader.offset < end) {
+        var id = (0, psdReader_1.readPascalString)(reader, 1);
+        var effectVersion = (0, psdReader_1.readInt32)(reader);
+        if (effectVersion !== 1)
+            throw new Error("Invalid filterEffect version ".concat(effectVersion));
+        if ((0, psdReader_1.readUint32)(reader))
+            throw new Error('filterEffect: 64 bit length is not supported');
+        /*const effectLength =*/ (0, psdReader_1.readUint32)(reader);
+        // const endOfEffect = reader.offset + effectLength;
+        var top_2 = (0, psdReader_1.readInt32)(reader);
+        var left = (0, psdReader_1.readInt32)(reader);
+        var bottom = (0, psdReader_1.readInt32)(reader);
+        var right = (0, psdReader_1.readInt32)(reader);
+        var depth = (0, psdReader_1.readInt32)(reader);
+        var maxChannels = (0, psdReader_1.readInt32)(reader);
+        var channels = [];
+        // 0 -> R, 1 -> G, 2 -> B, 25 -> A
+        for (var i = 0; i < (maxChannels + 2); i++) {
+            var exists = (0, psdReader_1.readInt32)(reader);
+            if (exists) {
+                if ((0, psdReader_1.readUint32)(reader))
+                    throw new Error('filterEffect: 64 bit length is not supported');
+                var channelLength = (0, psdReader_1.readUint32)(reader);
+                var compressionMode = (0, psdReader_1.readUint16)(reader);
+                var data = (0, psdReader_1.readBytes)(reader, channelLength - 2);
+                channels.push({ compressionMode: compressionMode, data: data });
+            }
+            else {
+                channels.push(undefined);
+            }
+        }
+        target.filterEffectsMasks.push({ id: id, top: top_2, left: left, bottom: bottom, right: right, depth: depth, channels: channels });
+        if (leftBytes() && (0, psdReader_1.readUint8)(reader)) {
+            var compressionMode = (0, psdReader_1.readUint16)(reader);
+            var data = (0, psdReader_1.readBytes)(reader, leftBytes());
+            target.filterEffectsMasks[target.filterEffectsMasks.length - 1].extra = { compressionMode: compressionMode, data: data };
+        }
+    }
+}, function (writer, target) {
+    var _a;
+    (0, psdWriter_1.writeInt32)(writer, 3);
+    (0, psdWriter_1.writeUint32)(writer, 0);
+    (0, psdWriter_1.writeUint32)(writer, 0);
+    var lengthOffset = writer.offset;
+    for (var _i = 0, _b = target.filterEffectsMasks; _i < _b.length; _i++) {
+        var mask = _b[_i];
+        (0, psdWriter_1.writePascalString)(writer, mask.id, 1);
+        (0, psdWriter_1.writeInt32)(writer, 1);
+        (0, psdWriter_1.writeUint32)(writer, 0);
+        (0, psdWriter_1.writeUint32)(writer, 0);
+        var length2Offset = writer.offset;
+        (0, psdWriter_1.writeInt32)(writer, mask.top);
+        (0, psdWriter_1.writeInt32)(writer, mask.left);
+        (0, psdWriter_1.writeInt32)(writer, mask.bottom);
+        (0, psdWriter_1.writeInt32)(writer, mask.right);
+        (0, psdWriter_1.writeInt32)(writer, mask.depth);
+        var maxChannels = Math.max(0, mask.channels.length - 2);
+        (0, psdWriter_1.writeInt32)(writer, maxChannels);
+        for (var i = 0; i < (maxChannels + 2); i++) {
+            var channel = mask.channels[i];
+            (0, psdWriter_1.writeInt32)(writer, channel ? 1 : 0);
+            if (channel) {
+                (0, psdWriter_1.writeUint32)(writer, 0);
+                (0, psdWriter_1.writeUint32)(writer, channel.data.length + 2);
+                (0, psdWriter_1.writeUint16)(writer, channel.compressionMode);
+                (0, psdWriter_1.writeBytes)(writer, channel.data);
+            }
+        }
+        writer.view.setUint32(length2Offset - 4, writer.offset - length2Offset, false);
+    }
+    var extra = (_a = target.filterEffectsMasks[target.filterEffectsMasks.length - 1]) === null || _a === void 0 ? void 0 : _a.extra;
+    if (extra) {
+        (0, psdWriter_1.writeUint8)(writer, 1);
+        (0, psdWriter_1.writeUint16)(writer, extra.compressionMode);
+        (0, psdWriter_1.writeBytes)(writer, extra.data);
+    }
+    writer.view.setUint32(lengthOffset - 4, writer.offset - lengthOffset, false);
+});
+addHandlerAlias('FXid', 'FEid');
 addHandler('FMsk', hasKey('filterMask'), function (reader, target) {
     target.filterMask = {
         colorSpace: (0, psdReader_1.readColor)(reader),
@@ -2420,14 +3184,17 @@ addHandler('lfx2', function (target) { return target.effects !== undefined && !h
 addHandler('cinf', hasKey('compositorUsed'), function (reader, target, left) {
     var desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
     // console.log(require('util').inspect(desc, false, 99, true));
+    function enumValue(desc) {
+        return desc.split('.')[1];
+    }
     target.compositorUsed = {
         description: desc.description,
         reason: desc.reason,
-        engine: desc.Engn.split('.')[1],
-        enableCompCore: desc.enableCompCore.split('.')[1],
-        enableCompCoreGPU: desc.enableCompCoreGPU.split('.')[1],
-        compCoreSupport: desc.compCoreSupport.split('.')[1],
-        compCoreGPUSupport: desc.compCoreGPUSupport.split('.')[1],
+        engine: enumValue(desc.Engn),
+        enableCompCore: enumValue(desc.enableCompCore),
+        enableCompCoreGPU: enumValue(desc.enableCompCoreGPU),
+        compCoreSupport: enumValue(desc.compCoreSupport),
+        compCoreGPUSupport: enumValue(desc.compCoreGPUSupport),
     };
     (0, psdReader_1.skipBytes)(reader, left());
 }, function (writer, target) {
@@ -2482,87 +3249,6 @@ addHandler('tsly', hasKey('transparencyShapesLayer'), function (reader, target)
     (0, psdWriter_1.writeUint8)(writer, target.transparencyShapesLayer ? 1 : 0);
     (0, psdWriter_1.writeZeros)(writer, 3);
 });
-/*addHandler(
-    'FEid',
-    hasKey('filterEffects'),
-    (reader, _target) => {
-        const version = readInt32(reader);
-        if (version < 1 || version > 3) throw new Error(`Invalid filterEffects version ${version}`);
-
-        if (readUint32(reader)) throw new Error('filterEffects: 64 bit length is not supported');
-        const length = readUint32(reader);
-        const end = reader.offset + length;
-
-        while (reader.offset < end) {
-            console.log('bytes to go', end - reader.offset, 'at', reader.offset.toString(16));
-            //
-            const id = readPascalString(reader, 1);
-            const effectVersion = readInt32(reader);
-            if (effectVersion !== 1) throw new Error(`Invalid filterEffect version ${effectVersion}`);
-            if (readUint32(reader)) throw new Error('filterEffect: 64 bit length is not supported');
-            const effectLength = readUint32(reader);
-            const endOfEffect = reader.offset + effectLength;
-            const top = readInt32(reader);
-            const left = readInt32(reader);
-            const bottom = readInt32(reader);
-            const right = readInt32(reader);
-            const depth = readInt32(reader);
-            const maxChannels = readInt32(reader);
-            const channels: any[] = [];
-
-            for (let i = 0; i < (maxChannels + 2); i++) {
-                const exists = readInt32(reader);
-                if (exists) {
-                    if (readUint32(reader)) throw new Error('filterEffect: 64 bit length is not supported');
-                    const channelLength = readUint32(reader);
-                    const compressionMode = readUint16(reader);
-                    const data = readBytes(reader, channelLength - 2);
-                    channels.push({ channelLength, compressionMode, data: data?.length + ' bytes' });
-                    // if (c < 3 || c == 25) e_ = _F.Cn(!0, rL, m, b.rect.F, b.rect.V, X, rp);
-                    // if (c == 0) _c.S = e_;
-                    // if (c == 1) _c.v = e_;
-                    // if (c == 2) _c.e = e_;
-                    // if (c == 25) _c.w = e_;
-                } else {
-                    channels.push(undefined);
-                }
-            }
-
-            console.log('left at the end', endOfEffect - reader.offset);
-            if (endOfEffect > reader.offset) {
-                if (readUint8(reader)) {
-                    const compressionMode = readUint16(reader);
-                    const data = endOfEffect > reader.offset ? readBytes(reader, endOfEffect - reader.offset) : undefined;
-                    console.log('extra data', { compressionMode, data: data?.length + ' bytes' });
-                } else {
-                    console.log('no extra');
-                }
-            }
-
-            console.log('effect', {
-                id,
-                effectVersion,
-                effectLength,
-                top,
-                left,
-                bottom,
-                right,
-                depth,
-                maxChannels,
-                channels,
-            });
-
-            console.log('bytes left after effect', endOfEffect - reader.offset);
-            // if (length % 4) skipBytes(reader, 4 - length % 4);
-        }
-
-        console.log({ version, length });
-    },
-    (_writer, _target) => {
-    },
-);
-
-addHandlerAlias('FXid', 'FEid');*/
 
 },{"./descriptor":4,"./effectsHelpers":5,"./engineData":6,"./helpers":7,"./psdReader":11,"./psdWriter":12,"./text":13,"base64-js":15}],3:[function(require,module,exports){
 "use strict";
@@ -2627,7 +3313,8 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.strokeStyleLineAlignment = exports.strokeStyleLineJoinType = exports.strokeStyleLineCapType = exports.ESliceBGColorType = exports.ESliceOrigin = exports.ESliceVertAlign = exports.ESliceHorzAlign = exports.ESliceType = exports.FrFl = exports.FStl = exports.ClrS = exports.gradientInterpolationMethodType = exports.stdTrackID = exports.animInterpStyleEnum = exports.GrdT = exports.IGSr = exports.BETE = exports.BESs = exports.bvlT = exports.BESl = exports.BlnM = exports.warpStyle = exports.Annt = exports.Ornt = exports.textGridding = exports.unitsValue = exports.unitsPercent = exports.unitsAngle = exports.parseUnitsToNumber = exports.parseUnitsOrNumber = exports.parseUnits = exports.parsePercentOrAngle = exports.parsePercent = exports.parseAngle = exports.serializeColor = exports.parseColor = exports.serializeVectorContent = exports.parseVectorContent = exports.serializeTrackList = exports.parseTrackList = exports.parseEffects = exports.serializeEffects = exports.xyToHorzVrtc = exports.horzVrtcToXY = exports.writeVersionAndDescriptor = exports.readVersionAndDescriptor = exports.writeDescriptorStructure = exports.readDescriptorStructure = exports.readAsciiStringOrClassId = exports.setLogErrors = void 0;
+exports.ESliceOrigin = exports.ESliceVertAlign = exports.ESliceHorzAlign = exports.ESliceType = exports.FrFl = exports.FStl = exports.ClrS = exports.gradientInterpolationMethodType = exports.stdTrackID = exports.animInterpStyleEnum = exports.GrdT = exports.IGSr = exports.BETE = exports.BESs = exports.bvlT = exports.BESl = exports.BlnM = exports.warpStyle = exports.Annt = exports.Ornt = exports.textGridding = exports.frac = exports.unitsValue = exports.unitsPercentF = exports.unitsPercent = exports.unitsAngle = exports.parseUnitsToNumber = exports.parseUnitsOrNumber = exports.parseUnits = exports.parsePercentOrAngle = exports.parsePercent = exports.parseAngle = exports.serializeColor = exports.parseColor = exports.serializeVectorContent = exports.parseVectorContent = exports.serializeTrackList = exports.parseTrackList = exports.parseEffects = exports.serializeEffects = exports.boundsToDescBounds = exports.descBoundsToBounds = exports.xyToHorzVrtc = exports.horzVrtcToXY = exports.writeVersionAndDescriptor = exports.readVersionAndDescriptor = exports.writeDescriptorStructure = exports.readDescriptorStructure = exports.readAsciiStringOrClassId = exports.setLogErrors = void 0;
+exports.prjM = exports.FlMd = exports.IntC = exports.IntE = exports.Drct = exports.WndM = exports.CntE = exports.FlCl = exports.ExtR = exports.ExtT = exports.DfsM = exports.blurType = exports.Lns = exports.MztT = exports.Chnl = exports.Dstr = exports.ZZTy = exports.Wvtp = exports.SphM = exports.RplS = exports.Cnvr = exports.UndA = exports.DspM = exports.SmBQ = exports.SmBM = exports.BlrQ = exports.BlrM = exports.strokeStyleLineAlignment = exports.strokeStyleLineJoinType = exports.strokeStyleLineCapType = exports.ESliceBGColorType = void 0;
 var helpers_1 = require("./helpers");
 var psdReader_1 = require("./psdReader");
 var psdWriter_1 = require("./psdWriter");
@@ -2722,6 +3409,7 @@ var fieldToExtType = {
     sheetStyle: nullType,
     translation: nullType,
     Skew: nullType,
+    boundingBox: makeType('', 'boundingBox'),
     'Lnk ': makeType('', 'ExternalFileLink'),
     frameReader: makeType('', 'FrameReader'),
     effectParams: makeType('', 'motionTrackEffectParams'),
@@ -2729,11 +3417,15 @@ var fieldToExtType = {
     Anch: makeType('', 'Pnt '),
     'Fwd ': makeType('', 'Pnt '),
     'Bwd ': makeType('', 'Pnt '),
+    FlrC: makeType('', 'Pnt '),
     meshBoundaryPath: makeType('', 'pathClass'),
     filterFX: makeType('', 'filterFXStyle'),
     Fltr: makeType('', 'rigidTransform'),
     FrgC: makeType('', 'RGBC'),
     BckC: makeType('', 'RGBC'),
+    sdwM: makeType('Parameters', 'adaptCorrectTones'),
+    hglM: makeType('Parameters', 'adaptCorrectTones'),
+    customShape: makeType('', 'customShape'),
 };
 var fieldToArrayExtType = {
     'Crv ': makeType('', 'CrPt'),
@@ -2762,15 +3454,20 @@ var fieldToArrayExtType = {
     pathComponents: makeType('', 'PaCm'),
     filterFXList: makeType('', 'filterFX'),
     puppetShapeList: makeType('', 'puppetShape'),
+    channelDenoise: makeType('', 'channelDenoiseParams'),
+    ShrP: makeType('', 'Pnt '),
 };
 var typeToField = {
     'TEXT': [
         'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
         'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
         'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
-        'altTag', 'url', 'cellText',
+        'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth',
+    ],
+    'tdta': [
+        'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
+        'LqMe',
     ],
-    'tdta': ['EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray'],
     'long': [
         'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
         'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
@@ -2781,16 +3478,19 @@ var typeToField = {
         'numBefore', 'numAfter', 'Spcn', 'minOpacity', 'maxOpacity', 'BlnM', 'sheetID', 'gblA', 'globalAltitude',
         'descVersion', 'frameReaderType', 'LyrI', 'zoomOrigin', 'fontSize', 'Rds ', 'sliceID',
         'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset', 'filterID', 'meshQuality',
-        'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN',
+        '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',
     ],
     'enum': [
-        'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS',
-        'sdwM', 'hglM', 'bvlT', 'bvlS', 'bvlD', 'Md  ', 'glwS', 'GrdF', 'GlwT',
+        'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
+        'bvlT', 'bvlS', 'bvlD', 'Md  ', 'glwS', 'GrdF', 'GlwT', 'RplS', 'BlrM', 'SmBM',
         'strokeStyleLineCapType', 'strokeStyleLineJoinType', 'strokeStyleLineAlignment',
         'strokeStyleBlendMode', 'PntT', 'Styl', 'lookupType', 'LUTFormat', 'dataOrder',
         'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
         'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
-        'vertAlign', 'bgColorType', 'shapeOperation',
+        'vertAlign', 'bgColorType', 'shapeOperation', 'UndA', 'Wvtp', 'Drct', 'WndM', 'Edg ', 'FlCl', 'IntE',
+        'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ',
     ],
     'bool': [
         'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -2802,7 +3502,8 @@ var typeToField = {
         'present', 'showInDialog', 'overprint', 'sheetDisclosed', 'lightsDisclosed', 'meshesDisclosed',
         'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
         'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
-        'filterMaskLinked', 'filterMaskExtendWithWhite',
+        'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
+        'moreAccurate', 'GpuY', 'LIWy',
     ],
     'doub': [
         'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
@@ -2812,10 +3513,10 @@ var typeToField = {
         'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
     ],
     'UntF': [
-        'Scl ', 'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
+        'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
         'Ckmt', 'Nose', 'Inpr', 'ShdN', 'strokeStyleLineWidth', 'strokeStyleLineDashOffset',
         'strokeStyleOpacity', 'H   ', 'Top ', 'Left', 'Btom', 'Rght', 'Rslt',
-        'topRight', 'topLeft', 'bottomLeft', 'bottomRight',
+        'topRight', 'topLeft', 'bottomLeft', 'bottomRight', 'ClNs', 'Shrp',
     ],
     'VlLs': [
         'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
@@ -2823,10 +3524,12 @@ var typeToField = {
         'solidFillMulti', 'frameFXMulti', 'innerShadowMulti', 'dropShadowMulti', 'FrIn', 'FSts', 'FsFr',
         'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
         'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
-        'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList',
+        'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
+        'channelDenoise', 'Mtrx',
     ],
     'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
-    'obj ': ['null'],
+    'obj ': ['null', 'Chnl'],
+    'Pth ': ['DspF'],
 };
 var channels = [
     'Rd  ', 'Grn ', 'Bl  ', 'Yllw', 'Ylw ', 'Cyn ', 'Mgnt', 'Blck', 'Gry ', 'Lmnc', 'A   ', 'B   ',
@@ -2865,6 +3568,9 @@ var fieldToArrayType = {
     PnDp: 'doub',
     filterFXList: 'Objc',
     puppetShapeList: 'Objc',
+    ShrP: 'Objc',
+    channelDenoise: 'Objc',
+    Mtrx: 'long',
 };
 var fieldToType = {};
 for (var _i = 0, _a = Object.keys(typeToField); _i < _a.length; _i++) {
@@ -2940,11 +3646,12 @@ function writeAsciiStringOrClassId(writer, value) {
     }
 }
 function readDescriptorStructure(reader) {
-    var object = {};
-    // object.__struct =
+    // const struct =
     readClassStructure(reader);
+    // const object: any = { _name: struct.name, _classID: struct.classID };
+    var object = {};
+    // console.log('>> ', struct);
     var itemsCount = (0, psdReader_1.readUint32)(reader);
-    // console.log('//', object.__struct);
     for (var i = 0; i < itemsCount; i++) {
         var key = readAsciiStringOrClassId(reader);
         var type = (0, psdReader_1.readSignature)(reader);
@@ -2963,21 +3670,63 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
     (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
     writeAsciiStringOrClassId(writer, classId);
     var keys = Object.keys(value);
-    (0, psdWriter_1.writeUint32)(writer, keys.length);
+    var keyCount = keys.length;
+    if ('_name' in value)
+        keyCount--;
+    if ('_classID' in value)
+        keyCount--;
+    (0, psdWriter_1.writeUint32)(writer, keyCount);
     for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
         var key = keys_1[_i];
+        if (key === '_name' || key === '_classID')
+            continue;
         var type = getTypeByKey(key, value[key], root, value);
         var extType = fieldToExtType[key];
-        if (key === 'origin') {
+        if (key === 'bounds' && root === 'text') {
+            extType = makeType('', 'bounds');
+        }
+        else if (key === 'origin') {
             type = root === 'slices' ? 'enum' : 'Objc';
         }
+        else if ((key === 'Cyn ' || key === 'Mgnt' || key === 'Ylw ' || key === 'Blck') && value._classID === 'CMYC') {
+            type = 'doub';
+        }
+        else if (/^PN[a-z][a-z]$/.test(key)) {
+            type = 'TEXT';
+        }
+        else if (/^PT[a-z][a-z]$/.test(key)) {
+            type = 'long';
+        }
+        else if (/^PF[a-z][a-z]$/.test(key)) {
+            type = 'doub';
+        }
+        else if (key === 'ClSz' || key === 'Rds ' || key === 'Amnt') {
+            type = typeof value[key] === 'number' ? 'long' : 'UntF';
+        }
+        else if ((key === 'sdwM' || key === 'hglM') && typeof value[key] === 'string') {
+            type = 'enum';
+        }
+        else if (key === 'blur' && typeof value[key] === 'string') {
+            type = 'enum';
+        }
+        else if (key === 'Angl' && typeof value[key] === 'number') {
+            type = 'doub'; // ???
+        }
         else if (key === 'bounds' && root === 'slices') {
             type = 'Objc';
             extType = makeType('', 'Rct1');
         }
-        else if (key === 'Scl ' && 'Hrzn' in value[key]) {
-            type = 'Objc';
-            extType = nullType;
+        else if (key === 'Scl ') {
+            if (typeof value[key] === 'object' && 'Hrzn' in value[key]) {
+                type = 'Objc';
+                extType = nullType;
+            }
+            else if (typeof value[key] === 'number') {
+                type = 'long';
+            }
+            else {
+                type = 'UntF';
+            }
         }
         else if (key === 'audioClipGroupList' && keys.length === 1) {
             type = 'VlLs';
@@ -2985,7 +3734,13 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
         else if ((key === 'Strt' || key === 'Brgh') && 'H   ' in value) {
             type = 'doub';
         }
-        else if (key === 'Strt') {
+        else if (key === 'Wdth' && typeof value[key] === 'object') {
+            type = 'UntF';
+        }
+        else if (key === 'Ofst' && typeof value[key] === 'number') {
+            type = 'long';
+        }
+        else if (key === 'Strt' && typeof value[key] === 'object') {
             type = 'Objc';
             extType = nullType;
         }
@@ -3105,11 +3860,11 @@ function readOSType(reader, type) {
             return items;
         }
         case 'Pth ': { // File path
-            /*const length =*/ (0, psdReader_1.readInt32)(reader);
+            /*const length =*/ (0, psdReader_1.readInt32)(reader); // total size of all fields below
             var sig = (0, psdReader_1.readSignature)(reader);
-            /*const pathSize =*/ (0, psdReader_1.readInt32LE)(reader);
+            /*const pathSize =*/ (0, psdReader_1.readInt32LE)(reader); // the same as length
             var charsCount = (0, psdReader_1.readInt32LE)(reader);
-            var path = (0, psdReader_1.readUnicodeStringWithLength)(reader, charsCount);
+            var path = (0, psdReader_1.readUnicodeStringWithLengthLE)(reader, charsCount);
             return { sig: sig, path: path };
         }
         default:
@@ -3127,12 +3882,19 @@ function writeOSType(writer, type, value, key, extType, root) {
             writeReferenceStructure(writer, key, value);
             break;
         case 'Objc': // Descriptor
-        case 'GlbO': // GlobalObject same as Descriptor
+        case 'GlbO': { // GlobalObject same as Descriptor
+            if (typeof value !== 'object')
+                throw new Error("Invalid struct value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             if (!extType)
                 throw new Error("Missing ext type for: '".concat(key, "' (").concat(JSON.stringify(value), ")"));
-            writeDescriptorStructure(writer, extType.name, extType.classID, value, root);
+            var name_1 = value._name || extType.name;
+            var classID = value._classID || extType.classID;
+            writeDescriptorStructure(writer, name_1, classID, value, root);
             break;
+        }
         case 'VlLs': // List
+            if (!Array.isArray(value))
+                throw new Error("Invalid list value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             (0, psdWriter_1.writeInt32)(writer, value.length);
             for (var i = 0; i < value.length; i++) {
                 var type_3 = fieldToArrayType[key];
@@ -3143,6 +3905,8 @@ function writeOSType(writer, type, value, key, extType, root) {
             }
             break;
         case 'doub': // Double
+            if (typeof value !== 'number')
+                throw new Error("Invalid number value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             (0, psdWriter_1.writeFloat64)(writer, value);
             break;
         case 'UntF': // Unit double
@@ -3161,17 +3925,23 @@ function writeOSType(writer, type, value, key, extType, root) {
             (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, value);
             break;
         case 'enum': { // Enumerated
+            if (typeof value !== 'string')
+                throw new Error("Invalid enum value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             var _a = value.split('.'), _type = _a[0], val = _a[1];
             writeAsciiStringOrClassId(writer, _type);
             writeAsciiStringOrClassId(writer, val);
             break;
         }
         case 'long': // Integer
+            if (typeof value !== 'number')
+                throw new Error("Invalid integer value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             (0, psdWriter_1.writeInt32)(writer, value);
             break;
         // case 'comp': // Large Integer
         // 	writeLargeInteger(reader);
         case 'bool': // Boolean
+            if (typeof value !== 'boolean')
+                throw new Error("Invalid boolean value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             (0, psdWriter_1.writeUint8)(writer, value ? 1 : 0);
             break;
         // case 'type': // Class
@@ -3202,8 +3972,15 @@ function writeOSType(writer, type, value, key, extType, root) {
             }
             break;
         }
-        // case 'Pth ': // File path
-        // 	writeFilePath(reader);
+        case 'Pth ': { // File path
+            var length_5 = 4 + 4 + 4 + value.path.length * 2;
+            (0, psdWriter_1.writeInt32)(writer, length_5);
+            (0, psdWriter_1.writeSignature)(writer, value.sig);
+            (0, psdWriter_1.writeInt32LE)(writer, length_5);
+            (0, psdWriter_1.writeInt32LE)(writer, value.path.length);
+            (0, psdWriter_1.writeUnicodeStringWithoutLengthLE)(writer, value.path);
+            break;
+        }
         default:
             throw new Error("Not implemented descriptor OSType: ".concat(type));
     }
@@ -3294,7 +4071,6 @@ function writeReferenceStructure(writer, _key, items) {
 function readClassStructure(reader) {
     var name = (0, psdReader_1.readUnicodeString)(reader);
     var classID = readAsciiStringOrClassId(reader);
-    // console.log({ name, classID });
     return { name: name, classID: classID };
 }
 function writeClassStructure(writer, name, classID) {
@@ -3324,6 +4100,26 @@ function xyToHorzVrtc(xy) {
     return { Hrzn: xy.x, Vrtc: xy.y };
 }
 exports.xyToHorzVrtc = xyToHorzVrtc;
+function descBoundsToBounds(desc) {
+    return {
+        top: parseUnits(desc['Top ']),
+        left: parseUnits(desc.Left),
+        right: parseUnits(desc.Rght),
+        bottom: parseUnits(desc.Btom),
+    };
+}
+exports.descBoundsToBounds = descBoundsToBounds;
+function boundsToDescBounds(bounds) {
+    var _a;
+    return _a = {
+            Left: unitsValue(bounds.left, 'bounds.left')
+        },
+        _a['Top '] = unitsValue(bounds.top, 'bounds.top'),
+        _a.Rght = unitsValue(bounds.right, 'bounds.right'),
+        _a.Btom = unitsValue(bounds.bottom, 'bounds.bottom'),
+        _a;
+}
+exports.boundsToDescBounds = boundsToDescBounds;
 function parseFxObject(fx) {
     var stroke = {
         enabled: !!fx.enab,
@@ -3474,7 +4270,8 @@ function parseKeyList(keyList, logMissingFeatures) {
     var keys = [];
     for (var j = 0; j < keyList.length; j++) {
         var key = keyList[j];
-        var time = key.time, selected = key.selected, animKey = key.animKey;
+        var _a = key.time, denominator = _a.denominator, numerator = _a.numerator, selected = key.selected, animKey = key.animKey;
+        var time = { numerator: numerator, denominator: denominator };
         var interpolation = exports.animInterpStyleEnum.decode(key.animInterpStyle);
         switch (animKey.Type) {
             case 'keyType.Opct':
@@ -3723,6 +4520,9 @@ function parseEffectObject(obj, reportErrors) {
             case 'antialiasGloss':
                 result[key] = val;
                 break;
+            case '_name':
+            case '_classID':
+                break;
             default:
                 reportErrors && console.log("Invalid effect key: '".concat(key, "', value:"), val);
         }
@@ -4075,25 +4875,25 @@ function parseColor(color) {
 exports.parseColor = parseColor;
 function serializeColor(color) {
     if (!color) {
-        return { 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
+        return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
     }
     else if ('r' in color) {
-        return { 'Rd  ': color.r || 0, 'Grn ': color.g || 0, 'Bl  ': color.b || 0 };
+        return { _name: '', _classID: 'RGBC', 'Rd  ': color.r || 0, 'Grn ': color.g || 0, 'Bl  ': color.b || 0 };
     }
     else if ('fr' in color) {
-        return { redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
+        return { _name: '', _classID: 'XXXX', redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
     }
     else if ('h' in color) {
-        return { 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
+        return { _name: '', _classID: 'HSBC', 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
     }
     else if ('c' in color) {
-        return { 'Cyn ': color.c || 0, Mgnt: color.m || 0, 'Ylw ': color.y || 0, Blck: color.k || 0 };
+        return { _name: '', _classID: 'CMYC', 'Cyn ': color.c || 0, Mgnt: color.m || 0, 'Ylw ': color.y || 0, Blck: color.k || 0 };
     }
     else if ('l' in color) {
-        return { Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
+        return { _name: '', _classID: 'LABC', Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
     }
     else if ('k' in color) {
-        return { 'Gry ': color.k };
+        return { _name: '', _classID: 'GRYC', 'Gry ': color.k };
     }
     else {
         throw new Error('Invalid color value');
@@ -4157,6 +4957,10 @@ function unitsPercent(value) {
     return { units: 'Percent', value: Math.round((value || 0) * 100) };
 }
 exports.unitsPercent = unitsPercent;
+function unitsPercentF(value) {
+    return { units: 'Percent', value: (value || 0) * 100 };
+}
+exports.unitsPercentF = unitsPercentF;
 function unitsValue(x, key) {
     if (x == null)
         return { units: 'Pixels', value: 0 };
@@ -4172,6 +4976,11 @@ function unitsValue(x, key) {
     return { units: units, value: value };
 }
 exports.unitsValue = unitsValue;
+function frac(_a) {
+    var numerator = _a.numerator, denominator = _a.denominator;
+    return { numerator: numerator, denominator: denominator };
+}
+exports.frac = frac;
 exports.textGridding = (0, helpers_1.createEnum)('textGridding', 'none', {
     none: 'None',
     round: 'Rnd ',
@@ -4293,6 +5102,7 @@ exports.ClrS = (0, helpers_1.createEnum)('ClrS', 'rgb', {
     rgb: 'RGBC',
     hsb: 'HSBl',
     lab: 'LbCl',
+    hsl: 'HSLC',
 });
 exports.FStl = (0, helpers_1.createEnum)('FStl', 'outside', {
     outside: 'OutF',
@@ -4339,6 +5149,142 @@ exports.strokeStyleLineAlignment = (0, helpers_1.createEnum)('strokeStyleLineAli
     center: 'strokeStyleAlignCenter',
     outside: 'strokeStyleAlignOutside',
 });
+exports.BlrM = (0, helpers_1.createEnum)('BlrM', 'ispinmage', {
+    spin: 'Spn ',
+    zoom: 'Zm  ',
+});
+exports.BlrQ = (0, helpers_1.createEnum)('BlrQ', 'good', {
+    draft: 'Drft',
+    good: 'Gd  ',
+    best: 'Bst ',
+});
+exports.SmBM = (0, helpers_1.createEnum)('SmBM', 'normal', {
+    normal: 'SBMN',
+    'edge only': 'SBME',
+    'overlay edge': 'SBMO',
+});
+exports.SmBQ = (0, helpers_1.createEnum)('SmBQ', 'medium', {
+    low: 'SBQL',
+    medium: 'SBQM',
+    high: 'SBQH',
+});
+exports.DspM = (0, helpers_1.createEnum)('DspM', 'stretch to fit', {
+    'stretch to fit': 'StrF',
+    'tile': 'Tile',
+});
+exports.UndA = (0, helpers_1.createEnum)('UndA', 'repeat edge pixels', {
+    'wrap around': 'WrpA',
+    'repeat edge pixels': 'RptE',
+});
+exports.Cnvr = (0, helpers_1.createEnum)('Cnvr', 'rectangular to polar', {
+    'rectangular to polar': 'RctP',
+    'polar to rectangular': 'PlrR',
+});
+exports.RplS = (0, helpers_1.createEnum)('RplS', 'medium', {
+    small: 'Sml ',
+    medium: 'Mdm ',
+    large: 'Lrg ',
+});
+exports.SphM = (0, helpers_1.createEnum)('SphM', 'normal', {
+    'normal': 'Nrml',
+    'horizontal only': 'HrzO',
+    'vertical only': 'VrtO',
+});
+exports.Wvtp = (0, helpers_1.createEnum)('Wvtp', 'sine', {
+    sine: 'WvSn',
+    triangle: 'WvTr',
+    square: 'WvSq',
+});
+exports.ZZTy = (0, helpers_1.createEnum)('ZZTy', 'pond ripples', {
+    'around center': 'ArnC',
+    'out from center': 'OtFr',
+    'pond ripples': 'PndR',
+});
+exports.Dstr = (0, helpers_1.createEnum)('Dstr', 'uniform', {
+    uniform: 'Unfr',
+    gaussian: 'Gsn ',
+});
+exports.Chnl = (0, helpers_1.createEnum)('Chnl', 'composite', {
+    red: 'Rd  ',
+    green: 'Grn ',
+    blue: 'Bl  ',
+    composite: 'Cmps',
+});
+exports.MztT = (0, helpers_1.createEnum)('MztT', 'fine dots', {
+    'fine dots': 'FnDt',
+    'medium dots': 'MdmD',
+    'grainy dots': 'GrnD',
+    'coarse dots': 'CrsD',
+    'short lines': 'ShrL',
+    'medium lines': 'MdmL',
+    'long lines': 'LngL',
+    'short strokes': 'ShSt',
+    'medium strokes': 'MdmS',
+    'long strokes': 'LngS',
+});
+exports.Lns = (0, helpers_1.createEnum)('Lns ', '50-300mm zoom', {
+    '50-300mm zoom': 'Zm  ',
+    '32mm prime': 'Nkn ',
+    '105mm prime': 'Nkn1',
+    'movie prime': 'PnVs',
+});
+exports.blurType = (0, helpers_1.createEnum)('blurType', 'gaussian blur', {
+    'gaussian blur': 'GsnB',
+    'lens blur': 'lensBlur',
+    'motion blur': 'MtnB',
+});
+exports.DfsM = (0, helpers_1.createEnum)('DfsM', 'normal', {
+    'normal': 'Nrml',
+    'darken only': 'DrkO',
+    'lighten only': 'LghO',
+    'anisotropic': 'anisotropic',
+});
+exports.ExtT = (0, helpers_1.createEnum)('ExtT', 'blocks', {
+    blocks: 'Blks',
+    pyramids: 'Pyrm',
+});
+exports.ExtR = (0, helpers_1.createEnum)('ExtR', 'random', {
+    random: 'Rndm',
+    'level-based': 'LvlB',
+});
+exports.FlCl = (0, helpers_1.createEnum)('FlCl', 'background color', {
+    'background color': 'FlBc',
+    'foreground color': 'FlFr',
+    'inverse image': 'FlIn',
+    'unaltered image': 'FlSm',
+});
+exports.CntE = (0, helpers_1.createEnum)('CntE', 'upper', {
+    lower: 'Lwr ',
+    upper: 'Upr ',
+});
+exports.WndM = (0, helpers_1.createEnum)('WndM', 'wind', {
+    wind: 'Wnd ',
+    blast: 'Blst',
+    stagger: 'Stgr',
+});
+exports.Drct = (0, helpers_1.createEnum)('Drct', 'from the right', {
+    left: 'Left',
+    right: 'Rght',
+});
+exports.IntE = (0, helpers_1.createEnum)('IntE', 'odd lines', {
+    'odd lines': 'ElmO',
+    'even lines': 'ElmE',
+});
+exports.IntC = (0, helpers_1.createEnum)('IntC', 'interpolation', {
+    duplication: 'CrtD',
+    interpolation: 'CrtI',
+});
+exports.FlMd = (0, helpers_1.createEnum)('FlMd', 'wrap around', {
+    'set to transparent': 'Bckg',
+    'repeat edge pixels': 'Rpt ',
+    'wrap around': 'Wrp ',
+});
+exports.prjM = (0, helpers_1.createEnum)('prjM', 'fisheye', {
+    'fisheye': 'fisP',
+    'perspective': 'perP',
+    'auto': 'auto',
+    'full spherical': 'fusP',
+});
 
 },{"./helpers":7,"./psdReader":11,"./psdWriter":12}],5:[function(require,module,exports){
 "use strict";
@@ -5734,15 +6680,14 @@ function (// Timeline Information
 target) { return target.timelineInformation !== undefined; }, function (reader, target, _, options) {
     var _a, _b;
     var desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-    // console.log('1075', require('util').inspect(desc, false, 99, true));
     target.timelineInformation = {
         enabled: desc.enab,
-        frameStep: desc.frameStep,
+        frameStep: (0, descriptor_1.frac)(desc.frameStep),
         frameRate: desc.frameRate,
-        time: desc.time,
-        duration: desc.duration,
-        workInTime: desc.workInTime,
-        workOutTime: desc.workOutTime,
+        time: (0, descriptor_1.frac)(desc.time),
+        duration: (0, descriptor_1.frac)(desc.duration),
+        workInTime: (0, descriptor_1.frac)(desc.workInTime),
+        workOutTime: (0, descriptor_1.frac)(desc.workOutTime),
         repeats: desc.LCnt,
         hasMotion: desc.hasMotion,
         globalTracks: (0, descriptor_1.parseTrackList)(desc.globalTrackList, !!options.logMissingFeatures),
@@ -5755,10 +6700,10 @@ target) { return target.timelineInformation !== undefined; }, function (reader,
                 var clipID = _a.clipID, timeScope = _a.timeScope, muted = _a.muted, audioLevel = _a.audioLevel, frameReader = _a.frameReader;
                 return ({
                     id: clipID,
-                    start: timeScope.Strt,
-                    duration: timeScope.duration,
-                    inTime: timeScope.inTime,
-                    outTime: timeScope.outTime,
+                    start: (0, descriptor_1.frac)(timeScope.Strt),
+                    duration: (0, descriptor_1.frac)(timeScope.duration),
+                    inTime: (0, descriptor_1.frac)(timeScope.inTime),
+                    outTime: (0, descriptor_1.frac)(timeScope.outTime),
                     muted: muted,
                     audioLevel: audioLevel,
                     frameReader: {
@@ -5819,14 +6764,12 @@ target) { return target.timelineInformation !== undefined; }, function (reader,
         },
         hasMotion: timeline.hasMotion,
     };
-    // console.log('WRITE:1075', require('util').inspect(desc, false, 99, true));
     (0, descriptor_1.writeVersionAndDescriptor)(writer, '', 'null', desc, 'anim');
 });
 addHandler(1076, // Sheet Disclosure
 function (// Sheet Disclosure
 target) { return target.sheetDisclosure !== undefined; }, function (reader, target) {
     var desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-    // console.log('1076', require('util').inspect(desc, false, 99, true));
     target.sheetDisclosure = {};
     if (desc.sheetTimelineOptions) {
         target.sheetDisclosure.sheetTimelineOptions = desc.sheetTimelineOptions.map(function (o) { return ({
@@ -5908,10 +6851,10 @@ target) { return target.slices ? target.slices.length : 0; }, function (reader,
             var associatedLayerId = origin_1 == 'layer' ? (0, psdReader_1.readUint32)(reader) : 0;
             var name_3 = (0, psdReader_1.readUnicodeString)(reader);
             var type = clamped(sliceTypes, (0, psdReader_1.readUint32)(reader));
-            var top_2 = (0, psdReader_1.readInt32)(reader);
             var left_1 = (0, psdReader_1.readInt32)(reader);
-            var bottom_1 = (0, psdReader_1.readInt32)(reader);
+            var top_2 = (0, psdReader_1.readInt32)(reader);
             var right_1 = (0, psdReader_1.readInt32)(reader);
+            var bottom_1 = (0, psdReader_1.readInt32)(reader);
             var url = (0, psdReader_1.readUnicodeString)(reader);
             var target_1 = (0, psdReader_1.readUnicodeString)(reader);
             var message = (0, psdReader_1.readUnicodeString)(reader);
@@ -5944,7 +6887,6 @@ target) { return target.slices ? target.slices.length : 0; }, function (reader,
                 backgroundColorType: backgroundColorType,
                 backgroundColor: { r: r, g: g, b: b, a: a },
             });
-            // console.log(require('util').inspect(slices[slices.length - 1], false, 99, true));
         }
         var desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
         desc.slices.forEach(function (d) {
@@ -5956,12 +6898,9 @@ target) { return target.slices ? target.slices.length : 0; }, function (reader,
                 slice.rightOutset = d.rightOutset;
             }
         });
-        // console.log(require('util').inspect(desc, false, 99, true));
-        // console.log(require('util').inspect(target.slices, false, 99, true));
     }
     else if (version == 7 || version == 8) {
         var desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-        // console.log(require('util').inspect(desc, false, 99, true));
         if (!target.slices)
             target.slices = [];
         target.slices.push({
@@ -6021,10 +6960,10 @@ target) { return target.slices ? target.slices.length : 0; }, function (reader,
             (0, psdWriter_1.writeUint32)(writer, slice.associatedLayerId);
         (0, psdWriter_1.writeUnicodeString)(writer, slice.name);
         (0, psdWriter_1.writeUint32)(writer, sliceTypes.indexOf(slice.type));
-        (0, psdWriter_1.writeInt32)(writer, slice.bounds.top);
         (0, psdWriter_1.writeInt32)(writer, slice.bounds.left);
-        (0, psdWriter_1.writeInt32)(writer, slice.bounds.bottom);
+        (0, psdWriter_1.writeInt32)(writer, slice.bounds.top);
         (0, psdWriter_1.writeInt32)(writer, slice.bounds.right);
+        (0, psdWriter_1.writeInt32)(writer, slice.bounds.bottom);
         (0, psdWriter_1.writeUnicodeString)(writer, slice.url);
         (0, psdWriter_1.writeUnicodeString)(writer, slice.target);
         (0, psdWriter_1.writeUnicodeString)(writer, slice.message);
@@ -6176,7 +7115,6 @@ addHandler(7001, function (target) { return target.imageReadyDataSets !== undefi
 });
 addHandler(1088, function (target) { return target.pathSelectionState !== undefined; }, function (reader, target, _left) {
     var desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-    // console.log(require('util').inspect(desc, false, 99, true));
     target.pathSelectionState = desc['null'];
 }, function (writer, target) {
     var desc = { 'null': target.pathSelectionState };
@@ -6422,7 +7360,7 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readPattern = exports.readColor = exports.readSection = exports.readDataRLE = exports.readDataZipWithoutPrediction = exports.readPsd = exports.checkSignature = exports.skipBytes = exports.readAsciiString = exports.readUnicodeStringWithLength = exports.readUnicodeString = exports.readPascalString = exports.readSignature = exports.readBytes = exports.readFixedPointPath32 = exports.readFixedPoint32 = exports.readFloat64 = exports.readFloat32 = exports.readUint32 = exports.readInt32LE = exports.readInt32 = exports.readUint16 = exports.readInt16 = exports.peekUint8 = exports.readUint8 = exports.warnOrThrow = exports.createReader = exports.supportedColorModes = void 0;
+exports.readPattern = exports.readColor = exports.readSection = exports.readDataRLE = exports.readDataZipWithoutPrediction = exports.readPsd = exports.checkSignature = exports.skipBytes = exports.readAsciiString = exports.readUnicodeStringWithLengthLE = exports.readUnicodeStringWithLength = exports.readUnicodeString = exports.readPascalString = exports.readSignature = exports.readBytes = exports.readFixedPointPath32 = exports.readFixedPoint32 = exports.readFloat64 = exports.readFloat32 = exports.readUint32 = exports.readInt32LE = exports.readInt32 = exports.readUint16LE = exports.readUint16 = exports.readInt16 = exports.peekUint8 = exports.readUint8 = exports.warnOrThrow = exports.createReader = exports.supportedColorModes = void 0;
 var pako_1 = require("pako");
 var helpers_1 = require("./helpers");
 var additionalInfo_1 = require("./additionalInfo");
@@ -6467,6 +7405,11 @@ function readUint16(reader) {
     return reader.view.getUint16(reader.offset - 2, false);
 }
 exports.readUint16 = readUint16;
+function readUint16LE(reader) {
+    reader.offset += 2;
+    return reader.view.getUint16(reader.offset - 2, true);
+}
+exports.readUint16LE = readUint16LE;
 function readInt32(reader) {
     reader.offset += 4;
     return reader.view.getInt32(reader.offset - 4, false);
@@ -6550,6 +7493,17 @@ function readUnicodeStringWithLength(reader, length) {
     return text;
 }
 exports.readUnicodeStringWithLength = readUnicodeStringWithLength;
+function readUnicodeStringWithLengthLE(reader, length) {
+    var text = '';
+    while (length--) {
+        var value = readUint16LE(reader);
+        if (value || length > 0) { // remove trailing \0
+            text += String.fromCharCode(value);
+        }
+    }
+    return text;
+}
+exports.readUnicodeStringWithLengthLE = readUnicodeStringWithLengthLE;
 function readAsciiString(reader, length) {
     var text = '';
     while (length--) {
@@ -6757,14 +7711,14 @@ function readLayerRecord(reader, psd, options) {
     var channelCount = readUint16(reader);
     var channels = [];
     for (var i = 0; i < channelCount; i++) {
-        var channelID = readInt16(reader);
-        var channelLength = readUint32(reader);
+        var id = readInt16(reader);
+        var length_1 = readUint32(reader);
         if (options.large) {
-            if (channelLength !== 0)
+            if (length_1 !== 0)
                 throw new Error('Sizes larger than 4GB are not supported');
-            channelLength = readUint32(reader);
+            length_1 = readUint32(reader);
         }
-        channels.push({ id: channelID, length: channelLength });
+        channels.push({ id: id, length: length_1 });
     }
     checkSignature(reader, '8BIM');
     var blendMode = readSignature(reader);
@@ -6776,11 +7730,12 @@ function readLayerRecord(reader, psd, options) {
     var flags = readUint8(reader);
     layer.transparencyProtected = (flags & 0x01) !== 0;
     layer.hidden = (flags & 0x02) !== 0;
+    if (flags & 0x20)
+        layer.effectsOpen = true;
     // 0x04 - obsolete
     // 0x08 - 1 for Photoshop 5.0 and later, tells if bit 4 has useful information
     // 0x10 - pixel data irrelevant to appearance of document
-    // 0x20 - ???
-    // if (flags & 0x20) (layer as any)._2 = true; // TEMP !!!!
+    // 0x20 - effects/filters panel is expanded
     skipBytes(reader, 1);
     readSection(reader, 1, function (left) {
         var mask = readLayerMaskData(reader, options);
@@ -7184,9 +8139,9 @@ function readDataRLE(reader, pixelData, _width, height, step, offsets, large) {
         }
         else {
             for (var y = 0, p = offset | 0; y < height; y++, li++) {
-                var length_1 = lengths[li];
-                var buffer = readBytes(reader, length_1);
-                for (var i = 0; i < length_1; i++) {
+                var length_2 = lengths[li];
+                var buffer = readBytes(reader, length_2);
+                for (var i = 0; i < length_2; i++) {
                     var header = buffer[i];
                     if (header > 128) {
                         var value = buffer[++i];
@@ -7330,7 +8285,7 @@ function readPattern(reader) {
         var has = readUint32(reader);
         if (!has)
             continue;
-        var length_2 = readUint32(reader);
+        var length_3 = readUint32(reader);
         var pixelDepth = readUint32(reader);
         var ctop = readUint32(reader);
         var cleft = readUint32(reader);
@@ -7338,7 +8293,7 @@ function readPattern(reader) {
         var cright = readUint32(reader);
         var pixelDepth2 = readUint16(reader);
         var compressionMode = readUint8(reader); // 0 - raw, 1 - zip
-        var dataLength = length_2 - (4 + 16 + 2 + 1);
+        var dataLength = length_3 - (4 + 16 + 2 + 1);
         var cdata = readBytes(reader, dataLength);
         if (pixelDepth !== 8 || pixelDepth2 !== 8) {
             throw new Error('16bit pixel depth not supported for patterns');
@@ -7409,7 +8364,7 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeColor = exports.writePsd = exports.writeSection = exports.writeUnicodeStringWithPadding = exports.writeUnicodeString = exports.writePascalString = exports.writeSignature = exports.writeZeros = exports.writeBytes = exports.writeFixedPointPath32 = exports.writeFixedPoint32 = exports.writeFloat64 = exports.writeFloat32 = exports.writeUint32 = exports.writeInt32 = exports.writeUint16 = exports.writeInt16 = exports.writeUint8 = exports.getWriterBufferNoCopy = exports.getWriterBuffer = exports.createWriter = void 0;
+exports.writeColor = exports.writePsd = exports.writeSection = exports.writeUnicodeStringWithPadding = exports.writeUnicodeString = exports.writeUnicodeStringWithoutLengthLE = exports.writeUnicodeStringWithoutLength = exports.writePascalString = exports.writeSignature = exports.writeZeros = exports.writeBytes = exports.writeFixedPointPath32 = exports.writeFixedPoint32 = exports.writeFloat64 = exports.writeFloat32 = exports.writeUint32 = exports.writeInt32LE = exports.writeInt32 = exports.writeUint16LE = exports.writeUint16 = exports.writeInt16 = exports.writeUint8 = exports.getWriterBufferNoCopy = exports.getWriterBuffer = exports.createWriter = void 0;
 var helpers_1 = require("./helpers");
 var additionalInfo_1 = require("./additionalInfo");
 var imageResources_1 = require("./imageResources");
@@ -7444,11 +8399,21 @@ function writeUint16(writer, value) {
     writer.view.setUint16(offset, value, false);
 }
 exports.writeUint16 = writeUint16;
+function writeUint16LE(writer, value) {
+    var offset = addSize(writer, 2);
+    writer.view.setUint16(offset, value, true);
+}
+exports.writeUint16LE = writeUint16LE;
 function writeInt32(writer, value) {
     var offset = addSize(writer, 4);
     writer.view.setInt32(offset, value, false);
 }
 exports.writeInt32 = writeInt32;
+function writeInt32LE(writer, value) {
+    var offset = addSize(writer, 4);
+    writer.view.setInt32(offset, value, true);
+}
+exports.writeInt32LE = writeInt32LE;
 function writeUint32(writer, value) {
     var offset = addSize(writer, 4);
     writer.view.setUint32(offset, value, false);
@@ -7502,6 +8467,7 @@ function writePascalString(writer, text, padTo) {
     writeUint8(writer, length);
     for (var i = 0; i < length; i++) {
         var code = text.charCodeAt(i);
+        // writeUint8(writer, code); // for testing
         writeUint8(writer, code < 128 ? code : '?'.charCodeAt(0));
     }
     while (++length % padTo) {
@@ -7509,12 +8475,22 @@ function writePascalString(writer, text, padTo) {
     }
 }
 exports.writePascalString = writePascalString;
-function writeUnicodeString(writer, text) {
-    writeUint32(writer, text.length);
+function writeUnicodeStringWithoutLength(writer, text) {
     for (var i = 0; i < text.length; i++) {
         writeUint16(writer, text.charCodeAt(i));
     }
 }
+exports.writeUnicodeStringWithoutLength = writeUnicodeStringWithoutLength;
+function writeUnicodeStringWithoutLengthLE(writer, text) {
+    for (var i = 0; i < text.length; i++) {
+        writeUint16LE(writer, text.charCodeAt(i));
+    }
+}
+exports.writeUnicodeStringWithoutLengthLE = writeUnicodeStringWithoutLengthLE;
+function writeUnicodeString(writer, text) {
+    writeUint32(writer, text.length);
+    writeUnicodeStringWithoutLength(writer, text);
+}
 exports.writeUnicodeString = writeUnicodeString;
 function writeUnicodeStringWithPadding(writer, text) {
     writeUint32(writer, text.length + 1);
@@ -7685,10 +8661,8 @@ function writeLayerInfo(tempBuffer, writer, psd, globalAlpha, options) {
             if (layer.vectorMask || (layer.sectionDivider && layer.sectionDivider.type !== 0 /* SectionDividerType.Other */)) {
                 flags |= 0x10; // pixel data irrelevant to appearance of document
             }
-            if (layer.effects && (0, additionalInfo_1.hasMultiEffects)(layer.effects)) { // TODO: this is not correct
-                flags |= 0x20; // just guessing this one, might be completely incorrect
-            }
-            // if ('_2' in layer) flags |= 0x20; // TEMP!!!
+            if (layer.effectsOpen)
+                flags |= 0x20;
             writeUint8(writer, flags);
             writeUint8(writer, 0); // filler
             writeSection(writer, 1, function () {