ag-psd 16.0.0 → 17.0.1

package/src/additionalInfo.ts

@@ -9,7 +9,7 @@ import {
 	CurvesAdjustment, CurvesAdjustmentChannel, HueSaturationAdjustment, HueSaturationAdjustmentChannel,
 	PresetInfo, Color, ColorBalanceValues, WriteOptions, LinkedFile, PlacedLayerType, Warp, KeyDescriptorItem,
 	BooleanOperation, LayerEffectsInfo, Annotation, LayerVectorMask, AnimationFrame, Timeline, PlacedLayerFilter,
-	UnitsValue, PlacedLayerPuppetFilter,
+	UnitsValue, Filter,
 } from './psd';
 import {
 	PsdReader, readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16,
@@ -28,7 +28,9 @@ import {
 	readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor,
 	FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects,
 	parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList,
-	serializeTrackList, FractionDescriptor,
+	serializeTrackList, FractionDescriptor, 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, descBoundsToBounds, boundsToDescBounds,
 } from './descriptor';
 import { serializeEngineData, parseEngineData } from './engineData';
 import { encodeEngineData, decodeEngineData } from './text';
@@ -49,6 +51,7 @@ export interface InfoHandler {
 	write: WriteMethod;
 }
 
+const fromAtoZ = 'abcdefghijklmnopqrstuvwxyz';
 export const infoHandlers: InfoHandler[] = [];
 export const infoHandlersMap: { [key: string]: InfoHandler; } = {};
 
@@ -111,6 +114,9 @@ addHandler(
 			},
 		};
 
+		if (text.bounds) target.text.bounds = descBoundsToBounds(text.bounds);
+		if (text.boundingBox) target.text.boundingBox = descBoundsToBounds(text.boundingBox);
+
 		if (text.EngineData) {
 			const engineData = parseEngineData(text.EngineData);
 			const textData = decodeEngineData(engineData);
@@ -138,6 +144,8 @@ addHandler(
 			textGridding: textGridding.encode(text.gridding),
 			Ornt: Ornt.encode(text.orientation),
 			AntA: Annt.encode(text.antiAlias),
+			...(text.bounds ? { bounds: boundsToDescBounds(text.bounds) } : {}),
+			...(text.boundingBox ? { boundingBox: boundsToDescBounds(text.boundingBox) } : {}),
 			TextIndex: text.index || 0,
 			EngineData: serializeEngineData(encodeEngineData(text)),
 		};
@@ -149,7 +157,7 @@ addHandler(
 		}
 
 		writeInt16(writer, 50); // text version
-		writeVersionAndDescriptor(writer, '', 'TxLr', textDescriptor);
+		writeVersionAndDescriptor(writer, '', 'TxLr', textDescriptor, 'text');
 
 		writeInt16(writer, 1); // warp version
 		writeVersionAndDescriptor(writer, '', 'warp', encodeWarp(warp));
@@ -771,10 +779,10 @@ addHandler(
 					// console.log('tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
 
 					const timeline: 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,
 					};
@@ -923,7 +931,7 @@ addHandler(
 	},
 	(writer, target) => {
 		const stroke = target.vectorStroke!;
-		const descriptor: StrokeDescriptor = {
+		const desc: StrokeDescriptor = {
 			strokeStyleVersion: 2,
 			strokeEnabled: !!stroke.strokeEnabled,
 			fillEnabled: !!stroke.fillEnabled,
@@ -943,7 +951,7 @@ addHandler(
 			strokeStyleResolution: stroke.resolution ?? 72,
 		};
 
-		writeVersionAndDescriptor(writer, '', 'strokeStyle', descriptor);
+		writeVersionAndDescriptor(writer, '', 'strokeStyle', desc);
 	},
 );
 
@@ -1048,7 +1056,7 @@ function encodeWarp(warp: Warp): WarpDescriptor {
 	const bounds = warp.bounds;
 	const desc: WarpDescriptor = {
 		warpStyle: warpStyle.encode(warp.style),
-		...(warp.values ? { warpValues: warp.values } : { warpValue: warp.value }),
+		...(warp.values ? { warpValues: warp.values } : { warpValue: warp.value || 0 }),
 		warpPerspective: warp.perspective || 0,
 		warpPerspectiveOther: warp.perspectiveOther || 0,
 		warpRotate: Ornt.encode(warp.rotate),
@@ -1077,6 +1085,8 @@ function encodeWarp(warp: Warp): WarpDescriptor {
 		if (isQuilt) {
 			const desc2 = desc as QuiltWarpDescriptor;
 			desc2.customEnvelopeWarp = {
+				_name: '',
+				_classID: 'customEnvelopeWarp',
 				quiltSliceX: [{
 					type: 'quiltSliceX',
 					values: customEnvelopeWarp.quiltSliceX || [],
@@ -1092,6 +1102,8 @@ function encodeWarp(warp: Warp): WarpDescriptor {
 			};
 		} else {
 			desc.customEnvelopeWarp = {
+				_name: '',
+				_classID: 'customEnvelopeWarp',
 				meshPoints: [
 					{ type: 'Hrzn', values: meshPoints.map(p => p.x) },
 					{ type: 'Vrtc', values: meshPoints.map(p => p.y) },
@@ -1154,78 +1166,687 @@ addHandler(
 );
 
 interface HrznVrtcDescriptor {
+	_name: '';
+	_classID: 'Pnt ';
 	Hrzn: DescriptorUnitsValue;
 	Vrtc: DescriptorUnitsValue;
 }
-
-type FltrDescriptor = {
-	'null': string[]; // [Ordn.Trgt]
-	rigidType: boolean;
-	puppetShapeList?: {
+/*
+interface K3DLight {
+	'Nm  ': string;
+	'Rd  ': number;
+	'Grn ': number;
+	'Bl  ': number;
+	hots: number;
+	FlOf: number;
+	shdw: number;
+	attn: boolean;
+	attt: number;
+	atta: number;
+	attb: number;
+	attc: number;
+	orad: number;
+	irad: number;
+	mult: number;
+	Type: number;
+	ison: boolean;
+	ssml: number;
+	afon: boolean;
+	afpw: number;
+	key3DMatrix: {
+		key3DMatrixData: Uint8Array;
+	},
+	'X   ': number;
+	'Y   ': number;
+	'Z   ': number;
+	tarx: number;
+	tary: number;
+	tarz: number;
+	key3DPosition: {
+		key3DXPos: number;
+		key3DYPos: number;
+		key3DZPos: number;
+		key3DXAngle: number;
+		key3DYAngle: number;
+		key3DZAngle: number;
+	};
+}
+*/
+
+type SoLdDescriptorFilterItem = {
+	_name: '',
+	_classID: 'filterFX',
+	'Nm  ': string;
+	blendOptions: {
+		_name: '';
+		_classID: 'blendOptions';
+		Opct: DescriptorUnitsValue;
+		'Md  ': string; // blend mode
+	};
+	enab: boolean;
+	hasoptions: boolean;
+	FrgC: DescriptorColor;
+	BckC: DescriptorColor;
+} & ({
+	filterID: 1098281575; // average
+} | {
+	filterID: 1114403360; // blur
+} | {
+	filterID: 1114403405; // blur more
+} | {
+	filterID: 697;
+	Fltr: {
+		_name: 'Box Blur';
+		_classID: 'boxblur';
+		'Rds ': DescriptorUnitsValue;
+	};
+} | {
+	filterID: 1198747202;
+	Fltr: {
+		_name: 'Gaussian Blur';
+		_classID: 'GsnB';
+		'Rds ': DescriptorUnitsValue;
+	};
+} | {
+	filterID: 1299476034;
+	Fltr: {
+		_name: 'Motion Blur';
+		_classID: 'MtnB';
+		Angl: number;
+		Dstn: DescriptorUnitsValue;
+	};
+} | {
+	filterID: 1382313026;
+	Fltr: {
+		_name: 'Radial Blur';
+		_classID: 'RdlB';
+		Amnt: number;
+		BlrM: string;
+		BlrQ: string;
+	};
+} | {
+	filterID: 702;
+	Fltr: {
+		_name: 'Shape Blur';
+		_classID: 'shapeBlur';
+		'Rds ': DescriptorUnitsValue;
+		customShape: {
+			_name: '';
+			_classID: 'customShape';
+			'Nm  ': string;
+			Idnt: string;
+		};
+	};
+} | {
+	filterID: 1399681602;
+	Fltr: {
+		_name: 'Smart Blur';
+		_classID: 'SmrB';
+		'Rds ': number;
+		Thsh: number;
+		SmBQ: string;
+		SmBM: string;
+	};
+} | {
+	filterID: 701;
+	Fltr: {
+		_name: 'Surface Blur';
+		_classID: 'surfaceBlur';
+		'Rds ': DescriptorUnitsValue;
+		Thsh: number;
+	};
+} | {
+	filterID: 1148416108;
+	Fltr: {
+		_name: 'Displace';
+		_classID: 'Dspl';
+		HrzS: number;
+		VrtS: number;
+		DspM: string;
+		UndA: string;
+		DspF: {
+			sig: string;
+			path: string;
+		};
+	};
+} | {
+	filterID: 1349411688;
+	Fltr: {
+		_name: 'Pinch';
+		_classID: 'Pnch';
+		Amnt: number;
+	};
+} | {
+	filterID: 1349284384;
+	Fltr: {
+		_name: 'Polar Coordinates';
+		_classID: 'Plr ';
+		Cnvr: string;
+	};
+} | {
+	filterID: 1383099493;
+	Fltr: {
+		_name: 'Ripple';
+		_classID: 'Rple';
+		Amnt: number;
+		RplS: string;
+	};
+} | {
+	filterID: 1399353888;
+	Fltr: {
+		_name: 'Shear';
+		_classID: 'Shr ';
+		ShrP: { _name: '', _classID: 'Pnt ', Hrzn: number; Vrtc: number; }[];
+		UndA: string;
+		ShrS: number;
+		ShrE: number;
+	};
+} | {
+	filterID: 1399875698;
+	Fltr: {
+		_name: 'Spherize';
+		_classID: 'Sphr';
+		Amnt: number;
+		SphM: string;
+	};
+} | {
+	filterID: 1417114220;
+	Fltr: {
+		_name: 'Twirl';
+		_classID: 'Twrl';
+		Angl: number;
+	};
+} | {
+	filterID: 1466005093;
+	Fltr: {
+		_name: 'Wave';
+		_classID: 'Wave';
+		Wvtp: string;
+		NmbG: number;
+		WLMn: number;
+		WLMx: number;
+		AmMn: number;
+		AmMx: number;
+		SclH: number;
+		SclV: number;
+		UndA: string;
+		RndS: number;
+	};
+} | {
+	filterID: 1516722791;
+	Fltr: {
+		_name: 'ZigZag';
+		_classID: 'ZgZg';
+		Amnt: number;
+		NmbR: number;
+		ZZTy: string;
+	};
+} | {
+	filterID: 1097092723;
+	Fltr: {
+		_name: 'Add Noise';
+		_classID: 'AdNs';
+		Dstr: string;
+		Nose: DescriptorUnitsValue;
+		Mnch: boolean;
+		FlRs: number;
+	};
+} | {
+	filterID: 1148416099;
+} | {
+	filterID: 1148417107;
+	Fltr: {
+		_name: 'Dust & Scratches';
+		_classID: 'DstS';
+		'Rds ': number;
+		Thsh: number;
+	};
+} | {
+	filterID: 1298427424;
+	Fltr: {
+		_name: 'Median';
+		_classID: 'Mdn ';
+		'Rds ': DescriptorUnitsValue;
+	};
+} | {
+	filterID: 633;
+	Fltr: {
+		_name: 'Reduce Noise';
+		_classID: 'denoise';
+		ClNs: DescriptorUnitsValue; // percent
+		Shrp: DescriptorUnitsValue; // percent
+		removeJPEGArtifact: boolean;
+		channelDenoise: {
+			_name: '';
+			_classID: 'channelDenoiseParams';
+			Chnl: string[];
+			Amnt: number;
+			EdgF?: number;
+		}[];
+		preset: string;
+	};
+} | {
+	filterID: 1131180616;
+	Fltr: {
+		_name: 'Color Halftone';
+		_classID: 'ClrH';
+		'Rds ': number;
+		Ang1: number;
+		Ang2: number;
+		Ang3: number;
+		Ang4: number;
+	};
+} | {
+	filterID: 1131574132;
+	Fltr: {
+		_name: 'Crystallize';
+		_classID: 'Crst';
+		ClSz: number;
+		FlRs: number;
+	};
+} | {
+	filterID: 1180922912;
+} | {
+	filterID: 1181902701;
+} | {
+	filterID: 1299870830;
+	Fltr: {
+		_name: 'Mezzotint';
+		_classID: 'Mztn';
+		MztT: string;
+		FlRs: number;
+	};
+} | {
+	filterID: 1299407648;
+	Fltr: {
+		_name: 'Mosaic';
+		_classID: 'Msc ';
+		ClSz: DescriptorUnitsValue;
+	};
+} | {
+	filterID: 1349416044;
+	Fltr: {
+		_name: 'Pointillize';
+		_classID: 'Pntl';
+		ClSz: number;
+		FlRs: number;
+	};
+} | {
+	filterID: 1131177075;
+	Fltr: {
+		_name: 'Clouds';
+		_classID: 'Clds';
+		FlRs: number;
+	};
+} | {
+	filterID: 1147564611;
+	Fltr: {
+		_name: 'Difference Clouds',
+		_classID: 'DfrC',
+		FlRs: number;
+	};
+} | {
+	filterID: 1180856947;
+	Fltr: {
+		_name: 'Fibers';
+		_classID: 'Fbrs';
+		Vrnc: number;
+		Strg: number;
+		RndS: number;
+	};
+} | {
+	filterID: 1282306886;
+	Fltr: {
+		_name: 'Lens Flare';
+		_classID: 'LnsF';
+		Brgh: number;
+		FlrC: { _name: ''; _classID: 'Pnt '; Hrzn: number; Vrtc: number; };
+		'Lns ': string;
+	};
+} /*| {
+	filterID: 587;
+	Fltr: {
+		k3DLights: K3DLight[];
+		key3DCurrentCameraPosition: {
+			key3DXPos: number;
+			key3DYPos: number;
+			key3DZPos: number;
+			key3DXAngle: number;
+			key3DYAngle: number;
+			key3DZAngle: number;
+		},
+		Glos: number;
+		Mtrl: number;
+		Exps: number;
+		AmbB: number;
+		AmbC: DescriptorColor;
+		BmpA: number;
+		BmpC: string[];
+		Wdth: number;
+		Hght: number;
+	};
+}*/ | {
+	filterID: 1399353968 | 1399353925 | 1399353933;
+} | {
+	filterID: 698;
+	Fltr: {
+		_name: 'Smart Sharpen';
+		_classID: 'smartSharpen';
+		Amnt: DescriptorUnitsValue; // %
+		'Rds ': DescriptorUnitsValue;
+		Thsh: number;
+		Angl: number;
+		moreAccurate: boolean;
+		blur: string;
+		preset: string;
+		sdwM: {
+			_name: 'Parameters',
+			_classID: 'adaptCorrectTones',
+			Amnt: DescriptorUnitsValue; // %
+			Wdth: DescriptorUnitsValue; // %
+			'Rds ': number;
+		};
+		hglM: {
+			_name: 'Parameters',
+			_classID: 'adaptCorrectTones',
+			Amnt: DescriptorUnitsValue; // %
+			Wdth: DescriptorUnitsValue; // %
+			'Rds ': number;
+		};
+	};
+} | {
+	filterID: 1433301837;
+	Fltr: {
+		_name: 'Unsharp Mask';
+		_classID: 'UnsM';
+		Amnt: DescriptorUnitsValue; // %
+		'Rds ': DescriptorUnitsValue;
+		Thsh: number;
+	};
+} | {
+	filterID: 1147564832;
+	Fltr: {
+		_name: 'Diffuse';
+		_classID: 'Dfs ';
+		'Md  ': string;
+		FlRs: number;
+	};
+} | {
+	filterID: 1164796531;
+	Fltr: {
+		_name: 'Emboss';
+		_classID: 'Embs';
+		Angl: number;
+		Hght: number;
+		Amnt: number;
+	};
+} | {
+	filterID: 1165522034;
+	Fltr: {
+		_name: 'Extrude';
+		_classID: 'Extr';
+		ExtS: number;
+		ExtD: number;
+		ExtF: boolean;
+		ExtM: boolean;
+		ExtT: string;
+		ExtR: string;
+		FlRs: number;
+	};
+} | {
+	filterID: 1181639749 | 1399616122;
+} | {
+	filterID: 1416393504;
+	Fltr: {
+		_name: 'Tiles';
+		_classID: 'Tls ';
+		TlNm: number;
+		TlOf: number;
+		FlCl: string;
+		FlRs: number;
+	};
+} | {
+	filterID: 1416782659;
+	Fltr: {
+		_name: 'Trace Contour';
+		_classID: 'TrcC';
+		'Lvl ': number;
+		'Edg ': string;
+	};
+} | {
+	filterID: 1466852384;
+	Fltr: {
+		_name: 'Wind';
+		_classID: 'Wnd ';
+		WndM: string;
+		Drct: string;
+	};
+} | {
+	filterID: 1148089458;
+	Fltr: {
+		_name: 'De-Interlace';
+		_classID: 'Dntr';
+		IntE: string;
+		IntC: string;
+	};
+} | {
+	filterID: 1314149187;
+} | {
+	filterID: 1131639917;
+	Fltr: {
+		_name: 'Custom';
+		_classID: 'Cstm';
+		'Scl ': number;
+		Ofst: number;
+		Mtrx: number[];
+	};
+} | {
+	filterID: 1214736464;
+	Fltr: {
+		_name: 'High Pass';
+		_classID: 'HghP';
+		'Rds ': DescriptorUnitsValue;
+	};
+} | {
+	filterID: 1299737888;
+	Fltr: {
+		_name: 'Maximum';
+		_classID: 'Mxm ';
+		'Rds ': DescriptorUnitsValue;
+	};
+} | {
+	filterID: 1299082528;
+	Fltr: {
+		_name: 'Minimum';
+		_classID: 'Mnm ';
+		'Rds ': DescriptorUnitsValue;
+	};
+} | {
+	filterID: 1332114292;
+	Fltr: {
+		_name: 'Offset';
+		_classID: 'Ofst';
+		Hrzn: number;
+		Vrtc: number;
+		'Fl  ': string;
+	};
+} | {
+	filterID: 991;
+	Fltr: {
+		_name: 'Rigid Transform';
+		_classID: 'rigidTransform';
+		'null': string[]; // [Ordn.Trgt]
 		rigidType: boolean;
-		VrsM: number;
-		VrsN: number;
-		originalVertexArray: Uint8Array;
-		deformedVertexArray: Uint8Array;
-		indexArray: Uint8Array;
-		pinOffsets: number[];
-		posFinalPins: number[];
-		pinVertexIndices: number[];
-		PinP: number[];
-		PnRt: number[];
-		PnOv: boolean[];
-		PnDp: number[];
-		meshQuality: number;
-		meshExpansion: number;
-		meshRigidity: number;
-		imageResolution: number;
-		meshBoundaryPath: {
-			pathComponents: {
-				shapeOperation: string; // shapeOperation.xor
-				SbpL: {
-					Clsp: boolean;
-					'Pts ': {
-						Anch: HrznVrtcDescriptor;
-						'Fwd ': HrznVrtcDescriptor;
-						'Bwd ': HrznVrtcDescriptor;
-						Smoo: boolean;
+		puppetShapeList?: {
+			_name: '';
+			_classID: 'puppetShape';
+			rigidType: boolean;
+			VrsM: number;
+			VrsN: number;
+			originalVertexArray: Uint8Array;
+			deformedVertexArray: Uint8Array;
+			indexArray: Uint8Array;
+			pinOffsets: number[];
+			posFinalPins: number[];
+			pinVertexIndices: number[];
+			PinP: number[];
+			PnRt: number[];
+			PnOv: boolean[];
+			PnDp: number[];
+			meshQuality: number;
+			meshExpansion: number;
+			meshRigidity: number;
+			imageResolution: number;
+			meshBoundaryPath: {
+				_name: '';
+				_classID: 'pathClass';
+				pathComponents: {
+					_name: '';
+					_classID: 'PaCm';
+					shapeOperation: string; // shapeOperation.xor
+					SbpL: {
+						_name: '';
+						_classID: 'Sbpl';
+						Clsp: boolean;
+						'Pts ': {
+							_name: '';
+							_classID: 'Pthp';
+							Anch: HrznVrtcDescriptor;
+							'Fwd ': HrznVrtcDescriptor;
+							'Bwd ': HrznVrtcDescriptor;
+							Smoo: boolean;
+						}[];
 					}[];
 				}[];
-			}[];
-		};
-		selectedPin: number[];
-	}[];
-	PuX0: number;
-	PuX1: number;
-	PuX2: number;
-	PuX3: number;
-	PuY0: number;
-	PuY1: number;
-	PuY2: number;
-	PuY3: number;
+			};
+			selectedPin: number[];
+		}[];
+		PuX0: number;
+		PuX1: number;
+		PuX2: number;
+		PuX3: number;
+		PuY0: number;
+		PuY1: number;
+		PuY2: number;
+		PuY3: number;
+	}
 } | {
-	LqMe: Uint8Array;
-};
+	filterID: 1348620396;
+	Fltr: {
+		_name: 'Oil Paint Plugin';
+		_classID: 'PbPl';
+		KnNm: string;
+		GpuY: boolean;
+		LIWy: boolean;
+		FPth: string;
+		// PNaa: string;
+		// PTaa: number;
+		// PFaa: number;
+		// PNab: string;
+		// PTab: number;
+		// PFab: number;
+		// ...
+	};
+} /*| {
+	filterID: 1282294642;
+	Fltr: {
+		_name: 'Lens Correction',
+		_classID: 'LnCr',
+		LnAg: boolean;
+		LnAc: boolean;
+		LnAv: boolean;
+		LnAs: boolean;
+		LnIp: boolean;
+		LnFo: number;
+		LnPr: string;
+		LnIa: number;
+		LnI0: number;
+		LnI1: number;
+		LnI2: number;
+		LnI3: number;
+		LnRa: number;
+		LnVp: number;
+		LnHp: number;
+		LnSi: number;
+		LnFt: number;
+		LnSb: number;
+		LnSt: number;
+		LnRc: number;
+		LnGm: number;
+		LnBy: number;
+		LnNa: number;
+		LnIh: number;
+		LnIv: number;
+		LnIs: DescriptorColor;
+		LnNm: boolean;
+	};
+}*//* | {
+	filterID: 2089;
+	Fltr: {
+		_name: 'Adaptive Wide Angle';
+		_classID: '22C3EEBF-A978-4ca9-91DF-E4F0CCEE5ACE';
+		actV: number;
+		cnsD?: Uint8Array;
+		prjM: string;
+		regM: string;
+		focL: number;
+		PhyF: number;
+		CrpF: number;
+		imgS: number;
+		imgX: number;
+		imgY: number;
+	};
+}*//* | {
+	filterID: 1195730531;
+	Fltr: {
+			_name: 'Filter Gallery';
+			_classID: 'GEfc';
+		} & ({
+			GEfk: string;
+			Pncl: number;
+			StrP: number;
+			PprB: number;
+		} | ...);
+	};
+}*/ | {
+	filterID: 1215521360;
+	Fltr: {
+		_name: 'HSB/HSL',
+		_classID: 'HsbP',
+		Inpt: string;
+		Otpt: string;
+	};
+} | {
+	filterID: 1122;
+	Fltr: {
+		_name: 'Oil Paint',
+		_classID: 'oilPaint',
+		lightingOn: boolean;
+		stylization: number;
+		cleanliness: number;
+		brushScale: number;
+		microBrush: number;
+		LghD: number;
+		specularity: number;
+	};
+} | {
+	filterID: 1282492025;
+	Fltr: {
+		_name: 'Liquify',
+		_classID: 'LqFy',
+		LqMe: Uint8Array;
+	};
+});
 
 interface SoLdDescriptorFilter {
+	_name: '',
+	_classID: 'filterFXStyle',
 	enab: boolean,
 	validAtPosition: boolean,
 	filterMaskEnable: boolean,
 	filterMaskLinked: boolean,
 	filterMaskExtendWithWhite: boolean,
-	filterFXList: {
-		'Nm  ': string;
-		blendOptions: {
-			Opct: DescriptorUnitsValue;
-			'Md  ': string; // blend mode
-		};
-		enab: boolean;
-		hasoptions: boolean;
-		FrgC: DescriptorColor;
-		BckC: DescriptorColor;
-		Fltr: FltrDescriptor;
-		filterID: number;
-	}[];
+	filterFXList: SoLdDescriptorFilterItem[];
 }
 
 function uint8ToFloat32(array: Uint8Array) {
@@ -1271,59 +1892,545 @@ function hrznVrtcToPoint(desc: HrznVrtcDescriptor) {
 
 function pointToHrznVrtc(point: { x: UnitsValue; y: UnitsValue; }): HrznVrtcDescriptor {
 	return {
+		_name: '',
+		_classID: 'Pnt ',
 		Hrzn: unitsValue(point.x, 'x'),
 		Vrtc: unitsValue(point.y, 'y'),
 	};
 }
 
-function parseFilterFXFilter(Fltr: FltrDescriptor): PlacedLayerPuppetFilter | {} {
-	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(p => ({
-				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(c => ({
-						shapeOperation: c.shapeOperation.split('.')[1],
-						paths: c.SbpL.map(t => ({
-							closed: t.Clsp,
-							points: t['Pts '].map(pt => ({
-								anchor: hrznVrtcToPoint(pt.Anch),
-								forward: hrznVrtcToPoint(pt['Fwd ']),
-								backward: hrznVrtcToPoint(pt['Bwd ']),
-								smooth: pt.Smoo,
+function parseFilterFXItem(f: SoLdDescriptorFilterItem): Filter {
+	const base: Omit<Filter, 'type' | 'filter'> = {
+		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 { ...base, type: 'average' };
+		case 1114403360: return { ...base, type: 'blur' };
+		case 1114403405: return { ...base, type: 'blur more' };
+		case 697: return {
+			...base,
+			type: 'box blur',
+			filter: {
+				radius: parseUnits(f.Fltr['Rds ']),
+			},
+		};
+		case 1198747202: return {
+			...base,
+			type: 'gaussian blur',
+			filter: {
+				radius: parseUnits(f.Fltr['Rds ']),
+			},
+		};
+		case 1299476034: return {
+			...base,
+			type: 'motion blur',
+			filter: {
+				angle: f.Fltr.Angl,
+				distance: parseUnits(f.Fltr.Dstn),
+			},
+		};
+		case 1382313026: return {
+			...base,
+			type: 'radial blur',
+			filter: {
+				amount: f.Fltr.Amnt,
+				method: BlrM.decode(f.Fltr.BlrM),
+				quality: BlrQ.decode(f.Fltr.BlrQ),
+			},
+		};
+		case 702: return {
+			...base,
+			type: 'shape blur',
+			filter: {
+				radius: parseUnits(f.Fltr['Rds ']),
+				customShape: { name: f.Fltr.customShape['Nm  '], id: f.Fltr.customShape.Idnt },
+			},
+		};
+		case 1399681602: return {
+			...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 {
+			...base,
+			type: 'surface blur',
+			filter: {
+				radius: parseUnits(f.Fltr['Rds ']),
+				threshold: f.Fltr.Thsh,
+			},
+		};
+		case 1148416108: return {
+			...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 {
+			...base,
+			type: 'pinch',
+			filter: {
+				amount: f.Fltr.Amnt,
+			},
+		};
+		case 1349284384: return {
+			...base,
+			type: 'polar coordinates',
+			filter: {
+				conversion: Cnvr.decode(f.Fltr.Cnvr),
+			},
+		};
+		case 1383099493: return {
+			...base,
+			type: 'ripple',
+			filter: {
+				amount: f.Fltr.Amnt,
+				size: RplS.decode(f.Fltr.RplS),
+			},
+		};
+		case 1399353888: return {
+			...base,
+			type: 'shear',
+			filter: {
+				shearPoints: f.Fltr.ShrP.map(p => ({ x: p.Hrzn, y: p.Vrtc })),
+				shearStart: f.Fltr.ShrS,
+				shearEnd: f.Fltr.ShrE,
+				undefinedAreas: UndA.decode(f.Fltr.UndA),
+			},
+		};
+		case 1399875698: return {
+			...base,
+			type: 'spherize',
+			filter: {
+				amount: f.Fltr.Amnt,
+				mode: SphM.decode(f.Fltr.SphM),
+			},
+		};
+		case 1417114220: return {
+			...base,
+			type: 'twirl',
+			filter: {
+				angle: f.Fltr.Angl,
+			},
+		};
+		case 1466005093: return {
+			...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 {
+			...base,
+			type: 'zigzag',
+			filter: {
+				amount: f.Fltr.Amnt,
+				ridges: f.Fltr.NmbR,
+				style: ZZTy.decode(f.Fltr.ZZTy),
+			},
+		};
+		case 1097092723: return {
+			...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 { ...base, type: 'despeckle' };
+		case 1148417107: return {
+			...base,
+			type: 'dust and scratches',
+			filter: {
+				radius: f.Fltr['Rds '],
+				threshold: f.Fltr.Thsh,
+			},
+		};
+		case 1298427424: return {
+			...base,
+			type: 'median',
+			filter: {
+				radius: parseUnits(f.Fltr['Rds ']),
+			},
+		};
+		case 633: return {
+			...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(c => ({
+					channels: c.Chnl.map(i => Chnl.decode(i)),
+					amount: c.Amnt,
+					...(c.EdgF ? { preserveDetails: c.EdgF } : {}),
+				})),
+			},
+		};
+		case 1131180616: return {
+			...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 {
+			...base,
+			type: 'crystallize',
+			filter: {
+				cellSize: f.Fltr.ClSz,
+				randomSeed: f.Fltr.FlRs,
+			},
+		};
+		case 1180922912: return { ...base, type: 'facet' };
+		case 1181902701: return { ...base, type: 'fragment' };
+		case 1299870830: return {
+			...base,
+			type: 'mezzotint',
+			filter: {
+				type: MztT.decode(f.Fltr.MztT),
+				randomSeed: f.Fltr.FlRs,
+			},
+		};
+		case 1299407648: return {
+			...base,
+			type: 'mosaic',
+			filter: {
+				cellSize: parseUnits(f.Fltr.ClSz),
+			},
+		};
+		case 1349416044: return {
+			...base,
+			type: 'pointillize',
+			filter: {
+				cellSize: f.Fltr.ClSz,
+				randomSeed: f.Fltr.FlRs,
+			},
+		};
+		case 1131177075: return {
+			...base,
+			type: 'clouds',
+			filter: {
+				randomSeed: f.Fltr.FlRs,
+			},
+		};
+		case 1147564611: return {
+			...base,
+			type: 'difference clouds',
+			filter: {
+				randomSeed: f.Fltr.FlRs,
+			},
+		};
+		case 1180856947: return {
+			...base,
+			type: 'fibers',
+			filter: {
+				variance: f.Fltr.Vrnc,
+				strength: f.Fltr.Strg,
+				randomSeed: f.Fltr.RndS,
+			},
+		};
+		case 1282306886: return {
+			...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 { ...base, type: 'sharpen' };
+		case 1399353925: return { ...base, type: 'sharpen edges' };
+		case 1399353933: return { ...base, type: 'sharpen more' };
+		case 698: return {
+			...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 {
+			...base,
+			type: 'unsharp mask',
+			filter: {
+				amount: parsePercent(f.Fltr.Amnt),
+				radius: parseUnits(f.Fltr['Rds ']),
+				threshold: f.Fltr.Thsh,
+			},
+		};
+		case 1147564832: return {
+			...base,
+			type: 'diffuse',
+			filter: {
+				mode: DfsM.decode(f.Fltr['Md  ']),
+				randomSeed: f.Fltr.FlRs,
+			},
+		};
+		case 1164796531: return {
+			...base,
+			type: 'emboss',
+			filter: {
+				angle: f.Fltr.Angl,
+				height: f.Fltr.Hght,
+				amount: f.Fltr.Amnt,
+			},
+		};
+		case 1165522034: return {
+			...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 { ...base, type: 'find edges' };
+		case 1399616122: return { ...base, type: 'solarize' };
+		case 1416393504: return {
+			...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 {
+			...base,
+			type: 'trace contour',
+			filter: {
+				level: f.Fltr['Lvl '],
+				edge: CntE.decode(f.Fltr['Edg ']),
+			},
+		};
+		case 1466852384: return {
+			...base,
+			type: 'wind',
+			filter: {
+				method: WndM.decode(f.Fltr.WndM),
+				direction: Drct.decode(f.Fltr.Drct),
+			},
+		};
+		case 1148089458: return {
+			...base,
+			type: 'de-interlace',
+			filter: {
+				eliminate: IntE.decode(f.Fltr.IntE),
+				newFieldsBy: IntC.decode(f.Fltr.IntC),
+			},
+		};
+		case 1314149187: return { ...base, type: 'ntsc colors' };
+		case 1131639917: return {
+			...base,
+			type: 'custom',
+			filter: {
+				scale: f.Fltr['Scl '],
+				offset: f.Fltr.Ofst,
+				matrix: f.Fltr.Mtrx,
+			},
+		};
+		case 1214736464: return {
+			...base,
+			type: 'high pass',
+			filter: {
+				radius: parseUnits(f.Fltr['Rds ']),
+			},
+		};
+		case 1299737888: return {
+			...base,
+			type: 'maximum',
+			filter: {
+				radius: parseUnits(f.Fltr['Rds ']),
+			},
+		};
+		case 1299082528: return {
+			...base,
+			type: 'minimum',
+			filter: {
+				radius: parseUnits(f.Fltr['Rds ']),
+			},
+		};
+		case 1332114292: return {
+			...base,
+			type: 'offset',
+			filter: {
+				horizontal: f.Fltr.Hrzn,
+				vertical: f.Fltr.Vrtc,
+				undefinedAreas: FlMd.decode(f.Fltr['Fl  ']),
+			},
+		};
+		case 991: return {
+			...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(p => ({
+					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(c => ({
+							shapeOperation: c.shapeOperation.split('.')[1],
+							paths: c.SbpL.map(t => ({
+								closed: t.Clsp,
+								points: t['Pts '].map(pt => ({
+									anchor: hrznVrtcToPoint(pt.Anch),
+									forward: hrznVrtcToPoint(pt['Fwd ']),
+									backward: hrznVrtcToPoint(pt['Bwd ']),
+									smooth: pt.Smoo,
+								})),
 							})),
 						})),
-					})),
+					},
+				})),
+			},
+		};
+		case 1348620396: {
+			const parameters: { name: string; value: number; }[] = [];
+			const Flrt = f.Fltr as any;
+
+			for (let i = 0; i < fromAtoZ.length; i++) {
+				if (!Flrt[`PN${fromAtoZ[i]}a`]) break;
+
+				for (let j = 0; j < fromAtoZ.length; j++) {
+					if (!Flrt[`PN${fromAtoZ[i]}${fromAtoZ[j]}`]) break;
+
+					parameters.push({
+						name: Flrt[`PN${fromAtoZ[i]}${fromAtoZ[j]}`],
+						value: Flrt[`PF${fromAtoZ[i]}${fromAtoZ[j]}`]
+					});
+				}
+			}
+
+			return {
+				...base,
+				type: 'oil paint plugin',
+				filter: {
+					name: f.Fltr.KnNm,
+					gpu: f.Fltr.GpuY,
+					lighting: f.Fltr.LIWy,
+					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 {
+			...base,
+			type: 'hsb/hsl',
+			filter: {
+				inputMode: ClrS.decode(f.Fltr.Inpt) as any,
+				rowOrder: ClrS.decode(f.Fltr.Otpt) as any,
+			},
 		};
-	} else {
-		return {
+		case 1122: return {
+			...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 {
+				...base,
+				type: 'liquify',
+				filter: {
+					liquifyMesh: f.Fltr.LqMe,
+				},
+			};
+		}
+		default:
+			throw new Error(`Unknown filterID: ${(f as any).filterID}`);
 	}
 }
 
@@ -1334,98 +2441,653 @@ function parseFilterFX(desc: SoLdDescriptorFilter): PlacedLayerFilter {
 		maskEnabled: desc.filterMaskEnable,
 		maskLinked: desc.filterMaskLinked,
 		maskExtendWithWhite: desc.filterMaskExtendWithWhite,
-		list: desc.filterFXList.map(f => ({
-			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: PlacedLayerPuppetFilter | {}): FltrDescriptor {
-	if ('puppetShapeList' in filter) {
-		return {
-			'null': ['Ordn.Trgt'], // ???
-			rigidType: filter.rigidType,
-			puppetShapeList: filter.puppetShapeList.map(p => ({
-				rigidType: p.rigidType,
-				VrsM: 1, // TODO: ...
-				VrsN: 0, // TODO: ...
-				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(c => ({
-						shapeOperation: `shapeOperation.${c.shapeOperation}`,
-						SbpL: (c.paths || []).map(path => ({
-							Clsp: path.closed,
-							'Pts ': (path.points || []).map(pt => ({
-								Anch: pointToHrznVrtc(pt.anchor),
-								'Fwd ': pointToHrznVrtc(pt.forward),
-								'Bwd ': pointToHrznVrtc(pt.backward),
-								Smoo: pt.smooth,
+function uvRadius(t: { radius: UnitsValue; }) {
+	return unitsValue(t.radius, 'radius');
+}
+
+function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
+	const base: Omit<SoLdDescriptorFilterItem, 'filterID' | 'filter'> = {
+		_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 { ...base, filterID: 1098281575 };
+		case 'blur': return { ...base, filterID: 1114403360 };
+		case 'blur more': return { ...base, filterID: 1114403405 };
+		case 'box blur': return {
+			...base,
+			Fltr: {
+				_name: 'Box Blur',
+				_classID: 'boxblur',
+				'Rds ': uvRadius(f.filter),
+			},
+			filterID: 697,
+		};
+		case 'gaussian blur': return {
+			...base,
+			Fltr: {
+				_name: 'Gaussian Blur',
+				_classID: 'GsnB',
+				'Rds ': uvRadius(f.filter),
+			},
+			filterID: 1198747202,
+		};
+		case 'motion blur': return {
+			...base,
+			Fltr: {
+				_name: 'Motion Blur',
+				_classID: 'MtnB',
+				Angl: f.filter.angle,
+				Dstn: unitsValue(f.filter.distance, 'distance'),
+			},
+			filterID: 1299476034,
+		};
+		case 'radial blur': return {
+			...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 {
+			...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 {
+			...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 {
+			...base,
+			Fltr: {
+				_name: 'Surface Blur',
+				_classID: 'surfaceBlur',
+				'Rds ': uvRadius(f.filter),
+				Thsh: f.filter.threshold,
+			},
+			filterID: 701,
+		};
+		case 'displace': return {
+			...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 {
+			...base,
+			Fltr: {
+				_name: 'Pinch',
+				_classID: 'Pnch',
+				Amnt: f.filter.amount,
+			},
+			filterID: 1349411688,
+		};
+		case 'polar coordinates': return {
+			...base,
+			Fltr: {
+				_name: 'Polar Coordinates',
+				_classID: 'Plr ',
+				Cnvr: Cnvr.encode(f.filter.conversion),
+			},
+			filterID: 1349284384,
+		};
+		case 'ripple': return {
+			...base,
+			Fltr: {
+				_name: 'Ripple',
+				_classID: 'Rple',
+				Amnt: f.filter.amount,
+				RplS: RplS.encode(f.filter.size),
+			},
+			filterID: 1383099493,
+		};
+		case 'shear': return {
+			...base,
+			Fltr: {
+				_name: 'Shear',
+				_classID: 'Shr ',
+				ShrP: f.filter.shearPoints.map(p => ({ _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 {
+			...base,
+			Fltr: {
+				_name: 'Spherize',
+				_classID: 'Sphr',
+				Amnt: f.filter.amount,
+				SphM: SphM.encode(f.filter.mode),
+			},
+			filterID: 1399875698,
+		};
+		case 'twirl': return {
+			...base,
+			Fltr: {
+				_name: 'Twirl',
+				_classID: 'Twrl',
+				Angl: f.filter.angle,
+			},
+			filterID: 1417114220,
+		};
+		case 'wave': return {
+			...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 {
+			...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 {
+			...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 { ...base, filterID: 1148416099 };
+		case 'dust and scratches': return {
+			...base,
+			Fltr: {
+				_name: 'Dust & Scratches',
+				_classID: 'DstS',
+				'Rds ': f.filter.radius,
+				Thsh: f.filter.threshold,
+			},
+			filterID: 1148417107,
+		};
+		case 'median': return {
+			...base,
+			Fltr: {
+				_name: 'Median',
+				_classID: 'Mdn ',
+				'Rds ': uvRadius(f.filter),
+			},
+			filterID: 1298427424,
+		};
+		case 'reduce noise': return {
+			...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(c => ({
+					_name: '',
+					_classID: 'channelDenoiseParams',
+					Chnl: c.channels.map(i => Chnl.encode(i)),
+					Amnt: c.amount,
+					...(c.preserveDetails ? { EdgF: c.preserveDetails } : {}),
+				})),
+				preset: f.filter.preset,
+			},
+			filterID: 633,
+		};
+		case 'color halftone': return {
+			...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 {
+			...base,
+			Fltr: {
+				_name: 'Crystallize',
+				_classID: 'Crst',
+				ClSz: f.filter.cellSize,
+				FlRs: f.filter.randomSeed,
+			},
+			filterID: 1131574132,
+		};
+		case 'facet': return { ...base, filterID: 1180922912 };
+		case 'fragment': return { ...base, filterID: 1181902701 };
+		case 'mezzotint': return {
+			...base,
+			Fltr: {
+				_name: 'Mezzotint',
+				_classID: 'Mztn',
+				MztT: MztT.encode(f.filter.type),
+				FlRs: f.filter.randomSeed,
+			},
+			filterID: 1299870830,
+		};
+		case 'mosaic': return {
+			...base,
+			Fltr: {
+				_name: 'Mosaic',
+				_classID: 'Msc ',
+				ClSz: unitsValue(f.filter.cellSize, 'cellSize'),
+			},
+			filterID: 1299407648,
+		};
+		case 'pointillize': return {
+			...base,
+			Fltr: {
+				_name: 'Pointillize',
+				_classID: 'Pntl',
+				ClSz: f.filter.cellSize,
+				FlRs: f.filter.randomSeed,
+			},
+			filterID: 1349416044,
+		};
+		case 'clouds': return {
+			...base,
+			Fltr: {
+				_name: 'Clouds',
+				_classID: 'Clds',
+				FlRs: f.filter.randomSeed,
+			},
+			filterID: 1131177075,
+		};
+		case 'difference clouds': return {
+			...base,
+			Fltr: {
+				_name: 'Difference Clouds',
+				_classID: 'DfrC',
+				FlRs: f.filter.randomSeed,
+			},
+			filterID: 1147564611,
+		};
+		case 'fibers': return {
+			...base,
+			Fltr: {
+				_name: 'Fibers',
+				_classID: 'Fbrs',
+				Vrnc: f.filter.variance,
+				Strg: f.filter.strength,
+				RndS: f.filter.randomSeed,
+			},
+			filterID: 1180856947,
+		};
+		case 'lens flare': return {
+			...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 { ...base, filterID: 1399353968 };
+		case 'sharpen edges': return { ...base, filterID: 1399353925 };
+		case 'sharpen more': return { ...base, filterID: 1399353933 };
+		case 'smart sharpen': return {
+			...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 {
+			...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 {
+			...base,
+			Fltr: {
+				_name: 'Diffuse',
+				_classID: 'Dfs ',
+				'Md  ': DfsM.encode(f.filter.mode),
+				FlRs: f.filter.randomSeed,
+			},
+			filterID: 1147564832,
+		};
+		case 'emboss': return {
+			...base,
+			Fltr: {
+				_name: 'Emboss',
+				_classID: 'Embs',
+				Angl: f.filter.angle,
+				Hght: f.filter.height,
+				Amnt: f.filter.amount,
+			},
+			filterID: 1164796531,
+		};
+		case 'extrude': return {
+			...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 { ...base, filterID: 1181639749 };
+		case 'solarize': return { ...base, filterID: 1399616122 };
+		case 'tiles': return {
+			...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 {
+			...base,
+			Fltr: {
+				_name: 'Trace Contour',
+				_classID: 'TrcC',
+				'Lvl ': f.filter.level,
+				'Edg ': CntE.encode(f.filter.edge),
+			},
+			filterID: 1416782659,
+		};
+		case 'wind': return {
+			...base,
+			Fltr: {
+				_name: 'Wind',
+				_classID: 'Wnd ',
+				WndM: WndM.encode(f.filter.method),
+				Drct: Drct.encode(f.filter.direction),
+			},
+			filterID: 1466852384,
+		};
+		case 'de-interlace': return {
+			...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 { ...base, filterID: 1314149187 };
+		case 'custom': return {
+			...base,
+			Fltr: {
+				_name: 'Custom',
+				_classID: 'Cstm',
+				'Scl ': f.filter.scale,
+				Ofst: f.filter.offset,
+				Mtrx: f.filter.matrix,
+			},
+			filterID: 1131639917,
+		};
+		case 'high pass': return {
+			...base,
+			Fltr: {
+				_name: 'High Pass',
+				_classID: 'HghP',
+				'Rds ': uvRadius(f.filter),
+			},
+			filterID: 1214736464,
+		};
+		case 'maximum': return {
+			...base,
+			Fltr: {
+				_name: 'Maximum',
+				_classID: 'Mxm ',
+				'Rds ': uvRadius(f.filter),
+			},
+			filterID: 1299737888,
+		};
+		case 'minimum': return {
+			...base,
+			Fltr: {
+				_name: 'Minimum',
+				_classID: 'Mnm ',
+				'Rds ': uvRadius(f.filter),
+			},
+			filterID: 1299082528,
+		};
+		case 'offset': return {
+			...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 {
+			...base,
+			Fltr: {
+				_name: 'Rigid Transform',
+				_classID: 'rigidTransform',
+				'null': ['Ordn.Trgt'], // TODO: ???
+				rigidType: f.filter.rigidType,
+				puppetShapeList: f.filter.puppetShapeList.map(p => ({
+					_name: '',
+					_classID: 'puppetShape',
+					rigidType: p.rigidType,
+					VrsM: 1, // TODO: ???
+					VrsN: 0, // TODO: ???
+					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(c => ({
+							_name: '',
+							_classID: 'PaCm',
+							shapeOperation: `shapeOperation.${c.shapeOperation}`,
+							SbpL: c.paths.map(path => ({
+								_name: '',
+								_classID: 'Sbpl',
+								Clsp: path.closed,
+								'Pts ': path.points.map(pt => ({
+									_name: '',
+									_classID: 'Pthp',
+									Anch: pointToHrznVrtc(pt.anchor),
+									'Fwd ': pointToHrznVrtc(pt.forward),
+									'Bwd ': pointToHrznVrtc(pt.backward),
+									Smoo: pt.smooth,
+								})),
 							})),
 						})),
-					})),
+					},
+					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': {
+			const params: any = {};
+
+			for (let i = 0; i < f.filter.parameters.length; i++) {
+				const { name, value } = f.filter.parameters[i];
+				const suffix = `${fromAtoZ[Math.floor(i / fromAtoZ.length)]}${fromAtoZ[i % fromAtoZ.length]}`;
+				params[`PN${suffix}`] = name;
+				params[`PT${suffix}`] = 0;
+				params[`PF${suffix}`] = value;
+			}
+
+			return {
+				...base,
+				Fltr: {
+					_name: 'Oil Paint Plugin',
+					_classID: 'PbPl',
+					KnNm: f.filter.name,
+					GpuY: f.filter.gpu,
+					LIWy: f.filter.lighting,
+					FPth: '1',
+					...params,
 				},
-			})),
-			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(),
+				filterID: 1348620396,
+			};
+		}
+		case 'oil paint': return {
+			...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 {
+			...base,
+			Fltr: {
+				_name: 'Liquify',
+				_classID: 'LqFy',
+				LqMe: f.filter.liquifyMesh,
+			},
+			filterID: 1282492025,
+		};
+		default: throw new Error(`Unknow filter type: ${(f as any).type}`);
 	}
 }
 
-function serializeFilterFX(filter: PlacedLayerFilter): SoLdDescriptorFilter {
-	return {
-		enab: filter.enabled,
-		validAtPosition: filter.validAtPosition,
-		filterMaskEnable: filter.maskEnabled,
-		filterMaskLinked: filter.maskLinked,
-		filterMaskExtendWithWhite: filter.maskExtendWithWhite,
-		filterFXList: (filter.list || []).map(f => ({
-			'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,
-		})),
-	};
-}
-
 interface SoLdDescriptor {
 	Idnt: string;
 	placed: string;
@@ -1441,7 +3103,7 @@ interface SoLdDescriptor {
 	nonAffineTransform: number[];
 	quiltWarp?: QuiltWarpDescriptor;
 	warp: WarpDescriptor;
-	'Sz  ': { Wdth: number; Hght: number; };
+	'Sz  ': { _name: '', _classID: 'Pnt ', Wdth: number; Hght: number; };
 	Rslt: DescriptorUnitsValue;
 	filterFX?: SoLdDescriptorFilter;
 	comp?: number;
@@ -1449,6 +3111,8 @@ interface SoLdDescriptor {
 	Impr?: {}; // ???
 }
 
+// let t: any;
+
 addHandler(
 	'SoLd',
 	hasKey('placedLayer'),
@@ -1461,7 +3125,9 @@ addHandler(
 		// 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,
@@ -1469,8 +3135,8 @@ addHandler(
 			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,
@@ -1485,9 +3151,16 @@ addHandler(
 
 		if (desc.Crop) 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
 	},
 	(writer, target) => {
@@ -1508,16 +3181,38 @@ addHandler(
 			Type: placedLayerTypes.indexOf(placed.type),
 			Trnf: placed.transform,
 			nonAffineTransform: placed.nonAffineTransform ?? placed.transform,
-			quiltWarp: {} as any,
+			// quiltWarp: {} as any,
 			warp: encodeWarp(placed.warp || {}),
 			'Sz  ': {
+				_name: '',
+				_classID: 'Pnt ',
 				Wdth: placed.width || 0, // TODO: find size ?
 				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(f => 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)) {
 			const quiltWarp = encodeWarp(placed.warp) as QuiltWarpDescriptor;
@@ -1728,7 +3423,15 @@ addHandler(
 
 			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) {
 				const year = readInt32(reader);
@@ -1785,7 +3488,10 @@ addHandler(
 
 			if (file.descriptor && file.descriptor.compInfo) {
 				const desc: FileOpenDescriptor = {
-					compInfo: file.descriptor.compInfo,
+					compInfo: {
+						compID: file.descriptor.compInfo.compID,
+						originalCompID: file.descriptor.compInfo.originalCompID,
+					}
 				};
 
 				writeUint8(writer, 1);
@@ -2759,6 +4465,103 @@ addHandler(
 	},
 );
 
+addHandler(
+	'FEid',
+	hasKey('filterEffectsMasks'),
+	(reader, target, leftBytes) => {
+		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;
+		target.filterEffectsMasks = [];
+
+		while (reader.offset < end) {
+			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: ({ compressionMode: number; data: Uint8Array; } | undefined)[] = [];
+
+			// 0 -> R, 1 -> G, 2 -> B, 25 -> A
+			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({ compressionMode, data });
+				} else {
+					channels.push(undefined);
+				}
+			}
+
+			target.filterEffectsMasks.push({ id, top, left, bottom, right, depth, channels });
+
+			if (leftBytes() && readUint8(reader)) {
+				const compressionMode = readUint16(reader);
+				const data = readBytes(reader, leftBytes());
+				target.filterEffectsMasks[target.filterEffectsMasks.length - 1].extra = { compressionMode, data };
+			}
+		}
+	},
+	(writer, target) => {
+		writeInt32(writer, 3);
+		writeUint32(writer, 0);
+		writeUint32(writer, 0);
+		const lengthOffset = writer.offset;
+
+		for (const mask of target.filterEffectsMasks!) {
+			writePascalString(writer, mask.id, 1);
+			writeInt32(writer, 1);
+			writeUint32(writer, 0);
+			writeUint32(writer, 0);
+			const length2Offset = writer.offset;
+			writeInt32(writer, mask.top);
+			writeInt32(writer, mask.left);
+			writeInt32(writer, mask.bottom);
+			writeInt32(writer, mask.right);
+			writeInt32(writer, mask.depth);
+			const maxChannels = Math.max(0, mask.channels.length - 2);
+			writeInt32(writer, maxChannels);
+
+			for (let i = 0; i < (maxChannels + 2); i++) {
+				const 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);
+		}
+
+		const extra = target.filterEffectsMasks![target.filterEffectsMasks!.length - 1]?.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'),
@@ -2871,14 +4674,18 @@ addHandler(
 		const desc = readVersionAndDescriptor(reader) as CinfDescriptor;
 		// console.log(require('util').inspect(desc, false, 99, true));
 
+		function enumValue(desc: string): string {
+			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());
@@ -2959,85 +4766,3 @@ addHandler(
 		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');*/