ag-psd 31.0.3 → 33.0.0

package/src/descriptor.ts

@@ -1,6 +1,6 @@
-import { createEnum } from './helpers';
+import { createEnum, normalizeLabAB, denormalizeLabAB } from './helpers';
 import {
-	AntiAlias, BevelDirection, BevelStyle, BevelTechnique, BlendMode, Color, EffectContour,
+	AntiAlias, BevelDirection, BevelStyle, BevelTechnique, BlendMode, Color, ColorStop, EffectContour,
 	EffectNoiseGradient, EffectPattern, EffectSolidGradient, ExtraGradientInfo, ExtraPatternInfo,
 	GlowSource, GlowTechnique, GradientStyle, InterpolationMethod, LayerEffectBevel,
 	LayerEffectGradientOverlay, LayerEffectInnerGlow, LayerEffectPatternOverlay,
@@ -15,7 +15,7 @@ import {
 } from './psdReader';
 import {
 	PsdWriter, writeSignature, writeBytes, writeUint32, writeFloat64, writeUint8,
-	writeUnicodeStringWithPadding, writeInt32, writeFloat32, writeUnicodeString, writeInt32LE,
+	writeUnicodeStringWithPadding, writeInt32, writeFloat32, writeInt32LE,
 	writeUnicodeStringWithoutLengthLE
 } from './psdWriter';
 
@@ -140,6 +140,8 @@ const fieldToExtType: ExtTypeDict = {
 	origFXRefPoint: nullType,
 	FXRefPoint: nullType,
 	ClMg: makeType('', 'ClMg'),
+	interpretation: makeType('', 'footageInterpretation'),
+	bgColor: makeType('', 'NativeQuad'),
 };
 
 const fieldToArrayExtType: ExtTypeDict = {
@@ -147,6 +149,7 @@ const fieldToArrayExtType: ExtTypeDict = {
 	Clrs: makeType('', 'Clrt'),
 	Trns: makeType('', 'TrnS'),
 	keyDescriptorList: nullType,
+	keyRootDescriptorList: nullType,
 	solidFillMulti: makeType('', 'SoFi'),
 	gradientFillMulti: makeType('', 'GrFl'),
 	dropShadowMulti: makeType('', 'DrSh'),
@@ -174,21 +177,30 @@ const fieldToArrayExtType: ExtTypeDict = {
 	layerSettings: nullType,
 	list: nullType,
 	Adjs: makeType('', 'CrvA'),
+	vertices: makeType('', 'Pnt '),
+	warpedVertices: makeType('', 'Pnt '),
+	quads: makeType('', 'quadIndices'),
 };
 
 const typeToField: { [key: string]: string[]; } = {
 	'TEXT': [
-		'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
+		'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName', 'exportOption', 'scaleSettings',
+		'BackgroundImagePath', 'ImageSubfolderName',
 		'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
 		'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
-		'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath',
+		'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath', 'Bk  ', 'pathUnicodeName',
 	],
 	'tdta': [
 		'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
-		'LqMe',
+		'LqMe', 'bookKey',
 	],
 	'long': [
-		'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
+		'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ', 'bookID',
+		'cropRectBottom', 'cropRectLeft', 'cropRectRight', 'cropRectTop',
+		// save for web output settings
+		'Version', 'BackgroundColorBlue', 'BackgroundColorGreen', 'BackgroundColorRed', 'BackgroundColorState', 'AttributeCase', 'Encoding',
+		'DuplicateFileNameBehavior', 'ImageMapLocation', 'ImageMapType', 'Indent', 'LineEndings', 'SpacersEmptyCells',
+		'SpacersHorizontal', 'SpacersVertical', 'StylesFormat', 'TDWidthHeight', 'TagCase', 'ColorPolicy', 'MetadataPolicy',
 		'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'comp', 'compID', 'originalCompID',
 		'curvesPresetKind', 'mixerPresetKind', 'uOrder', 'vOrder', 'PgNm', 'totalPages', 'Crop',
 		'numerator', 'denominator', 'frameCount', 'Annt', 'keyOriginType', 'unitValueQuadVersion',
@@ -200,6 +212,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN', 'NmbG', 'WLMn', 'WLMx', 'AmMn', 'AmMx', 'SclH', 'SclV',
 		'Lvl ', 'TlNm', 'TlOf', 'FlRs', 'Thsh', 'ShrS', 'ShrE', 'FlRs', 'Vrnc', 'Strg', 'ExtS', 'ExtD',
 		'HrzS', 'VrtS', 'NmbR', 'EdgF', 'Ang1', 'Ang2', 'Ang3', 'Ang4', 'lastAppliedComp', 'capturedInfo',
+		'pixelSourceType',
 	],
 	'enum': [
 		'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
@@ -209,7 +222,8 @@ 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', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod',
+		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod', 'pathSymmetryMode',
+		'interpretAlpha',
 	],
 	'bool': [
 		'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -222,14 +236,15 @@ 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', 'Cnty',
+		'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn',
 	],
 	'doub': [
-		'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
+		'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght', 'Gmm ',
 		'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
 		'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
 		'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
-		'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
+		'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3',
+		'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity',
 	],
 	'UntF': [
 		'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -238,31 +253,59 @@ const typeToField: { [key: string]: string[]; } = {
 		'topRight', 'topLeft', 'bottomLeft', 'bottomRight', 'ClNs', 'Shrp',
 	],
 	'VlLs': [
-		'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
+		'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'keyRootDescriptorList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
 		'LaSt', 'Trnf', 'nonAffineTransform', 'keyDescriptorList', 'guideIndeces', 'gradientFillMulti',
 		'solidFillMulti', 'frameFXMulti', 'innerShadowMulti', 'dropShadowMulti', 'FrIn', 'FSts', 'FsFr',
 		'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
 		'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
 		'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
 		'channelDenoise', 'Mtrx', 'layerSettings', 'list', 'compList', 'Adjs',
+		'vertices', 'warpedVertices', 'quads', 'indices', 'Mpng',
 	],
 	'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
 	'obj ': ['null', 'Chnl'],
 	'Pth ': ['DspF'],
+	'alis': ['alis'],
 };
 
 const channels = [
 	'Rd  ', 'Grn ', 'Bl  ', 'Yllw', 'Ylw ', 'Cyn ', 'Mgnt', 'Blck', 'Gry ', 'Lmnc', 'A   ', 'B   ',
 ];
 
+// color classes whose channel values are written as doubles ('GRYC' and 'LABC' are kept for backwards compatibility)
+const doubleColorClasses = ['Grsc', 'LbCl', 'GRYC', 'LABC'];
+
+// fallback for unknown keys, based on the type of the value
+function guessOSType(value: any): string | undefined {
+	if (typeof value === 'boolean') return 'bool';
+	if (typeof value === 'number' && !Number.isInteger(value)) return 'doub';
+	if (Array.isArray(value)) return 'VlLs';
+
+	if (value && typeof value === 'object') {
+		if (typeof value._classID === 'string') return 'Objc';
+		if (typeof value.classID === 'string') return 'type'; // class read from 'type' or 'GlbC'
+		if (typeof value.low === 'number' && typeof value.high === 'number') return 'comp';
+		if (typeof value.units === 'string' && typeof value.value === 'number') return 'UntF';
+	}
+
+	return undefined;
+}
+
 const fieldToArrayType: Dict = {
 	'Mnm ': 'long',
 	'Mxm ': 'long',
+	HtmlFileNameComponents: 'long', // save for web output settings
+	SavingFileNameComponents: 'long',
+	SliceFileNameComponents: 'long',
+	Inpt: 'long', // levels filter
+	Otpt: 'long', // levels filter
 	FrLs: 'long',
 	strokeStyleLineDashSet: 'UntF',
 	Trnf: 'doub',
 	nonAffineTransform: 'doub',
 	keyDescriptorList: 'Objc',
+	keyRootDescriptorList: 'Objc',
+	pathList: 'Objc',
 	gradientFillMulti: 'Objc',
 	solidFillMulti: 'Objc',
 	frameFXMulti: 'Objc',
@@ -294,6 +337,8 @@ const fieldToArrayType: Dict = {
 	Mtrx: 'long',
 	compList: 'long',
 	Chnl: 'enum',
+	indices: 'long',
+	Mpng: 'long',
 };
 
 const fieldToType: Dict = {};
@@ -312,6 +357,8 @@ for (const field of Object.keys(fieldToArrayExtType)) {
 	fieldToArrayType[field] = 'Objc';
 }
 
+const pixelSourceOriginRoot = 'PixelSource.origin';
+
 function getTypeByKey(key: string, value: any, root: string, parent: any) {
 	if (key === 'presetKind') {
 		return typeof value === 'string' ? 'enum' : 'long';
@@ -325,7 +372,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' || parent._classID === 'Ofst')) {
+	} else if ((key === 'Hrzn' || key === 'Vrtc') && (parent.Type === 'keyType.Pstn' || parent._classID === 'Ofst' || root === pixelSourceOriginRoot)) {
 		return 'long';
 	} else if (key === 'Hrzn' || key === 'Vrtc' || key === 'Top ' || key === 'Left' || key === 'Btom' || key === 'Rght') {
 		if (root === 'slices') return 'long';
@@ -336,6 +383,18 @@ function getTypeByKey(key: string, value: any, root: string, parent: any) {
 		return root === 'artd' ? 'long' : 'doub';
 	} else if (key === 'Trnf') {
 		return Array.isArray(value) ? 'VlLs' : 'Objc';
+	} else if (key === 'alpha' && root === 'slices') {
+		return 'long';
+	} else if ((key === 'Inpt' || key === 'Otpt') && parent._classID === 'HsbP') {
+		return 'enum';
+	} else if ((key === 'Inpt' || key === 'Otpt') && parent._classID === 'LvlA') {
+		return 'VlLs';
+	} else if (key === 'Intr' && typeof value === 'boolean') {
+		return 'bool'; // interpolation in print style
+	} else if (key === 'PgPs') {
+		return 'enum';
+	} else if (key === 'LghD' && parent._classID === 'oilPaint') {
+		return 'long';
 	} else {
 		return fieldToType[key];
 	}
@@ -346,8 +405,8 @@ export function readAsciiStringOrClassId(reader: PsdReader) {
 	return readAsciiString(reader, length || 4);
 }
 
-function writeAsciiStringOrClassId(writer: PsdWriter, value: string) {
-	if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list') {
+export function writeAsciiStringOrClassId(writer: PsdWriter, value: string) {
+	if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list' && value !== 'json') {
 		// write classId
 		writeInt32(writer, 0);
 		writeSignature(writer, value);
@@ -379,30 +438,41 @@ export function readDescriptorStructure(reader: PsdReader, includeClass: boolean
 	return object;
 }
 
+export const outputSettingsRoot = 'outputSettings';
+
 export function writeDescriptorStructure(writer: PsdWriter, name: string, classId: string, value: any, root: string) {
 	if (logErrors && !classId) console.log('Missing classId for: ', name, classId, value);
 
 	// write class structure
 	writeUnicodeStringWithPadding(writer, name);
-	writeAsciiStringOrClassId(writer, classId);
 
-	const keys = Object.keys(value);
-	let keyCount = keys.length;
-	if ('_name' in value) keyCount--;
-	if ('_classID' in value) keyCount--;
+	if (root === outputSettingsRoot && classId === 'null') {
+		// Photoshop writes 'null' class id as 4 character string in save for web output settings
+		writeInt32(writer, 4);
+		writeSignature(writer, classId);
+	} else {
+		writeAsciiStringOrClassId(writer, classId);
+	}
 
-	writeUint32(writer, keyCount);
+	const allKeys = Object.keys(value);
+	const keys = allKeys.filter(key => key !== '_name' && key !== '_classID' && value[key] !== undefined);
 
-	for (const key of keys) {
-		if (key === '_name' || key === '_classID') continue;
+	writeUint32(writer, keys.length);
 
-		let type = getTypeByKey(key, value[key], root, value);
+	for (const key of keys) {
+		let type: string | undefined = getTypeByKey(key, value[key], root, value);
+		let childRoot = root;
 		let extType = fieldToExtType[key];
 
 		if (key === 'bounds' && root === 'text') {
 			extType = makeType('', 'bounds');
 		} else if (key === 'origin') {
 			type = root === 'slices' ? 'enum' : 'Objc';
+
+			if (classId === 'PixelSource') {
+				extType = nullType; // stored as 'null' class with integer Hrzn/Vrtc
+				childRoot = pixelSourceOriginRoot;
+			}
 		} else if ((key === 'Cyn ' || key === 'Mgnt' || key === 'Ylw ' || key === 'Blck') && value._classID === 'CMYC') {
 			type = 'doub';
 		} else if (/^PN[a-z][a-z]$/.test(key)) {
@@ -449,9 +519,12 @@ export function writeDescriptorStructure(writer: PsdWriter, name: string, classI
 			type = 'Objc';
 			extType = nullType;
 		} else if (channels.indexOf(key) !== -1) {
-			type = (classId === 'RGBC' && root !== 'artd') ? 'doub' : 'long';
+			type = ((classId === 'RGBC' && root !== 'artd') || doubleColorClasses.indexOf(classId) !== -1) ? 'doub' : 'long';
 		} else if (key === 'profile') {
-			type = classId === 'printOutput' ? 'TEXT' : 'tdta';
+			type = (classId === 'printOutput' || classId === 'proofSetup') ? 'TEXT' : 'tdta';
+		} else if (key === 'alis' && typeof value[key] === 'string') {
+			// 'alis' is read as a binary string (one char per byte), strings with wider chars can only be stored as TEXT
+			type = /[^\x00-\xff]/.test(value[key]) ? 'TEXT' : 'alis';
 		} else if (key === 'strokeStyleContent') {
 			if (value[key]['Clr ']) {
 				extType = makeType('', 'solidColorLayer');
@@ -466,14 +539,19 @@ export function writeDescriptorStructure(writer: PsdWriter, name: string, classI
 			extType = makeType('', 'classFloatRect');
 		}
 
+		// guess color class from its fields (colors created by serializeColor always have _classID set)
 		if (extType && extType.classID === 'RGBC') {
 			if ('H   ' in value[key]) extType = { classID: 'HSBC', name: '' };
-			// TODO: other color spaces
+			else if ('Cyn ' in value[key]) extType = { classID: 'CMYC', name: '' };
+			else if ('Lmnc' in value[key]) extType = { classID: 'LbCl', name: '' };
+			else if ('Gry ' in value[key]) extType = { classID: 'Grsc', name: '' };
 		}
 
+		if (!type) type = guessOSType(value[key]);
+
 		writeAsciiStringOrClassId(writer, key);
 		writeSignature(writer, type || 'long');
-		writeOSType(writer, type || 'long', value[key], key, extType, root);
+		writeOSType(writer, type || 'long', value[key], key, extType, childRoot);
 		if (logErrors && !type) console.log(`Missing descriptor field type for: '${key}' in`, value);
 	}
 }
@@ -541,14 +619,13 @@ function readOSType(reader: PsdReader, type: string, includeClass: boolean) {
 		case 'ObAr': { // Object array
 			readInt32(reader); // version: 16
 			readUnicodeString(reader); // name: ''
-			readAsciiStringOrClassId(reader); // 'rationalPoint'
+			readAsciiStringOrClassId(reader); // classID: 'rationalPoint'
 			const length = readInt32(reader);
 			const items: any[] = [];
 
 			for (let i = 0; i < length; i++) {
 				const type1 = readAsciiStringOrClassId(reader); // type Hrzn | Vrtc
 				readSignature(reader); // UnFl
-
 				readSignature(reader); // units ? '#Pxl'
 				const valuesCount = readInt32(reader);
 				const values: number[] = [];
@@ -588,9 +665,9 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 		case 'Objc': // Descriptor
 		case 'GlbO': { // GlobalObject same as Descriptor
 			if (typeof value !== 'object') throw new Error(`Invalid struct value: ${JSON.stringify(value)}, key: ${key}`);
-			if (!extType) throw new Error(`Missing ext type for: '${key}' (${JSON.stringify(value)})`);
-			const name = value._name || extType.name;
-			const classID = value._classID || extType.classID;
+			if (!extType && !value._classID) throw new Error(`Missing ext type for: '${key}' (${JSON.stringify(value)})`);
+			const name = value._name || extType?.name || '';
+			const classID = value._classID || extType!.classID;
 			writeDescriptorStructure(writer, name, classID, value, root);
 			break;
 		}
@@ -599,7 +676,7 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 			writeInt32(writer, value.length);
 
 			for (let i = 0; i < value.length; i++) {
-				const type = fieldToArrayType[key];
+				const type = fieldToArrayType[key] ?? guessOSType(value[i]);
 				writeSignature(writer, type || 'long');
 				writeOSType(writer, type || 'long', value[i], `${key}[]`, fieldToArrayExtType[key], root);
 				if (logErrors && !type) console.log(`Missing descriptor array type for: '${key}' in`, value);
@@ -631,19 +708,31 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 		}
 		case 'long': // Integer
 			if (typeof value !== 'number') throw new Error(`Invalid integer value: ${JSON.stringify(value)}, key: ${key}`);
-			writeInt32(writer, value);
+			writeInt32(writer, Math.round(value)); // round instead of truncating fractional values
+			break;
+		case 'comp': // Large Integer
+			if (!value || typeof value !== 'object') throw new Error(`Invalid large integer value: ${JSON.stringify(value)}, key: ${key}`);
+			writeUint32(writer, value.low >>> 0);
+			writeUint32(writer, value.high >>> 0);
 			break;
-		// case 'comp': // Large Integer
-		// 	writeLargeInteger(reader);
 		case 'bool': // Boolean
 			if (typeof value !== 'boolean') throw new Error(`Invalid boolean value: ${JSON.stringify(value)}, key: ${key}`);
 			writeUint8(writer, value ? 1 : 0);
 			break;
-		// case 'type': // Class
-		// case 'GlbC': // Class
-		// 	writeClassStructure(reader);
-		// case 'alis': // Alias
-		// 	writeAliasStructure(reader);
+		case 'type': // Class
+		case 'GlbC': // Class
+			if (!value || typeof value !== 'object') throw new Error(`Invalid class value: ${JSON.stringify(value)}, key: ${key}`);
+			writeUnicodeStringWithPadding(writer, value.name || '');
+			writeAsciiStringOrClassId(writer, value.classID);
+			break;
+		case 'alis': { // Alias (read as a binary string, one char per byte)
+			if (typeof value !== 'string') throw new Error(`Invalid alias value: ${JSON.stringify(value)}, key: ${key}`);
+			writeInt32(writer, value.length);
+			for (let i = 0; i < value.length; i++) {
+				writeUint8(writer, value.charCodeAt(i) & 0xff);
+			}
+			break;
+		}
 		case 'tdta': // Raw Data
 			writeInt32(writer, value.byteLength);
 			writeBytes(writer, value);
@@ -669,12 +758,13 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 			break;
 		}
 		case 'Pth ': { // File path
-			const length = 4 + 4 + 4 + value.path.length * 2;
+			const path = value.path + '\0'; // Photoshop stores trailing null character (stripped when reading)
+			const length = 4 + 4 + 4 + path.length * 2;
 			writeInt32(writer, length);
 			writeSignature(writer, value.sig);
 			writeInt32LE(writer, length);
-			writeInt32LE(writer, value.path.length);
-			writeUnicodeStringWithoutLengthLE(writer, value.path);
+			writeInt32LE(writer, path.length);
+			writeUnicodeStringWithoutLengthLE(writer, path);
 			break;
 		}
 		default:
@@ -682,6 +772,24 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 	}
 }
 
+// Reference item with explicit reference type and class, can be used in place of a value in reference arrays
+// passed to writeVersionAndDescriptor (references are read as values only: strings, numbers and class objects)
+export interface DescriptorReferenceItem {
+	type: 'prop' | 'Clss' | 'Enmr' | 'rele' | 'Idnt' | 'indx' | 'name';
+	_name?: string; // class name
+	_classID?: string;
+	keyID?: string; // prop
+	typeID?: string; // Enmr
+	enumValue?: string; // Enmr
+	value?: string | number; // rele, Idnt, indx, name
+}
+
+const referenceTypes = ['prop', 'Clss', 'Enmr', 'rele', 'Idnt', 'indx', 'name'];
+
+function isReferenceItem(value: any): value is DescriptorReferenceItem {
+	return !!value && typeof value === 'object' && referenceTypes.indexOf(value.type) !== -1;
+}
+
 function readReferenceStructure(reader: PsdReader) {
 	const itemsCount = readInt32(reader);
 	const items: any[] = [];
@@ -690,39 +798,32 @@ function readReferenceStructure(reader: PsdReader) {
 		const type = readSignature(reader);
 
 		switch (type) {
-			case 'prop': { // Property
+			case 'prop': // Property
 				readClassStructure(reader);
-				const keyID = readAsciiStringOrClassId(reader);
-				items.push(keyID);
+				items.push(readAsciiStringOrClassId(reader));
 				break;
-			}
 			case 'Clss': // Class
 				items.push(readClassStructure(reader));
 				break;
 			case 'Enmr': { // Enumerated Reference
 				readClassStructure(reader);
 				const typeID = readAsciiStringOrClassId(reader);
-				const value = readAsciiStringOrClassId(reader);
-				items.push(`${typeID}.${value}`);
+				const enumValue = readAsciiStringOrClassId(reader);
+				items.push(`${typeID}.${enumValue}`);
 				break;
 			}
-			case 'rele': { // Offset
-				// const { name, classID } =
+			case 'rele': // Offset
 				readClassStructure(reader);
 				items.push(readUint32(reader));
 				break;
-			}
 			case 'Idnt': // Identifier
-				items.push(readInt32(reader));
-				break;
 			case 'indx': // Index
 				items.push(readInt32(reader));
 				break;
-			case 'name': { // Name
+			case 'name': // Name
 				readClassStructure(reader);
 				items.push(readUnicodeString(reader));
 				break;
-			}
 			default:
 				throw new Error(`Invalid descriptor reference type: ${type}`);
 		}
@@ -731,43 +832,73 @@ function readReferenceStructure(reader: PsdReader) {
 	return items;
 }
 
+function guessReferenceItem(value: any): DescriptorReferenceItem {
+	if (typeof value === 'string') {
+		// enumerated references are read as `${typeID}.${enumValue}` where typeID is a 4 character ID or a string ID
+		// (values like 'My.Path' or 'Logo.v2' can't be typeID/enum value, so they are written as name references)
+		const match = /^([a-z ]{4}|[a-z]{5,})\.([a-z ]+)$/i.exec(value);
+
+		if (match) {
+			return { type: 'Enmr', _name: '', _classID: match[1], typeID: match[1], enumValue: match[2] };
+		} else {
+			return { type: 'name', _name: '', _classID: 'Lyr ', value };
+		}
+	} else if (typeof value === 'number') {
+		return { type: 'Idnt', value };
+	} else if (value && typeof value === 'object' && typeof value.classID === 'string') {
+		return { type: 'Clss', _name: value.name || '', _classID: value.classID };
+	} else {
+		throw new Error(`Invalid descriptor reference value: ${JSON.stringify(value)}`);
+	}
+}
+
+// path selection state (image resource 1088) is a reference to paths, enumerated references there use 'Path' class
+// (name references use 'Lyr ' class, they reference layer of the vector mask)
+export function pathSelectionStateToReference(items: string[]): DescriptorReferenceItem[] {
+	return items.map(value => {
+		const item = guessReferenceItem(value);
+		if (item.type === 'Enmr') item._classID = 'Path';
+		return item;
+	});
+}
+
 function writeReferenceStructure(writer: PsdWriter, _key: string, items: any[]) {
-	writeInt32(writer, items.length);
+	if (!Array.isArray(items)) throw new Error(`Invalid reference value: ${JSON.stringify(items)}, key: ${_key}`);
 
-	for (let i = 0; i < items.length; i++) {
-		const value = items[i];
-		let type = 'unknown';
+	writeInt32(writer, items.length);
 
-		if (typeof value === 'string') {
-			if (/^[a-z ]+\.[a-z ]+$/i.test(value)) {
-				type = 'Enmr';
-			} else {
-				type = 'name';
-			}
-		}
+	for (const value of items) {
+		const item = isReferenceItem(value) ? value : guessReferenceItem(value);
 
-		writeSignature(writer, type);
+		writeSignature(writer, item.type);
 
-		switch (type) {
-			// case 'prop': // Property
-			// case 'Clss': // Class
-			case 'Enmr': { // Enumerated Reference
-				const [typeID, enumValue] = value.split('.');
-				writeClassStructure(writer, '\0', typeID);
-				writeAsciiStringOrClassId(writer, typeID);
-				writeAsciiStringOrClassId(writer, enumValue);
+		switch (item.type) {
+			case 'prop': // Property
+				writeClassStructure(writer, item._name || '', item._classID!);
+				writeAsciiStringOrClassId(writer, item.keyID!);
 				break;
-			}
-			// case 'rele': // Offset
-			// case 'Idnt': // Identifier
-			// case 'indx': // Index
-			case 'name': { // Name
-				writeClassStructure(writer, '\0', 'Lyr ');
-				writeUnicodeString(writer, value + '\0');
+			case 'Clss': // Class
+				writeClassStructure(writer, item._name || '', item._classID!);
+				break;
+			case 'Enmr': // Enumerated Reference
+				writeClassStructure(writer, item._name || '', item._classID!);
+				writeAsciiStringOrClassId(writer, item.typeID!);
+				writeAsciiStringOrClassId(writer, item.enumValue!);
+				break;
+			case 'rele': // Offset
+				writeClassStructure(writer, item._name || '', item._classID!);
+				writeUint32(writer, item.value as number);
+				break;
+			case 'Idnt': // Identifier
+			case 'indx': // Index
+				writeInt32(writer, item.value as number);
+				break;
+			case 'name': // Name
+				writeClassStructure(writer, item._name || '', item._classID!);
+				writeUnicodeStringWithPadding(writer, `${item.value}`);
 				break;
-			}
 			default:
-				throw new Error(`Invalid descriptor reference type: ${type}`);
+				throw new Error(`Invalid descriptor reference type: ${item.type}`);
 		}
 	}
 
@@ -780,8 +911,8 @@ function readClassStructure(reader: PsdReader) {
 	return { name, classID };
 }
 
-function writeClassStructure(writer: PsdWriter, name: string, classID: string) {
-	writeUnicodeString(writer, name);
+export function writeClassStructure(writer: PsdWriter, name: string, classID: string) {
+	writeUnicodeStringWithPadding(writer, name);
 	writeAsciiStringOrClassId(writer, classID);
 }
 
@@ -827,11 +958,11 @@ export type DescriptorColor = {
 	Blck: number;
 } | {
 	_name: '';
-	_classID: 'GRYC'; // ???
+	_classID: 'Grsc' | 'GRYC'; // 'GRYC' was written by older versions of ag-psd
 	'Gry ': number;
 } | {
 	_name: '';
-	_classID: 'LABC'; // ???
+	_classID: 'LbCl' | 'LABC'; // 'LABC' was written by older versions of ag-psd
 	Lmnc: number;
 	'A   ': number;
 	'B   ': number;
@@ -853,8 +984,8 @@ export type DesciptorGradient = {
 	GrdF: 'GrdF.CstS';
 	Intr: number;
 	Clrs: {
-		'Clr ': DescriptorColor;
-		Type: 'Clry.UsrS';
+		'Clr '?: DescriptorColor;
+		Type?: string; // 'Clry.UsrS' | 'Clry.FrgC' | 'Clry.BckC'
 		Lctn: number;
 		Mdpn: number;
 	}[];
@@ -894,7 +1025,9 @@ export interface DescriptorGradientContent {
 export interface DescriptorPatternContent {
 	Ptrn: DesciptorPattern;
 	Lnkd?: boolean;
-	phase?: { Hrzn: number; Vrtc: number; };
+	phase?: { Hrzn: number | DescriptorUnitsValue; Vrtc: number | DescriptorUnitsValue; };
+	'Scl '?: DescriptorUnitsValue;
+	Angl?: DescriptorUnitsValue;
 }
 
 export type DescriptorVectorContent = DescriptorColorContent | DescriptorGradientContent | DescriptorPatternContent;
@@ -1190,7 +1323,7 @@ function parseFxObject(fx: EffectDescriptor) {
 		fillType: FrFl.decode(fx.PntT!),
 		blendMode: BlnM.decode(fx['Md  ']!),
 		opacity: parsePercent(fx.Opct),
-		size: parseUnits(fx['Sz  ']!),
+		size: parseUnitsOrNumber(fx['Sz  '] as DescriptorUnitsValue | number), // stored as number (pixels) in old versions
 	};
 
 	if (fx.present !== undefined) stroke.present = fx.present;
@@ -1258,9 +1391,11 @@ export function serializeEffects(e: LayerEffectsInfo, log: boolean, multi: boole
 
 		for (const key of Object.keys(e)) {
 			const value = (e as any)[key];
+			if (value == null || typeof value !== 'object') continue;
+
 			if (Array.isArray(value)) {
 				for (const effect of value) {
-					if (effect.enabled) info.numModifyingFX++;
+					if (effect?.enabled) info.numModifyingFX++;
 				}
 			} else if (value.enabled) {
 				info.numModifyingFX++;
@@ -1273,16 +1408,16 @@ export function serializeEffects(e: LayerEffectsInfo, log: boolean, multi: boole
 
 export function parseEffects(info: Lfx2Descriptor & LmfxDescriptor, log: boolean) {
 	const effects: LayerEffectsInfo = {};
-	const { masterFXSwitch, DrSh, dropShadowMulti, IrSh, innerShadowMulti, OrGl, IrGl, ebbl, SoFi, solidFillMulti, patternFill, GrFl, gradientFillMulti, ChFX, FrFX, frameFXMulti, numModifyingFX, ...rest } = info;
+	const { _name, _classID, 'Scl ': scale, masterFXSwitch, DrSh, dropShadowMulti, IrSh, innerShadowMulti, OrGl, IrGl, ebbl, SoFi, solidFillMulti, patternFill, GrFl, gradientFillMulti, ChFX, FrFX, frameFXMulti, numModifyingFX, ...rest } = info as typeof info & { _name?: string; _classID?: string; };
 	if (!masterFXSwitch) effects.disabled = true;
-	if (info['Scl ']) effects.scale = parsePercent(info['Scl ']);
+	if (scale) effects.scale = parsePercent(scale);
 	if (DrSh) effects.dropShadow = [parseEffectObject(DrSh, log)];
 	if (dropShadowMulti) effects.dropShadow = dropShadowMulti.map(i => parseEffectObject(i, log));
 	if (IrSh) effects.innerShadow = [parseEffectObject(IrSh, log)];
 	if (innerShadowMulti) effects.innerShadow = innerShadowMulti.map(i => parseEffectObject(i, log));
 	if (OrGl) effects.outerGlow = parseEffectObject(OrGl, log);
 	if (IrGl) effects.innerGlow = parseEffectObject(IrGl, log);
-	if (ebbl) effects.bevel = parseEffectObject(ebbl, log);
+	if (ebbl) effects.bevel = parseEffectObject(ebbl, log, 'bevel');
 	if (SoFi) effects.solidFill = [parseEffectObject(SoFi, log)];
 	if (solidFillMulti) effects.solidFill = solidFillMulti.map(i => parseEffectObject(i, log));
 	if (patternFill) effects.patternOverlay = parseEffectObject(patternFill, log);
@@ -1291,7 +1426,7 @@ export function parseEffects(info: Lfx2Descriptor & LmfxDescriptor, log: boolean
 	if (ChFX) effects.satin = parseEffectObject(ChFX, log);
 	if (FrFX) effects.stroke = [parseFxObject(FrFX)];
 	if (frameFXMulti) effects.stroke = frameFXMulti.map(i => parseFxObject(i));
-	if (log && Object.keys(rest).length > 1) console.log('Unhandled effect keys:', rest);
+	if (log && Object.keys(rest).length) console.log('Unhandled effect keys:', rest);
 	return effects;
 }
 
@@ -1410,7 +1545,7 @@ export function serializeTrackList(tracks: TimelineTrack[]): TimelineTrackDescri
 			Effc: !!t.effectParams,
 			...(t.effectParams ? {
 				effectParams: {
-					keyList: serializeKeyList(t.keys),
+					keyList: serializeKeyList(t.effectParams.keys),
 					fillCanvas: t.effectParams.fillCanvas,
 					zoomOrigin: t.effectParams.zoomOrigin,
 				}
@@ -1426,7 +1561,7 @@ type AllEffects = LayerEffectShadow & LayerEffectsOuterGlow & LayerEffectStroke
 	LayerEffectInnerGlow & LayerEffectBevel & LayerEffectSolidFill &
 	LayerEffectPatternOverlay & LayerEffectSatin & LayerEffectGradientOverlay;
 
-function parseEffectObject(obj: any, reportErrors: boolean) {
+function parseEffectObject(obj: any, reportErrors: boolean, objName?: string) {
 	const result: AllEffects = {} as any;
 
 	for (const key of Object.keys(obj)) {
@@ -1453,7 +1588,10 @@ function parseEffectObject(obj: any, reportErrors: boolean) {
 			case 'GlwT': result.technique = BETE.decode(val) as any; break;
 			case 'glwS': result.source = IGSr.decode(val); break;
 			case 'Type': result.type = GrdT.decode(val); break;
-			case 'gs99': result.interpolationMethod = gradientInterpolationMethodType.decode(val); break;
+			case 'gs99': // gradient overlay
+			case 'gradientsInterpolationMethod': // glows
+				result.interpolationMethod = gradientInterpolationMethodType.decode(val);
+				break;
 			case 'Opct': result.opacity = parsePercent(val); break;
 			case 'hglO': result.highlightOpacity = parsePercent(val); break;
 			case 'sdwO': result.shadowOpacity = parsePercent(val); break;
@@ -1470,15 +1608,23 @@ function parseEffectObject(obj: any, reportErrors: boolean) {
 			case 'Dstn': result.distance = parseUnits(val); break;
 			case 'Scl ': result.scale = parsePercent(val); break;
 			case 'Ptrn': result.pattern = { name: val['Nm  '], id: val.Idnt }; break;
-			case 'phase': result.phase = { x: val.Hrzn, y: val.Vrtc }; break;
+			case 'phase': result.phase = parsePhase(val); break;
 			case 'Ofst': result.offset = { x: parsePercent(val.Hrzn), y: parsePercent(val.Vrtc) }; break;
 			case 'MpgS':
-			case 'TrnS':
-				result.contour = {
+			case 'TrnS': {
+				const contour: EffectContour = {
 					name: val['Nm  '],
 					curve: (val['Crv '] as any[]).map(p => ({ x: p.Hrzn, y: p.Vrtc })),
 				};
+
+				// bevel can have both: gloss contour (TrnS) and contour of the shape (MpgS)
+				if (objName === 'bevel' && key === 'MpgS') {
+					result.shapeContour = contour;
+				} else {
+					result.contour = contour;
+				}
 				break;
+			}
 			case 'Grad': result.gradient = parseGradient(val); break;
 			case 'useTexture':
 			case 'useShape':
@@ -1536,12 +1682,14 @@ function serializeEffectObject(obj: any, objName: string, reportErrors: boolean)
 				break;
 			case 'source': result.glwS = IGSr.encode(val); break;
 			case 'type': result.Type = GrdT.encode(val); break;
-			case 'interpolationMethod': result.gs99 = gradientInterpolationMethodType.encode(val); break;
+			case 'interpolationMethod':
+				result[(objName === 'outerGlow' || objName === 'innerGlow') ? 'gradientsInterpolationMethod' : 'gs99'] = gradientInterpolationMethodType.encode(val);
+				break;
 			case 'opacity': result.Opct = unitsPercent(val); break;
 			case 'highlightOpacity': result.hglO = unitsPercent(val); break;
 			case 'shadowOpacity': result.sdwO = unitsPercent(val); break;
 			case 'angle':
-				if (objName === 'gradientOverlay' || objName === 'patternFill') {
+				if (objName === 'gradientOverlay' || objName === 'patternOverlay') {
 					result.Angl = unitsAngle(val);
 				} else {
 					result.lagl = unitsAngle(val);
@@ -1559,14 +1707,9 @@ function serializeEffectObject(obj: any, objName: string, reportErrors: boolean)
 			case 'scale': result['Scl '] = unitsPercent(val); break;
 			case 'pattern': result.Ptrn = { 'Nm  ': val.name, Idnt: val.id }; break;
 			case 'phase': result.phase = { Hrzn: val.x, Vrtc: val.y }; break;
-			case 'offset': result.Ofst = { Hrzn: unitsPercent(val.x), Vrtc: unitsPercent(val.y) }; break;
-			case 'contour': {
-				result[objName === 'satin' ? 'MpgS' : 'TrnS'] = {
-					'Nm  ': (val as EffectContour).name,
-					'Crv ': (val as EffectContour).curve.map(p => ({ Hrzn: p.x, Vrtc: p.y })),
-				};
-				break;
-			}
+			case 'offset': result.Ofst = { Hrzn: unitsPercentF(val.x), Vrtc: unitsPercentF(val.y) }; break;
+			case 'contour': result[objName === 'satin' ? 'MpgS' : 'TrnS'] = serializeContour(val); break;
+			case 'shapeContour': result.MpgS = serializeContour(val); break;
 			case 'gradient': result.Grad = serializeGradient(val); break;
 			case 'useTexture':
 			case 'useShape':
@@ -1584,19 +1727,38 @@ function serializeEffectObject(obj: any, objName: string, reportErrors: boolean)
 	return result;
 }
 
+function serializeContour(contour: EffectContour) {
+	return {
+		'Nm  ': contour.name,
+		'Crv ': contour.curve.map(p => ({ Hrzn: p.x, Vrtc: p.y })),
+	};
+}
+
 function parseGradient(grad: DesciptorGradient): EffectSolidGradient | EffectNoiseGradient {
 	if (grad.GrdF === 'GrdF.CstS') {
-		const samples: number = grad.Intr || 4096;
+		// stop locations are always in 0..4096 range, independent of smoothness (Intr)
+		const samples = 4096;
 
 		return {
 			type: 'solid',
 			name: grad['Nm  '],
 			smoothness: grad.Intr / 4096,
-			colorStops: grad.Clrs.map(s => ({
-				color: parseColor(s['Clr ']),
-				location: s.Lctn / samples,
-				midpoint: s.Mdpn / 100,
-			})),
+			colorStops: grad.Clrs.map(s => {
+				const stop: ColorStop = {
+					color: s['Clr '] ? parseColor(s['Clr ']) : { r: 0, g: 0, b: 0 },
+					location: s.Lctn / samples,
+					midpoint: s.Mdpn / 100,
+				};
+
+				if (s.Type) {
+					try {
+						const type = Clry.decode(s.Type);
+						if (type !== 'user') stop.type = type;
+					} catch { } // unknown stop type, read as user color
+				}
+
+				return stop;
+			}),
 			opacityStops: grad.Trns.map(s => ({
 				opacity: parsePercent(s.Opct),
 				location: s.Lctn / samples,
@@ -1620,19 +1782,20 @@ function parseGradient(grad: DesciptorGradient): EffectSolidGradient | EffectNoi
 
 function serializeGradient(grad: EffectSolidGradient | EffectNoiseGradient): DesciptorGradient {
 	if (grad.type === 'solid') {
-		const samples = Math.round((grad.smoothness ?? 1) * 4096);
+		// stop locations are always in 0..4096 range, independent of smoothness (Intr)
+		const samples = 4096;
 		return {
 			'Nm  ': grad.name || '',
 			GrdF: 'GrdF.CstS',
-			Intr: samples,
+			Intr: Math.round((grad.smoothness ?? 1) * 4096),
 			Clrs: grad.colorStops.map(s => ({
 				'Clr ': serializeColor(s.color),
-				Type: 'Clry.UsrS',
+				Type: Clry.encode(s.type ?? 'user'),
 				Lctn: Math.round(s.location * samples),
 				Mdpn: Math.round((s.midpoint ?? 0.5) * 100),
 			})),
 			Trns: grad.opacityStops.map(s => ({
-				Opct: unitsPercent(s.opacity),
+				Opct: unitsPercentF(s.opacity),
 				Lctn: Math.round(s.location * samples),
 				Mdpn: Math.round((s.midpoint ?? 0.5) * 100),
 			})),
@@ -1646,8 +1809,8 @@ function serializeGradient(grad: EffectSolidGradient | EffectNoiseGradient): Des
 			ClrS: ClrS.encode(grad.colorModel),
 			RndS: grad.randomSeed || 0,
 			Smth: Math.round((grad.roughness ?? 1) * 4096),
-			'Mnm ': (grad.min || [0, 0, 0, 0]).map(x => x * 100),
-			'Mxm ': (grad.max || [1, 1, 1, 1]).map(x => x * 100),
+			'Mnm ': (grad.min || [0, 0, 0, 0]).map(x => Math.round(x * 100)),
+			'Mxm ': (grad.max || [1, 1, 1, 1]).map(x => Math.round(x * 100)),
 		};
 	}
 }
@@ -1670,13 +1833,23 @@ function parseGradientContent(descriptor: DescriptorGradientContent) {
 	return result;
 }
 
+// phase is usually stored as plain numbers, but some files store it as unit values
+function parsePhase({ Hrzn, Vrtc }: { Hrzn: number | DescriptorUnitsValue; Vrtc: number | DescriptorUnitsValue; }) {
+	return {
+		x: typeof Hrzn === 'number' ? Hrzn : Hrzn.value,
+		y: typeof Vrtc === 'number' ? Vrtc : Vrtc.value,
+	};
+}
+
 function parsePatternContent(descriptor: DescriptorPatternContent) {
 	const result: EffectPattern & ExtraPatternInfo = {
 		name: descriptor.Ptrn['Nm  '],
 		id: descriptor.Ptrn.Idnt,
 	};
 	if (descriptor.Lnkd !== undefined) result.linked = descriptor.Lnkd;
-	if (descriptor.phase !== undefined) result.phase = { x: descriptor.phase.Hrzn, y: descriptor.phase.Vrtc };
+	if (descriptor.phase !== undefined) result.phase = parsePhase(descriptor.phase);
+	if (descriptor['Scl '] !== undefined) result.scale = parsePercent(descriptor['Scl ']);
+	if (descriptor.Angl !== undefined) result.angle = parseAngle(descriptor.Angl);
 	return result;
 }
 
@@ -1701,11 +1874,11 @@ function serializeGradientContent(content: (EffectSolidGradient | EffectNoiseGra
 	if (content.angle !== undefined) result.Angl = unitsAngle(content.angle);
 	result.Type = GrdT.encode(content.style);
 	if (content.align !== undefined) result.Algn = content.align;
-	if (content.scale !== undefined) result['Scl '] = unitsPercent(content.scale);
+	if (content.scale !== undefined) result['Scl '] = unitsPercentF(content.scale);
 	if (content.offset) {
 		result.Ofst = {
-			Hrzn: unitsPercent(content.offset.x),
-			Vrtc: unitsPercent(content.offset.y),
+			Hrzn: unitsPercentF(content.offset.x),
+			Vrtc: unitsPercentF(content.offset.y),
 		};
 	}
 	result.Grad = serializeGradient(content);
@@ -1721,6 +1894,8 @@ function serializePatternContent(content: EffectPattern & ExtraPatternInfo) {
 	};
 	if (content.linked !== undefined) result.Lnkd = !!content.linked;
 	if (content.phase !== undefined) result.phase = { Hrzn: content.phase.x, Vrtc: content.phase.y };
+	if (content.scale !== undefined) result['Scl '] = unitsPercentF(content.scale);
+	if (content.angle !== undefined) result.Angl = unitsAngle(content.angle);
 	return result;
 }
 
@@ -1734,19 +1909,64 @@ export function serializeVectorContent(content: VectorContent): { descriptor: De
 	}
 }
 
+// Descriptor color values: HSB saturation/brightness 0..100, CMYK 0..100, Gray 0..100, Lab L 0..100, a/b -128..127
+// Color values (see psd.ts): HSB 0..1, CMYK 0..255, Gray 0..255, Lab L 0..1, a/b -1..1 (same as readColor/writeColor)
+
+const colorConversions: { [key: string]: ((x: number) => number)[] | undefined; } = {
+	// key: [descriptor -> color, color -> descriptor]
+	'H   ': [x => x / 360, x => x * 360], // angle
+	Strt: [x => x / 100, x => x * 100],
+	Brgh: [x => x / 100, x => x * 100],
+	'Cyn ': [x => x * 255 / 100, x => x * 100 / 255],
+	Mgnt: [x => x * 255 / 100, x => x * 100 / 255],
+	'Ylw ': [x => x * 255 / 100, x => x * 100 / 255],
+	Blck: [x => x * 255 / 100, x => x * 100 / 255],
+	'Gry ': [x => x * 255 / 100, x => x * 100 / 255],
+	Lmnc: [x => x / 100, x => x * 100],
+	'A   ': [normalizeLabAB, denormalizeLabAB],
+	'B   ': [normalizeLabAB, denormalizeLabAB],
+};
+
+function colorToDescriptorValue(key: string, value: number) {
+	const conversion = colorConversions[key];
+	if (!conversion) return value;
+	const [from, to] = conversion;
+	const result = to(value);
+	if (!isFinite(result)) return result;
+
+	// prefer shortest number that converts back to the same value (avoids values like 30.200000000000003)
+	for (let precision = 1; precision < 17; precision++) {
+		const candidate = +result.toPrecision(precision);
+		if (from(candidate) === value) return candidate;
+	}
+
+	return result;
+}
+
+function isBookColor(color: any) {
+	return color._classID === 'BkCl' || 'Bk  ' in color || 'bookID' in color;
+}
+
 export function parseColor(color: DescriptorColor): Color {
 	if ('H   ' in color) {
-		return { h: parsePercentOrAngle(color['H   ']), s: color.Strt, b: color.Brgh };
+		return { h: parsePercentOrAngle(color['H   ']), s: color.Strt / 100, b: color.Brgh / 100 };
 	} else if ('Rd  ' in color) {
 		return { r: color['Rd  '], g: color['Grn '], b: color['Bl  '] };
 	} else if ('Cyn ' in color) {
-		return { c: color['Cyn '], m: color.Mgnt, y: color['Ylw '], k: color.Blck };
+		return {
+			c: color['Cyn '] * 255 / 100,
+			m: color.Mgnt * 255 / 100,
+			y: color['Ylw '] * 255 / 100,
+			k: color.Blck * 255 / 100,
+		};
 	} else if ('Gry ' in color) {
-		return { k: color['Gry '] };
+		return { k: color['Gry '] * 255 / 100 };
 	} else if ('Lmnc' in color) {
-		return { l: color.Lmnc, a: color['A   '], b: color['B   '] };
+		return { l: color.Lmnc / 100, a: normalizeLabAB(color['A   ']), b: normalizeLabAB(color['B   ']) };
 	} else if ('redFloat' in color) {
 		return { fr: color.redFloat, fg: color.greenFloat, fb: color.blueFloat };
+	} else if (isBookColor(color)) {
+		return { r: 0, g: 0, b: 0 }; // book (Pantone) colors are not supported
 	} else {
 		throw new Error('Unsupported color descriptor');
 	}
@@ -1760,13 +1980,29 @@ export function serializeColor(color: Color | undefined): DescriptorColor {
 	} else if ('fr' in color) {
 		return { _name: '', _classID: 'RGBC', redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
 	} else if ('h' in color) {
-		return { _name: '', _classID: 'HSBC', 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
+		return {
+			_name: '', _classID: 'HSBC',
+			'H   ': unitsAngle(colorToDescriptorValue('H   ', color.h || 0)),
+			Strt: colorToDescriptorValue('Strt', color.s || 0),
+			Brgh: colorToDescriptorValue('Brgh', color.b || 0),
+		};
 	} else if ('c' in color) {
-		return { _name: '', _classID: 'CMYC', 'Cyn ': color.c || 0, Mgnt: color.m || 0, 'Ylw ': color.y || 0, Blck: color.k || 0 };
+		return {
+			_name: '', _classID: 'CMYC',
+			'Cyn ': colorToDescriptorValue('Cyn ', color.c || 0),
+			Mgnt: colorToDescriptorValue('Mgnt', color.m || 0),
+			'Ylw ': colorToDescriptorValue('Ylw ', color.y || 0),
+			Blck: colorToDescriptorValue('Blck', color.k || 0),
+		};
 	} else if ('l' in color) {
-		return { _name: '', _classID: 'LABC', Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
+		return {
+			_name: '', _classID: 'LbCl',
+			Lmnc: colorToDescriptorValue('Lmnc', color.l || 0),
+			'A   ': colorToDescriptorValue('A   ', color.a || 0),
+			'B   ': colorToDescriptorValue('B   ', color.b || 0),
+		};
 	} else if ('k' in color) {
-		return { _name: '', _classID: 'GRYC', 'Gry ': color.k };
+		return { _name: '', _classID: 'Grsc', 'Gry ': colorToDescriptorValue('Gry ', color.k || 0) };
 	} else {
 		throw new Error('Invalid color value');
 	}
@@ -1794,7 +2030,8 @@ export function parsePercentOrAngle(x: DescriptorUnitsValue | undefined) {
 export function parseUnits({ units, value }: DescriptorUnitsValue): UnitsValue {
 	if (
 		units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
-		units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density'
+		units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density' &&
+		units !== 'Distance'
 	) {
 		throw new Error(`Invalid units: ${JSON.stringify({ units, value })}`);
 	}
@@ -1836,7 +2073,8 @@ export function unitsValue(x: UnitsValue | undefined, key: string): DescriptorUn
 
 	if (
 		units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
-		units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density'
+		units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density' &&
+		units !== 'Distance'
 	) {
 		throw new Error(`Invalid units in ${JSON.stringify(x)} (key: ${key})`);
 	}
@@ -1982,6 +2220,12 @@ export const gradientInterpolationMethodType = createEnum<InterpolationMethod>('
 	// TODO: stripes
 });
 
+export const Clry = createEnum<'user' | 'foreground' | 'background'>('Clry', 'user', {
+	user: 'UsrS',
+	foreground: 'FrgC',
+	background: 'BckC',
+});
+
 export const ClrS = createEnum<'rgb' | 'hsb' | 'lab' | 'hsl'>('ClrS', 'rgb', {
 	rgb: 'RGBC',
 	hsb: 'HSBl',