ag-psd 23.1.1 → 25.0.0

package/src/additionalInfo.ts

@@ -4,7 +4,7 @@ import { clamp, createEnum, layerColors, MOCK_HANDLERS } from './helpers';
 import { LayerAdditionalInfo, BezierPath, Psd, BrightnessAdjustment, ExposureAdjustment, VibranceAdjustment, ColorBalanceAdjustment, BlackAndWhiteAdjustment, PhotoFilterAdjustment, ChannelMixerChannel, ChannelMixerAdjustment, PosterizeAdjustment, ThresholdAdjustment, GradientMapAdjustment, CMYK, SelectiveColorAdjustment, ColorLookupAdjustment, LevelsAdjustmentChannel, LevelsAdjustment, CurvesAdjustment, CurvesAdjustmentChannel, HueSaturationAdjustment, HueSaturationAdjustmentChannel, PresetInfo, Color, ColorBalanceValues, WriteOptions, LinkedFile, PlacedLayerType, Warp, KeyDescriptorItem, BooleanOperation, LayerEffectsInfo, Annotation, LayerVectorMask, AnimationFrame, Timeline, PlacedLayerFilter, UnitsValue, Filter, PlacedLayer, ReadOptions } from './psd';
 import { PsdReader, readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16, readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32, readPascalString, readUnicodeStringWithLength, readAsciiString, readPattern, readLayerInfo } from './psdReader';
 import { PsdWriter, writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32 } from './psdWriter';
-import { Annt, BlnM, DescriptorColor, DescriptorUnitsValue, parsePercent, parseUnits, parseUnitsOrNumber, QuiltWarpDescriptor, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, TextDescriptor, textGridding, unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor, FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, 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 { Annt, BlnM, DescriptorColor, DescriptorUnitsValue, parsePercent, parseUnits, parseUnitsOrNumber, QuiltWarpDescriptor, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, TextDescriptor, textGridding, unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor, FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, 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, presetKindType } from './descriptor';
 import { serializeEngineData, parseEngineData } from './engineData';
 import { encodeEngineData, decodeEngineData } from './text';
 
@@ -357,6 +357,17 @@ addHandler(
 addHandlerAlias('vsms', 'vmsk');
 // addHandlerAlias('vmsk', 'vsms');
 
+addHandler(
+	'vowv', // something with vectors?
+	hasKey('vowv'),
+	(reader, target) => {
+		target.vowv = readUint32(reader); // always 2 ????
+	},
+	(writer, target) => {
+		writeUint32(writer, target.vowv!);
+	},
+);
+
 interface VogkDescriptor {
 	keyDescriptorList: {
 		keyShapeInvalidated?: boolean;
@@ -581,7 +592,9 @@ addHandler(
 addHandler(
 	'lyid',
 	hasKey('id'),
-	(reader, target) => target.id = readUint32(reader),
+	(reader, target) => {
+		target.id = readUint32(reader);
+	},
 	(writer, target, _psd, options) => {
 		let id = target.id!;
 		while (options.layerIds.has(id)) id += 100; // make sure we don't have duplicate layer ids
@@ -731,9 +744,8 @@ interface CmlsDescriptor {
 }
 
 addHandler(
-	'shmd',
-	target => target.timestamp !== undefined || target.animationFrames !== undefined ||
-		target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined,
+	'shmd', // Metadata setting
+	target => target.timestamp !== undefined || target.animationFrames !== undefined || target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined,
 	(reader, target, left) => {
 		const count = readUint32(reader);
 
@@ -824,6 +836,7 @@ addHandler(
 					}
 
 					const desc = readVersionAndDescriptor(reader) as ExtnDescriptor;
+					// console.log(require('util').inspect(desc, false, 99, true));
 					desc; // TODO: save this
 					reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
 				} else {
@@ -1889,8 +1902,8 @@ type SoLdDescriptorFilterItem = {
 } | {
 	filterID: 1122;
 	Fltr: {
-		_name: 'Oil Paint',
-		_classID: 'oilPaint',
+		_name: 'Oil Paint';
+		_classID: 'oilPaint';
 		lightingOn: boolean;
 		stylization: number;
 		cleanliness: number;
@@ -1902,8 +1915,8 @@ type SoLdDescriptorFilterItem = {
 } | {
 	filterID: 1282492025;
 	Fltr: {
-		_name: 'Liquify',
-		_classID: 'LqFy',
+		_name: 'Liquify';
+		_classID: 'LqFy';
 		LqMe: Uint8Array;
 	};
 } | {
@@ -1911,12 +1924,34 @@ type SoLdDescriptorFilterItem = {
 	Fltr: {
 		_name: 'Perspective Warp';
 		_classID: 'perspectiveWarpTransform';
-		quads: { indices: number[] }[];
+		quads: { indices: number[]; }[];
 		vertices: HrznVrtcDescriptor[];
 		warpedVertices: HrznVrtcDescriptor[];
-	}
+	};
+} | {
+	filterID: 1131574899;
+	Fltr: {
+		_name: 'Curves';
+		_classID: 'Crvs';
+		presetKind: string; // 'presetKindType.presetKindCustom';
+		Adjs: {
+			_name: '';
+			_classID: 'CrvA';
+			Chnl: string[]; // 'Chnl.Cmps' | 'Chnl.Rd  ' | 'Chnl.Grn ' | 'Chnl.Bl  '
+			'Crv '?: FilterCurvesCurvePoint[];
+			Mpng?: number[];
+		}[];
+	};
 });
 
+interface FilterCurvesCurvePoint {
+	_name: '';
+	_classID: 'Pnt ';
+	Hrzn: 0;
+	Vrtc: 0;
+	Cnty?: boolean;
+}
+
 interface SoLdDescriptorFilter {
 	_name: '',
 	_classID: 'filterFXStyle',
@@ -2508,6 +2543,33 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 					},
 				};
 			};
+			case 'Crvs': {
+				return {
+					...base,
+					type: 'curves',
+					filter: {
+						presetKind: presetKindType.decode(f.Fltr.presetKind),
+						adjustments: f.Fltr.Adjs.map(a => {
+							const channels = a.Chnl.map(c => Chnl.decode(c));
+
+							if (a['Crv ']) {
+								return {
+									channels,
+									curve: a['Crv '].map(c => {
+										const point: { x: number; y: number; curved?: boolean; } = { x: c.Hrzn, y: c.Vrtc };
+										if (c.Cnty) point.curved = true;
+										return point;
+									}),
+								};
+							} else if (a.Mpng) {
+								return { channels, values: a.Mpng };
+							} else {
+								throw new Error(`Unknown curve adjustment`);
+							}
+						}),
+					},
+				};
+			};
 			default:
 				if (options.throwForMissingFeatures) {
 					throw new Error(`Unknown filter classId: ${(f as any).Fltr._classID}`);
@@ -3198,6 +3260,35 @@ function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
 			},
 			filterID: 442,
 		};
+		case 'curves': return {
+			...base,
+			Fltr: {
+				_name: 'Curves',
+				_classID: 'Crvs',
+				presetKind: presetKindType.encode(f.filter.presetKind),
+				Adjs: f.filter.adjustments.map(a => 'curve' in a ? {
+					_name: '',
+					_classID: 'CrvA',
+					Chnl: a.channels.map(c => Chnl.encode(c)),
+					'Crv ': a.curve.map(c => ({
+						_name: '',
+						_classID: 'Pnt ',
+						Hrzn: c.x,
+						Vrtc: c.y,
+						...(c.curved ? { Cnty: true } : {}),
+					}) as FilterCurvesCurvePoint),
+				} : {
+					_name: '',
+					_classID: 'CrvA',
+					Chnl: a.channels.map(c => Chnl.encode(c)),
+					Mpng: a.values,
+				}),
+			},
+			filterID: 1131574899,
+		};
+		// case 'hsb/hsl': return {
+		// TODO: ...
+		// };
 		default: throw new Error(`Unknow filter type: ${(f as any).type}`);
 	}
 }
@@ -3220,9 +3311,14 @@ interface SoLdDescriptor {
 	'Sz  ': { _name: '', _classID: 'Pnt ', Wdth: number; Hght: number; };
 	Rslt: DescriptorUnitsValue;
 	filterFX?: SoLdDescriptorFilter;
-	comp?: number;
-	compInfo?: { compID: number; originalCompID: number; };
+	comp?: number; // TODO: support this ?
+	compInfo?: { compID: number; originalCompID: number; }; // TODO: support this ?
 	Impr?: {}; // ???
+	ClMg?: { // TODO: support this ?
+		_name: '';
+		_classID: 'ClMg';
+		placedLayerOCIOConversion: string; // 'placedLayerOCIOConversion.placedLayerOCIOConvertEmbedded'
+	};
 }
 
 // let t: any;
@@ -3359,7 +3455,14 @@ addHandler(
 			};
 		}
 
-		// console.log('write', require('util').inspect(desc.filterFX, false, 99, true)); ///
+		// TODO:
+		// desc.comp = -1;
+		// desc.compInfo = { _name: '', _classID: 'null', compID: -1, originalCompID: -1 } as any;
+		// desc.ClMg = {
+		// 	_name: '',
+		// 	_classID: 'ClMg',
+		// 	placedLayerOCIOConversion: 'placedLayerOCIOConversion.placedLayerOCIOConvertEmbedded'
+		// } as any;
 
 		// if (JSON.stringify(t) !== JSON.stringify(desc)) {
 		// 	console.log('read', require('util').inspect(t, false, 99, true));
@@ -3450,21 +3553,6 @@ addHandler(
 	},
 );
 
-if (MOCK_HANDLERS) {
-	addHandler(
-		'vowv', // appears with Lr16 section ?
-		_ => false,
-		(reader, target, left) => {
-			const value = readUint32(reader); // always 2 ????
-			reader; target;
-			console.log('vowv', { value }, left());
-		},
-		(_writer, _target) => {
-			// TODO: write
-		},
-	);
-}
-
 if (MOCK_HANDLERS) {
 	addHandler(
 		'Patt',
@@ -3515,31 +3603,50 @@ addHandler(
 );
 */
 
-/*addHandler(
-	'OCIO', // generative tech?
-	() => false,
-	(reader, _target, left) => {
-	},
-	(_writer, _target) => {
-	},
-);*/
+if (MOCK_HANDLERS) {
+	addHandler(
+		'CAI ',
+		target => (target as any)._CAI_ !== undefined,
+		(reader, target, left) => {
+			(target as any)._CAI_ = readBytes(reader, left());
+		},
+		(writer, target) => {
+			writeBytes(writer, (target as any)._CAI_);
+		},
+	);
+}
 
-/*
-interface GenIDesc {
-	isUsingGenTech: number;
+if (MOCK_HANDLERS) {
+	addHandler(
+		'OCIO', // generative tech?
+		target => (target as any)._OCIO !== undefined,
+		(reader, target, left) => {
+			(target as any)._OCIO = readBytes(reader, left());
+		},
+		(writer, target) => {
+			writeBytes(writer, (target as any)._OCIO);
+		},
+	);
 }
 
-addHandler(
-	'GenI', // generative tech
-	() => false,
-	(reader, _target, left) => {
-		const desc = readVersionAndDescriptor(reader) as GenIDesc;
-		console.log('GenI', require('util').inspect(desc, false, 99, true));
-	},
-	(_writer, _target) => {
-	},
-);
-*/
+// interface GenIDesc {
+// 	isUsingGenTech: number;
+// }
+
+if (MOCK_HANDLERS) {
+	addHandler(
+		'GenI', // generative tech
+		target => (target as any)._GenI !== undefined,
+		(reader, target, left) => {
+			(target as any)._GenI = readBytes(reader, left());
+			// const desc = readVersionAndDescriptor(reader) as GenIDesc;
+			// console.log('GenI', require('util').inspect(desc, false, 99, true));
+		},
+		(writer, target) => {
+			writeBytes(writer, (target as any)._GenI);
+		},
+	);
+}
 
 function readRect(reader: PsdReader) {
 	const top = readInt32(reader);
@@ -4794,18 +4901,22 @@ addHandler(
 		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) {
+		while (leftBytes() > 8) {
+			if (readUint32(reader)) throw new Error('filterEffects: 64 bit length is not supported');
+			const length = readUint32(reader);
+			const end = reader.offset + length;
+
 			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);
@@ -4815,11 +4926,12 @@ addHandler(
 			const channels: ({ compressionMode: number; data: Uint8Array; } | undefined)[] = [];
 
 			// 0 -> R, 1 -> G, 2 -> B, 25 -> A
-			for (let i = 0; i < (maxChannels + 2); i++) {
+			for (let i = 0; i < (maxChannels + 2); i++) { // channels + user mask + sheet mask
 				const exists = readInt32(reader);
 				if (exists) {
 					if (readUint32(reader)) throw new Error('filterEffect: 64 bit length is not supported');
 					const channelLength = readUint32(reader);
+					if (!channelLength) throw new Error('filterEffect: Empty channel');
 					const compressionMode = readUint16(reader);
 					const data = readBytes(reader, channelLength - 2);
 					channels.push({ compressionMode, data });
@@ -4830,25 +4942,41 @@ addHandler(
 
 			target.filterEffectsMasks.push({ id, top, left, bottom, right, depth, channels });
 
-			if (leftBytes() && readUint8(reader)) {
+			if (reader.offset < end && readUint8(reader)) {
+				const top = readInt32(reader);
+				const left = readInt32(reader);
+				const bottom = readInt32(reader);
+				const right = readInt32(reader);
+				if (readUint32(reader)) throw new Error('filterEffect: 64 bit length is not supported');
+				const extraLength = readUint32(reader);
 				const compressionMode = readUint16(reader);
-				const data = readBytes(reader, leftBytes());
-				target.filterEffectsMasks[target.filterEffectsMasks.length - 1].extra = { compressionMode, data };
+				const data = readBytes(reader, extraLength - 2);
+				target.filterEffectsMasks[target.filterEffectsMasks.length - 1].extra = { top, left, bottom, right, compressionMode, data };
+			}
+
+			reader.offset = end;
+			let len = length;
+			while (len % 4) {
+				reader.offset++;
+				len++;
 			}
 		}
 	},
 	(writer, target) => {
-		writeInt32(writer, 3);
-		writeUint32(writer, 0);
-		writeUint32(writer, 0);
-		const lengthOffset = writer.offset;
+		writeInt32(writer, 3); // version
 
 		for (const mask of target.filterEffectsMasks!) {
+			writeUint32(writer, 0);
+			writeUint32(writer, 0);
+			const lengthOffset = writer.offset;
+
 			writePascalString(writer, mask.id, 1);
-			writeInt32(writer, 1);
+			writeInt32(writer, 1); // version
+
 			writeUint32(writer, 0);
 			writeUint32(writer, 0);
 			const length2Offset = writer.offset;
+
 			writeInt32(writer, mask.top);
 			writeInt32(writer, mask.left);
 			writeInt32(writer, mask.bottom);
@@ -4869,16 +4997,28 @@ addHandler(
 			}
 
 			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);
-		}
+			const extra = target.filterEffectsMasks![target.filterEffectsMasks!.length - 1]?.extra;
+			if (extra) {
+				writeUint8(writer, 1);
+				writeInt32(writer, extra.top);
+				writeInt32(writer, extra.left);
+				writeInt32(writer, extra.bottom);
+				writeInt32(writer, extra.right);
+				writeUint32(writer, 0);
+				writeUint32(writer, extra.data.byteLength + 2);
+				writeUint16(writer, extra.compressionMode);
+				writeBytes(writer, extra.data);
+			}
+
+			let length = writer.offset - lengthOffset;
+			writer.view.setUint32(lengthOffset - 4, length, false);
 
-		writer.view.setUint32(lengthOffset - 4, writer.offset - lengthOffset, false);
+			while (length % 4) {
+				writeZeros(writer, 1);
+				length++;
+			}
+		}
 	},
 );
 
@@ -5006,8 +5146,11 @@ addHandler(
 			engine: enumValue(desc.Engn)!,
 		};
 
+		if (desc.Vrsn) target.compositorUsed.version = desc.Vrsn;
+		if (desc.psVersion) target.compositorUsed.photoshopVersion = desc.psVersion;
 		if (desc.enableCompCore) target.compositorUsed.enableCompCore = enumValue(desc.enableCompCore);
 		if (desc.enableCompCoreGPU) target.compositorUsed.enableCompCoreGPU = enumValue(desc.enableCompCoreGPU);
+		if (desc.enableCompCoreThreads) target.compositorUsed.enableCompCoreThreads = enumValue(desc.enableCompCoreThreads);
 		if (desc.compCoreSupport) target.compositorUsed.compCoreSupport = enumValue(desc.compCoreSupport);
 		if (desc.compCoreGPUSupport) target.compositorUsed.compCoreGPUSupport = enumValue(desc.compCoreGPUSupport);
 
@@ -5016,16 +5159,16 @@ addHandler(
 	(writer, target) => {
 		const cinf = target.compositorUsed!;
 		const desc: CinfDescriptor = {
-			Vrsn: { major: 1, minor: 0, fix: 0 }, // TEMP
-			// psVersion: { major: 22, minor: 3, fix: 1 }, // TESTING
-			description: cinf.description,
-			reason: cinf.reason,
-			Engn: `Engn.${cinf.engine}`,
-		};
+			Vrsn: cinf.version || { major: 1, minor: 0, fix: 0 },
+		} as any;
 
+		if (cinf.photoshopVersion) desc.psVersion = cinf.photoshopVersion;
+		desc.description = cinf.description;
+		desc.reason = cinf.reason;
+		desc.Engn = `Engn.${cinf.engine}`;
 		if (cinf.enableCompCore) desc.enableCompCore = `enable.${cinf.enableCompCore}`;
 		if (cinf.enableCompCoreGPU) desc.enableCompCoreGPU = `enable.${cinf.enableCompCoreGPU}`;
-		// desc.enableCompCoreThreads = `enable.feature`; // TESTING
+		if (cinf.enableCompCoreThreads) desc.enableCompCoreThreads = `enable.${cinf.enableCompCoreThreads}`;
 		if (cinf.compCoreSupport) desc.compCoreSupport = `reason.${cinf.compCoreSupport}`;
 		if (cinf.compCoreGPUSupport) desc.compCoreGPUSupport = `reason.${cinf.compCoreGPUSupport}`;
 

package/src/descriptor.ts

@@ -138,6 +138,7 @@ const fieldToExtType: ExtTypeDict = {
 	customShape: makeType('', 'customShape'),
 	origFXRefPoint: nullType,
 	FXRefPoint: nullType,
+	ClMg: makeType('', 'ClMg'),
 };
 
 const fieldToArrayExtType: ExtTypeDict = {
@@ -171,6 +172,7 @@ const fieldToArrayExtType: ExtTypeDict = {
 	ShrP: makeType('', 'Pnt '),
 	layerSettings: nullType,
 	list: nullType,
+	Adjs: makeType('', 'CrvA'),
 };
 
 const typeToField: { [key: string]: string[]; } = {
@@ -186,7 +188,7 @@ const typeToField: { [key: string]: string[]; } = {
 	],
 	'long': [
 		'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
-		'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
+		'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'comp', 'compID', 'originalCompID',
 		'curvesPresetKind', 'mixerPresetKind', 'uOrder', 'vOrder', 'PgNm', 'totalPages', 'Crop',
 		'numerator', 'denominator', 'frameCount', 'Annt', 'keyOriginType', 'unitValueQuadVersion',
 		'keyOriginIndex', 'major', 'minor', 'fix', 'docDefaultNewArtboardBackgroundType', 'artboardBackgroundType',
@@ -206,7 +208,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
 		'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
 		'vertAlign', 'bgColorType', 'shapeOperation', 'UndA', 'Wvtp', 'Drct', 'WndM', 'Edg ', 'FlCl', 'IntE',
-		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ',
+		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod',
 	],
 	'bool': [
 		'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -219,7 +221,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
 		'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
 		'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
-		'moreAccurate', 'GpuY', 'LIWy',
+		'moreAccurate', 'GpuY', 'LIWy', 'Cnty',
 	],
 	'doub': [
 		'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
@@ -241,7 +243,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
 		'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
 		'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
-		'channelDenoise', 'Mtrx', 'layerSettings', 'list', 'compList',
+		'channelDenoise', 'Mtrx', 'layerSettings', 'list', 'compList', 'Adjs',
 	],
 	'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
 	'obj ': ['null', 'Chnl'],
@@ -290,6 +292,7 @@ const fieldToArrayType: Dict = {
 	channelDenoise: 'Objc',
 	Mtrx: 'long',
 	compList: 'long',
+	Chnl: 'enum',
 };
 
 const fieldToType: Dict = {};
@@ -309,7 +312,9 @@ for (const field of Object.keys(fieldToArrayExtType)) {
 }
 
 function getTypeByKey(key: string, value: any, root: string, parent: any) {
-	if (key === 'null' && root === 'slices') {
+	if (key === 'presetKind') {
+		return typeof value === 'string' ? 'enum' : 'long';
+	} if (key === 'null' && root === 'slices') {
 		return 'TEXT';
 	} else if (key === 'groupID') {
 		return root === 'slices' ? 'long' : 'TEXT';
@@ -319,7 +324,7 @@ function getTypeByKey(key: string, value: any, root: string, parent: any) {
 		return typeof value === 'string' ? 'enum' : 'long';
 	} else if (key === 'AntA') {
 		return typeof value === 'string' ? 'enum' : 'bool';
-	} else if ((key === 'Hrzn' || key === 'Vrtc') && parent.Type === 'keyType.Pstn') {
+	} else if ((key === 'Hrzn' || key === 'Vrtc') && (parent.Type === 'keyType.Pstn' || parent._classID === 'Ofst')) {
 		return 'long';
 	} else if (key === 'Hrzn' || key === 'Vrtc' || key === 'Top ' || key === 'Left' || key === 'Btom' || key === 'Rght') {
 		if (root === 'slices') return 'long';
@@ -405,12 +410,18 @@ export function writeDescriptorStructure(writer: PsdWriter, name: string, classI
 			type = 'long';
 		} else if (/^PF[a-z][a-z]$/.test(key)) {
 			type = 'doub';
+		} else if ((key === 'Rds ' || key === 'Thsh') && typeof value[key] === 'number' && value._classID === 'SmrB') {
+			type = 'doub';
 		} else if (key === 'ClSz' || key === 'Rds ' || key === 'Amnt') {
 			type = typeof value[key] === 'number' ? 'long' : 'UntF';
 		} else if ((key === 'sdwM' || key === 'hglM') && typeof value[key] === 'string') {
 			type = 'enum';
 		} else if (key === 'blur' && typeof value[key] === 'string') {
 			type = 'enum';
+		} else if (key === 'Hght' && typeof value[key] === 'number' && value._classID === 'Embs') {
+			type = 'long';
+		} else if (key === 'Angl' && typeof value[key] === 'number' && (value._classID === 'Embs' || value._classID === 'smartSharpen' || value._classID === 'Twrl' || value._classID === 'MtnB')) {
+			type = 'long';
 		} else if (key === 'Angl' && typeof value[key] === 'number') {
 			type = 'doub'; // ???
 		} else if (key === 'bounds' && root === 'slices') {
@@ -727,7 +738,7 @@ function writeReferenceStructure(writer: PsdWriter, _key: string, items: any[])
 		let type = 'unknown';
 
 		if (typeof value === 'string') {
-			if (/^[a-z]+\.[a-z]+$/i.test(value)) {
+			if (/^[a-z ]+\.[a-z ]+$/i.test(value)) {
 				type = 'Enmr';
 			} else {
 				type = 'name';
@@ -868,11 +879,12 @@ export interface DescriptorColorContent {
 }
 
 export interface DescriptorGradientContent {
-	Grad: DesciptorGradient;
-	Type: string;
 	Dthr?: boolean;
-	Rvrs?: boolean;
+	gradientsInterpolationMethod?: string; // 'gradientInterpolationMethodType.Smoo'
 	Angl?: DescriptorUnitsValue;
+	Type: string;
+	Grad: DesciptorGradient;
+	Rvrs?: boolean;
 	'Scl '?: DescriptorUnitsValue;
 	Algn?: boolean;
 	Ofst?: { Hrzn: DescriptorUnitsValue; Vrtc: DescriptorUnitsValue; };
@@ -1600,6 +1612,7 @@ function parseGradientContent(descriptor: DescriptorGradientContent) {
 	const result = parseGradient(descriptor.Grad) as (EffectSolidGradient | EffectNoiseGradient) & ExtraGradientInfo;
 	result.style = GrdT.decode(descriptor.Type);
 	if (descriptor.Dthr !== undefined) result.dither = descriptor.Dthr;
+	if (descriptor.gradientsInterpolationMethod !== undefined) result.interpolationMethod = gradientInterpolationMethodType.decode(descriptor.gradientsInterpolationMethod);
 	if (descriptor.Rvrs !== undefined) result.reverse = descriptor.Rvrs;
 	if (descriptor.Angl !== undefined) result.angle = parseAngle(descriptor.Angl);
 	if (descriptor['Scl '] !== undefined) result.scale = parsePercent(descriptor['Scl ']);
@@ -1639,6 +1652,7 @@ export function parseVectorContent(descriptor: DescriptorVectorContent): VectorC
 function serializeGradientContent(content: (EffectSolidGradient | EffectNoiseGradient) & ExtraGradientInfo) {
 	const result: DescriptorGradientContent = {} as any;
 	if (content.dither !== undefined) result.Dthr = content.dither;
+	if (content.interpolationMethod !== undefined) result.gradientsInterpolationMethod = gradientInterpolationMethodType.encode(content.interpolationMethod);
 	if (content.reverse !== undefined) result.Rvrs = content.reverse;
 	if (content.angle !== undefined) result.Angl = unitsAngle(content.angle);
 	result.Type = GrdT.encode(content.style);
@@ -2146,3 +2160,8 @@ export const prjM = createEnum<'fisheye' | 'perspective' | 'auto' | 'full spheri
 	'auto': 'auto',
 	'full spherical': 'fusP',
 });
+
+export const presetKindType = createEnum<'custom' | 'default'>('presetKindType', 'presetKindCustom', {
+	custom: 'presetKindCustom',
+	default: 'presetKindDefault',
+});

package/src/engineData2.ts

@@ -58,7 +58,7 @@ const keysStyleSheet: KeysDict = {
 
 	'52': { name: 'NoBreak' },
 	'53': { name: 'FillColor', children: keysColor },
-	'54': { name: 'StrokeColor?', children: keysColor },
+	'54': { name: 'StrokeColor', children: keysColor },
 	'55': { children: { '99': { uproot: true } } },
 
 	// '68': ???
@@ -321,6 +321,13 @@ const keysRoot: KeysDict = {
 						// 		// '6'
 						// 	},
 						// }
+						//     "1": [ // this is probably bounding box? there seem to be many of them nested
+						//       0,
+						//       0,
+						//       999,
+						//       176.30014
+						//     ],
+						// various types: /PC, /F, /R, /L, /S, /G
 					},
 				},
 			},