ag-psd 33.0.0 → 34.0.0

package/src/descriptor.ts

@@ -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 '),
@@ -185,7 +181,7 @@ const fieldToArrayExtType: ExtTypeDict = {
 const typeToField: { [key: string]: string[]; } = {
 	'TEXT': [
 		'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName', 'exportOption', 'scaleSettings',
-		'BackgroundImagePath', 'ImageSubfolderName',
+		'BackgroundImagePath', 'ImageSubfolderName', 'SavedIteratedName',
 		'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
 		'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
 		'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath', 'Bk  ', 'pathUnicodeName',
@@ -212,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',
@@ -236,7 +232,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
 		'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
 		'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
-		'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn',
+		'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn', 'LockPPI',
 	],
 	'doub': [
 		'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght', 'Gmm ',
@@ -244,7 +240,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'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',
@@ -276,6 +272,14 @@ const channels = [
 const doubleColorClasses = ['Grsc', 'LbCl', 'GRYC', 'LABC'];
 
 // fallback for unknown keys, based on the type of the value
+export const cameraRawFilterClassID = 'Adobe Camera Raw Filter';
+
+// 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',
+};
+
 function guessOSType(value: any): string | undefined {
 	if (typeof value === 'boolean') return 'bool';
 	if (typeof value === 'number' && !Number.isInteger(value)) return 'doub';
@@ -441,7 +445,7 @@ export function readDescriptorStructure(reader: PsdReader, includeClass: boolean
 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);
@@ -464,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') {
@@ -533,7 +542,7 @@ 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');
@@ -552,7 +561,7 @@ export function writeDescriptorStructure(writer: PsdWriter, name: string, classI
 		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);
 	}
 }
 
@@ -676,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 = 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
@@ -1353,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,
@@ -1370,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) {
@@ -1406,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 { _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 (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, '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);
-	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 (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) 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++) {
@@ -1454,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;
 			}
@@ -1472,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++) {
@@ -1493,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 };
@@ -1508,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++) {
@@ -1516,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),
 			};
 		}
 
@@ -1533,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++) {
@@ -1545,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),
 		});
 	}
 
@@ -1561,7 +1570,7 @@ type AllEffects = LayerEffectShadow & LayerEffectsOuterGlow & LayerEffectStroke
 	LayerEffectInnerGlow & LayerEffectBevel & LayerEffectSolidFill &
 	LayerEffectPatternOverlay & LayerEffectSatin & LayerEffectGradientOverlay;
 
-function parseEffectObject(obj: any, reportErrors: boolean, objName?: string) {
+function parseEffectObject(obj: any, reader: PsdReader, objName?: string) {
 	const result: AllEffects = {} as any;
 
 	for (const key of Object.keys(obj)) {
@@ -1636,14 +1645,14 @@ function parseEffectObject(obj: any, reportErrors: boolean, objName?: string) {
 			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,
 	};
@@ -1720,7 +1729,7 @@ 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);
 		}
 	}
 
@@ -1948,6 +1957,23 @@ function isBookColor(color: any) {
 }
 
 export function parseColor(color: DescriptorColor): 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) {
 		return { h: parsePercentOrAngle(color['H   ']), s: color.Strt / 100, b: color.Brgh / 100 };
 	} else if ('Rd  ' in color) {
@@ -1966,13 +1992,26 @@ export function parseColor(color: DescriptorColor): Color {
 	} 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
+		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 });
+	}
+
+	return result;
+}
+
+function serializeColorValues(color: Color | undefined): DescriptorColor {
 	if (!color) {
 		return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
 	} else if ('r' in color) {
@@ -2455,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',
+});

package/src/helpers.ts

@@ -40,7 +40,7 @@ export const toBlendMode: { [key: string]: BlendMode } = {
 Object.keys(toBlendMode).forEach(key => fromBlendMode[toBlendMode[key]] = key);
 
 export const layerColors: LayerColor[] = [
-	'none', 'red', 'orange', 'yellow', 'green', 'blue', 'violet', 'gray'
+	'none', 'red', 'orange', 'yellow', 'green', 'blue', 'violet', 'gray', 'seafoam', 'indigo', 'magenta', 'fuchsia',
 ];
 
 // keys not listed in documentation that Photoshop writes with 64bit length in PSB files (with 8B64 signature)
@@ -165,9 +165,10 @@ export function clamp(value: number, min: number, max: number) {
 
 export function hasAlpha(data: PixelData) {
 	const size = data.width * data.height * 4;
+	const max = data.data instanceof Float32Array ? 1 : (data.data instanceof Uint16Array ? 0xffff : 0xff);
 
 	for (let i = 3; i < size; i += 4) {
-		if (data.data[i] !== 255) {
+		if (data.data[i] !== max) {
 			return true;
 		}
 	}
@@ -175,6 +176,154 @@ export function hasAlpha(data: PixelData) {
 	return false;
 }
 
+// Polynomial approximation of U.S. Web Coated (SWOP) v2 CMYK to RGB conversion (default CMYK profile of Photoshop).
+// Coefficients are taken from pdf.js (DeviceCmykCS in src/core/colorspace.js, https://github.com/mozilla/pdf.js),
+// Copyright 2012 Mozilla Foundation, licensed under the Apache License, Version 2.0
+// (http://www.apache.org/licenses/LICENSE-2.0)
+// c, m, y, k - ink values (0 - 1), output - RGB values (0 - 255, not rounded or clamped)
+export function cmykToRgbValues(c: number, m: number, y: number, k: number, out: number[]) {
+	out[0] = 255 +
+		c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k - 285.2331026137004) +
+		m * (1.7149763477362134 * m - 5.6096736904047315 * y - 17.873870861415444 * k - 5.497006427196366) +
+		y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) +
+		k * (-21.86122147463605 * k - 189.48180835922747);
+	out[1] = 255 +
+		c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k - 79.2970844816548) +
+		m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) +
+		y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) +
+		k * (-20.737325471181034 * k - 187.80453709719578);
+	out[2] = 255 +
+		c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k - 14.183576799673286) +
+		m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) +
+		y * (0.03296041114873217 * y + 115.60384449646641 * k - 193.58209356861505) +
+		k * (-22.33816807309886 * k - 180.12613974708367);
+}
+
+const clamp01 = (v: number) => v < 0 ? 0 : (v > 1 ? 1 : v);
+
+// finds c, m, y (with fixed k) for given RGB color using Gauss-Newton method, returns squared error
+function solveCmy(r: number, g: number, b: number, k: number, x: number[]) {
+	const f = [0, 0, 0], f2 = [0, 0, 0], e = [0, 0, 0];
+	const J = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+	const h = 1e-4;
+
+	for (let iteration = 0; iteration < 20; iteration++) {
+		cmykToRgbValues(x[0], x[1], x[2], k, f);
+		e[0] = f[0] - r; e[1] = f[1] - g; e[2] = f[2] - b;
+		if ((e[0] * e[0] + e[1] * e[1] + e[2] * e[2]) < 1e-6) break;
+
+		for (let j = 0; j < 3; j++) {
+			const s = x[j];
+			x[j] = s + h;
+			cmykToRgbValues(x[0], x[1], x[2], k, f2);
+			x[j] = s;
+			for (let i = 0; i < 3; i++) J[i][j] = (f2[i] - f[i]) / h;
+		}
+
+		const [[a, b_, c], [d, e_, f_], [g_, h_, i_]] = J;
+		const det = a * (e_ * i_ - f_ * h_) - b_ * (d * i_ - f_ * g_) + c * (d * h_ - e_ * g_);
+		if (Math.abs(det) < 1e-12) break;
+
+		const inverse = [
+			[(e_ * i_ - f_ * h_), (c * h_ - b_ * i_), (b_ * f_ - c * e_)],
+			[(f_ * g_ - d * i_), (a * i_ - c * g_), (c * d - a * f_)],
+			[(d * h_ - e_ * g_), (b_ * g_ - a * h_), (a * e_ - b_ * d)],
+		];
+
+		let changed = 0;
+
+		for (let j = 0; j < 3; j++) {
+			const delta = -(inverse[j][0] * e[0] + inverse[j][1] * e[1] + inverse[j][2] * e[2]) / det;
+			const value = clamp01(x[j] + delta);
+			changed += Math.abs(value - x[j]);
+			x[j] = value;
+		}
+
+		if (changed < 1e-9) break;
+	}
+
+	cmykToRgbValues(x[0], x[1], x[2], k, f);
+	return (f[0] - r) * (f[0] - r) + (f[1] - g) * (f[1] - g) + (f[2] - b) * (f[2] - b);
+}
+
+// finds CMYK ink values (0 - 1) for RGB color (0 - 255), out of gamut colors are approximated
+function rgbToCmykExact(r: number, g: number, b: number, out: number[]) {
+	const max = Math.max(r, g, b) / 255;
+	const blackGeneration = Math.pow(clamp01((1 - max - 0.2) / 0.8), 1.3);
+	const x = [0, 0, 0];
+	let bestScore = Infinity, bestError = Infinity;
+
+	const tryBlack = (k: number) => {
+		x[0] = clamp01(1 - r / 255 - k);
+		x[1] = clamp01(1 - g / 255 - k);
+		x[2] = clamp01(1 - b / 255 - k);
+		const error = solveCmy(r, g, b, k, x);
+		// prefer solutions close to black generation value if the error is small enough
+		const score = Math.max(error, 0.1) + Math.abs(k - blackGeneration) * 0.01;
+
+		if (score < bestScore) {
+			bestScore = score;
+			bestError = error;
+			out[0] = x[0]; out[1] = x[1]; out[2] = x[2]; out[3] = k;
+		}
+	};
+
+	tryBlack(blackGeneration);
+
+	if (bestError > 0.1) {
+		for (let i = 0; i <= 10; i++) tryBlack(i / 10);
+	}
+
+	if (bestError > 0.1) {
+		const k = out[3];
+		for (let i = -5; i <= 5; i++) tryBlack(clamp01(k + i / 100));
+	}
+}
+
+const cmykLutSize = 33;
+let cmykLut: Float32Array | undefined;
+
+function getCmykLut() {
+	if (!cmykLut) {
+		const n = cmykLutSize;
+		const lut = new Float32Array(n * n * n * 4);
+		const out = [0, 0, 0, 0];
+
+		for (let r = 0, o = 0; r < n; r++) {
+			for (let g = 0; g < n; g++) {
+				for (let b = 0; b < n; b++, o += 4) {
+					rgbToCmykExact(r * 255 / (n - 1), g * 255 / (n - 1), b * 255 / (n - 1), out);
+					lut[o] = out[0]; lut[o + 1] = out[1]; lut[o + 2] = out[2]; lut[o + 3] = out[3];
+				}
+			}
+		}
+
+		cmykLut = lut;
+	}
+
+	return cmykLut;
+}
+
+// inverse of cmykToRgbValues, r, g, b - RGB values (0 - 1), output - CMYK ink values (0 - 1)
+export function rgbToCmykValues(r: number, g: number, b: number, out: number[]) {
+	const lut = getCmykLut();
+	const n1 = cmykLutSize - 1;
+	const fr = clamp01(r) * n1, fg = clamp01(g) * n1, fb = clamp01(b) * n1;
+	const r0 = Math.min(n1 - 1, Math.floor(fr)), g0 = Math.min(n1 - 1, Math.floor(fg)), b0 = Math.min(n1 - 1, Math.floor(fb));
+	const dr = fr - r0, dg = fg - g0, db = fb - b0;
+	out[0] = out[1] = out[2] = out[3] = 0;
+
+	for (let i = 0; i < 8; i++) {
+		const ir = i >> 2, ig = (i >> 1) & 1, ib = i & 1;
+		const w = (ir ? dr : 1 - dr) * (ig ? dg : 1 - dg) * (ib ? db : 1 - db);
+		const o = (((r0 + ir) * cmykLutSize + g0 + ig) * cmykLutSize + b0 + ib) * 4;
+		out[0] += w * lut[o];
+		out[1] += w * lut[o + 1];
+		out[2] += w * lut[o + 2];
+		out[3] += w * lut[o + 3];
+	}
+}
+
 export function resetImageData({ data }: PixelData) {
 	const alpha = (data instanceof Float32Array) ? 1.0 : ((data instanceof Uint16Array) ? 0xffff : 0xff);
 
@@ -353,6 +502,117 @@ export function writeDataRLE(buffer: Uint8Array, { data, width, height }: PixelD
 	return buffer.subarray(0, o);
 }
 
+// single channel of image data (8bit, 16bit or 32bit values)
+export type PlanarData = Uint8Array | Uint16Array | Float32Array;
+
+// converts channel values to big-endian bytes
+export function planarToBytes(values: PlanarData): Uint8Array {
+	if (values instanceof Uint8Array) return values;
+
+	const bytes = new Uint8Array(values.byteLength);
+	const view = new DataView(bytes.buffer);
+
+	if (values instanceof Uint16Array) {
+		for (let i = 0; i < values.length; i++) view.setUint16(i * 2, values[i], false);
+	} else {
+		for (let i = 0; i < values.length; i++) view.setFloat32(i * 4, values[i], false);
+	}
+
+	return bytes;
+}
+
+// RLE (PackBits) compression of rows of bytes, prefixed with byte counts of each row
+export function writeDataRLEBytes(bytes: Uint8Array, rowBytes: number, height: number, large: boolean) {
+	const countSize = large ? 4 : 2;
+	const buffer = new Uint8Array(height * (countSize + rowBytes + Math.ceil(rowBytes / 128)));
+	let o = countSize * height;
+
+	for (let y = 0; y < height; y++) {
+		const start = o;
+		const rowStart = y * rowBytes;
+		const rowEnd = rowStart + rowBytes;
+		let i = rowStart;
+
+		while (i < rowEnd) {
+			let run = 1;
+			while (i + run < rowEnd && run < 128 && bytes[i + run] === bytes[i]) run++;
+
+			if (run > 1) {
+				buffer[o++] = 257 - run;
+				buffer[o++] = bytes[i];
+				i += run;
+			} else {
+				// literal bytes until a run of at least 3 equal bytes
+				const countIndex = o++;
+				let count = 0;
+
+				while (i < rowEnd && count < 128) {
+					if (i + 2 < rowEnd && bytes[i] === bytes[i + 1] && bytes[i] === bytes[i + 2]) break;
+					buffer[o++] = bytes[i++];
+					count++;
+				}
+
+				buffer[countIndex] = count - 1;
+			}
+		}
+
+		const length = o - start;
+
+		for (let j = 0; j < countSize; j++) {
+			buffer[y * countSize + j] = (length >>> ((countSize - j - 1) * 8)) & 0xff;
+		}
+	}
+
+	return buffer.subarray(0, o);
+}
+
+// zip compression with prediction (values are delta encoded per row, 32bit values are split into byte planes first)
+export function writeDataZipWithPrediction(values: PlanarData, width: number, height: number) {
+	let bytes: Uint8Array;
+
+	if (values instanceof Uint8Array) {
+		bytes = new Uint8Array(width * height);
+
+		for (let y = 0, i = 0; y < height; y++) {
+			for (let x = 0, prev = 0; x < width; x++, i++) {
+				bytes[i] = values[i] - prev; // Uint8Array wraps values on assignment
+				prev = values[i];
+			}
+		}
+	} else if (values instanceof Uint16Array) {
+		bytes = new Uint8Array(width * height * 2);
+
+		for (let y = 0, i = 0; y < height; y++) {
+			for (let x = 0, prev = 0; x < width; x++, i++) {
+				const delta = (values[i] - prev) & 0xffff;
+				bytes[i * 2] = delta >> 8;
+				bytes[i * 2 + 1] = delta & 0xff;
+				prev = values[i];
+			}
+		}
+	} else {
+		const rowBytes = width * 4;
+		const source = planarToBytes(values);
+		bytes = new Uint8Array(rowBytes * height);
+
+		for (let y = 0; y < height; y++) {
+			const row = y * rowBytes;
+
+			for (let x = 0; x < width; x++) {
+				for (let b = 0; b < 4; b++) {
+					bytes[row + b * width + x] = source[row + x * 4 + b];
+				}
+			}
+
+			for (let x = rowBytes - 1; x > 0; x--) {
+				bytes[row + x] -= bytes[row + x - 1];
+			}
+		}
+	}
+
+	return deflateSync(bytes);
+}
+
 export function writeDataZipWithoutPrediction({ data, width, height }: PixelData, offsets: number[]) {
 	const size = width * height;
 	const channel = new Uint8Array(size);