ag-psd 15.0.4 → 15.0.5

package/src/descriptor.ts

@@ -0,0 +1,1804 @@
+import { createEnum } from './helpers';
+import {
+	AntiAlias, BevelDirection, BevelStyle, BevelTechnique, BlendMode, Color, EffectContour,
+	EffectNoiseGradient, EffectPattern, EffectSolidGradient, ExtraGradientInfo, ExtraPatternInfo,
+	GlowSource, GlowTechnique, GradientStyle, InterpolationMethod, LayerEffectBevel,
+	LayerEffectGradientOverlay, LayerEffectInnerGlow, LayerEffectPatternOverlay,
+	LayerEffectSatin, LayerEffectShadow, LayerEffectsInfo, LayerEffectSolidFill,
+	LayerEffectsOuterGlow, LayerEffectStroke, LineAlignment, LineCapType, LineJoinType,
+	Orientation, TextGridding, TimelineKey, TimelineKeyInterpolation, TimelineTrack, TimelineTrackType,
+	Units, UnitsValue, VectorContent, WarpStyle
+} from './psd';
+import {
+	PsdReader, readSignature, readUnicodeString, readUint32, readUint8, readFloat64,
+	readBytes, readAsciiString, readInt32, readFloat32, readInt32LE, readUnicodeStringWithLength
+} from './psdReader';
+import {
+	PsdWriter, writeSignature, writeBytes, writeUint32, writeFloat64, writeUint8,
+	writeUnicodeStringWithPadding, writeInt32, writeFloat32, writeUnicodeString
+} from './psdWriter';
+
+interface Dict { [key: string]: string; }
+interface NameClassID { name: string; classID: string; }
+interface ExtTypeDict { [key: string]: NameClassID; }
+
+function revMap(map: Dict) {
+	const result: Dict = {};
+	Object.keys(map).forEach(key => result[map[key]] = key);
+	return result;
+}
+
+const unitsMap: Dict = {
+	'#Ang': 'Angle',
+	'#Rsl': 'Density',
+	'#Rlt': 'Distance',
+	'#Nne': 'None',
+	'#Prc': 'Percent',
+	'#Pxl': 'Pixels',
+	'#Mlm': 'Millimeters',
+	'#Pnt': 'Points',
+	'RrPi': 'Picas',
+	'RrIn': 'Inches',
+	'RrCm': 'Centimeters',
+};
+
+const unitsMapRev = revMap(unitsMap);
+let logErrors = false;
+
+export function setLogErrors(value: boolean) {
+	logErrors = value;
+}
+
+function makeType(name: string, classID: string) {
+	return { name, classID };
+}
+
+const nullType = makeType('', 'null');
+
+const fieldToExtType: ExtTypeDict = {
+	strokeStyleContent: makeType('', 'solidColorLayer'),
+	// printProofSetup: makeType('校样设置', 'proofSetup'), // TESTING
+	printProofSetup: makeType('Proof Setup', 'proofSetup'),
+	patternFill: makeType('', 'patternFill'),
+	Grad: makeType('Gradient', 'Grdn'),
+	ebbl: makeType('', 'ebbl'),
+	SoFi: makeType('', 'SoFi'),
+	GrFl: makeType('', 'GrFl'),
+	sdwC: makeType('', 'RGBC'),
+	hglC: makeType('', 'RGBC'),
+	'Clr ': makeType('', 'RGBC'),
+	'tintColor': makeType('', 'RGBC'),
+	Ofst: makeType('', 'Pnt '),
+	ChFX: makeType('', 'ChFX'),
+	MpgS: makeType('', 'ShpC'),
+	DrSh: makeType('', 'DrSh'),
+	IrSh: makeType('', 'IrSh'),
+	OrGl: makeType('', 'OrGl'),
+	IrGl: makeType('', 'IrGl'),
+	TrnS: makeType('', 'ShpC'),
+	Ptrn: makeType('', 'Ptrn'),
+	FrFX: makeType('', 'FrFX'),
+	phase: makeType('', 'Pnt '),
+	frameStep: nullType,
+	duration: nullType,
+	workInTime: nullType,
+	workOutTime: nullType,
+	audioClipGroupList: nullType,
+	bounds: makeType('', 'Rctn'),
+	customEnvelopeWarp: makeType('', 'customEnvelopeWarp'),
+	warp: makeType('', 'warp'),
+	'Sz  ': makeType('', 'Pnt '),
+	origin: makeType('', 'Pnt '),
+	autoExpandOffset: makeType('', 'Pnt '),
+	keyOriginShapeBBox: makeType('', 'unitRect'),
+	Vrsn: nullType,
+	psVersion: nullType,
+	docDefaultNewArtboardBackgroundColor: makeType('', 'RGBC'),
+	artboardRect: makeType('', 'classFloatRect'),
+	keyOriginRRectRadii: makeType('', 'radii'),
+	keyOriginBoxCorners: nullType,
+	rectangleCornerA: makeType('', 'Pnt '),
+	rectangleCornerB: makeType('', 'Pnt '),
+	rectangleCornerC: makeType('', 'Pnt '),
+	rectangleCornerD: makeType('', 'Pnt '),
+	compInfo: nullType,
+	Trnf: makeType('Transform', 'Trnf'),
+	quiltWarp: makeType('', 'quiltWarp'),
+	generatorSettings: nullType,
+	crema: nullType,
+	FrIn: nullType,
+	blendOptions: nullType,
+	FXRf: nullType,
+	Lefx: nullType,
+	time: nullType,
+	animKey: nullType,
+	timeScope: nullType,
+	inTime: nullType,
+	outTime: nullType,
+	sheetStyle: nullType,
+	translation: nullType,
+	Skew: nullType,
+	'Lnk ': makeType('', 'ExternalFileLink'),
+	frameReader: makeType('', 'FrameReader'),
+	effectParams: makeType('', 'motionTrackEffectParams'),
+};
+
+const fieldToArrayExtType: ExtTypeDict = {
+	'Crv ': makeType('', 'CrPt'),
+	Clrs: makeType('', 'Clrt'),
+	Trns: makeType('', 'TrnS'),
+	keyDescriptorList: nullType,
+	solidFillMulti: makeType('', 'SoFi'),
+	gradientFillMulti: makeType('', 'GrFl'),
+	dropShadowMulti: makeType('', 'DrSh'),
+	innerShadowMulti: makeType('', 'IrSh'),
+	frameFXMulti: makeType('', 'FrFX'),
+	FrIn: nullType,
+	FSts: nullType,
+	LaSt: nullType,
+	sheetTimelineOptions: nullType,
+	trackList: makeType('', 'animationTrack'),
+	globalTrackList: makeType('', 'animationTrack'),
+	keyList: nullType,
+	audioClipGroupList: nullType,
+	audioClipList: nullType,
+	countObjectList: makeType('', 'countObject'),
+	countGroupList: makeType('', 'countGroup'),
+	slices: makeType('', 'slice'),
+};
+
+const typeToField: { [key: string]: string[]; } = {
+	'TEXT': [
+		'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
+		'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
+		'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
+		'altTag', 'url', 'cellText',
+	],
+	'tdta': ['EngineData', 'LUT3DFileData'],
+	'long': [
+		'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
+		'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
+		'curvesPresetKind', 'mixerPresetKind', 'uOrder', 'vOrder', 'PgNm', 'totalPages', 'Crop',
+		'numerator', 'denominator', 'frameCount', 'Annt', 'keyOriginType', 'unitValueQuadVersion',
+		'keyOriginIndex', 'major', 'minor', 'fix', 'docDefaultNewArtboardBackgroundType', 'artboardBackgroundType',
+		'numModifyingFX', 'deformNumRows', 'deformNumCols', 'FrID', 'FrDl', 'FsID', 'LCnt', 'AFrm', 'AFSt',
+		'numBefore', 'numAfter', 'Spcn', 'minOpacity', 'maxOpacity', 'BlnM', 'sheetID', 'gblA', 'globalAltitude',
+		'descVersion', 'frameReaderType', 'LyrI', 'zoomOrigin', 'fontSize', 'Rds ', 'sliceID',
+		'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset',
+	],
+	'enum': [
+		'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS',
+		'sdwM', 'hglM', 'bvlT', 'bvlS', 'bvlD', 'Md  ', 'glwS', 'GrdF', 'GlwT',
+		'strokeStyleLineCapType', 'strokeStyleLineJoinType', 'strokeStyleLineAlignment',
+		'strokeStyleBlendMode', 'PntT', 'Styl', 'lookupType', 'LUTFormat', 'dataOrder',
+		'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
+		'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
+		'vertAlign', 'bgColorType',
+	],
+	'bool': [
+		'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
+		'useShape', 'useTexture', 'uglg', 'antialiasGloss', 'useShape', 'Vsbl',
+		'useTexture', 'Algn', 'Rvrs', 'Dthr', 'Invr', 'VctC', 'ShTr', 'layerConceals',
+		'strokeEnabled', 'fillEnabled', 'strokeStyleScaleLock', 'strokeStyleStrokeAdjust',
+		'hardProof', 'MpBl', 'paperWhite', 'useLegacy', 'Auto', 'Lab ', 'useTint', 'keyShapeInvalidated',
+		'autoExpandEnabled', 'autoNestEnabled', 'autoPositionEnabled', 'shrinkwrapOnSaveEnabled',
+		'present', 'showInDialog', 'overprint', 'sheetDisclosed', 'lightsDisclosed', 'meshesDisclosed',
+		'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
+		'cellTextIsHTML',
+	],
+	'doub': [
+		'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
+		'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
+		'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
+		'X   ', 'Y   ',
+	],
+	'UntF': [
+		'Scl ', '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',
+	],
+	'VlLs': [
+		'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
+		'LaSt', 'Trnf', 'nonAffineTransform', 'keyDescriptorList', 'guideIndeces', 'gradientFillMulti',
+		'solidFillMulti', 'frameFXMulti', 'innerShadowMulti', 'dropShadowMulti', 'FrIn', 'FSts', 'FsFr',
+		'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
+		'warpValues',
+	],
+	'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
+	'obj ': ['null'],
+};
+
+const channels = [
+	'Rd  ', 'Grn ', 'Bl  ', 'Yllw', 'Ylw ', 'Cyn ', 'Mgnt', 'Blck', 'Gry ', 'Lmnc', 'A   ', 'B   ',
+];
+
+const fieldToArrayType: Dict = {
+	'Mnm ': 'long',
+	'Mxm ': 'long',
+	'FrLs': 'long',
+	'strokeStyleLineDashSet': 'UntF',
+	'Trnf': 'doub',
+	'nonAffineTransform': 'doub',
+	'keyDescriptorList': 'Objc',
+	'gradientFillMulti': 'Objc',
+	'solidFillMulti': 'Objc',
+	'frameFXMulti': 'Objc',
+	'innerShadowMulti': 'Objc',
+	'dropShadowMulti': 'Objc',
+	'LaSt': 'Objc',
+	'FrIn': 'Objc',
+	'FSts': 'Objc',
+	'FsFr': 'long',
+	'blendOptions': 'Objc',
+	'sheetTimelineOptions': 'Objc',
+	'keyList': 'Objc',
+	'warpValues': 'doub',
+};
+
+const fieldToType: Dict = {};
+
+for (const type of Object.keys(typeToField)) {
+	for (const field of typeToField[type]) {
+		fieldToType[field] = type;
+	}
+}
+
+for (const field of Object.keys(fieldToExtType)) {
+	if (!fieldToType[field]) fieldToType[field] = 'Objc';
+}
+
+for (const field of Object.keys(fieldToArrayExtType)) {
+	fieldToArrayType[field] = 'Objc';
+}
+
+function getTypeByKey(key: string, value: any, root: string, parent: any) {
+	if (key === 'null' && root === 'slices') {
+		return 'TEXT';
+	} else if (key === 'groupID') {
+		return root === 'slices' ? 'long' : 'TEXT';
+	} else if (key === 'Sz  ') {
+		return ('Wdth' in value) ? 'Objc' : (('units' in value) ? 'UntF' : 'doub');
+	} else if (key === 'Type') {
+		return typeof value === 'string' ? 'enum' : 'long';
+	} else if (key === 'AntA') {
+		return typeof value === 'string' ? 'enum' : 'bool';
+	} else if ((key === 'Hrzn' || key === 'Vrtc') && parent.Type === 'keyType.Pstn') {
+		return 'long';
+	} else if (key === 'Hrzn' || key === 'Vrtc' || key === 'Top ' || key === 'Left' || key === 'Btom' || key === 'Rght') {
+		if (root === 'slices') return 'long';
+		return typeof value === 'number' ? 'doub' : 'UntF';
+	} else if (key === 'Vrsn') {
+		return typeof value === 'number' ? 'long' : 'Objc';
+	} else if (key === 'Rd  ' || key === 'Grn ' || key === 'Bl  ') {
+		return root === 'artd' ? 'long' : 'doub';
+	} else if (key === 'Trnf') {
+		return Array.isArray(value) ? 'VlLs' : 'Objc';
+	} else {
+		return fieldToType[key];
+	}
+}
+
+export function readAsciiStringOrClassId(reader: PsdReader) {
+	const length = readInt32(reader);
+	return readAsciiString(reader, length || 4);
+}
+
+function writeAsciiStringOrClassId(writer: PsdWriter, value: string) {
+	if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold') {
+		// write classId
+		writeInt32(writer, 0);
+		writeSignature(writer, value);
+	} else {
+		// write ascii string
+		writeInt32(writer, value.length);
+
+		for (let i = 0; i < value.length; i++) {
+			writeUint8(writer, value.charCodeAt(i));
+		}
+	}
+}
+
+export function readDescriptorStructure(reader: PsdReader) {
+	const object: any = {};
+	// object.__struct =
+	readClassStructure(reader);
+	const itemsCount = readUint32(reader);
+	// console.log('//', object.__struct);
+	for (let i = 0; i < itemsCount; i++) {
+		const key = readAsciiStringOrClassId(reader);
+		const type = readSignature(reader);
+		// console.log(`> '${key}' '${type}'`);
+		const data = readOSType(reader, type);
+		// if (!getTypeByKey(key, data)) console.log(`> '${key}' '${type}'`, data);
+		object[key] = data;
+	}
+
+	return object;
+}
+
+export function writeDescriptorStructure(writer: PsdWriter, name: string, classId: string, value: any, root: string) {
+	if (logErrors && !classId) console.log('Missing classId for: ', name, classId, value);
+
+	// write class structure
+	writeUnicodeStringWithPadding(writer, name);
+	writeAsciiStringOrClassId(writer, classId);
+
+	const keys = Object.keys(value);
+	writeUint32(writer, keys.length);
+
+	for (const key of keys) {
+		let type = getTypeByKey(key, value[key], root, value);
+		let extType = fieldToExtType[key];
+
+		if (key === 'origin') {
+			type = root === 'slices' ? 'enum' : 'Objc';
+		} 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 === 'audioClipGroupList' && keys.length === 1) {
+			type = 'VlLs';
+		} else if ((key === 'Strt' || key === 'Brgh') && 'H   ' in value) {
+			type = 'doub';
+		} else if (key === 'Strt') {
+			type = 'Objc';
+			extType = nullType;
+		} else if (channels.indexOf(key) !== -1) {
+			type = (classId === 'RGBC' && root !== 'artd') ? 'doub' : 'long';
+		} else if (key === 'profile') {
+			type = classId === 'printOutput' ? 'TEXT' : 'tdta';
+		} else if (key === 'strokeStyleContent') {
+			if (value[key]['Clr ']) {
+				extType = makeType('', 'solidColorLayer');
+			} else if (value[key].Grad) {
+				extType = makeType('', 'gradientLayer');
+			} else if (value[key].Ptrn) {
+				extType = makeType('', 'patternLayer');
+			} else {
+				logErrors && console.log('Invalid strokeStyleContent value', value[key]);
+			}
+		} else if (key === 'bounds' && root === 'quiltWarp') {
+			extType = makeType('', 'classFloatRect');
+		}
+
+		if (extType && extType.classID === 'RGBC') {
+			if ('H   ' in value[key]) extType = { classID: 'HSBC', name: '' };
+			// TODO: other color spaces
+		}
+
+		writeAsciiStringOrClassId(writer, key);
+		writeSignature(writer, type || 'long');
+		writeOSType(writer, type || 'long', value[key], key, extType, root);
+		if (logErrors && !type) console.log(`Missing descriptor field type for: '${key}' in`, value);
+	}
+}
+
+function readOSType(reader: PsdReader, type: string) {
+	switch (type) {
+		case 'obj ': // Reference
+			return readReferenceStructure(reader);
+		case 'Objc': // Descriptor
+		case 'GlbO': // GlobalObject same as Descriptor
+			return readDescriptorStructure(reader);
+		case 'VlLs': { // List
+			const length = readInt32(reader);
+			const items: any[] = [];
+
+			for (let i = 0; i < length; i++) {
+				const type = readSignature(reader);
+				// console.log('  >', type);
+				items.push(readOSType(reader, type));
+			}
+
+			return items;
+		}
+		case 'doub': // Double
+			return readFloat64(reader);
+		case 'UntF': { // Unit double
+			const units = readSignature(reader);
+			const value = readFloat64(reader);
+			if (!unitsMap[units]) throw new Error(`Invalid units: ${units}`);
+			return { units: unitsMap[units], value };
+		}
+		case 'UnFl': { // Unit float
+			const units = readSignature(reader);
+			const value = readFloat32(reader);
+			if (!unitsMap[units]) throw new Error(`Invalid units: ${units}`);
+			return { units: unitsMap[units], value };
+		}
+		case 'TEXT': // String
+			return readUnicodeString(reader);
+		case 'enum': { // Enumerated
+			const type = readAsciiStringOrClassId(reader);
+			const value = readAsciiStringOrClassId(reader);
+			return `${type}.${value}`;
+		}
+		case 'long': // Integer
+			return readInt32(reader);
+		case 'comp': { // Large Integer
+			const low = readUint32(reader);
+			const high = readUint32(reader);
+			return { low, high };
+		}
+		case 'bool': // Boolean
+			return !!readUint8(reader);
+		case 'type': // Class
+		case 'GlbC': // Class
+			return readClassStructure(reader);
+		case 'alis': { // Alias
+			const length = readInt32(reader);
+			return readAsciiString(reader, length);
+		}
+		case 'tdta': { // Raw Data
+			const length = readInt32(reader);
+			return readBytes(reader, length);
+		}
+		case 'ObAr': { // Object array
+			readInt32(reader); // version: 16
+			readUnicodeString(reader); // name: ''
+			readAsciiStringOrClassId(reader); // 'rationalPoint'
+			const length = readInt32(reader);
+			const items: any[] = [];
+
+			for (let i = 0; i < length; i++) {
+				const type1 = readAsciiStringOrClassId(reader); // type Hrzn | Vrtc
+				readSignature(reader); // UnFl
+
+				readSignature(reader); // units ? '#Pxl'
+				const valuesCount = readInt32(reader);
+				const values: number[] = [];
+				for (let j = 0; j < valuesCount; j++) {
+					values.push(readFloat64(reader));
+				}
+
+				items.push({ type: type1, values });
+			}
+
+			return items;
+		}
+		case 'Pth ': { // File path
+			/*const length =*/ readInt32(reader);
+			const sig = readSignature(reader);
+			/*const pathSize =*/ readInt32LE(reader);
+			const charsCount = readInt32LE(reader);
+			const path = readUnicodeStringWithLength(reader, charsCount);
+			return { sig, path };
+		}
+		default:
+			throw new Error(`Invalid TySh descriptor OSType: ${type} at ${reader.offset.toString(16)}`);
+	}
+}
+
+const ObArTypes: { [key: string]: string | undefined; } = {
+	meshPoints: 'rationalPoint',
+	quiltSliceX: 'UntF',
+	quiltSliceY: 'UntF',
+};
+
+function writeOSType(writer: PsdWriter, type: string, value: any, key: string, extType: NameClassID | undefined, root: string) {
+	switch (type) {
+		case 'obj ': // Reference
+			writeReferenceStructure(writer, key, value);
+			break;
+		case 'Objc': // Descriptor
+		case 'GlbO': // GlobalObject same as Descriptor
+			if (!extType) throw new Error(`Missing ext type for: '${key}' (${JSON.stringify(value)})`);
+			writeDescriptorStructure(writer, extType.name, extType.classID, value, root);
+			break;
+		case 'VlLs': // List
+			writeInt32(writer, value.length);
+
+			for (let i = 0; i < value.length; i++) {
+				const type = fieldToArrayType[key];
+				writeSignature(writer, type || 'long');
+				writeOSType(writer, type || 'long', value[i], '', fieldToArrayExtType[key], root);
+				if (logErrors && !type) console.log(`Missing descriptor array type for: '${key}' in`, value);
+			}
+			break;
+		case 'doub': // Double
+			writeFloat64(writer, value);
+			break;
+		case 'UntF': // Unit double
+			if (!unitsMapRev[value.units]) throw new Error(`Invalid units: ${value.units} in ${key}`);
+			writeSignature(writer, unitsMapRev[value.units]);
+			writeFloat64(writer, value.value);
+			break;
+		case 'UnFl': // Unit float
+			if (!unitsMapRev[value.units]) throw new Error(`Invalid units: ${value.units} in ${key}`);
+			writeSignature(writer, unitsMapRev[value.units]);
+			writeFloat32(writer, value.value);
+			break;
+		case 'TEXT': // String
+			writeUnicodeStringWithPadding(writer, value);
+			break;
+		case 'enum': { // Enumerated
+			const [_type, val] = value.split('.');
+			writeAsciiStringOrClassId(writer, _type);
+			writeAsciiStringOrClassId(writer, val);
+			break;
+		}
+		case 'long': // Integer
+			writeInt32(writer, value);
+			break;
+		// case 'comp': // Large Integer
+		// 	writeLargeInteger(reader);
+		case 'bool': // Boolean
+			writeUint8(writer, value ? 1 : 0);
+			break;
+		// case 'type': // Class
+		// case 'GlbC': // Class
+		// 	writeClassStructure(reader);
+		// case 'alis': // Alias
+		// 	writeAliasStructure(reader);
+		case 'tdta': // Raw Data
+			writeInt32(writer, value.byteLength);
+			writeBytes(writer, value);
+			break;
+		case 'ObAr': { // Object array
+			writeInt32(writer, 16); // version
+			writeUnicodeStringWithPadding(writer, ''); // name
+			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++) {
+				writeAsciiStringOrClassId(writer, value[i].type); // Hrzn | Vrtc
+				writeSignature(writer, 'UnFl');
+				writeSignature(writer, '#Pxl');
+				writeInt32(writer, value[i].values.length);
+
+				for (let j = 0; j < value[i].values.length; j++) {
+					writeFloat64(writer, value[i].values[j]);
+				}
+			}
+			break;
+		}
+		// case 'Pth ': // File path
+		// 	writeFilePath(reader);
+		default:
+			throw new Error(`Not implemented descriptor OSType: ${type}`);
+	}
+}
+
+function readReferenceStructure(reader: PsdReader) {
+	const itemsCount = readInt32(reader);
+	const items: any[] = [];
+
+	for (let i = 0; i < itemsCount; i++) {
+		const type = readSignature(reader);
+
+		switch (type) {
+			case 'prop': { // Property
+				readClassStructure(reader);
+				const keyID = readAsciiStringOrClassId(reader);
+				items.push(keyID);
+				break;
+			}
+			case 'Clss': // Class
+				items.push(readClassStructure(reader));
+				break;
+			case 'Enmr': { // Enumerated Reference
+				readClassStructure(reader);
+				const typeID = readAsciiStringOrClassId(reader);
+				const value = readAsciiStringOrClassId(reader);
+				items.push(`${typeID}.${value}`);
+				break;
+			}
+			case 'rele': { // Offset
+				// const { name, classID } =
+				readClassStructure(reader);
+				items.push(readUint32(reader));
+				break;
+			}
+			case 'Idnt': // Identifier
+				items.push(readInt32(reader));
+				break;
+			case 'indx': // Index
+				items.push(readInt32(reader));
+				break;
+			case 'name': { // Name
+				readClassStructure(reader);
+				items.push(readUnicodeString(reader));
+				break;
+			}
+			default:
+				throw new Error(`Invalid descriptor reference type: ${type}`);
+		}
+	}
+
+	return items;
+}
+
+function writeReferenceStructure(writer: PsdWriter, _key: string, items: any[]) {
+	writeInt32(writer, items.length);
+
+	for (let i = 0; i < items.length; i++) {
+		const value = items[i];
+		let type = 'unknown';
+
+		if (typeof value === 'string') {
+			if (/^[a-z]+\.[a-z]+$/i.test(value)) {
+				type = 'Enmr';
+			} else {
+				type = 'name';
+			}
+		}
+
+		writeSignature(writer, type);
+
+		switch (type) {
+			// case 'prop': // Property
+			// case 'Clss': // Class
+			case 'Enmr': { // Enumerated Reference
+				const [typeID, enumValue] = value.split('.');
+				writeClassStructure(writer, '\0', typeID);
+				writeAsciiStringOrClassId(writer, typeID);
+				writeAsciiStringOrClassId(writer, enumValue);
+				break;
+			}
+			// case 'rele': // Offset
+			// case 'Idnt': // Identifier
+			// case 'indx': // Index
+			case 'name': { // Name
+				writeClassStructure(writer, '\0', 'Lyr ');
+				writeUnicodeString(writer, value + '\0');
+				break;
+			}
+			default:
+				throw new Error(`Invalid descriptor reference type: ${type}`);
+		}
+	}
+
+	return items;
+}
+
+function readClassStructure(reader: PsdReader) {
+	const name = readUnicodeString(reader);
+	const classID = readAsciiStringOrClassId(reader);
+	// console.log({ name, classID });
+	return { name, classID };
+}
+
+function writeClassStructure(writer: PsdWriter, name: string, classID: string) {
+	writeUnicodeString(writer, name);
+	writeAsciiStringOrClassId(writer, classID);
+}
+
+export function readVersionAndDescriptor(reader: PsdReader) {
+	const version = readUint32(reader);
+	if (version !== 16) throw new Error(`Invalid descriptor version: ${version}`);
+	const desc = readDescriptorStructure(reader);
+	// console.log(require('util').inspect(desc, false, 99, true));
+	return desc;
+}
+
+export function writeVersionAndDescriptor(writer: PsdWriter, name: string, classID: string, descriptor: any, root = '') {
+	writeUint32(writer, 16); // version
+	writeDescriptorStructure(writer, name, classID, descriptor, root);
+}
+
+export type DescriptorUnits = 'Angle' | 'Density' | 'Distance' | 'None' | 'Percent' | 'Pixels' |
+	'Millimeters' | 'Points' | 'Picas' | 'Inches' | 'Centimeters';
+
+export interface DescriptorUnitsValue {
+	units: DescriptorUnits;
+	value: number;
+}
+
+export type DescriptorColor = {
+	'Rd  ': number;
+	'Grn ': number;
+	'Bl  ': number;
+} | {
+	'H   ': DescriptorUnitsValue;
+	Strt: number;
+	Brgh: number;
+} | {
+	'Cyn ': number;
+	Mgnt: number;
+	'Ylw ': number;
+	Blck: number;
+} | {
+	'Gry ': number;
+} | {
+	Lmnc: number;
+	'A   ': number;
+	'B   ': number;
+};
+
+export interface DesciptorPattern {
+	'Nm  ': string;
+	Idnt: string;
+}
+
+export type DesciptorGradient = {
+	'Nm  ': string;
+	GrdF: 'GrdF.CstS';
+	Intr: number;
+	Clrs: {
+		'Clr ': DescriptorColor;
+		Type: 'Clry.UsrS';
+		Lctn: number;
+		Mdpn: number;
+	}[];
+	Trns: {
+		Opct: DescriptorUnitsValue;
+		Lctn: number;
+		Mdpn: number;
+	}[];
+} | {
+	GrdF: 'GrdF.ClNs';
+	Smth: number;
+	'Nm  ': string;
+	ClrS: string;
+	RndS: number;
+	VctC?: boolean;
+	ShTr?: boolean;
+	'Mnm ': number[];
+	'Mxm ': number[];
+};
+
+export interface DescriptorColorContent {
+	'Clr ': DescriptorColor;
+}
+
+export interface DescriptorGradientContent {
+	Grad: DesciptorGradient;
+	Type: string;
+	Dthr?: boolean;
+	Rvrs?: boolean;
+	Angl?: DescriptorUnitsValue;
+	'Scl '?: DescriptorUnitsValue;
+	Algn?: boolean;
+	Ofst?: { Hrzn: DescriptorUnitsValue; Vrtc: DescriptorUnitsValue; };
+}
+
+export interface DescriptorPatternContent {
+	Ptrn: DesciptorPattern;
+	Lnkd?: boolean;
+	phase?: { Hrzn: number; Vrtc: number; };
+}
+
+export type DescriptorVectorContent = DescriptorColorContent | DescriptorGradientContent | DescriptorPatternContent;
+
+export interface StrokeDescriptor {
+	strokeStyleVersion: number;
+	strokeEnabled: boolean;
+	fillEnabled: boolean;
+	strokeStyleLineWidth: DescriptorUnitsValue;
+	strokeStyleLineDashOffset: DescriptorUnitsValue;
+	strokeStyleMiterLimit: number;
+	strokeStyleLineCapType: string;
+	strokeStyleLineJoinType: string;
+	strokeStyleLineAlignment: string;
+	strokeStyleScaleLock: boolean;
+	strokeStyleStrokeAdjust: boolean;
+	strokeStyleLineDashSet: DescriptorUnitsValue[];
+	strokeStyleBlendMode: string;
+	strokeStyleOpacity: DescriptorUnitsValue;
+	strokeStyleContent: DescriptorVectorContent;
+	strokeStyleResolution: number;
+}
+
+export interface TextDescriptor {
+	'Txt ': string;
+	textGridding: string;
+	Ornt: string;
+	AntA: string;
+	TextIndex: number;
+	EngineData?: Uint8Array;
+}
+
+export interface WarpDescriptor {
+	warpStyle: string;
+	warpValue?: number;
+	warpValues?: number[]
+	warpPerspective: number;
+	warpPerspectiveOther: number;
+	warpRotate: string;
+	bounds?: {
+		'Top ': DescriptorUnitsValue;
+		Left: DescriptorUnitsValue;
+		Btom: DescriptorUnitsValue;
+		Rght: DescriptorUnitsValue;
+	};
+	uOrder: number;
+	vOrder: number;
+	customEnvelopeWarp?: {
+		meshPoints: {
+			type: 'Hrzn' | 'Vrtc';
+			values: number[];
+		}[];
+	};
+}
+
+export interface QuiltWarpDescriptor extends WarpDescriptor {
+	deformNumRows: number;
+	deformNumCols: number;
+	customEnvelopeWarp: {
+		quiltSliceX: {
+			type: 'quiltSliceX';
+			values: number[];
+		}[];
+		quiltSliceY: {
+			type: 'quiltSliceY';
+			values: number[];
+		}[];
+		meshPoints: {
+			type: 'Hrzn' | 'Vrtc';
+			values: number[];
+		}[];
+	};
+}
+
+export interface FractionDescriptor {
+	numerator: number;
+	denominator: number;
+}
+
+export interface HrznVrtcDescriptor {
+	Hrzn: number;
+	Vrtc: number;
+}
+
+export interface FrameDescriptor {
+	FrLs: number[];
+	enab?: boolean;
+	IMsk?: { Ofst: HrznVrtcDescriptor };
+	VMsk?: { Ofst: HrznVrtcDescriptor };
+	Ofst?: HrznVrtcDescriptor;
+	FXRf?: HrznVrtcDescriptor;
+	Lefx?: Lfx2Descriptor;
+	blendOptions?: { Opct: DescriptorUnitsValue; };
+}
+
+export interface FrameListDescriptor {
+	LaID: number; // layer ID
+	LaSt: FrameDescriptor[];
+}
+
+export function horzVrtcToXY(hv: HrznVrtcDescriptor): { x: number; y: number; } {
+	return { x: hv.Hrzn, y: hv.Vrtc };
+}
+
+export function xyToHorzVrtc(xy: { x: number; y: number; }): HrznVrtcDescriptor {
+	return { Hrzn: xy.x, Vrtc: xy.y };
+}
+
+export type TimelineAnimKeyDescriptor = {
+	Type: 'keyType.Opct';
+	Opct: DescriptorUnitsValue;
+} | {
+	Type: 'keyType.Trnf';
+	'Scl ': HrznVrtcDescriptor;
+	Skew: HrznVrtcDescriptor;
+	rotation: number;
+	translation: HrznVrtcDescriptor;
+} | {
+	Type: 'keyType.Pstn';
+	Hrzn: number;
+	Vrtc: number;
+} | {
+	Type: 'keyType.sheetStyle';
+	sheetStyle: {
+		Vrsn: number;
+		Lefx?: Lfx2Descriptor;
+		blendOptions: {};
+	};
+} | {
+	Type: 'keyType.globalLighting';
+	gblA: number;
+	globalAltitude: number;
+};
+
+export interface TimelineKeyDescriptor {
+	Vrsn: 1;
+	animInterpStyle: 'animInterpStyle.Lnr ' | 'animInterpStyle.hold';
+	time: FractionDescriptor;
+	animKey: TimelineAnimKeyDescriptor;
+	selected: boolean;
+}
+
+export interface TimelineTrackDescriptor {
+	trackID: 'stdTrackID.globalLightingTrack' | 'stdTrackID.opacityTrack' | 'stdTrackID.styleTrack' | 'stdTrackID.sheetTransformTrack' | 'stdTrackID.sheetPositionTrack';
+	Vrsn: 1;
+	enab: boolean;
+	Effc: boolean;
+	effectParams?: {
+		keyList: TimelineKeyDescriptor[];
+		fillCanvas: boolean;
+		zoomOrigin: number;
+	};
+	keyList: TimelineKeyDescriptor[];
+}
+
+export interface TimeScopeDescriptor {
+	Vrsn: 1;
+	Strt: FractionDescriptor;
+	duration: FractionDescriptor;
+	inTime: FractionDescriptor;
+	outTime: FractionDescriptor;
+}
+
+export interface TimelineDescriptor {
+	Vrsn: 1;
+	timeScope: TimeScopeDescriptor;
+	autoScope: boolean;
+	audioLevel: number;
+	LyrI: number;
+	trackList?: TimelineTrackDescriptor[];
+}
+
+export interface EffectDescriptor extends Partial<DescriptorGradientContent>, Partial<DescriptorPatternContent> {
+	enab?: boolean;
+	Styl: string;
+	PntT?: string;
+	'Md  '?: string;
+	Opct?: DescriptorUnitsValue;
+	'Sz  '?: DescriptorUnitsValue;
+	'Clr '?: DescriptorColor;
+	present?: boolean;
+	showInDialog?: boolean;
+	overprint?: boolean;
+}
+
+export interface Lfx2Descriptor {
+	'Scl '?: DescriptorUnitsValue;
+	masterFXSwitch?: boolean;
+	DrSh?: EffectDescriptor;
+	IrSh?: EffectDescriptor;
+	OrGl?: EffectDescriptor;
+	IrGl?: EffectDescriptor;
+	ebbl?: EffectDescriptor;
+	SoFi?: EffectDescriptor;
+	patternFill?: EffectDescriptor;
+	GrFl?: EffectDescriptor;
+	ChFX?: EffectDescriptor;
+	FrFX?: EffectDescriptor;
+}
+
+export interface LmfxDescriptor {
+	'Scl '?: DescriptorUnitsValue;
+	masterFXSwitch?: boolean;
+	numModifyingFX?: number;
+	OrGl?: EffectDescriptor;
+	IrGl?: EffectDescriptor;
+	ebbl?: EffectDescriptor;
+	ChFX?: EffectDescriptor;
+	dropShadowMulti?: EffectDescriptor[];
+	innerShadowMulti?: EffectDescriptor[];
+	solidFillMulti?: EffectDescriptor[];
+	gradientFillMulti?: EffectDescriptor[];
+	frameFXMulti?: EffectDescriptor[];
+	patternFill?: EffectDescriptor; // ???
+}
+
+function parseFxObject(fx: EffectDescriptor) {
+	const stroke: LayerEffectStroke = {
+		enabled: !!fx.enab,
+		position: FStl.decode(fx.Styl),
+		fillType: FrFl.decode(fx.PntT!),
+		blendMode: BlnM.decode(fx['Md  ']!),
+		opacity: parsePercent(fx.Opct),
+		size: parseUnits(fx['Sz  ']!),
+	};
+
+	if (fx.present !== undefined) stroke.present = fx.present;
+	if (fx.showInDialog !== undefined) stroke.showInDialog = fx.showInDialog;
+	if (fx.overprint !== undefined) stroke.overprint = fx.overprint;
+	if (fx['Clr ']) stroke.color = parseColor(fx['Clr ']);
+	if (fx.Grad) stroke.gradient = parseGradientContent(fx as any);
+	if (fx.Ptrn) stroke.pattern = parsePatternContent(fx as any);
+
+	return stroke;
+}
+
+function serializeFxObject(stroke: LayerEffectStroke) {
+	let FrFX: EffectDescriptor = {} as any;
+	FrFX.enab = !!stroke.enabled;
+	if (stroke.present !== undefined) FrFX.present = !!stroke.present;
+	if (stroke.showInDialog !== undefined) FrFX.showInDialog = !!stroke.showInDialog;
+	FrFX.Styl = FStl.encode(stroke.position);
+	FrFX.PntT = FrFl.encode(stroke.fillType);
+	FrFX['Md  '] = BlnM.encode(stroke.blendMode);
+	FrFX.Opct = unitsPercent(stroke.opacity);
+	FrFX['Sz  '] = unitsValue(stroke.size, 'size');
+	if (stroke.color) FrFX['Clr '] = serializeColor(stroke.color);
+	if (stroke.gradient) FrFX = { ...FrFX, ...serializeGradientContent(stroke.gradient) };
+	if (stroke.pattern) FrFX = { ...FrFX, ...serializePatternContent(stroke.pattern) };
+	if (stroke.overprint !== undefined) FrFX.overprint = !!stroke.overprint;
+	return FrFX;
+}
+
+export function serializeEffects(e: LayerEffectsInfo, log: boolean, multi: boolean) {
+	const info: Lfx2Descriptor & LmfxDescriptor = multi ? {
+		'Scl ': unitsPercent(e.scale ?? 1),
+		masterFXSwitch: !e.disabled,
+	} : {
+		masterFXSwitch: !e.disabled,
+		'Scl ': unitsPercent(e.scale ?? 1),
+	};
+
+	const arrayKeys: (keyof LayerEffectsInfo)[] = ['dropShadow', 'innerShadow', 'solidFill', 'gradientOverlay', 'stroke'];
+	for (const key of arrayKeys) {
+		if (e[key] && !Array.isArray(e[key])) throw new Error(`${key} should be an array`);
+	}
+
+	if (e.dropShadow?.[0] && !multi) info.DrSh = serializeEffectObject(e.dropShadow[0], 'dropShadow', log);
+	if (e.dropShadow?.[0] && multi) info.dropShadowMulti = e.dropShadow.map(i => serializeEffectObject(i, 'dropShadow', log));
+	if (e.innerShadow?.[0] && !multi) info.IrSh = serializeEffectObject(e.innerShadow[0], 'innerShadow', log);
+	if (e.innerShadow?.[0] && multi) info.innerShadowMulti = e.innerShadow.map(i => serializeEffectObject(i, 'innerShadow', log));
+	if (e.outerGlow) info.OrGl = serializeEffectObject(e.outerGlow, 'outerGlow', log);
+	if (e.solidFill?.[0] && multi) info.solidFillMulti = e.solidFill.map(i => serializeEffectObject(i, 'solidFill', log));
+	if (e.gradientOverlay?.[0] && multi) info.gradientFillMulti = e.gradientOverlay.map(i => serializeEffectObject(i, 'gradientOverlay', log));
+	if (e.stroke?.[0] && multi) 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 (e.solidFill?.[0] && !multi) info.SoFi = serializeEffectObject(e.solidFill[0], 'solidFill', log);
+	if (e.patternOverlay) info.patternFill = serializeEffectObject(e.patternOverlay, 'patternOverlay', log);
+	if (e.gradientOverlay?.[0] && !multi) info.GrFl = serializeEffectObject(e.gradientOverlay[0], 'gradientOverlay', log);
+	if (e.satin) info.ChFX = serializeEffectObject(e.satin, 'satin', log);
+	if (e.stroke?.[0] && !multi) info.FrFX = serializeFxObject(e.stroke?.[0]);
+
+	if (multi) {
+		info.numModifyingFX = 0;
+
+		for (const key of Object.keys(e)) {
+			const value = (e as any)[key];
+			if (Array.isArray(value)) {
+				for (const effect of value) {
+					if (effect.enabled) info.numModifyingFX++;
+				}
+			}
+		}
+	}
+
+	return info;
+}
+
+export function parseEffects(info: Lfx2Descriptor & LmfxDescriptor, log: boolean) {
+	const effects: LayerEffectsInfo = {};
+	if (!info.masterFXSwitch) effects.disabled = true;
+	if (info['Scl ']) effects.scale = parsePercent(info['Scl ']);
+	if (info.DrSh) effects.dropShadow = [parseEffectObject(info.DrSh, log)];
+	if (info.dropShadowMulti) effects.dropShadow = info.dropShadowMulti.map(i => parseEffectObject(i, log));
+	if (info.IrSh) effects.innerShadow = [parseEffectObject(info.IrSh, log)];
+	if (info.innerShadowMulti) effects.innerShadow = info.innerShadowMulti.map(i => parseEffectObject(i, log));
+	if (info.OrGl) effects.outerGlow = parseEffectObject(info.OrGl, log);
+	if (info.IrGl) effects.innerGlow = parseEffectObject(info.IrGl, log);
+	if (info.ebbl) effects.bevel = parseEffectObject(info.ebbl, log);
+	if (info.SoFi) effects.solidFill = [parseEffectObject(info.SoFi, log)];
+	if (info.solidFillMulti) effects.solidFill = info.solidFillMulti.map(i => parseEffectObject(i, log));
+	if (info.patternFill) effects.patternOverlay = parseEffectObject(info.patternFill, log);
+	if (info.GrFl) effects.gradientOverlay = [parseEffectObject(info.GrFl, log)];
+	if (info.gradientFillMulti) effects.gradientOverlay = info.gradientFillMulti.map(i => parseEffectObject(i, log));
+	if (info.ChFX) effects.satin = parseEffectObject(info.ChFX, log);
+	if (info.FrFX) effects.stroke = [parseFxObject(info.FrFX)];
+	if (info.frameFXMulti) effects.stroke = info.frameFXMulti.map(i => parseFxObject(i));
+	return effects;
+}
+
+function parseKeyList(keyList: TimelineKeyDescriptor[], logMissingFeatures: boolean) {
+	const keys: TimelineKey[] = [];
+
+	for (let j = 0; j < keyList.length; j++) {
+		const key = keyList[j];
+		const { time, selected, animKey } = key;
+		const interpolation = animInterpStyleEnum.decode(key.animInterpStyle);
+
+		switch (animKey.Type) {
+			case 'keyType.Opct':
+				keys.push({ interpolation, time, selected, type: 'opacity', value: parsePercent(animKey.Opct) });
+				break;
+			case 'keyType.Pstn':
+				keys.push({ interpolation, time, selected, type: 'position', x: animKey.Hrzn, y: animKey.Vrtc });
+				break;
+			case 'keyType.Trnf':
+				keys.push({
+					interpolation, time, selected, type: 'transform',
+					scale: horzVrtcToXY(animKey['Scl ']), skew: horzVrtcToXY(animKey.Skew), rotation: animKey.rotation, translation: horzVrtcToXY(animKey.translation)
+				});
+				break;
+			case 'keyType.sheetStyle': {
+				const key: TimelineKey = { interpolation, time, selected, type: 'style' };
+				if (animKey.sheetStyle.Lefx) key.style = parseEffects(animKey.sheetStyle.Lefx, logMissingFeatures);
+				keys.push(key);
+				break;
+			}
+			case 'keyType.globalLighting': {
+				keys.push({
+					interpolation, time, selected, type: 'globalLighting',
+					globalAngle: animKey.gblA, globalAltitude: animKey.globalAltitude
+				});
+				break;
+			}
+			default: throw new Error(`Unsupported keyType value`);
+		}
+	}
+
+	return keys;
+}
+
+function serializeKeyList(keys: TimelineKey[]): TimelineKeyDescriptor[] {
+	const keyList: TimelineKeyDescriptor[] = [];
+
+	for (let j = 0; j < keys.length; j++) {
+		const key = keys[j];
+		const { time, selected = false, interpolation } = key;
+		const animInterpStyle = animInterpStyleEnum.encode(interpolation) as 'animInterpStyle.Lnr ' | 'animInterpStyle.hold';
+		let animKey: TimelineAnimKeyDescriptor;
+
+		switch (key.type) {
+			case 'opacity':
+				animKey = { Type: 'keyType.Opct', Opct: unitsPercent(key.value) };
+				break;
+			case 'position':
+				animKey = { Type: 'keyType.Pstn', Hrzn: key.x, Vrtc: key.y };
+				break;
+			case 'transform':
+				animKey = { Type: 'keyType.Trnf', 'Scl ': xyToHorzVrtc(key.scale), Skew: xyToHorzVrtc(key.skew), rotation: key.rotation, translation: xyToHorzVrtc(key.translation) };
+				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: {} };
+				break;
+			case 'globalLighting': {
+				animKey = { Type: 'keyType.globalLighting', gblA: key.globalAngle, globalAltitude: key.globalAltitude };
+				break;
+			}
+			default: throw new Error(`Unsupported keyType value`);
+		}
+
+		keyList.push({ Vrsn: 1, animInterpStyle, time, animKey, selected });
+	}
+
+	return keyList;
+}
+
+export function parseTrackList(trackList: TimelineTrackDescriptor[], logMissingFeatures: boolean) {
+	const tracks: TimelineTrack[] = [];
+
+	for (let i = 0; i < trackList.length; i++) {
+		const tr = trackList[i];
+		const track: TimelineTrack = {
+			type: stdTrackID.decode(tr.trackID),
+			enabled: tr.enab,
+			keys: parseKeyList(tr.keyList, logMissingFeatures),
+		};
+
+		if (tr.effectParams) {
+			track.effectParams = {
+				fillCanvas: tr.effectParams.fillCanvas,
+				zoomOrigin: tr.effectParams.zoomOrigin,
+				keys: parseKeyList(tr.effectParams.keyList, logMissingFeatures),
+			};
+		}
+
+		tracks.push(track);
+	}
+
+	return tracks;
+}
+
+export function serializeTrackList(tracks: TimelineTrack[]): TimelineTrackDescriptor[] {
+	const trackList: TimelineTrackDescriptor[] = [];
+
+	for (let i = 0; i < tracks.length; i++) {
+		const t = tracks[i];
+		trackList.push({
+			trackID: stdTrackID.encode(t.type) as any,
+			Vrsn: 1,
+			enab: !!t.enabled,
+			Effc: !!t.effectParams,
+			...(t.effectParams ? {
+				effectParams: {
+					keyList: serializeKeyList(t.keys),
+					fillCanvas: t.effectParams.fillCanvas,
+					zoomOrigin: t.effectParams.zoomOrigin,
+				}
+			} : {}),
+			keyList: serializeKeyList(t.keys),
+		});
+	}
+
+	return trackList;
+}
+
+type AllEffects = LayerEffectShadow & LayerEffectsOuterGlow & LayerEffectStroke &
+	LayerEffectInnerGlow & LayerEffectBevel & LayerEffectSolidFill &
+	LayerEffectPatternOverlay & LayerEffectSatin & LayerEffectGradientOverlay;
+
+function parseEffectObject(obj: any, reportErrors: boolean) {
+	const result: AllEffects = {} as any;
+
+	for (const key of Object.keys(obj)) {
+		const val = obj[key];
+
+		switch (key) {
+			case 'enab': result.enabled = !!val; break;
+			case 'uglg': result.useGlobalLight = !!val; break;
+			case 'AntA': result.antialiased = !!val; break;
+			case 'Algn': result.align = !!val; break;
+			case 'Dthr': result.dither = !!val; break;
+			case 'Invr': result.invert = !!val; break;
+			case 'Rvrs': result.reverse = !!val; break;
+			case 'Clr ': result.color = parseColor(val); break;
+			case 'hglC': result.highlightColor = parseColor(val); break;
+			case 'sdwC': result.shadowColor = parseColor(val); break;
+			case 'Styl': result.position = FStl.decode(val); break;
+			case 'Md  ': result.blendMode = BlnM.decode(val); break;
+			case 'hglM': result.highlightBlendMode = BlnM.decode(val); break;
+			case 'sdwM': result.shadowBlendMode = BlnM.decode(val); break;
+			case 'bvlS': result.style = BESl.decode(val); break;
+			case 'bvlD': result.direction = BESs.decode(val); break;
+			case 'bvlT': result.technique = bvlT.decode(val) as any; break;
+			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 'Opct': result.opacity = parsePercent(val); break;
+			case 'hglO': result.highlightOpacity = parsePercent(val); break;
+			case 'sdwO': result.shadowOpacity = parsePercent(val); break;
+			case 'lagl': result.angle = parseAngle(val); break;
+			case 'Angl': result.angle = parseAngle(val); break;
+			case 'Lald': result.altitude = parseAngle(val); break;
+			case 'Sftn': result.soften = parseUnits(val); break;
+			case 'srgR': result.strength = parsePercent(val); break;
+			case 'blur': result.size = parseUnits(val); break;
+			case 'Nose': result.noise = parsePercent(val); break;
+			case 'Inpr': result.range = parsePercent(val); break;
+			case 'Ckmt': result.choke = parseUnits(val); break;
+			case 'ShdN': result.jitter = parsePercent(val); break;
+			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 'Ofst': result.offset = { x: parsePercent(val.Hrzn), y: parsePercent(val.Vrtc) }; break;
+			case 'MpgS':
+			case 'TrnS':
+				result.contour = {
+					name: val['Nm  '],
+					curve: (val['Crv '] as any[]).map(p => ({ x: p.Hrzn, y: p.Vrtc })),
+				};
+				break;
+			case 'Grad': result.gradient = parseGradient(val); break;
+			case 'useTexture':
+			case 'useShape':
+			case 'layerConceals':
+			case 'present':
+			case 'showInDialog':
+			case 'antialiasGloss': result[key] = val; break;
+			default:
+				reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+		}
+	}
+
+	return result;
+}
+
+function serializeEffectObject(obj: any, objName: string, reportErrors: boolean) {
+	const result: any = {};
+
+	for (const objKey of Object.keys(obj)) {
+		const key: keyof AllEffects = objKey as any;
+		const val = obj[key];
+
+		switch (key) {
+			case 'enabled': result.enab = !!val; break;
+			case 'useGlobalLight': result.uglg = !!val; break;
+			case 'antialiased': result.AntA = !!val; break;
+			case 'align': result.Algn = !!val; break;
+			case 'dither': result.Dthr = !!val; break;
+			case 'invert': result.Invr = !!val; break;
+			case 'reverse': result.Rvrs = !!val; break;
+			case 'color': result['Clr '] = serializeColor(val); break;
+			case 'highlightColor': result.hglC = serializeColor(val); break;
+			case 'shadowColor': result.sdwC = serializeColor(val); break;
+			case 'position': result.Styl = FStl.encode(val); break;
+			case 'blendMode': result['Md  '] = BlnM.encode(val); break;
+			case 'highlightBlendMode': result.hglM = BlnM.encode(val); break;
+			case 'shadowBlendMode': result.sdwM = BlnM.encode(val); break;
+			case 'style': result.bvlS = BESl.encode(val); break;
+			case 'direction': result.bvlD = BESs.encode(val); break;
+			case 'technique':
+				if (objName === 'bevel') {
+					result.bvlT = bvlT.encode(val);
+				} else {
+					result.GlwT = BETE.encode(val);
+				}
+				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 'opacity': result.Opct = unitsPercent(val); break;
+			case 'highlightOpacity': result.hglO = unitsPercent(val); break;
+			case 'shadowOpacity': result.sdwO = unitsPercent(val); break;
+			case 'angle':
+				if (objName === 'gradientOverlay') {
+					result.Angl = unitsAngle(val);
+				} else {
+					result.lagl = unitsAngle(val);
+				}
+				break;
+			case 'altitude': result.Lald = unitsAngle(val); break;
+			case 'soften': result.Sftn = unitsValue(val, key); break;
+			case 'strength': result.srgR = unitsPercent(val); break;
+			case 'size': result.blur = unitsValue(val, key); break;
+			case 'noise': result.Nose = unitsPercent(val); break;
+			case 'range': result.Inpr = unitsPercent(val); break;
+			case 'choke': result.Ckmt = unitsValue(val, key); break;
+			case 'jitter': result.ShdN = unitsPercent(val); break;
+			case 'distance': result.Dstn = unitsValue(val, key); break;
+			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 'gradient': result.Grad = serializeGradient(val); break;
+			case 'useTexture':
+			case 'useShape':
+			case 'layerConceals':
+			case 'present':
+			case 'showInDialog':
+			case 'antialiasGloss':
+				result[key] = val;
+				break;
+			default:
+				reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+		}
+	}
+
+	return result;
+}
+
+function parseGradient(grad: DesciptorGradient): EffectSolidGradient | EffectNoiseGradient {
+	if (grad.GrdF === 'GrdF.CstS') {
+		const samples: number = grad.Intr || 4096;
+
+		return {
+			type: 'solid',
+			name: grad['Nm  '],
+			smoothness: grad.Intr / 4096,
+			colorStops: grad.Clrs.map(s => ({
+				color: parseColor(s['Clr ']),
+				location: s.Lctn / samples,
+				midpoint: s.Mdpn / 100,
+			})),
+			opacityStops: grad.Trns.map(s => ({
+				opacity: parsePercent(s.Opct),
+				location: s.Lctn / samples,
+				midpoint: s.Mdpn / 100,
+			})),
+		};
+	} else {
+		return {
+			type: 'noise',
+			name: grad['Nm  '],
+			roughness: grad.Smth / 4096,
+			colorModel: ClrS.decode(grad.ClrS),
+			randomSeed: grad.RndS,
+			restrictColors: !!grad.VctC,
+			addTransparency: !!grad.ShTr,
+			min: grad['Mnm '].map(x => x / 100),
+			max: grad['Mxm '].map(x => x / 100),
+		};
+	}
+}
+
+function serializeGradient(grad: EffectSolidGradient | EffectNoiseGradient): DesciptorGradient {
+	if (grad.type === 'solid') {
+		const samples = Math.round((grad.smoothness ?? 1) * 4096);
+		return {
+			'Nm  ': grad.name || '',
+			GrdF: 'GrdF.CstS',
+			Intr: samples,
+			Clrs: grad.colorStops.map(s => ({
+				'Clr ': serializeColor(s.color),
+				Type: 'Clry.UsrS',
+				Lctn: Math.round(s.location * samples),
+				Mdpn: Math.round((s.midpoint ?? 0.5) * 100),
+			})),
+			Trns: grad.opacityStops.map(s => ({
+				Opct: unitsPercent(s.opacity),
+				Lctn: Math.round(s.location * samples),
+				Mdpn: Math.round((s.midpoint ?? 0.5) * 100),
+			})),
+		};
+	} else {
+		return {
+			GrdF: 'GrdF.ClNs',
+			'Nm  ': grad.name || '',
+			ShTr: !!grad.addTransparency,
+			VctC: !!grad.restrictColors,
+			ClrS: ClrS.encode(grad.colorModel),
+			RndS: grad.randomSeed || 0,
+			Smth: Math.round((grad.roughness ?? 1) * 4096),
+			'Mnm ': (grad.min || [0, 0, 0, 0]).map(x => x * 100),
+			'Mxm ': (grad.max || [1, 1, 1, 1]).map(x => x * 100),
+		};
+	}
+}
+
+function parseGradientContent(descriptor: DescriptorGradientContent) {
+	const result = parseGradient(descriptor.Grad) as (EffectSolidGradient | EffectNoiseGradient) & ExtraGradientInfo;
+	result.style = GrdT.decode(descriptor.Type);
+	if (descriptor.Dthr !== undefined) result.dither = descriptor.Dthr;
+	if (descriptor.Rvrs !== undefined) result.reverse = descriptor.Rvrs;
+	if (descriptor.Angl !== undefined) result.angle = parseAngle(descriptor.Angl);
+	if (descriptor['Scl '] !== undefined) result.scale = parsePercent(descriptor['Scl ']);
+	if (descriptor.Algn !== undefined) result.align = descriptor.Algn;
+	if (descriptor.Ofst !== undefined) {
+		result.offset = {
+			x: parsePercent(descriptor.Ofst.Hrzn),
+			y: parsePercent(descriptor.Ofst.Vrtc)
+		};
+	}
+	return result;
+}
+
+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 };
+	return result;
+}
+
+
+export function parseVectorContent(descriptor: DescriptorVectorContent): VectorContent {
+	if ('Grad' in descriptor) {
+		return parseGradientContent(descriptor);
+	} else if ('Ptrn' in descriptor) {
+		return { type: 'pattern', ...parsePatternContent(descriptor) };
+	} else if ('Clr ' in descriptor) {
+		return { type: 'color', color: parseColor(descriptor['Clr ']) };
+	} else {
+		throw new Error('Invalid vector content');
+	}
+}
+
+function serializeGradientContent(content: (EffectSolidGradient | EffectNoiseGradient) & ExtraGradientInfo) {
+	const result: DescriptorGradientContent = {} as any;
+	if (content.dither !== undefined) result.Dthr = content.dither;
+	if (content.reverse !== undefined) result.Rvrs = content.reverse;
+	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.offset) {
+		result.Ofst = {
+			Hrzn: unitsPercent(content.offset.x),
+			Vrtc: unitsPercent(content.offset.y),
+		};
+	}
+	result.Grad = serializeGradient(content);
+	return result;
+}
+
+function serializePatternContent(content: EffectPattern & ExtraPatternInfo) {
+	const result: DescriptorPatternContent = {
+		Ptrn: {
+			'Nm  ': content.name || '',
+			Idnt: content.id || '',
+		}
+	};
+	if (content.linked !== undefined) result.Lnkd = !!content.linked;
+	if (content.phase !== undefined) result.phase = { Hrzn: content.phase.x, Vrtc: content.phase.y };
+	return result;
+}
+
+export function serializeVectorContent(content: VectorContent): { descriptor: DescriptorVectorContent; key: string; } {
+	if (content.type === 'color') {
+		return { key: 'SoCo', descriptor: { 'Clr ': serializeColor(content.color) } };
+	} else if (content.type === 'pattern') {
+		return { key: 'PtFl', descriptor: serializePatternContent(content) };
+	} else {
+		return { key: 'GdFl', descriptor: serializeGradientContent(content) };
+	}
+}
+
+export function parseColor(color: DescriptorColor): Color {
+	if ('H   ' in color) {
+		return { h: parsePercentOrAngle(color['H   ']), s: color.Strt, b: color.Brgh };
+	} else if ('Rd  ' in color) {
+		return { r: color['Rd  '], g: color['Grn '], b: color['Bl  '] };
+	} else if ('Cyn ' in color) {
+		return { c: color['Cyn '], m: color.Mgnt, y: color['Ylw '], k: color.Blck };
+	} else if ('Gry ' in color) {
+		return { k: color['Gry '] };
+	} else if ('Lmnc' in color) {
+		return { l: color.Lmnc, a: color['A   '], b: color['B   '] };
+	} else {
+		throw new Error('Unsupported color descriptor');
+	}
+}
+
+export function serializeColor(color: Color | undefined): DescriptorColor {
+	if (!color) {
+		return { 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
+	} else if ('r' in color) {
+		return { 'Rd  ': color.r || 0, 'Grn ': color.g || 0, 'Bl  ': color.b || 0 };
+	} else if ('h' in color) {
+		return { '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 };
+	} else if ('l' in color) {
+		return { Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
+	} else if ('k' in color) {
+		return { 'Gry ': color.k };
+	} else {
+		throw new Error('Invalid color value');
+	}
+}
+
+export function parseAngle(x: DescriptorUnitsValue) {
+	if (x === undefined) return 0;
+	if (x.units !== 'Angle') throw new Error(`Invalid units: ${x.units}`);
+	return x.value;
+}
+
+export function parsePercent(x: DescriptorUnitsValue | undefined) {
+	if (x === undefined) return 1;
+	if (x.units !== 'Percent') throw new Error(`Invalid units: ${x.units}`);
+	return x.value / 100;
+}
+
+export function parsePercentOrAngle(x: DescriptorUnitsValue | undefined) {
+	if (x === undefined) return 1;
+	if (x.units === 'Percent') return x.value / 100;
+	if (x.units === 'Angle') return x.value / 360;
+	throw new Error(`Invalid units: ${x.units}`);
+}
+
+export function parseUnits({ units, value }: DescriptorUnitsValue): UnitsValue {
+	if (
+		units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
+		units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density'
+	) {
+		throw new Error(`Invalid units: ${JSON.stringify({ units, value })}`);
+	}
+	return { value, units };
+}
+
+export function parseUnitsOrNumber(value: DescriptorUnitsValue | number, units: Units = 'Pixels'): UnitsValue {
+	if (typeof value === 'number') return { value, units };
+	return parseUnits(value);
+}
+
+export function parseUnitsToNumber({ units, value }: DescriptorUnitsValue, expectedUnits: string): number {
+	if (units !== expectedUnits) throw new Error(`Invalid units: ${JSON.stringify({ units, value })}`);
+	return value;
+}
+
+export function unitsAngle(value: number | undefined): DescriptorUnitsValue {
+	return { units: 'Angle', value: value || 0 };
+}
+
+export function unitsPercent(value: number | undefined): DescriptorUnitsValue {
+	return { units: 'Percent', value: Math.round((value || 0) * 100) };
+}
+
+export function unitsValue(x: UnitsValue | undefined, key: string): DescriptorUnitsValue {
+	if (x == null) return { units: 'Pixels', value: 0 };
+
+	if (typeof x !== 'object')
+		throw new Error(`Invalid value: ${JSON.stringify(x)} (key: ${key}) (should have value and units)`);
+
+	const { units, value } = x;
+
+	if (typeof value !== 'number')
+		throw new Error(`Invalid value in ${JSON.stringify(x)} (key: ${key})`);
+
+	if (
+		units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
+		units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density'
+	) {
+		throw new Error(`Invalid units in ${JSON.stringify(x)} (key: ${key})`);
+	}
+
+	return { units, value };
+}
+
+export const textGridding = createEnum<TextGridding>('textGridding', 'none', {
+	none: 'None',
+	round: 'Rnd ',
+});
+
+export const Ornt = createEnum<Orientation>('Ornt', 'horizontal', {
+	horizontal: 'Hrzn',
+	vertical: 'Vrtc',
+});
+
+export const Annt = createEnum<AntiAlias>('Annt', 'sharp', {
+	none: 'Anno',
+	sharp: 'antiAliasSharp',
+	crisp: 'AnCr',
+	strong: 'AnSt',
+	smooth: 'AnSm',
+	platform: 'antiAliasPlatformGray',
+	platformLCD: 'antiAliasPlatformLCD',
+});
+
+export const warpStyle = createEnum<WarpStyle>('warpStyle', 'none', {
+	none: 'warpNone',
+	arc: 'warpArc',
+	arcLower: 'warpArcLower',
+	arcUpper: 'warpArcUpper',
+	arch: 'warpArch',
+	bulge: 'warpBulge',
+	shellLower: 'warpShellLower',
+	shellUpper: 'warpShellUpper',
+	flag: 'warpFlag',
+	wave: 'warpWave',
+	fish: 'warpFish',
+	rise: 'warpRise',
+	fisheye: 'warpFisheye',
+	inflate: 'warpInflate',
+	squeeze: 'warpSqueeze',
+	twist: 'warpTwist',
+	cylinder: 'warpCylinder',
+	custom: 'warpCustom',
+});
+
+export const BlnM = createEnum<BlendMode>('BlnM', 'normal', {
+	'normal': 'Nrml',
+	'dissolve': 'Dslv',
+	'darken': 'Drkn',
+	'multiply': 'Mltp',
+	'color burn': 'CBrn',
+	'linear burn': 'linearBurn',
+	'darker color': 'darkerColor',
+	'lighten': 'Lghn',
+	'screen': 'Scrn',
+	'color dodge': 'CDdg',
+	'linear dodge': 'linearDodge',
+	'lighter color': 'lighterColor',
+	'overlay': 'Ovrl',
+	'soft light': 'SftL',
+	'hard light': 'HrdL',
+	'vivid light': 'vividLight',
+	'linear light': 'linearLight',
+	'pin light': 'pinLight',
+	'hard mix': 'hardMix',
+	'difference': 'Dfrn',
+	'exclusion': 'Xclu',
+	'subtract': 'blendSubtraction',
+	'divide': 'blendDivide',
+	'hue': 'H   ',
+	'saturation': 'Strt',
+	'color': 'Clr ',
+	'luminosity': 'Lmns',
+	// used in ABR
+	'linear height': 'linearHeight',
+	'height': 'Hght',
+	'subtraction': 'Sbtr', // 2nd version of subtract ?
+});
+
+export const BESl = createEnum<BevelStyle>('BESl', 'inner bevel', {
+	'inner bevel': 'InrB',
+	'outer bevel': 'OtrB',
+	'emboss': 'Embs',
+	'pillow emboss': 'PlEb',
+	'stroke emboss': 'strokeEmboss',
+});
+
+export const bvlT = createEnum<BevelTechnique>('bvlT', 'smooth', {
+	'smooth': 'SfBL',
+	'chisel hard': 'PrBL',
+	'chisel soft': 'Slmt',
+});
+
+export const BESs = createEnum<BevelDirection>('BESs', 'up', {
+	up: 'In  ',
+	down: 'Out ',
+});
+
+export const BETE = createEnum<GlowTechnique>('BETE', 'softer', {
+	softer: 'SfBL',
+	precise: 'PrBL',
+});
+
+export const IGSr = createEnum<GlowSource>('IGSr', 'edge', {
+	edge: 'SrcE',
+	center: 'SrcC',
+});
+
+export const GrdT = createEnum<GradientStyle>('GrdT', 'linear', {
+	linear: 'Lnr ',
+	radial: 'Rdl ',
+	angle: 'Angl',
+	reflected: 'Rflc',
+	diamond: 'Dmnd',
+});
+
+export const animInterpStyleEnum = createEnum<TimelineKeyInterpolation>('animInterpStyle', 'linear', {
+	linear: 'Lnr ',
+	hold: 'hold',
+});
+
+export const stdTrackID = createEnum<TimelineTrackType>('stdTrackID', 'opacity', {
+	opacity: 'opacityTrack',
+	style: 'styleTrack',
+	sheetTransform: 'sheetTransformTrack',
+	sheetPosition: 'sheetPositionTrack',
+	globalLighting: 'globalLightingTrack',
+});
+
+export const gradientInterpolationMethodType = createEnum<InterpolationMethod>('gradientInterpolationMethodType', 'perceptual', {
+	perceptual: 'Perc',
+	linear: 'Lnr',
+	classic: 'Gcls',
+});
+
+export const ClrS = createEnum<'rgb' | 'hsb' | 'lab'>('ClrS', 'rgb', {
+	rgb: 'RGBC',
+	hsb: 'HSBl',
+	lab: 'LbCl',
+});
+
+export const FStl = createEnum<'inside' | 'center' | 'outside'>('FStl', 'outside', {
+	outside: 'OutF',
+	center: 'CtrF',
+	inside: 'InsF'
+});
+
+export const FrFl = createEnum<'color' | 'gradient' | 'pattern'>('FrFl', 'color', {
+	color: 'SClr',
+	gradient: 'GrFl',
+	pattern: 'Ptrn',
+});
+
+export const ESliceType = createEnum<'image' | 'noImage'>('ESliceType', 'image', {
+	image: 'Img ',
+	noImage: 'noImage',
+});
+
+export const ESliceHorzAlign = createEnum<'default'>('ESliceHorzAlign', 'default', {
+	default: 'default',
+});
+
+export const ESliceVertAlign = createEnum<'default'>('ESliceVertAlign', 'default', {
+	default: 'default',
+});
+
+export const ESliceOrigin = createEnum<'userGenerated' | 'autoGenerated' | 'layer'>('ESliceOrigin', 'userGenerated', {
+	userGenerated: 'userGenerated',
+	autoGenerated: 'autoGenerated',
+	layer: 'layer',
+});
+
+export const ESliceBGColorType = createEnum<'none' | 'matte' | 'color'>('ESliceBGColorType', 'none', {
+	none: 'None',
+	matte: 'matte',
+	color: 'Clr ',
+});
+
+export const strokeStyleLineCapType = createEnum<LineCapType>('strokeStyleLineCapType', 'butt', {
+	butt: 'strokeStyleButtCap',
+	round: 'strokeStyleRoundCap',
+	square: 'strokeStyleSquareCap',
+});
+
+export const strokeStyleLineJoinType = createEnum<LineJoinType>('strokeStyleLineJoinType', 'miter', {
+	miter: 'strokeStyleMiterJoin',
+	round: 'strokeStyleRoundJoin',
+	bevel: 'strokeStyleBevelJoin',
+});
+
+export const strokeStyleLineAlignment = createEnum<LineAlignment>('strokeStyleLineAlignment', 'inside', {
+	inside: 'strokeStyleAlignInside',
+	center: 'strokeStyleAlignCenter',
+	outside: 'strokeStyleAlignOutside',
+});