ag-psd 16.0.0 → 17.0.0

package/dist-es/additionalInfo.js

@@ -14,9 +14,10 @@ import { readEffects, writeEffects } from './effectsHelpers';
 import { clamp, createEnum, layerColors, MOCK_HANDLERS } from './helpers';
 import { readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16, readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32, readPascalString, readUnicodeStringWithLength, readAsciiString, readPattern, } from './psdReader';
 import { writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32, } from './psdWriter';
-import { Annt, BlnM, parsePercent, parseUnits, parseUnitsOrNumber, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, textGridding, unitsPercent, unitsValue, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, Ornt, horzVrtcToXY, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, } from './descriptor';
+import { Annt, BlnM, parsePercent, parseUnits, parseUnitsOrNumber, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, textGridding, unitsPercent, unitsValue, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, Ornt, horzVrtcToXY, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy, Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd, unitsPercentF, frac, ClrS, } from './descriptor';
 import { serializeEngineData, parseEngineData } from './engineData';
 import { encodeEngineData, decodeEngineData } from './text';
+var fromAtoZ = 'abcdefghijklmnopqrstuvwxyz';
 export var infoHandlers = [];
 export var infoHandlersMap = {};
 function addHandler(key, has, read, write) {
@@ -541,10 +542,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: frac(timeScope.Strt),
+                    duration: frac(timeScope.duration),
+                    inTime: frac(timeScope.inTime),
+                    outTime: frac(timeScope.outTime),
                     autoScope: desc.autoScope,
                     audioLevel: desc.audioLevel,
                 };
@@ -685,7 +686,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,
@@ -703,7 +704,7 @@ addHandler('vstk', hasKey('vectorStroke'), function (reader, target, left) {
         strokeStyleContent: serializeVectorContent(stroke.content || { type: 'color', color: { r: 0, g: 0, b: 0 } }).descriptor,
         strokeStyleResolution: (_c = stroke.resolution) !== null && _c !== void 0 ? _c : 72,
     };
-    writeVersionAndDescriptor(writer, '', 'strokeStyle', descriptor);
+    writeVersionAndDescriptor(writer, '', 'strokeStyle', desc);
 });
 addHandler('artb', // per-layer arboard info
 hasKey('artboard'), function (reader, target, left) {
@@ -768,7 +769,7 @@ function isQuiltWarp(warp) {
 }
 function encodeWarp(warp) {
     var bounds = warp.bounds;
-    var desc = __assign(__assign({ warpStyle: warpStyle.encode(warp.style) }, (warp.values ? { warpValues: warp.values } : { warpValue: warp.value })), { warpPerspective: warp.perspective || 0, warpPerspectiveOther: warp.perspectiveOther || 0, warpRotate: Ornt.encode(warp.rotate), bounds: {
+    var desc = __assign(__assign({ warpStyle: warpStyle.encode(warp.style) }, (warp.values ? { warpValues: warp.values } : { warpValue: warp.value || 0 })), { warpPerspective: warp.perspective || 0, warpPerspectiveOther: warp.perspectiveOther || 0, warpRotate: Ornt.encode(warp.rotate), bounds: {
             'Top ': unitsValue(bounds && bounds.top || { units: 'Pixels', value: 0 }, 'bounds.top'),
             Left: unitsValue(bounds && bounds.left || { units: 'Pixels', value: 0 }, 'bounds.left'),
             Btom: unitsValue(bounds && bounds.bottom || { units: 'Pixels', value: 0 }, 'bounds.bottom'),
@@ -786,6 +787,8 @@ function encodeWarp(warp) {
         if (isQuilt) {
             var desc2 = desc;
             desc2.customEnvelopeWarp = {
+                _name: '',
+                _classID: 'customEnvelopeWarp',
                 quiltSliceX: [{
                         type: 'quiltSliceX',
                         values: customEnvelopeWarp.quiltSliceX || [],
@@ -802,6 +805,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; }) },
@@ -893,58 +898,345 @@ function hrznVrtcToPoint(desc) {
 }
 function pointToHrznVrtc(point) {
     return {
+        _name: '',
+        _classID: 'Pnt ',
         Hrzn: unitsValue(point.x, 'x'),
         Vrtc: 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: parsePercent(f.blendOptions.Opct),
+        blendMode: BlnM.decode(f.blendOptions['Md  ']),
+        enabled: f.enab,
+        hasOptions: f.hasoptions,
+        foregroundColor: parseColor(f.FrgC),
+        backgroundColor: 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: parseUnits(f.Fltr['Rds ']),
+            } });
+        case 1198747202: return __assign(__assign({}, base), { type: 'gaussian blur', filter: {
+                radius: parseUnits(f.Fltr['Rds ']),
+            } });
+        case 1299476034: return __assign(__assign({}, base), { type: 'motion blur', filter: {
+                angle: f.Fltr.Angl,
+                distance: parseUnits(f.Fltr.Dstn),
+            } });
+        case 1382313026: return __assign(__assign({}, base), { type: 'radial blur', filter: {
+                amount: f.Fltr.Amnt,
+                method: BlrM.decode(f.Fltr.BlrM),
+                quality: BlrQ.decode(f.Fltr.BlrQ),
+            } });
+        case 702: return __assign(__assign({}, base), { type: 'shape blur', filter: {
+                radius: 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: SmBQ.decode(f.Fltr.SmBQ),
+                mode: SmBM.decode(f.Fltr.SmBM),
+            } });
+        case 701: return __assign(__assign({}, base), { type: 'surface blur', filter: {
+                radius: 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: DspM.decode(f.Fltr.DspM),
+                undefinedAreas: 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: Cnvr.decode(f.Fltr.Cnvr),
+            } });
+        case 1383099493: return __assign(__assign({}, base), { type: 'ripple', filter: {
+                amount: f.Fltr.Amnt,
+                size: 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: UndA.decode(f.Fltr.UndA),
+            } });
+        case 1399875698: return __assign(__assign({}, base), { type: 'spherize', filter: {
+                amount: f.Fltr.Amnt,
+                mode: 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: 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: UndA.decode(f.Fltr.UndA),
+            } });
+        case 1516722791: return __assign(__assign({}, base), { type: 'zigzag', filter: {
+                amount: f.Fltr.Amnt,
+                ridges: f.Fltr.NmbR,
+                style: ZZTy.decode(f.Fltr.ZZTy),
+            } });
+        case 1097092723: return __assign(__assign({}, base), { type: 'add noise', filter: {
+                amount: parsePercent(f.Fltr.Nose),
+                distribution: 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: parseUnits(f.Fltr['Rds ']),
+            } });
+        case 633: return __assign(__assign({}, base), { type: 'reduce noise', filter: {
+                preset: f.Fltr.preset,
+                removeJpegArtifact: f.Fltr.removeJPEGArtifact,
+                reduceColorNoise: parsePercent(f.Fltr.ClNs),
+                sharpenDetails: parsePercent(f.Fltr.Shrp),
+                channelDenoise: f.Fltr.channelDenoise.map(function (c) { return (__assign({ channels: c.Chnl.map(function (i) { return 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: MztT.decode(f.Fltr.MztT),
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1299407648: return __assign(__assign({}, base), { type: 'mosaic', filter: {
+                cellSize: 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: 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: parsePercent(f.Fltr.Amnt),
+                radius: parseUnits(f.Fltr['Rds ']),
+                threshold: f.Fltr.Thsh,
+                angle: f.Fltr.Angl,
+                moreAccurate: f.Fltr.moreAccurate,
+                blur: blurType.decode(f.Fltr.blur),
+                preset: f.Fltr.preset,
+                shadow: {
+                    fadeAmount: parsePercent(f.Fltr.sdwM.Amnt),
+                    tonalWidth: parsePercent(f.Fltr.sdwM.Wdth),
+                    radius: f.Fltr.sdwM['Rds '],
+                },
+                highlight: {
+                    fadeAmount: parsePercent(f.Fltr.hglM.Amnt),
+                    tonalWidth: parsePercent(f.Fltr.hglM.Wdth),
+                    radius: f.Fltr.hglM['Rds '],
+                },
+            } });
+        case 1433301837: return __assign(__assign({}, base), { type: 'unsharp mask', filter: {
+                amount: parsePercent(f.Fltr.Amnt),
+                radius: parseUnits(f.Fltr['Rds ']),
+                threshold: f.Fltr.Thsh,
+            } });
+        case 1147564832: return __assign(__assign({}, base), { type: 'diffuse', filter: {
+                mode: 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: ExtT.decode(f.Fltr.ExtT),
+                size: f.Fltr.ExtS,
+                depth: f.Fltr.ExtD,
+                depthMode: 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: FlCl.decode(f.Fltr.FlCl),
+                randomSeed: f.Fltr.FlRs,
+            } });
+        case 1416782659: return __assign(__assign({}, base), { type: 'trace contour', filter: {
+                level: f.Fltr['Lvl '],
+                edge: CntE.decode(f.Fltr['Edg ']),
+            } });
+        case 1466852384: return __assign(__assign({}, base), { type: 'wind', filter: {
+                method: WndM.decode(f.Fltr.WndM),
+                direction: Drct.decode(f.Fltr.Drct),
+            } });
+        case 1148089458: return __assign(__assign({}, base), { type: 'de-interlace', filter: {
+                eliminate: IntE.decode(f.Fltr.IntE),
+                newFieldsBy: 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: parseUnits(f.Fltr['Rds ']),
+            } });
+        case 1299737888: return __assign(__assign({}, base), { type: 'maximum', filter: {
+                radius: parseUnits(f.Fltr['Rds ']),
+            } });
+        case 1299082528: return __assign(__assign({}, base), { type: 'minimum', filter: {
+                radius: parseUnits(f.Fltr['Rds ']),
+            } });
+        case 1332114292: return __assign(__assign({}, base), { type: 'offset', filter: {
+                horizontal: f.Fltr.Hrzn,
+                vertical: f.Fltr.Vrtc,
+                undefinedAreas: 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: ClrS.decode(f.Fltr.Inpt),
+                rowOrder: 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) {
@@ -954,96 +1246,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: parsePercent(f.blendOptions.Opct),
-            blendMode: BlnM.decode(f.blendOptions['Md  ']),
-            enabled: f.enab,
-            hasOptions: f.hasoptions,
-            foregroundColor: parseColor(f.FrgC),
-            backgroundColor: 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 unitsValue(t.radius, 'radius');
+}
+function serializeFilterFXItem(f) {
+    var base = {
+        _name: '',
+        _classID: 'filterFX',
+        'Nm  ': f.name,
+        blendOptions: {
+            _name: '',
+            _classID: 'blendOptions',
+            Opct: unitsPercentF(f.opacity),
+            'Md  ': BlnM.encode(f.blendMode),
+        },
+        enab: f.enabled,
+        hasoptions: f.hasOptions,
+        FrgC: serializeColor(f.foregroundColor),
+        BckC: 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: 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: BlrM.encode(f.filter.method),
+                BlrQ: 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: SmBQ.encode(f.filter.quality),
+                SmBM: 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: DspM.encode(f.filter.displacementMap),
+                UndA: 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: Cnvr.encode(f.filter.conversion),
+            }, filterID: 1349284384 });
+        case 'ripple': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Ripple',
+                _classID: 'Rple',
+                Amnt: f.filter.amount,
+                RplS: 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: 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: 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: 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: 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: ZZTy.encode(f.filter.style),
+            }, filterID: 1516722791 });
+        case 'add noise': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Add Noise',
+                _classID: 'AdNs',
+                Dstr: Dstr.encode(f.filter.distribution),
+                Nose: 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: unitsPercentF(f.filter.reduceColorNoise),
+                Shrp: 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 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: MztT.encode(f.filter.type),
+                FlRs: f.filter.randomSeed,
+            }, filterID: 1299870830 });
+        case 'mosaic': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Mosaic',
+                _classID: 'Msc ',
+                ClSz: 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 ': 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: unitsPercentF(f.filter.amount),
+                'Rds ': uvRadius(f.filter),
+                Thsh: f.filter.threshold,
+                Angl: f.filter.angle,
+                moreAccurate: f.filter.moreAccurate,
+                blur: blurType.encode(f.filter.blur),
+                preset: f.filter.preset,
+                sdwM: {
+                    _name: 'Parameters',
+                    _classID: 'adaptCorrectTones',
+                    Amnt: unitsPercentF(f.filter.shadow.fadeAmount),
+                    Wdth: unitsPercentF(f.filter.shadow.tonalWidth),
+                    'Rds ': f.filter.shadow.radius,
+                },
+                hglM: {
+                    _name: 'Parameters',
+                    _classID: 'adaptCorrectTones',
+                    Amnt: unitsPercentF(f.filter.highlight.fadeAmount),
+                    Wdth: 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: 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  ': 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: ExtT.encode(f.filter.type),
+                ExtR: 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: 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 ': CntE.encode(f.filter.edge),
+            }, filterID: 1416782659 });
+        case 'wind': return __assign(__assign({}, base), { Fltr: {
+                _name: 'Wind',
+                _classID: 'Wnd ',
+                WndM: WndM.encode(f.filter.method),
+                Drct: Drct.encode(f.filter.direction),
+            }, filterID: 1466852384 });
+        case 'de-interlace': return __assign(__assign({}, base), { Fltr: {
+                _name: 'De-Interlace',
+                _classID: 'Dntr',
+                IntE: IntE.encode(f.filter.eliminate),
+                IntC: 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  ': 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: unitsPercent(f.opacity),
-                'Md  ': BlnM.encode(f.blendMode),
-            },
-            enab: f.enabled,
-            hasoptions: f.hasOptions,
-            FrgC: serializeColor(f.foregroundColor),
-            BckC: serializeColor(f.backgroundColor),
-            Fltr: serializeFltr(f.filter),
-            filterID: f.id,
-        }); }),
-    };
-}
+// let t: any;
 addHandler('SoLd', hasKey('placedLayer'), function (reader, target, left) {
     if (readSignature(reader) !== 'soLD')
         throw new Error("Invalid SoLd type");
@@ -1055,15 +1697,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: frac(desc.frameStep),
+        duration: frac(desc.duration),
         frameCount: desc.frameCount,
         transform: desc.Trnf,
         width: desc['Sz  '].Wdth,
@@ -1078,22 +1722,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));
     skipBytes(reader, left()); // HACK
 }, function (writer, target) {
     var _a, _b;
     writeSignature(writer, 'soLD');
     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 ? 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;
@@ -1179,7 +1849,7 @@ addHandler('Anno', function (target) { return target.annotations !== undefined;
         var popupLocation = readRect(reader);
         var color = readColor(reader);
         var author = readPascalString(reader, 2);
-        var name_1 = readPascalString(reader, 2);
+        var name_2 = readPascalString(reader, 2);
         var date = readPascalString(reader, 2);
         /*const contentLength =*/ readUint32(reader);
         /*const dataType =*/ readSignature(reader);
@@ -1208,7 +1878,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,
         });
@@ -1267,20 +1937,26 @@ addHandler('lnk2', function (target) { return !!target.linkedFiles && target.lin
         var type = readSignature(reader);
         var version = readInt32(reader);
         var id = readPascalString(reader, 1);
-        var name_2 = readUnicodeString(reader);
+        var name_3 = readUnicodeString(reader);
         var fileType = readSignature(reader).trim(); // '    ' if empty
         var fileCreator = readSignature(reader).trim(); // '    ' or '\0\0\0\0' if empty
         var dataSize = readLength64(reader);
         var hasFileOpenDescriptor = readUint8(reader);
         var fileOpenDescriptor = hasFileOpenDescriptor ? readVersionAndDescriptor(reader) : undefined;
         var linkedFileDescriptor = type === 'liFE' ? 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 = readInt32(reader);
             var month = readUint8(reader);
@@ -1338,7 +2014,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,
+                }
             };
             writeUint8(writer, 1);
             writeVersionAndDescriptor(writer, '', 'null', desc);
@@ -2078,6 +2757,94 @@ addHandler('Txt2', hasKey('engineData'), function (reader, target, left) {
     var buffer = toByteArray(target.engineData);
     writeBytes(writer, buffer);
 });
+addHandler('FEid', hasKey('filterEffectsMasks'), function (reader, target, leftBytes) {
+    var version = readInt32(reader);
+    if (version < 1 || version > 3)
+        throw new Error("Invalid filterEffects version ".concat(version));
+    if (readUint32(reader))
+        throw new Error('filterEffects: 64 bit length is not supported');
+    var length = readUint32(reader);
+    var end = reader.offset + length;
+    target.filterEffectsMasks = [];
+    while (reader.offset < end) {
+        var id = readPascalString(reader, 1);
+        var effectVersion = readInt32(reader);
+        if (effectVersion !== 1)
+            throw new Error("Invalid filterEffect version ".concat(effectVersion));
+        if (readUint32(reader))
+            throw new Error('filterEffect: 64 bit length is not supported');
+        /*const effectLength =*/ readUint32(reader);
+        // const endOfEffect = reader.offset + effectLength;
+        var top_2 = readInt32(reader);
+        var left = readInt32(reader);
+        var bottom = readInt32(reader);
+        var right = readInt32(reader);
+        var depth = readInt32(reader);
+        var maxChannels = readInt32(reader);
+        var channels = [];
+        // 0 -> R, 1 -> G, 2 -> B, 25 -> A
+        for (var i = 0; i < (maxChannels + 2); i++) {
+            var exists = readInt32(reader);
+            if (exists) {
+                if (readUint32(reader))
+                    throw new Error('filterEffect: 64 bit length is not supported');
+                var channelLength = readUint32(reader);
+                var compressionMode = readUint16(reader);
+                var data = 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() && readUint8(reader)) {
+            var compressionMode = readUint16(reader);
+            var data = readBytes(reader, leftBytes());
+            target.filterEffectsMasks[target.filterEffectsMasks.length - 1].extra = { compressionMode: compressionMode, data: data };
+        }
+    }
+}, function (writer, target) {
+    var _a;
+    writeInt32(writer, 3);
+    writeUint32(writer, 0);
+    writeUint32(writer, 0);
+    var lengthOffset = writer.offset;
+    for (var _i = 0, _b = target.filterEffectsMasks; _i < _b.length; _i++) {
+        var mask = _b[_i];
+        writePascalString(writer, mask.id, 1);
+        writeInt32(writer, 1);
+        writeUint32(writer, 0);
+        writeUint32(writer, 0);
+        var length2Offset = writer.offset;
+        writeInt32(writer, mask.top);
+        writeInt32(writer, mask.left);
+        writeInt32(writer, mask.bottom);
+        writeInt32(writer, mask.right);
+        writeInt32(writer, mask.depth);
+        var maxChannels = Math.max(0, mask.channels.length - 2);
+        writeInt32(writer, maxChannels);
+        for (var i = 0; i < (maxChannels + 2); i++) {
+            var channel = mask.channels[i];
+            writeInt32(writer, channel ? 1 : 0);
+            if (channel) {
+                writeUint32(writer, 0);
+                writeUint32(writer, channel.data.length + 2);
+                writeUint16(writer, channel.compressionMode);
+                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) {
+        writeUint8(writer, 1);
+        writeUint16(writer, extra.compressionMode);
+        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: readColor(reader),
@@ -2142,14 +2909,17 @@ addHandler('lfx2', function (target) { return target.effects !== undefined && !h
 addHandler('cinf', hasKey('compositorUsed'), function (reader, target, left) {
     var desc = 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),
     };
     skipBytes(reader, left());
 }, function (writer, target) {
@@ -2204,85 +2974,4 @@ addHandler('tsly', hasKey('transparencyShapesLayer'), function (reader, target)
     writeUint8(writer, target.transparencyShapesLayer ? 1 : 0);
     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');*/
 //# sourceMappingURL=additionalInfo.js.map