ag-psd 16.0.0 → 17.0.1

package/src/descriptor.ts

@@ -7,15 +7,16 @@ import {
 	LayerEffectSatin, LayerEffectShadow, LayerEffectsInfo, LayerEffectSolidFill,
 	LayerEffectsOuterGlow, LayerEffectStroke, LineAlignment, LineCapType, LineJoinType,
 	Orientation, TextGridding, TimelineKey, TimelineKeyInterpolation, TimelineTrack, TimelineTrackType,
-	Units, UnitsValue, VectorContent, WarpStyle
+	Units, UnitsBounds, UnitsValue, VectorContent, WarpStyle
 } from './psd';
 import {
 	PsdReader, readSignature, readUnicodeString, readUint32, readUint8, readFloat64,
-	readBytes, readAsciiString, readInt32, readFloat32, readInt32LE, readUnicodeStringWithLength
+	readBytes, readAsciiString, readInt32, readFloat32, readInt32LE, readUnicodeStringWithLengthLE
 } from './psdReader';
 import {
 	PsdWriter, writeSignature, writeBytes, writeUint32, writeFloat64, writeUint8,
-	writeUnicodeStringWithPadding, writeInt32, writeFloat32, writeUnicodeString
+	writeUnicodeStringWithPadding, writeInt32, writeFloat32, writeUnicodeString, writeInt32LE,
+	writeUnicodeStringWithoutLengthLE
 } from './psdWriter';
 
 interface Dict { [key: string]: string; }
@@ -118,6 +119,7 @@ const fieldToExtType: ExtTypeDict = {
 	sheetStyle: nullType,
 	translation: nullType,
 	Skew: nullType,
+	boundingBox: makeType('', 'boundingBox'),
 	'Lnk ': makeType('', 'ExternalFileLink'),
 	frameReader: makeType('', 'FrameReader'),
 	effectParams: makeType('', 'motionTrackEffectParams'),
@@ -125,11 +127,15 @@ const fieldToExtType: ExtTypeDict = {
 	Anch: makeType('', 'Pnt '),
 	'Fwd ': makeType('', 'Pnt '),
 	'Bwd ': makeType('', 'Pnt '),
+	FlrC: makeType('', 'Pnt '),
 	meshBoundaryPath: makeType('', 'pathClass'),
 	filterFX: makeType('', 'filterFXStyle'),
 	Fltr: makeType('', 'rigidTransform'),
 	FrgC: makeType('', 'RGBC'),
 	BckC: makeType('', 'RGBC'),
+	sdwM: makeType('Parameters', 'adaptCorrectTones'),
+	hglM: makeType('Parameters', 'adaptCorrectTones'),
+	customShape: makeType('', 'customShape'),
 };
 
 const fieldToArrayExtType: ExtTypeDict = {
@@ -159,6 +165,8 @@ const fieldToArrayExtType: ExtTypeDict = {
 	pathComponents: makeType('', 'PaCm'),
 	filterFXList: makeType('', 'filterFX'),
 	puppetShapeList: makeType('', 'puppetShape'),
+	channelDenoise: makeType('', 'channelDenoiseParams'),
+	ShrP: makeType('', 'Pnt '),
 };
 
 const typeToField: { [key: string]: string[]; } = {
@@ -166,9 +174,12 @@ const typeToField: { [key: string]: string[]; } = {
 		'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
 		'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
 		'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
-		'altTag', 'url', 'cellText',
+		'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth',
+	],
+	'tdta': [
+		'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
+		'LqMe',
 	],
-	'tdta': ['EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray'],
 	'long': [
 		'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
 		'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
@@ -179,16 +190,19 @@ const typeToField: { [key: string]: string[]; } = {
 		'numBefore', 'numAfter', 'Spcn', 'minOpacity', 'maxOpacity', 'BlnM', 'sheetID', 'gblA', 'globalAltitude',
 		'descVersion', 'frameReaderType', 'LyrI', 'zoomOrigin', 'fontSize', 'Rds ', 'sliceID',
 		'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset', 'filterID', 'meshQuality',
-		'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN',
+		'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',
 	],
 	'enum': [
-		'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS',
-		'sdwM', 'hglM', 'bvlT', 'bvlS', 'bvlD', 'Md  ', 'glwS', 'GrdF', 'GlwT',
+		'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
+		'bvlT', 'bvlS', 'bvlD', 'Md  ', 'glwS', 'GrdF', 'GlwT', 'RplS', 'BlrM', 'SmBM',
 		'strokeStyleLineCapType', 'strokeStyleLineJoinType', 'strokeStyleLineAlignment',
 		'strokeStyleBlendMode', 'PntT', 'Styl', 'lookupType', 'LUTFormat', 'dataOrder',
 		'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
 		'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
-		'vertAlign', 'bgColorType', 'shapeOperation',
+		'vertAlign', 'bgColorType', 'shapeOperation', 'UndA', 'Wvtp', 'Drct', 'WndM', 'Edg ', 'FlCl', 'IntE',
+		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ',
 	],
 	'bool': [
 		'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -200,7 +214,8 @@ const typeToField: { [key: string]: string[]; } = {
 		'present', 'showInDialog', 'overprint', 'sheetDisclosed', 'lightsDisclosed', 'meshesDisclosed',
 		'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
 		'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
-		'filterMaskLinked', 'filterMaskExtendWithWhite',
+		'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
+		'moreAccurate', 'GpuY', 'LIWy',
 	],
 	'doub': [
 		'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
@@ -210,10 +225,10 @@ const typeToField: { [key: string]: string[]; } = {
 		'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
 	],
 	'UntF': [
-		'Scl ', 'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
+		'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
 		'Ckmt', 'Nose', 'Inpr', 'ShdN', 'strokeStyleLineWidth', 'strokeStyleLineDashOffset',
 		'strokeStyleOpacity', 'H   ', 'Top ', 'Left', 'Btom', 'Rght', 'Rslt',
-		'topRight', 'topLeft', 'bottomLeft', 'bottomRight',
+		'topRight', 'topLeft', 'bottomLeft', 'bottomRight', 'ClNs', 'Shrp',
 	],
 	'VlLs': [
 		'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
@@ -221,10 +236,12 @@ const typeToField: { [key: string]: string[]; } = {
 		'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',
+		'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
+		'channelDenoise', 'Mtrx',
 	],
 	'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
-	'obj ': ['null'],
+	'obj ': ['null', 'Chnl'],
+	'Pth ': ['DspF'],
 };
 
 const channels = [
@@ -265,6 +282,9 @@ const fieldToArrayType: Dict = {
 	PnDp: 'doub',
 	filterFXList: 'Objc',
 	puppetShapeList: 'Objc',
+	ShrP: 'Objc',
+	channelDenoise: 'Objc',
+	Mtrx: 'long',
 };
 
 const fieldToType: Dict = {};
@@ -331,11 +351,13 @@ function writeAsciiStringOrClassId(writer: PsdWriter, value: string) {
 }
 
 export function readDescriptorStructure(reader: PsdReader) {
-	const object: any = {};
-	// object.__struct =
+	// const struct =
 	readClassStructure(reader);
+	// const object: any = { _name: struct.name, _classID: struct.classID };
+	const object: any = {};
+	// console.log('>> ', struct);
 	const itemsCount = readUint32(reader);
-	// console.log('//', object.__struct);
+
 	for (let i = 0; i < itemsCount; i++) {
 		const key = readAsciiStringOrClassId(reader);
 		const type = readSignature(reader);
@@ -356,25 +378,59 @@ export function writeDescriptorStructure(writer: PsdWriter, name: string, classI
 	writeAsciiStringOrClassId(writer, classId);
 
 	const keys = Object.keys(value);
-	writeUint32(writer, keys.length);
+	let keyCount = keys.length;
+	if ('_name' in value) keyCount--;
+	if ('_classID' in value) keyCount--;
+
+	writeUint32(writer, keyCount);
 
 	for (const key of keys) {
+		if (key === '_name' || key === '_classID') continue;
+
 		let type = getTypeByKey(key, value[key], root, value);
 		let extType = fieldToExtType[key];
 
-		if (key === 'origin') {
+		if (key === 'bounds' && root === 'text') {
+			extType = makeType('', 'bounds');
+		} else if (key === 'origin') {
 			type = root === 'slices' ? 'enum' : 'Objc';
+		} else if ((key === 'Cyn ' || key === 'Mgnt' || key === 'Ylw ' || key === 'Blck') && value._classID === 'CMYC') {
+			type = 'doub';
+		} else if (/^PN[a-z][a-z]$/.test(key)) {
+			type = 'TEXT';
+		} else if (/^PT[a-z][a-z]$/.test(key)) {
+			type = 'long';
+		} else if (/^PF[a-z][a-z]$/.test(key)) {
+			type = 'doub';
+		} else if (key === 'ClSz' || key === 'Rds ' || key === 'Amnt') {
+			type = typeof value[key] === 'number' ? 'long' : 'UntF';
+		} else if ((key === 'sdwM' || key === 'hglM') && typeof value[key] === 'string') {
+			type = 'enum';
+		} else if (key === 'blur' && typeof value[key] === 'string') {
+			type = 'enum';
+		} else if (key === 'Angl' && typeof value[key] === 'number') {
+			type = 'doub'; // ???
 		} else if (key === 'bounds' && root === 'slices') {
 			type = 'Objc';
 			extType = makeType('', 'Rct1');
-		} else if (key === 'Scl ' && 'Hrzn' in value[key]) {
-			type = 'Objc';
-			extType = nullType;
+		} else if (key === 'Scl ') {
+			if (typeof value[key] === 'object' && 'Hrzn' in value[key]) {
+				type = 'Objc';
+				extType = nullType;
+			} else if (typeof value[key] === 'number') {
+				type = 'long';
+			} else {
+				type = 'UntF';
+			}
 		} else if (key === 'audioClipGroupList' && keys.length === 1) {
 			type = 'VlLs';
 		} else if ((key === 'Strt' || key === 'Brgh') && 'H   ' in value) {
 			type = 'doub';
-		} else if (key === 'Strt') {
+		} else if (key === 'Wdth' && typeof value[key] === 'object') {
+			type = 'UntF';
+		} else if (key === 'Ofst' && typeof value[key] === 'number') {
+			type = 'long';
+		} else if (key === 'Strt' && typeof value[key] === 'object') {
 			type = 'Objc';
 			extType = nullType;
 		} else if (channels.indexOf(key) !== -1) {
@@ -491,11 +547,11 @@ function readOSType(reader: PsdReader, type: string) {
 			return items;
 		}
 		case 'Pth ': { // File path
-			/*const length =*/ readInt32(reader);
+			/*const length =*/ readInt32(reader); // total size of all fields below
 			const sig = readSignature(reader);
-			/*const pathSize =*/ readInt32LE(reader);
+			/*const pathSize =*/ readInt32LE(reader); // the same as length
 			const charsCount = readInt32LE(reader);
-			const path = readUnicodeStringWithLength(reader, charsCount);
+			const path = readUnicodeStringWithLengthLE(reader, charsCount);
 			return { sig, path };
 		}
 		default:
@@ -515,11 +571,16 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 			writeReferenceStructure(writer, key, value);
 			break;
 		case 'Objc': // Descriptor
-		case 'GlbO': // GlobalObject same as 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)})`);
-			writeDescriptorStructure(writer, extType.name, extType.classID, value, root);
+			const name = value._name || extType.name;
+			const classID = value._classID || extType.classID;
+			writeDescriptorStructure(writer, name, classID, value, root);
 			break;
+		}
 		case 'VlLs': // List
+			if (!Array.isArray(value)) throw new Error(`Invalid list value: ${JSON.stringify(value)}, key: ${key}`);
 			writeInt32(writer, value.length);
 
 			for (let i = 0; i < value.length; i++) {
@@ -530,6 +591,7 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 			}
 			break;
 		case 'doub': // Double
+			if (typeof value !== 'number') throw new Error(`Invalid number value: ${JSON.stringify(value)}, key: ${key}`);
 			writeFloat64(writer, value);
 			break;
 		case 'UntF': // Unit double
@@ -546,17 +608,20 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 			writeUnicodeStringWithPadding(writer, value);
 			break;
 		case 'enum': { // Enumerated
+			if (typeof value !== 'string') throw new Error(`Invalid enum value: ${JSON.stringify(value)}, key: ${key}`);
 			const [_type, val] = value.split('.');
 			writeAsciiStringOrClassId(writer, _type);
 			writeAsciiStringOrClassId(writer, val);
 			break;
 		}
 		case 'long': // Integer
+			if (typeof value !== 'number') throw new Error(`Invalid integer value: ${JSON.stringify(value)}, key: ${key}`);
 			writeInt32(writer, value);
 			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
@@ -588,8 +653,15 @@ function writeOSType(writer: PsdWriter, type: string, value: any, key: string, e
 			}
 			break;
 		}
-		// case 'Pth ': // File path
-		// 	writeFilePath(reader);
+		case 'Pth ': { // File path
+			const length = 4 + 4 + 4 + value.path.length * 2;
+			writeInt32(writer, length);
+			writeSignature(writer, value.sig);
+			writeInt32LE(writer, length);
+			writeInt32LE(writer, value.path.length);
+			writeUnicodeStringWithoutLengthLE(writer, value.path);
+			break;
+		}
 		default:
 			throw new Error(`Not implemented descriptor OSType: ${type}`);
 	}
@@ -690,7 +762,6 @@ function writeReferenceStructure(writer: PsdWriter, _key: string, items: any[])
 function readClassStructure(reader: PsdReader) {
 	const name = readUnicodeString(reader);
 	const classID = readAsciiStringOrClassId(reader);
-	// console.log({ name, classID });
 	return { name, classID };
 }
 
@@ -721,25 +792,37 @@ export interface DescriptorUnitsValue {
 }
 
 export type DescriptorColor = {
+	_name: '';
+	_classID: 'RGBC';
 	'Rd  ': number;
 	'Grn ': number;
 	'Bl  ': number;
 } | {
+	_name: '';
+	_classID: 'HSBC'; // ???
 	'H   ': DescriptorUnitsValue;
 	Strt: number;
 	Brgh: number;
 } | {
+	_name: '';
+	_classID: 'CMYC';
 	'Cyn ': number;
 	Mgnt: number;
 	'Ylw ': number;
 	Blck: number;
 } | {
+	_name: '';
+	_classID: 'GRYC'; // ???
 	'Gry ': number;
 } | {
+	_name: '';
+	_classID: 'LABC'; // ???
 	Lmnc: number;
 	'A   ': number;
 	'B   ': number;
 } | {
+	_name: '';
+	_classID: 'XXXX'; // ???
 	redFloat: number;
 	greenFloat: number;
 	blueFloat: number;
@@ -819,11 +902,20 @@ export interface StrokeDescriptor {
 	strokeStyleResolution: number;
 }
 
+export interface BoundsDescriptor {
+	Left: DescriptorUnitsValue;
+	'Top ': DescriptorUnitsValue;
+	Rght: DescriptorUnitsValue;
+	Btom: DescriptorUnitsValue;
+}
+
 export interface TextDescriptor {
 	'Txt ': string;
 	textGridding: string;
 	Ornt: string;
 	AntA: string;
+	bounds?: BoundsDescriptor;
+	boundingBox?: BoundsDescriptor;
 	TextIndex: number;
 	EngineData?: Uint8Array;
 }
@@ -844,6 +936,8 @@ export interface WarpDescriptor {
 	uOrder: number;
 	vOrder: number;
 	customEnvelopeWarp?: {
+		_name: '';
+		_classID: 'customEnvelopeWarp';
 		meshPoints: {
 			type: 'Hrzn' | 'Vrtc';
 			values: number[];
@@ -855,6 +949,8 @@ export interface QuiltWarpDescriptor extends WarpDescriptor {
 	deformNumRows: number;
 	deformNumCols: number;
 	customEnvelopeWarp: {
+		_name: '';
+		_classID: 'customEnvelopeWarp';
 		quiltSliceX: {
 			type: 'quiltSliceX';
 			values: number[];
@@ -904,6 +1000,24 @@ export function xyToHorzVrtc(xy: { x: number; y: number; }): HrznVrtcDescriptor
 	return { Hrzn: xy.x, Vrtc: xy.y };
 }
 
+export function descBoundsToBounds(desc: BoundsDescriptor): UnitsBounds {
+	return {
+		top: parseUnits(desc['Top ']),
+		left: parseUnits(desc.Left),
+		right: parseUnits(desc.Rght),
+		bottom: parseUnits(desc.Btom),
+	};
+}
+
+export function boundsToDescBounds(bounds: UnitsBounds): BoundsDescriptor {
+	return {
+		Left: unitsValue(bounds.left, 'bounds.left'),
+		['Top ']: unitsValue(bounds.top, 'bounds.top'),
+		Rght: unitsValue(bounds.right, 'bounds.right'),
+		Btom: unitsValue(bounds.bottom, 'bounds.bottom'),
+	};
+}
+
 export type TimelineAnimKeyDescriptor = {
 	Type: 'keyType.Opct';
 	Opct: DescriptorUnitsValue;
@@ -1122,7 +1236,8 @@ function parseKeyList(keyList: TimelineKeyDescriptor[], logMissingFeatures: bool
 
 	for (let j = 0; j < keyList.length; j++) {
 		const key = keyList[j];
-		const { time, selected, animKey } = key;
+		const { time: { denominator, numerator }, selected, animKey } = key;
+		const time = { numerator, denominator };
 		const interpolation = animInterpStyleEnum.decode(key.animInterpStyle);
 
 		switch (animKey.Type) {
@@ -1307,6 +1422,9 @@ function parseEffectObject(obj: any, reportErrors: boolean) {
 			case 'present':
 			case 'showInDialog':
 			case 'antialiasGloss': result[key] = val; break;
+			case '_name':
+			case '_classID':
+				break;
 			default:
 				reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
 		}
@@ -1564,19 +1682,19 @@ export function parseColor(color: DescriptorColor): Color {
 
 export function serializeColor(color: Color | undefined): DescriptorColor {
 	if (!color) {
-		return { 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
+		return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
 	} else if ('r' in color) {
-		return { 'Rd  ': color.r || 0, 'Grn ': color.g || 0, 'Bl  ': color.b || 0 };
+		return { _name: '', _classID: 'RGBC', 'Rd  ': color.r || 0, 'Grn ': color.g || 0, 'Bl  ': color.b || 0 };
 	} else if ('fr' in color) {
-		return { redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
+		return { _name: '', _classID: 'XXXX', redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
 	} else if ('h' in color) {
-		return { 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
+		return { _name: '', _classID: 'HSBC', 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
 	} else if ('c' in color) {
-		return { 'Cyn ': color.c || 0, Mgnt: color.m || 0, 'Ylw ': color.y || 0, Blck: color.k || 0 };
+		return { _name: '', _classID: 'CMYC', 'Cyn ': color.c || 0, Mgnt: color.m || 0, 'Ylw ': color.y || 0, Blck: color.k || 0 };
 	} else if ('l' in color) {
-		return { Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
+		return { _name: '', _classID: 'LABC', Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
 	} else if ('k' in color) {
-		return { 'Gry ': color.k };
+		return { _name: '', _classID: 'GRYC', 'Gry ': color.k };
 	} else {
 		throw new Error('Invalid color value');
 	}
@@ -1629,6 +1747,10 @@ export function unitsPercent(value: number | undefined): DescriptorUnitsValue {
 	return { units: 'Percent', value: Math.round((value || 0) * 100) };
 }
 
+export function unitsPercentF(value: number | undefined): DescriptorUnitsValue {
+	return { units: 'Percent', value: (value || 0) * 100 };
+}
+
 export function unitsValue(x: UnitsValue | undefined, key: string): DescriptorUnitsValue {
 	if (x == null) return { units: 'Pixels', value: 0 };
 
@@ -1650,6 +1772,10 @@ export function unitsValue(x: UnitsValue | undefined, key: string): DescriptorUn
 	return { units, value };
 }
 
+export function frac({ numerator, denominator }: FractionDescriptor) {
+	return { numerator, denominator };
+}
+
 export const textGridding = createEnum<TextGridding>('textGridding', 'none', {
 	none: 'None',
 	round: 'Rnd ',
@@ -1785,6 +1911,7 @@ export const ClrS = createEnum<'rgb' | 'hsb' | 'lab'>('ClrS', 'rgb', {
 	rgb: 'RGBC',
 	hsb: 'HSBl',
 	lab: 'LbCl',
+	hsl: 'HSLC',
 });
 
 export const FStl = createEnum<'inside' | 'center' | 'outside'>('FStl', 'outside', {
@@ -1841,3 +1968,166 @@ export const strokeStyleLineAlignment = createEnum<LineAlignment>('strokeStyleLi
 	center: 'strokeStyleAlignCenter',
 	outside: 'strokeStyleAlignOutside',
 });
+
+export const BlrM = createEnum<'spin' | 'zoom'>('BlrM', 'ispinmage', {
+	spin: 'Spn ',
+	zoom: 'Zm  ',
+});
+
+export const BlrQ = createEnum<'draft' | 'good' | 'best'>('BlrQ', 'good', {
+	draft: 'Drft',
+	good: 'Gd  ',
+	best: 'Bst ',
+});
+
+export const SmBM = createEnum<'normal' | 'edge only' | 'overlay edge'>('SmBM', 'normal', {
+	normal: 'SBMN',
+	'edge only': 'SBME',
+	'overlay edge': 'SBMO',
+});
+
+export const SmBQ = createEnum<'low' | 'medium' | 'high'>('SmBQ', 'medium', {
+	low: 'SBQL',
+	medium: 'SBQM',
+	high: 'SBQH',
+});
+
+export const DspM = createEnum<'stretch to fit' | 'tile'>('DspM', 'stretch to fit', {
+	'stretch to fit': 'StrF',
+	'tile': 'Tile',
+});
+
+export const UndA = createEnum<'wrap around' | 'repeat edge pixels'>('UndA', 'repeat edge pixels', {
+	'wrap around': 'WrpA',
+	'repeat edge pixels': 'RptE',
+});
+
+export const Cnvr = createEnum<'rectangular to polar' | 'polar to rectangular'>('Cnvr', 'rectangular to polar', {
+	'rectangular to polar': 'RctP',
+	'polar to rectangular': 'PlrR',
+});
+
+export const RplS = createEnum<'small' | 'medium' | 'large'>('RplS', 'medium', {
+	small: 'Sml ',
+	medium: 'Mdm ',
+	large: 'Lrg ',
+});
+
+export const SphM = createEnum<'normal' | 'horizontal only' | 'vertical only'>('SphM', 'normal', {
+	'normal': 'Nrml',
+	'horizontal only': 'HrzO',
+	'vertical only': 'VrtO',
+});
+
+export const Wvtp = createEnum<'sine' | 'triangle' | 'square'>('Wvtp', 'sine', {
+	sine: 'WvSn',
+	triangle: 'WvTr',
+	square: 'WvSq',
+});
+
+export const ZZTy = createEnum<'around center' | 'out from center' | 'pond ripples'>('ZZTy', 'pond ripples', {
+	'around center': 'ArnC',
+	'out from center': 'OtFr',
+	'pond ripples': 'PndR',
+});
+
+export const Dstr = createEnum<'uniform' | 'gaussian'>('Dstr', 'uniform', {
+	uniform: 'Unfr',
+	gaussian: 'Gsn ',
+});
+
+export const Chnl = createEnum<'red' | 'green' | 'blue' | 'composite'>('Chnl', 'composite', {
+	red: 'Rd  ',
+	green: 'Grn ',
+	blue: 'Bl  ',
+	composite: 'Cmps',
+});
+
+export const MztT = createEnum<'fine dots' | 'medium dots' | 'grainy dots' | 'coarse dots' | 'short lines' | 'medium lines' | 'long lines' | 'short strokes' | 'medium strokes' | 'long strokes'>('MztT', 'fine dots', {
+	'fine dots': 'FnDt',
+	'medium dots': 'MdmD',
+	'grainy dots': 'GrnD',
+	'coarse dots': 'CrsD',
+	'short lines': 'ShrL',
+	'medium lines': 'MdmL',
+	'long lines': 'LngL',
+	'short strokes': 'ShSt',
+	'medium strokes': 'MdmS',
+	'long strokes': 'LngS',
+});
+
+export const Lns = createEnum<'50-300mm zoom' | '32mm prime' | '105mm prime' | 'movie prime'>('Lns ', '50-300mm zoom', {
+	'50-300mm zoom': 'Zm  ',
+	'32mm prime': 'Nkn ',
+	'105mm prime': 'Nkn1',
+	'movie prime': 'PnVs',
+});
+
+export const blurType = createEnum<'gaussian blur' | 'lens blur' | 'motion blur'>('blurType', 'gaussian blur', {
+	'gaussian blur': 'GsnB',
+	'lens blur': 'lensBlur',
+	'motion blur': 'MtnB',
+});
+
+export const DfsM = createEnum<'normal' | 'darken only' | 'lighten only' | 'anisotropic'>('DfsM', 'normal', {
+	'normal': 'Nrml',
+	'darken only': 'DrkO',
+	'lighten only': 'LghO',
+	'anisotropic': 'anisotropic',
+});
+
+export const ExtT = createEnum<'blocks' | 'pyramids'>('ExtT', 'blocks', {
+	blocks: 'Blks',
+	pyramids: 'Pyrm',
+});
+
+export const ExtR = createEnum<'random' | 'level-based'>('ExtR', 'random', {
+	random: 'Rndm',
+	'level-based': 'LvlB',
+});
+
+export const FlCl = createEnum<'background color' | 'foreground color' | 'inverse image' | 'unaltered image'>('FlCl', 'background color', {
+	'background color': 'FlBc',
+	'foreground color': 'FlFr',
+	'inverse image': 'FlIn',
+	'unaltered image': 'FlSm',
+});
+
+export const CntE = createEnum<'lower' | 'upper'>('CntE', 'upper', {
+	lower: 'Lwr ',
+	upper: 'Upr ',
+});
+
+export const WndM = createEnum<'wind' | 'blast' | 'stagger'>('WndM', 'wind', {
+	wind: 'Wnd ',
+	blast: 'Blst',
+	stagger: 'Stgr',
+});
+
+export const Drct = createEnum<'left' | 'right'>('Drct', 'from the right', {
+	left: 'Left',
+	right: 'Rght',
+});
+
+export const IntE = createEnum<'odd lines' | 'even lines'>('IntE', 'odd lines', {
+	'odd lines': 'ElmO',
+	'even lines': 'ElmE',
+});
+
+export const IntC = createEnum<'duplication' | 'interpolation'>('IntC', 'interpolation', {
+	duplication: 'CrtD',
+	interpolation: 'CrtI',
+});
+
+export const FlMd = createEnum<'set to transparent' | 'repeat edge pixels' | 'wrap around'>('FlMd', 'wrap around', {
+	'set to transparent': 'Bckg',
+	'repeat edge pixels': 'Rpt ',
+	'wrap around': 'Wrp ',
+});
+
+export const prjM = createEnum<'fisheye' | 'perspective' | 'auto' | 'full spherical'>('prjM', 'fisheye', {
+	'fisheye': 'fisP',
+	'perspective': 'perP',
+	'auto': 'auto',
+	'full spherical': 'fusP',
+});