ag-psd 32.0.0 → 34.0.0

package/src/descriptor.ts

@@ -1,6 +1,6 @@
 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,
@@ -44,11 +44,6 @@ const unitsMap: Dict = {
 };
 
 const unitsMapRev = revMap(unitsMap);
-let logErrors = false;
-
-export function setLogErrors(value: boolean) {
-	logErrors = value;
-}
 
 function makeType(name: string, classID: string) {
 	return { name, classID };
@@ -98,6 +93,7 @@ const fieldToExtType: ExtTypeDict = {
 	psVersion: nullType,
 	docDefaultNewArtboardBackgroundColor: makeType('', 'RGBC'),
 	artboardRect: makeType('', 'classFloatRect'),
+	framedGroupRect: makeType('', 'classFloatRect'),
 	keyOriginRRectRadii: makeType('', 'radii'),
 	keyOriginBoxCorners: nullType,
 	rectangleCornerA: makeType('', 'Pnt '),
@@ -149,6 +145,7 @@ const fieldToArrayExtType: ExtTypeDict = {
 	Clrs: makeType('', 'Clrt'),
 	Trns: makeType('', 'TrnS'),
 	keyDescriptorList: nullType,
+	keyRootDescriptorList: nullType,
 	solidFillMulti: makeType('', 'SoFi'),
 	gradientFillMulti: makeType('', 'GrFl'),
 	dropShadowMulti: makeType('', 'DrSh'),
@@ -183,17 +180,23 @@ const fieldToArrayExtType: ExtTypeDict = {
 
 const typeToField: { [key: string]: string[]; } = {
 	'TEXT': [
-		'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
+		'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName', 'exportOption', 'scaleSettings',
+		'BackgroundImagePath', 'ImageSubfolderName', 'SavedIteratedName',
 		'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',
@@ -205,7 +208,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',
+		'pixelSourceType', 'framedGroupType',
 	],
 	'enum': [
 		'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
@@ -215,7 +218,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', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod',
+		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod', 'pathSymmetryMode',
 		'interpretAlpha',
 	],
 	'bool': [
@@ -229,15 +232,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', 'Lnkd', 'showAlteredVideo', 'lightingOn',
+		'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn', 'LockPPI',
 	],
 	'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',
-		'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity',
+		'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity', 'PreferredResolution',
 	],
 	'UntF': [
 		'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -246,7 +249,7 @@ 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',
@@ -268,53 +271,45 @@ const channels = [
 // color classes whose channel values are written as doubles ('GRYC' and 'LABC' are kept for backwards compatibility)
 const doubleColorClasses = ['Grsc', 'LbCl', 'GRYC', 'LABC'];
 
-// Hidden (non-enumerable) markers used to remember how values were stored in the file, so they can be
-// written back the same way. They don't change the shape of the objects returned by the reader.
-const osTypeKey = typeof Symbol !== 'undefined' ? Symbol('agPsdOSType') : '__agPsdOSType';
-const obArInfoKey = typeof Symbol !== 'undefined' ? Symbol('agPsdObAr') : '__agPsdObAr';
-const referenceInfoKey = typeof Symbol !== 'undefined' ? Symbol('agPsdReference') : '__agPsdReference';
-
-function setHidden<T extends object>(target: T, key: symbol | string, value: any): T {
-	Object.defineProperty(target, key, { value, enumerable: false, configurable: true, writable: true });
-	return target;
-}
-
-function getHidden(target: any, key: symbol | string): any {
-	return (target && typeof target === 'object') ? target[key] : undefined;
-}
+// fallback for unknown keys, based on the type of the value
+export const cameraRawFilterClassID = 'Adobe Camera Raw Filter';
 
-const osTypeFamilies: { [key: string]: string; } = {
-	UntF: 'UntF', UnFl: 'UntF',
-	Objc: 'Objc', GlbO: 'Objc',
-	type: 'type', GlbC: 'type',
-	comp: 'comp',
+// types of Camera Raw Filter settings (keys clash with other descriptors so they're typed by class)
+export const cameraRawFilterKeyTypes: Dict = {
+	CrVe: 'TEXT', PrVN: 'long', PrVe: 'long', WBal: 'enum', Ex12: 'doub', ShpR: 'doub',
+	'Crv ': 'VlLs', CrvR: 'VlLs', CrvG: 'VlLs', CrvB: 'VlLs',
 };
 
-// returns the OS type the value was originally read with, if it's compatible with the type we'd write it as
-// 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' && typeof value._classID === 'string') return 'Objc';
-	return undefined;
-}
 
-function getRecordedOSType(value: any, type: string | undefined): string | undefined {
-	const recorded: string | undefined = getHidden(value, osTypeKey);
-	if (!recorded) return type;
-	if (!type || recorded === 'comp' || recorded === 'type' || recorded === 'GlbC') return recorded;
-	return osTypeFamilies[recorded] === osTypeFamilies[type] ? recorded : type;
+	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',
@@ -396,6 +391,12 @@ function getTypeByKey(key: string, value: any, root: string, parent: any) {
 		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 {
@@ -409,7 +410,7 @@ export function readAsciiStringOrClassId(reader: PsdReader) {
 }
 
 export function writeAsciiStringOrClassId(writer: PsdWriter, value: string) {
-	if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list') {
+	if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list' && value !== 'json') {
 		// write classId
 		writeInt32(writer, 0);
 		writeSignature(writer, value);
@@ -441,12 +442,21 @@ 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);
+	if (writer.logMissingFeatures && !classId) writer.log('Missing classId for: ', name, classId, value);
 
 	// write class structure
 	writeUnicodeStringWithPadding(writer, name);
-	writeAsciiStringOrClassId(writer, classId);
+
+	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);
+	}
 
 	const allKeys = Object.keys(value);
 	const keys = allKeys.filter(key => key !== '_name' && key !== '_classID' && value[key] !== undefined);
@@ -458,6 +468,11 @@ export function writeDescriptorStructure(writer: PsdWriter, name: string, classI
 		let childRoot = root;
 		let extType = fieldToExtType[key];
 
+		if (classId === cameraRawFilterClassID) {
+			type = cameraRawFilterKeyTypes[key] ?? 'long'; // other settings are integer levels
+			childRoot = cameraRawFilterClassID; // lists (curves) contain integer levels
+		}
+
 		if (key === 'bounds' && root === 'text') {
 			extType = makeType('', 'bounds');
 		} else if (key === 'origin') {
@@ -527,24 +542,26 @@ export function writeDescriptorStructure(writer: PsdWriter, name: string, classI
 			} else if (value[key].Ptrn) {
 				extType = makeType('', 'patternLayer');
 			} else {
-				logErrors && console.log('Invalid strokeStyleContent value', value[key]);
+				writer.logMissingFeatures && writer.log('Invalid strokeStyleContent value', value[key]);
 			}
 		} else if (key === 'bounds' && root === 'quiltWarp') {
 			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: '' };
 		}
 
-		type = getRecordedOSType(value[key], type);
 		if (!type) type = guessOSType(value[key]);
 
 		writeAsciiStringOrClassId(writer, key);
 		writeSignature(writer, type || 'long');
 		writeOSType(writer, type || 'long', value[key], key, extType, childRoot);
-		if (logErrors && !type) console.log(`Missing descriptor field type for: '${key}' in`, value);
+		if (writer.logMissingFeatures && !type) writer.log(`Missing descriptor field type for: '${key}' in`, value);
 	}
 }
 
@@ -553,9 +570,8 @@ function readOSType(reader: PsdReader, type: string, includeClass: boolean) {
 		case 'obj ': // Reference
 			return readReferenceStructure(reader);
 		case 'Objc': // Descriptor
-			return readDescriptorStructure(reader, includeClass);
 		case 'GlbO': // GlobalObject same as Descriptor
-			return setHidden(readDescriptorStructure(reader, includeClass), osTypeKey, type);
+			return readDescriptorStructure(reader, includeClass);
 		case 'VlLs': { // List
 			const length = readInt32(reader);
 			const items: any[] = [];
@@ -580,7 +596,7 @@ function readOSType(reader: PsdReader, type: string, includeClass: boolean) {
 			const units = readSignature(reader);
 			const value = readFloat32(reader);
 			if (!unitsMap[units]) throw new Error(`Invalid units: ${units}`);
-			return setHidden({ units: unitsMap[units], value }, osTypeKey, type);
+			return { units: unitsMap[units], value };
 		}
 		case 'TEXT': // String
 			return readUnicodeString(reader);
@@ -594,13 +610,13 @@ function readOSType(reader: PsdReader, type: string, includeClass: boolean) {
 		case 'comp': { // Large Integer
 			const low = readUint32(reader);
 			const high = readUint32(reader);
-			return setHidden({ low, high }, osTypeKey, type);
+			return { low, high };
 		}
 		case 'bool': // Boolean
 			return !!readUint8(reader);
 		case 'type': // Class
 		case 'GlbC': // Class
-			return setHidden(readClassStructure(reader), osTypeKey, type);
+			return readClassStructure(reader);
 		case 'alis': { // Alias
 			const length = readInt32(reader);
 			return readAsciiString(reader, length);
@@ -612,24 +628,24 @@ function readOSType(reader: PsdReader, type: string, includeClass: boolean) {
 		case 'ObAr': { // Object array
 			readInt32(reader); // version: 16
 			readUnicodeString(reader); // name: ''
-			const classID = 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
-				const valueType = readSignature(reader); // UnFl
-				const units = readSignature(reader); // units ? '#Pxl'
+				readSignature(reader); // UnFl
+				readSignature(reader); // units ? '#Pxl'
 				const valuesCount = readInt32(reader);
 				const values: number[] = [];
 				for (let j = 0; j < valuesCount; j++) {
 					values.push(readFloat64(reader));
 				}
 
-				items.push(setHidden({ type: type1, values }, obArInfoKey, { valueType, units }));
+				items.push({ type: type1, values });
 			}
 
-			return setHidden(items, obArInfoKey, { classID });
+			return items;
 		}
 		case 'Pth ': { // File path
 			/*const length =*/ readInt32(reader); // total size of all fields below
@@ -669,10 +685,10 @@ 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 = getRecordedOSType(value[i], fieldToArrayType[key]) ?? guessOSType(value[i]);
+				const type = root === cameraRawFilterClassID ? 'long' : (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);
+				if (writer.logMissingFeatures && !type) writer.log(`Missing descriptor array type for: '${key}' in`, value);
 			}
 			break;
 		case 'doub': // Double
@@ -733,16 +749,15 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 		case 'ObAr': { // Object array
 			writeInt32(writer, 16); // version
 			writeUnicodeStringWithPadding(writer, ''); // name
-			const type = getHidden(value, obArInfoKey)?.classID ?? ObArTypes[key];
+			const type = ObArTypes[key];
 			if (!type) throw new Error(`Not implemented ObArType for: ${key}`);
 			writeAsciiStringOrClassId(writer, type);
 			writeInt32(writer, value.length);
 
 			for (let i = 0; i < value.length; i++) {
-				const info = getHidden(value[i], obArInfoKey);
 				writeAsciiStringOrClassId(writer, value[i].type); // Hrzn | Vrtc
-				writeSignature(writer, info?.valueType ?? 'UnFl');
-				writeSignature(writer, info?.units ?? '#Pxl');
+				writeSignature(writer, 'UnFl');
+				writeSignature(writer, '#Pxl');
 				writeInt32(writer, value[i].values.length);
 
 				for (let j = 0; j < value[i].values.length; j++) {
@@ -752,12 +767,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:
@@ -765,86 +781,64 @@ 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;
+	_name?: string; // class name
+	_classID?: string;
 	keyID?: string; // prop
 	typeID?: string; // Enmr
 	enumValue?: string; // Enmr
 	value?: string | number; // rele, Idnt, indx, name
 }
 
-function referenceItemToValue(item: DescriptorReferenceItem): any {
-	switch (item.type) {
-		case 'prop': return item.keyID;
-		case 'Clss': return { name: item.name || '', classID: item.classID };
-		case 'Enmr': return `${item.typeID}.${item.enumValue}`;
-		default: return item.value;
-	}
-}
-
-function referenceItemMatches(item: DescriptorReferenceItem | undefined, value: any) {
-	if (!item) return false;
-	const expected = referenceItemToValue(item);
-	if (expected && typeof expected === 'object') {
-		return !!value && typeof value === 'object' && value.name === expected.name && value.classID === expected.classID;
-	}
-	return expected === value;
-}
+const referenceTypes = ['prop', 'Clss', 'Enmr', 'rele', 'Idnt', 'indx', 'name'];
 
-// Attaches information about how each item of reference should be written (class IDs, reference types),
-// the public value of the array stays the same (array of strings/numbers/class objects)
-export function createDescriptorReference(items: DescriptorReferenceItem[]): any[] {
-	return setHidden(items.map(referenceItemToValue), referenceInfoKey, items);
+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 infos: DescriptorReferenceItem[] = [];
+	const items: any[] = [];
 
 	for (let i = 0; i < itemsCount; i++) {
 		const type = readSignature(reader);
 
 		switch (type) {
-			case 'prop': { // Property
-				const { name, classID } = readClassStructure(reader);
-				const keyID = readAsciiStringOrClassId(reader);
-				infos.push({ type, name, classID, keyID });
+			case 'prop': // Property
+				readClassStructure(reader);
+				items.push(readAsciiStringOrClassId(reader));
 				break;
-			}
-			case 'Clss': { // Class
-				const { name, classID } = readClassStructure(reader);
-				infos.push({ type, name, classID });
+			case 'Clss': // Class
+				items.push(readClassStructure(reader));
 				break;
-			}
 			case 'Enmr': { // Enumerated Reference
-				const { name, classID } = readClassStructure(reader);
+				readClassStructure(reader);
 				const typeID = readAsciiStringOrClassId(reader);
 				const enumValue = readAsciiStringOrClassId(reader);
-				infos.push({ type, name, classID, typeID, enumValue });
+				items.push(`${typeID}.${enumValue}`);
 				break;
 			}
-			case 'rele': { // Offset
-				const { name, classID } = readClassStructure(reader);
-				infos.push({ type, name, classID, value: readUint32(reader) });
+			case 'rele': // Offset
+				readClassStructure(reader);
+				items.push(readUint32(reader));
 				break;
-			}
 			case 'Idnt': // Identifier
 			case 'indx': // Index
-				infos.push({ type, value: readInt32(reader) });
+				items.push(readInt32(reader));
 				break;
-			case 'name': { // Name
-				const { name, classID } = readClassStructure(reader);
-				infos.push({ type, name, classID, value: readUnicodeString(reader) });
+			case 'name': // Name
+				readClassStructure(reader);
+				items.push(readUnicodeString(reader));
 				break;
-			}
 			default:
 				throw new Error(`Invalid descriptor reference type: ${type}`);
 		}
 	}
 
-	return createDescriptorReference(infos);
+	return items;
 }
 
 function guessReferenceItem(value: any): DescriptorReferenceItem {
@@ -854,14 +848,14 @@ function guessReferenceItem(value: any): DescriptorReferenceItem {
 		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] };
+			return { type: 'Enmr', _name: '', _classID: match[1], typeID: match[1], enumValue: match[2] };
 		} else {
-			return { type: 'name', name: '', classID: 'Lyr ', value };
+			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 };
+		return { type: 'Clss', _name: value.name || '', _classID: value.classID };
 	} else {
 		throw new Error(`Invalid descriptor reference value: ${JSON.stringify(value)}`);
 	}
@@ -869,46 +863,39 @@ function guessReferenceItem(value: any): DescriptorReferenceItem {
 
 // 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[]): any[] {
-	const infos: DescriptorReferenceItem[] | undefined = getHidden(items, referenceInfoKey);
-
-	return createDescriptorReference(items.map((value, i) => {
-		if (referenceItemMatches(infos?.[i], value)) return infos![i]; // keep information read from the file
-
+export function pathSelectionStateToReference(items: string[]): DescriptorReferenceItem[] {
+	return items.map(value => {
 		const item = guessReferenceItem(value);
-		if (item.type === 'Enmr') item.classID = 'Path';
+		if (item.type === 'Enmr') item._classID = 'Path';
 		return item;
-	}));
+	});
 }
 
 function writeReferenceStructure(writer: PsdWriter, _key: string, items: any[]) {
 	if (!Array.isArray(items)) throw new Error(`Invalid reference value: ${JSON.stringify(items)}, key: ${_key}`);
 
-	const infos: DescriptorReferenceItem[] | undefined = getHidden(items, referenceInfoKey);
 	writeInt32(writer, items.length);
 
-	for (let i = 0; i < items.length; i++) {
-		const value = items[i];
-		const recorded = infos?.[i];
-		const item = referenceItemMatches(recorded, value) ? recorded! : guessReferenceItem(value);
+	for (const value of items) {
+		const item = isReferenceItem(value) ? value : guessReferenceItem(value);
 
 		writeSignature(writer, item.type);
 
 		switch (item.type) {
 			case 'prop': // Property
-				writeClassStructure(writer, item.name || '', item.classID!);
+				writeClassStructure(writer, item._name || '', item._classID!);
 				writeAsciiStringOrClassId(writer, item.keyID!);
 				break;
 			case 'Clss': // Class
-				writeClassStructure(writer, item.name || '', item.classID!);
+				writeClassStructure(writer, item._name || '', item._classID!);
 				break;
 			case 'Enmr': // Enumerated Reference
-				writeClassStructure(writer, item.name || '', item.classID!);
+				writeClassStructure(writer, item._name || '', item._classID!);
 				writeAsciiStringOrClassId(writer, item.typeID!);
 				writeAsciiStringOrClassId(writer, item.enumValue!);
 				break;
 			case 'rele': // Offset
-				writeClassStructure(writer, item.name || '', item.classID!);
+				writeClassStructure(writer, item._name || '', item._classID!);
 				writeUint32(writer, item.value as number);
 				break;
 			case 'Idnt': // Identifier
@@ -916,7 +903,7 @@ function writeReferenceStructure(writer: PsdWriter, _key: string, items: any[])
 				writeInt32(writer, item.value as number);
 				break;
 			case 'name': // Name
-				writeClassStructure(writer, item.name || '', item.classID!);
+				writeClassStructure(writer, item._name || '', item._classID!);
 				writeUnicodeStringWithPadding(writer, `${item.value}`);
 				break;
 			default:
@@ -1006,8 +993,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;
 	}[];
@@ -1047,7 +1034,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;
@@ -1343,7 +1332,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;
@@ -1373,7 +1362,7 @@ function serializeFxObject(stroke: LayerEffectStroke) {
 	return FrFX;
 }
 
-export function serializeEffects(e: LayerEffectsInfo, log: boolean, multi: boolean) {
+export function serializeEffects(e: LayerEffectsInfo, writer: PsdWriter, multi: boolean) {
 	const info: Lfx2Descriptor & LmfxDescriptor = multi ? {
 		'Scl ': unitsPercentF(e.scale ?? 1),
 		masterFXSwitch: !e.disabled,
@@ -1390,20 +1379,20 @@ export function serializeEffects(e: LayerEffectsInfo, log: boolean, multi: boole
 	const useMulti = <T>(arr: undefined | T[]): arr is T[] => !!arr && arr.length > 1 && multi;
 	const useSingle = <T>(arr: undefined | T[]): arr is T[] => !!arr && arr.length >= 1 && (!multi || arr.length === 1);
 
-	if (useSingle(e.dropShadow)) info.DrSh = serializeEffectObject(e.dropShadow[0], 'dropShadow', log);
-	if (useMulti(e.dropShadow)) info.dropShadowMulti = e.dropShadow.map(i => serializeEffectObject(i, 'dropShadow', log));
-	if (useSingle(e.innerShadow)) info.IrSh = serializeEffectObject(e.innerShadow[0], 'innerShadow', log);
-	if (useMulti(e.innerShadow)) info.innerShadowMulti = e.innerShadow.map(i => serializeEffectObject(i, 'innerShadow', log));
-	if (e.outerGlow) info.OrGl = serializeEffectObject(e.outerGlow, 'outerGlow', log);
-	if (useMulti(e.solidFill)) info.solidFillMulti = e.solidFill.map(i => serializeEffectObject(i, 'solidFill', log));
-	if (useMulti(e.gradientOverlay)) info.gradientFillMulti = e.gradientOverlay.map(i => serializeEffectObject(i, 'gradientOverlay', log));
+	if (useSingle(e.dropShadow)) info.DrSh = serializeEffectObject(e.dropShadow[0], 'dropShadow', writer);
+	if (useMulti(e.dropShadow)) info.dropShadowMulti = e.dropShadow.map(i => serializeEffectObject(i, 'dropShadow', writer));
+	if (useSingle(e.innerShadow)) info.IrSh = serializeEffectObject(e.innerShadow[0], 'innerShadow', writer);
+	if (useMulti(e.innerShadow)) info.innerShadowMulti = e.innerShadow.map(i => serializeEffectObject(i, 'innerShadow', writer));
+	if (e.outerGlow) info.OrGl = serializeEffectObject(e.outerGlow, 'outerGlow', writer);
+	if (useMulti(e.solidFill)) info.solidFillMulti = e.solidFill.map(i => serializeEffectObject(i, 'solidFill', writer));
+	if (useMulti(e.gradientOverlay)) info.gradientFillMulti = e.gradientOverlay.map(i => serializeEffectObject(i, 'gradientOverlay', writer));
 	if (useMulti(e.stroke)) info.frameFXMulti = e.stroke.map(i => serializeFxObject(i));
-	if (e.innerGlow) info.IrGl = serializeEffectObject(e.innerGlow, 'innerGlow', log);
-	if (e.bevel) info.ebbl = serializeEffectObject(e.bevel, 'bevel', log);
-	if (useSingle(e.solidFill)) info.SoFi = serializeEffectObject(e.solidFill[0], 'solidFill', log);
-	if (e.patternOverlay) info.patternFill = serializeEffectObject(e.patternOverlay, 'patternOverlay', log);
-	if (useSingle(e.gradientOverlay)) info.GrFl = serializeEffectObject(e.gradientOverlay[0], 'gradientOverlay', log);
-	if (e.satin) info.ChFX = serializeEffectObject(e.satin, 'satin', log);
+	if (e.innerGlow) info.IrGl = serializeEffectObject(e.innerGlow, 'innerGlow', writer);
+	if (e.bevel) info.ebbl = serializeEffectObject(e.bevel, 'bevel', writer);
+	if (useSingle(e.solidFill)) info.SoFi = serializeEffectObject(e.solidFill[0], 'solidFill', writer);
+	if (e.patternOverlay) info.patternFill = serializeEffectObject(e.patternOverlay, 'patternOverlay', writer);
+	if (useSingle(e.gradientOverlay)) info.GrFl = serializeEffectObject(e.gradientOverlay[0], 'gradientOverlay', writer);
+	if (e.satin) info.ChFX = serializeEffectObject(e.satin, 'satin', writer);
 	if (useSingle(e.stroke)) info.FrFX = serializeFxObject(e.stroke?.[0]);
 
 	if (multi) {
@@ -1426,31 +1415,31 @@ export function serializeEffects(e: LayerEffectsInfo, log: boolean, multi: boole
 	return info;
 }
 
-export function parseEffects(info: Lfx2Descriptor & LmfxDescriptor, log: boolean) {
+export function parseEffects(info: Lfx2Descriptor & LmfxDescriptor, reader: PsdReader) {
 	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 (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 (SoFi) effects.solidFill = [parseEffectObject(SoFi, log)];
-	if (solidFillMulti) effects.solidFill = solidFillMulti.map(i => parseEffectObject(i, log));
-	if (patternFill) effects.patternOverlay = parseEffectObject(patternFill, log);
-	if (GrFl) effects.gradientOverlay = [parseEffectObject(GrFl, log)];
-	if (gradientFillMulti) effects.gradientOverlay = gradientFillMulti.map(i => parseEffectObject(i, log));
-	if (ChFX) effects.satin = parseEffectObject(ChFX, log);
+	if (scale) effects.scale = parsePercent(scale);
+	if (DrSh) effects.dropShadow = [parseEffectObject(DrSh, reader)];
+	if (dropShadowMulti) effects.dropShadow = dropShadowMulti.map(i => parseEffectObject(i, reader));
+	if (IrSh) effects.innerShadow = [parseEffectObject(IrSh, reader)];
+	if (innerShadowMulti) effects.innerShadow = innerShadowMulti.map(i => parseEffectObject(i, reader));
+	if (OrGl) effects.outerGlow = parseEffectObject(OrGl, reader);
+	if (IrGl) effects.innerGlow = parseEffectObject(IrGl, reader);
+	if (ebbl) effects.bevel = parseEffectObject(ebbl, reader, 'bevel');
+	if (SoFi) effects.solidFill = [parseEffectObject(SoFi, reader)];
+	if (solidFillMulti) effects.solidFill = solidFillMulti.map(i => parseEffectObject(i, reader));
+	if (patternFill) effects.patternOverlay = parseEffectObject(patternFill, reader);
+	if (GrFl) effects.gradientOverlay = [parseEffectObject(GrFl, reader)];
+	if (gradientFillMulti) effects.gradientOverlay = gradientFillMulti.map(i => parseEffectObject(i, reader));
+	if (ChFX) effects.satin = parseEffectObject(ChFX, reader);
 	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 (reader.logMissingFeatures && Object.keys(rest).length) reader.log('Unhandled effect keys:', rest);
 	return effects;
 }
 
-function parseKeyList(keyList: TimelineKeyDescriptor[], logMissingFeatures: boolean) {
+function parseKeyList(keyList: TimelineKeyDescriptor[], reader: PsdReader) {
 	const keys: TimelineKey[] = [];
 
 	for (let j = 0; j < keyList.length; j++) {
@@ -1474,7 +1463,7 @@ function parseKeyList(keyList: TimelineKeyDescriptor[], logMissingFeatures: bool
 				break;
 			case 'keyType.sheetStyle': {
 				const key: TimelineKey = { interpolation, time, selected, type: 'style' };
-				if (animKey.sheetStyle.Lefx) key.style = parseEffects(animKey.sheetStyle.Lefx, logMissingFeatures);
+				if (animKey.sheetStyle.Lefx) key.style = parseEffects(animKey.sheetStyle.Lefx, reader);
 				keys.push(key);
 				break;
 			}
@@ -1492,7 +1481,7 @@ function parseKeyList(keyList: TimelineKeyDescriptor[], logMissingFeatures: bool
 	return keys;
 }
 
-function serializeKeyList(keys: TimelineKey[]): TimelineKeyDescriptor[] {
+function serializeKeyList(keys: TimelineKey[], writer: PsdWriter): TimelineKeyDescriptor[] {
 	const keyList: TimelineKeyDescriptor[] = [];
 
 	for (let j = 0; j < keys.length; j++) {
@@ -1513,7 +1502,7 @@ function serializeKeyList(keys: TimelineKey[]): TimelineKeyDescriptor[] {
 				break;
 			case 'style':
 				animKey = { Type: 'keyType.sheetStyle', sheetStyle: { Vrsn: 1, blendOptions: {} } };
-				if (key.style) animKey.sheetStyle = { Vrsn: 1, Lefx: serializeEffects(key.style, false, false), blendOptions: {} };
+				if (key.style) animKey.sheetStyle = { Vrsn: 1, Lefx: serializeEffects(key.style, writer, false), blendOptions: {} };
 				break;
 			case 'globalLighting': {
 				animKey = { Type: 'keyType.globalLighting', gblA: key.globalAngle, globalAltitude: key.globalAltitude };
@@ -1528,7 +1517,7 @@ function serializeKeyList(keys: TimelineKey[]): TimelineKeyDescriptor[] {
 	return keyList;
 }
 
-export function parseTrackList(trackList: TimelineTrackDescriptor[], logMissingFeatures: boolean) {
+export function parseTrackList(trackList: TimelineTrackDescriptor[], reader: PsdReader) {
 	const tracks: TimelineTrack[] = [];
 
 	for (let i = 0; i < trackList.length; i++) {
@@ -1536,14 +1525,14 @@ export function parseTrackList(trackList: TimelineTrackDescriptor[], logMissingF
 		const track: TimelineTrack = {
 			type: stdTrackID.decode(tr.trackID),
 			enabled: tr.enab,
-			keys: parseKeyList(tr.keyList, logMissingFeatures),
+			keys: parseKeyList(tr.keyList, reader),
 		};
 
 		if (tr.effectParams) {
 			track.effectParams = {
 				fillCanvas: tr.effectParams.fillCanvas,
 				zoomOrigin: tr.effectParams.zoomOrigin,
-				keys: parseKeyList(tr.effectParams.keyList, logMissingFeatures),
+				keys: parseKeyList(tr.effectParams.keyList, reader),
 			};
 		}
 
@@ -1553,7 +1542,7 @@ export function parseTrackList(trackList: TimelineTrackDescriptor[], logMissingF
 	return tracks;
 }
 
-export function serializeTrackList(tracks: TimelineTrack[]): TimelineTrackDescriptor[] {
+export function serializeTrackList(tracks: TimelineTrack[], writer: PsdWriter): TimelineTrackDescriptor[] {
 	const trackList: TimelineTrackDescriptor[] = [];
 
 	for (let i = 0; i < tracks.length; i++) {
@@ -1565,12 +1554,12 @@ export function serializeTrackList(tracks: TimelineTrack[]): TimelineTrackDescri
 			Effc: !!t.effectParams,
 			...(t.effectParams ? {
 				effectParams: {
-					keyList: serializeKeyList(t.effectParams.keys),
+					keyList: serializeKeyList(t.effectParams.keys, writer),
 					fillCanvas: t.effectParams.fillCanvas,
 					zoomOrigin: t.effectParams.zoomOrigin,
 				}
 			} : {}),
-			keyList: serializeKeyList(t.keys),
+			keyList: serializeKeyList(t.keys, writer),
 		});
 	}
 
@@ -1581,7 +1570,7 @@ type AllEffects = LayerEffectShadow & LayerEffectsOuterGlow & LayerEffectStroke
 	LayerEffectInnerGlow & LayerEffectBevel & LayerEffectSolidFill &
 	LayerEffectPatternOverlay & LayerEffectSatin & LayerEffectGradientOverlay;
 
-function parseEffectObject(obj: any, reportErrors: boolean) {
+function parseEffectObject(obj: any, reader: PsdReader, objName?: string) {
 	const result: AllEffects = {} as any;
 
 	for (const key of Object.keys(obj)) {
@@ -1608,7 +1597,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;
@@ -1625,15 +1617,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':
@@ -1645,14 +1645,14 @@ function parseEffectObject(obj: any, reportErrors: boolean) {
 			case '_classID':
 				break;
 			default:
-				reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+				reader.logMissingFeatures && reader.log(`Invalid effect key: '${key}', value:`, val);
 		}
 	}
 
 	return result;
 }
 
-function serializeEffectObject(obj: any, objName: string, reportErrors: boolean) {
+function serializeEffectObject(obj: any, objName: string, writer: PsdWriter) {
 	const result: any = {
 		enab: false,
 	};
@@ -1691,7 +1691,9 @@ 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;
@@ -1714,14 +1716,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':
@@ -1732,13 +1729,20 @@ function serializeEffectObject(obj: any, objName: string, reportErrors: boolean)
 				result[key] = val;
 				break;
 			default:
-				reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+				writer.logMissingFeatures && writer.log(`Invalid effect key: '${key}', value:`, val);
 		}
 	}
 
 	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') {
 		// stop locations are always in 0..4096 range, independent of smoothness (Intr)
@@ -1748,11 +1752,22 @@ function parseGradient(grad: DesciptorGradient): EffectSolidGradient | EffectNoi
 			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,
@@ -1784,12 +1799,12 @@ function serializeGradient(grad: EffectSolidGradient | EffectNoiseGradient): Des
 			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),
 			})),
@@ -1827,13 +1842,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;
 }
 
@@ -1858,11 +1883,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);
@@ -1878,6 +1903,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;
 }
 
@@ -1894,10 +1921,9 @@ 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 colorSourceKey = typeof Symbol !== 'undefined' ? Symbol('agPsdColorSource') : '__agPsdColorSource';
-
 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],
@@ -1926,38 +1952,63 @@ function colorToDescriptorValue(key: string, value: number) {
 	return result;
 }
 
-function shallowEqual(a: any, b: any) {
-	const keys = Object.keys(a);
-	if (keys.length !== Object.keys(b).length) return false;
-	return keys.every(key => a[key] === b[key]);
+function isBookColor(color: any) {
+	return color._classID === 'BkCl' || 'Bk  ' in color || 'bookID' in color;
 }
 
 export function parseColor(color: DescriptorColor): Color {
-	let result: Color;
+	const result = parseColorValues(color);
+
+	if (isBookColor(color)) {
+		const book = color as any as { 'Bk  '?: string; 'Nm  '?: string; bookID?: number; bookKey?: Uint8Array | string; };
+		const key = book.bookKey;
+		result.book = {
+			book: book['Bk  '] ?? '',
+			name: book['Nm  '] ?? '',
+			bookID: book.bookID ?? 0,
+			bookKey: typeof key === 'string' ? key : (key ? String.fromCharCode(...Array.from(key)) : ''),
+		};
+	}
+
+	return result;
+}
 
+function parseColorValues(color: DescriptorColor): Color {
 	if ('H   ' in color) {
-		result = { h: parsePercentOrAngle(color['H   ']), s: color.Strt / 100, b: color.Brgh / 100 };
+		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) {
-		result = {
+		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) {
-		result = { k: color['Gry '] * 255 / 100 };
+		return { k: color['Gry '] * 255 / 100 };
 	} else if ('Lmnc' in color) {
-		result = { l: color.Lmnc / 100, a: normalizeLabAB(color['A   ']), b: normalizeLabAB(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) color without color values
 	} else {
 		throw new Error('Unsupported color descriptor');
 	}
+}
+
+export function serializeColor(color: Color | undefined): DescriptorColor {
+	const result = serializeColorValues(color);
+
+	if (color?.book) {
+		const { book, name, bookID, bookKey } = color.book;
+		const key = new Uint8Array(bookKey.length);
+		for (let i = 0; i < key.length; i++) key[i] = bookKey.charCodeAt(i) & 0xff;
+		Object.assign(result, { 'Bk  ': book, 'Nm  ': name, bookID, bookKey: key });
+	}
 
-	// remember original descriptor values, so unmodified colors can be written back without conversion errors
-	return setHidden(result, colorSourceKey, { color: { ...result }, descriptor: color });
+	return result;
 }
 
 function serializeColorValues(color: Color | undefined): DescriptorColor {
@@ -1970,7 +2021,7 @@ function serializeColorValues(color: Color | undefined): DescriptorColor {
 	} else if ('h' in color) {
 		return {
 			_name: '', _classID: 'HSBC',
-			'H   ': unitsAngle((color.h || 0) * 360),
+			'H   ': unitsAngle(colorToDescriptorValue('H   ', color.h || 0)),
 			Strt: colorToDescriptorValue('Strt', color.s || 0),
 			Brgh: colorToDescriptorValue('Brgh', color.b || 0),
 		};
@@ -1996,22 +2047,6 @@ function serializeColorValues(color: Color | undefined): DescriptorColor {
 	}
 }
 
-export function serializeColor(color: Color | undefined): DescriptorColor {
-	const result: any = serializeColorValues(color);
-	const source = getHidden(color, colorSourceKey);
-
-	if (source && shallowEqual(source.color, color)) {
-		// color was not modified since it was read, use exact original values
-		for (const key of Object.keys(result)) {
-			if (colorConversions[key] && typeof source.descriptor[key] === 'number') {
-				result[key] = source.descriptor[key];
-			}
-		}
-	}
-
-	return result;
-}
-
 export function parseAngle(x: DescriptorUnitsValue) {
 	if (x === undefined) return 0;
 	if (x.units !== 'Angle') throw new Error(`Invalid units: ${x.units}`);
@@ -2034,7 +2069,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 })}`);
 	}
@@ -2076,7 +2112,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})`);
 	}
@@ -2222,6 +2259,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',
@@ -2451,3 +2494,9 @@ export const presetKindType = createEnum<'custom' | 'default'>('presetKindType',
 	custom: 'presetKindCustom',
 	default: 'presetKindDefault',
 });
+
+export const patternColorHandling = createEnum<'convert' | 'avoid conversion' | 'luminance only'>('', 'convert', {
+	'convert': 'conv',
+	'avoid conversion': 'avod',
+	'luminance only': 'lumi',
+});