ag-psd 15.2.0 → 15.3.0

package/src/additionalInfo.ts

@@ -8,7 +8,7 @@ import {
 	SelectiveColorAdjustment, ColorLookupAdjustment, LevelsAdjustmentChannel, LevelsAdjustment,
 	CurvesAdjustment, CurvesAdjustmentChannel, HueSaturationAdjustment, HueSaturationAdjustmentChannel,
 	PresetInfo, Color, ColorBalanceValues, WriteOptions, LinkedFile, PlacedLayerType, Warp, KeyDescriptorItem,
-	BooleanOperation, LayerEffectsInfo, Annotation, LayerVectorMask, AnimationFrame, Timeline,
+	BooleanOperation, LayerEffectsInfo, Annotation, LayerVectorMask, AnimationFrame, Timeline, PlacedLayerFilter, UnitsValue,
 } from './psd';
 import {
 	PsdReader, readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16,
@@ -26,7 +26,8 @@ import {
 	unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor,
 	readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor,
 	FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects,
-	parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, FractionDescriptor,
+	parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList,
+	serializeTrackList, FractionDescriptor,
 } from './descriptor';
 import { serializeEngineData, parseEngineData } from './engineData';
 import { encodeEngineData, decodeEngineData } from './text';
@@ -1151,6 +1152,256 @@ addHandler(
 	},
 );
 
+interface HrznVrtcDescriptor {
+	Hrzn: DescriptorUnitsValue;
+	Vrtc: DescriptorUnitsValue;
+}
+
+interface SoLdDescriptorFilter {
+	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: {
+			'null': string[]; // [Ordn.Trgt]
+			rigidType: boolean;
+			puppetShapeList: {
+				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;
+							}[];
+						}[];
+					}[];
+				};
+				selectedPin: number[];
+			}[];
+			PuX0: number;
+			PuX1: number;
+			PuX2: number;
+			PuX3: number;
+			PuY0: number;
+			PuY1: number;
+			PuY2: number;
+			PuY3: number;
+		};
+		filterID: number;
+	}[];
+}
+
+function uint8ToFloat32(array: Uint8Array) {
+	return new Float32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+}
+
+function uint8ToUint32(array: Uint8Array) {
+	return new Uint32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+}
+
+function toUint8(array: Uint32Array | Float32Array) {
+	return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+}
+
+function arrayToPoints(array: number[] | Uint32Array | Float32Array) {
+	const points: { x: number; y: number }[] = [];
+
+	for (let i = 0; i < array.length; i += 2) {
+		points.push({ x: array[i], y: array[i + 1] });
+	}
+
+	return points;
+}
+
+function pointsToArray(points: { x: number; y: number }[]) {
+	const array: number[] = [];
+	for (let i = 0; i < points.length; i++) {
+		array.push(points[i].x, points[i].y);
+	}
+	return array;
+}
+
+function uin8ToPoints(array: Uint8Array) {
+	return arrayToPoints(uint8ToFloat32(array));
+}
+
+function hrznVrtcToPoint(desc: HrznVrtcDescriptor) {
+	return {
+		x: parseUnits(desc.Hrzn),
+		y: parseUnits(desc.Vrtc),
+	};
+}
+
+function pointToHrznVrtc(point: { x: UnitsValue; y: UnitsValue; }): HrznVrtcDescriptor {
+	return {
+		Hrzn: unitsValue(point.x, 'x'),
+		Vrtc: unitsValue(point.y, 'y'),
+	};
+}
+
+function parseFilterFX(desc: SoLdDescriptorFilter): PlacedLayerFilter {
+	return {
+		enabled: desc.enab,
+		validAtPosition: desc.validAtPosition,
+		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: {
+				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: uin8ToPoints(p.originalVertexArray),
+					deformedVertexArray: uin8ToPoints(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 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: {
+				'null': ['Ordn.Trgt'], // ???
+				rigidType: f.filter.rigidType,
+				puppetShapeList: f.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,
+								})),
+							})),
+						})),
+					},
+				})),
+				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: f.id,
+		})),
+	};
+}
+
 interface SoLdDescriptor {
 	Idnt: string;
 	placed: string;
@@ -1168,8 +1419,10 @@ interface SoLdDescriptor {
 	warp: WarpDescriptor;
 	'Sz  ': { Wdth: number; Hght: number; };
 	Rslt: DescriptorUnitsValue;
+	filterFX?: SoLdDescriptorFilter;
 	comp?: number;
 	compInfo?: { compID: number; originalCompID: number; };
+	Impr?: {}; // ???
 }
 
 addHandler(
@@ -1183,6 +1436,8 @@ addHandler(
 		// console.log('SoLd', require('util').inspect(desc, false, 99, true));
 		// 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));
 
 		target.placedLayer = {
 			id: desc.Idnt,
@@ -1207,6 +1462,7 @@ 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.filterFX) target.placedLayer.filter = parseFilterFX(desc.filterFX);
 
 		skipBytes(reader, left()); // HACK
 	},
@@ -1237,6 +1493,8 @@ addHandler(
 			Rslt: placed.resolution ? unitsValue(placed.resolution, 'resolution') : { units: 'Density', value: 72 },
 		};
 
+		if (placed.filter) desc.filterFX = serializeFilterFX(placed.filter);
+
 		if (placed.warp && isQuiltWarp(placed.warp)) {
 			const quiltWarp = encodeWarp(placed.warp) as QuiltWarpDescriptor;
 			desc.quiltWarp = quiltWarp;
@@ -2677,3 +2935,85 @@ 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');*/

package/src/descriptor.ts

@@ -121,6 +121,15 @@ const fieldToExtType: ExtTypeDict = {
 	'Lnk ': makeType('', 'ExternalFileLink'),
 	frameReader: makeType('', 'FrameReader'),
 	effectParams: makeType('', 'motionTrackEffectParams'),
+	Impr: makeType('None', 'none'),
+	Anch: makeType('', 'Pnt '),
+	'Fwd ': makeType('', 'Pnt '),
+	'Bwd ': makeType('', 'Pnt '),
+	meshBoundaryPath: makeType('', 'pathClass'),
+	filterFX: makeType('', 'filterFXStyle'),
+	Fltr: makeType('', 'rigidTransform'),
+	FrgC: makeType('', 'RGBC'),
+	BckC: makeType('', 'RGBC'),
 };
 
 const fieldToArrayExtType: ExtTypeDict = {
@@ -145,6 +154,11 @@ const fieldToArrayExtType: ExtTypeDict = {
 	countObjectList: makeType('', 'countObject'),
 	countGroupList: makeType('', 'countGroup'),
 	slices: makeType('', 'slice'),
+	'Pts ': makeType('', 'Pthp'),
+	SbpL: makeType('', 'SbpL'),
+	pathComponents: makeType('', 'PaCm'),
+	filterFXList: makeType('', 'filterFX'),
+	puppetShapeList: makeType('', 'puppetShape'),
 };
 
 const typeToField: { [key: string]: string[]; } = {
@@ -154,7 +168,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
 		'altTag', 'url', 'cellText',
 	],
-	'tdta': ['EngineData', 'LUT3DFileData'],
+	'tdta': ['EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray'],
 	'long': [
 		'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
 		'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
@@ -164,7 +178,8 @@ const typeToField: { [key: string]: string[]; } = {
 		'numModifyingFX', 'deformNumRows', 'deformNumCols', 'FrID', 'FrDl', 'FsID', 'LCnt', 'AFrm', 'AFSt',
 		'numBefore', 'numAfter', 'Spcn', 'minOpacity', 'maxOpacity', 'BlnM', 'sheetID', 'gblA', 'globalAltitude',
 		'descVersion', 'frameReaderType', 'LyrI', 'zoomOrigin', 'fontSize', 'Rds ', 'sliceID',
-		'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset',
+		'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset', 'filterID', 'meshQuality',
+		'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN',
 	],
 	'enum': [
 		'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS',
@@ -173,7 +188,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'strokeStyleBlendMode', 'PntT', 'Styl', 'lookupType', 'LUTFormat', 'dataOrder',
 		'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
 		'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
-		'vertAlign', 'bgColorType',
+		'vertAlign', 'bgColorType', 'shapeOperation',
 	],
 	'bool': [
 		'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -184,13 +199,15 @@ const typeToField: { [key: string]: string[]; } = {
 		'autoExpandEnabled', 'autoNestEnabled', 'autoPositionEnabled', 'shrinkwrapOnSaveEnabled',
 		'present', 'showInDialog', 'overprint', 'sheetDisclosed', 'lightsDisclosed', 'meshesDisclosed',
 		'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
-		'cellTextIsHTML',
+		'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
+		'filterMaskLinked', 'filterMaskExtendWithWhite',
 	],
 	'doub': [
 		'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
 		'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
 		'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
-		'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat',
+		'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
+		'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
 	],
 	'UntF': [
 		'Scl ', 'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -203,7 +220,8 @@ const typeToField: { [key: string]: string[]; } = {
 		'LaSt', 'Trnf', 'nonAffineTransform', 'keyDescriptorList', 'guideIndeces', 'gradientFillMulti',
 		'solidFillMulti', 'frameFXMulti', 'innerShadowMulti', 'dropShadowMulti', 'FrIn', 'FSts', 'FsFr',
 		'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
-		'warpValues',
+		'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
+		'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList',
 	],
 	'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
 	'obj ': ['null'],
@@ -216,24 +234,37 @@ const channels = [
 const fieldToArrayType: Dict = {
 	'Mnm ': 'long',
 	'Mxm ': 'long',
-	'FrLs': 'long',
-	'strokeStyleLineDashSet': 'UntF',
-	'Trnf': 'doub',
-	'nonAffineTransform': 'doub',
-	'keyDescriptorList': 'Objc',
-	'gradientFillMulti': 'Objc',
-	'solidFillMulti': 'Objc',
-	'frameFXMulti': 'Objc',
-	'innerShadowMulti': 'Objc',
-	'dropShadowMulti': 'Objc',
-	'LaSt': 'Objc',
-	'FrIn': 'Objc',
-	'FSts': 'Objc',
-	'FsFr': 'long',
-	'blendOptions': 'Objc',
-	'sheetTimelineOptions': 'Objc',
-	'keyList': 'Objc',
-	'warpValues': 'doub',
+	FrLs: 'long',
+	strokeStyleLineDashSet: 'UntF',
+	Trnf: 'doub',
+	nonAffineTransform: 'doub',
+	keyDescriptorList: 'Objc',
+	gradientFillMulti: 'Objc',
+	solidFillMulti: 'Objc',
+	frameFXMulti: 'Objc',
+	innerShadowMulti: 'Objc',
+	dropShadowMulti: 'Objc',
+	LaSt: 'Objc',
+	FrIn: 'Objc',
+	FSts: 'Objc',
+	FsFr: 'long',
+	blendOptions: 'Objc',
+	sheetTimelineOptions: 'Objc',
+	keyList: 'Objc',
+	warpValues: 'doub',
+	selectedPin: 'long',
+	'Pts ': 'Objc',
+	SbpL: 'Objc',
+	pathComponents: 'Objc',
+	pinOffsets: 'doub',
+	posFinalPins: 'doub',
+	pinVertexIndices: 'long',
+	PinP: 'doub',
+	PnRt: 'long',
+	PnOv: 'bool',
+	PnDp: 'doub',
+	filterFXList: 'Objc',
+	puppetShapeList: 'Objc',
 };
 
 const fieldToType: Dict = {};
@@ -494,7 +525,7 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 			for (let i = 0; i < value.length; i++) {
 				const type = fieldToArrayType[key];
 				writeSignature(writer, type || 'long');
-				writeOSType(writer, type || 'long', value[i], '', fieldToArrayExtType[key], root);
+				writeOSType(writer, type || 'long', value[i], `${key}[]`, fieldToArrayExtType[key], root);
 				if (logErrors && !type) console.log(`Missing descriptor array type for: '${key}' in`, value);
 			}
 			break;

package/src/psd.ts

@@ -674,6 +674,62 @@ export interface LinkedFile {
 	assetLockedState?: number;
 }
 
+export interface PlacedLayerFilter {
+	enabled: boolean;
+	validAtPosition: boolean;
+	maskEnabled: boolean;
+	maskLinked: boolean;
+	maskExtendWithWhite: boolean;
+	list: {
+		id: number;
+		name: string;
+		opacity: number;
+		blendMode: BlendMode;
+		enabled: boolean;
+		hasOptions: boolean;
+		foregroundColor: Color;
+		backgroundColor: Color;
+		filter: {
+			rigidType: boolean;
+			bounds: { x: number; y: number; }[];
+			puppetShapeList: {
+				rigidType: boolean;
+				// VrsM: number;
+				// VrsN: number;
+				originalVertexArray: { x: number; y: number; }[];
+				deformedVertexArray: { x: number; y: number; }[];
+				indexArray: number[];
+				pinOffsets: { x: number; y: number; }[];
+				posFinalPins: { x: number; y: number; }[];
+				pinVertexIndices: number[];
+				selectedPin: number[];
+				pinPosition: { x: number; y: number; }[];
+				pinRotation: number[]; // in degrees
+				pinOverlay: boolean[];
+				pinDepth: number[];
+				meshQuality: number;
+				meshExpansion: number;
+				meshRigidity: number;
+				imageResolution: number;
+				meshBoundaryPath: {
+					pathComponents: {
+						shapeOperation: string;
+						paths: {
+							closed: boolean;
+							points: {
+								anchor: { x: UnitsValue; y: UnitsValue; };
+								forward: { x: UnitsValue; y: UnitsValue; };
+								backward: { x: UnitsValue; y: UnitsValue; };
+								smooth: boolean;
+							}[];
+						}[];
+					}[];
+				};
+			}[];
+		};
+	}[];
+}
+
 export type PlacedLayerType = 'unknown' | 'vector' | 'raster' | 'image stack';
 
 export interface PlacedLayer {
@@ -695,6 +751,7 @@ export interface PlacedLayer {
 	crop?: number;
 	comp?: number;
 	compInfo?: { compID: number; originalCompID: number; };
+	filter?: PlacedLayerFilter;
 }
 
 export type AdjustmentLayer = BrightnessAdjustment | LevelsAdjustment | CurvesAdjustment |
@@ -894,6 +951,7 @@ export interface LayerAdditionalInfo {
 		unifyLayerVisibility?: boolean;
 	};
 	timeline?: Timeline;
+	filterEffects?: any;
 
 	// Base64 encoded raw EngineData, currently just kept in original state to support
 	// loading and modifying PSD file without breaking text layers.