ag-psd 19.0.1 → 20.0.0

package/src/additionalInfo.ts

@@ -1,37 +1,10 @@
 import { fromByteArray, toByteArray } from 'base64-js';
 import { readEffects, writeEffects } from './effectsHelpers';
 import { clamp, createEnum, layerColors, MOCK_HANDLERS } from './helpers';
-import {
-	LayerAdditionalInfo, BezierPath, Psd, ReadOptions, BrightnessAdjustment, ExposureAdjustment, VibranceAdjustment,
-	ColorBalanceAdjustment, BlackAndWhiteAdjustment, PhotoFilterAdjustment, ChannelMixerChannel,
-	ChannelMixerAdjustment, PosterizeAdjustment, ThresholdAdjustment, GradientMapAdjustment, CMYK,
-	SelectiveColorAdjustment, ColorLookupAdjustment, LevelsAdjustmentChannel, LevelsAdjustment,
-	CurvesAdjustment, CurvesAdjustmentChannel, HueSaturationAdjustment, HueSaturationAdjustmentChannel,
-	PresetInfo, Color, ColorBalanceValues, WriteOptions, LinkedFile, PlacedLayerType, Warp, KeyDescriptorItem,
-	BooleanOperation, LayerEffectsInfo, Annotation, LayerVectorMask, AnimationFrame, Timeline, PlacedLayerFilter,
-	UnitsValue, Filter, PlacedLayer,
-} from './psd';
-import {
-	PsdReader, readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16,
-	readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32,
-	readPascalString, readUnicodeStringWithLength, readAsciiString, readPattern,
-} from './psdReader';
-import {
-	PsdWriter, writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8,
-	writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding,
-	writeColor, writePascalString, writeInt32,
-} from './psdWriter';
-import {
-	Annt, BlnM, DescriptorColor, DescriptorUnitsValue, parsePercent, parseUnits, parseUnitsOrNumber, QuiltWarpDescriptor,
-	strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, TextDescriptor, textGridding,
-	unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor,
-	readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor,
-	FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects,
-	parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList,
-	serializeTrackList, FractionDescriptor, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy,
-	Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd,
-	unitsPercentF, frac, ClrS, descBoundsToBounds, boundsToDescBounds,
-} from './descriptor';
+import { LayerAdditionalInfo, BezierPath, Psd, BrightnessAdjustment, ExposureAdjustment, VibranceAdjustment, ColorBalanceAdjustment, BlackAndWhiteAdjustment, PhotoFilterAdjustment, ChannelMixerChannel, ChannelMixerAdjustment, PosterizeAdjustment, ThresholdAdjustment, GradientMapAdjustment, CMYK, SelectiveColorAdjustment, ColorLookupAdjustment, LevelsAdjustmentChannel, LevelsAdjustment, CurvesAdjustment, CurvesAdjustmentChannel, HueSaturationAdjustment, HueSaturationAdjustmentChannel, PresetInfo, Color, ColorBalanceValues, WriteOptions, LinkedFile, PlacedLayerType, Warp, KeyDescriptorItem, BooleanOperation, LayerEffectsInfo, Annotation, LayerVectorMask, AnimationFrame, Timeline, PlacedLayerFilter, UnitsValue, Filter, PlacedLayer } from './psd';
+import { PsdReader, readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16, readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32, readPascalString, readUnicodeStringWithLength, readAsciiString, readPattern, readLayerInfo, ReadOptionsExt } from './psdReader';
+import { PsdWriter, writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32 } from './psdWriter';
+import { Annt, BlnM, DescriptorColor, DescriptorUnitsValue, parsePercent, parseUnits, parseUnitsOrNumber, QuiltWarpDescriptor, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, TextDescriptor, textGridding, unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor, FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, FractionDescriptor, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy, Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd, unitsPercentF, frac, ClrS, descBoundsToBounds, boundsToDescBounds } from './descriptor';
 import { serializeEngineData, parseEngineData } from './engineData';
 import { encodeEngineData, decodeEngineData } from './text';
 
@@ -41,7 +14,7 @@ export interface ExtendedWriteOptions extends WriteOptions {
 }
 
 type HasMethod = (target: LayerAdditionalInfo) => boolean;
-type ReadMethod = (reader: PsdReader, target: LayerAdditionalInfo, left: () => number, psd: Psd, options: ReadOptions) => void;
+type ReadMethod = (reader: PsdReader, target: LayerAdditionalInfo, left: () => number, psd: Psd, options: ReadOptionsExt) => void;
 type WriteMethod = (writer: PsdWriter, target: LayerAdditionalInfo, psd: Psd, options: ExtendedWriteOptions) => void;
 
 export interface InfoHandler {
@@ -90,9 +63,11 @@ addHandler(
 
 		if (readInt16(reader) !== 50) throw new Error(`Invalid TySh text version`);
 		const text: TextDescriptor = readVersionAndDescriptor(reader);
+		// console.log(require('util').inspect(text, false, 99, false), 'utf8');
 
 		if (readInt16(reader) !== 1) throw new Error(`Invalid TySh warp version`);
 		const warp: WarpDescriptor = readVersionAndDescriptor(reader);
+		// console.log(require('util').inspect(warp, false, 99, false), 'utf8');
 
 		target.text = {
 			transform,
@@ -120,6 +95,7 @@ addHandler(
 		if (text.EngineData) {
 			const engineData = parseEngineData(text.EngineData);
 			const textData = decodeEngineData(engineData);
+			// console.log(require('util').inspect(engineData, false, 99, false), 'utf8');
 
 			// require('fs').writeFileSync(`layer-${target.name}.txt`, require('util').inspect(engineData, false, 99, false), 'utf8');
 			// const before = parseEngineData(text.EngineData);
@@ -732,10 +708,21 @@ interface CustomDescriptor {
 	layerTime?: number;
 }
 
+interface CmlsDescriptor {
+	origFXRefPoint?: { Hrzn: number; Vrtc: number; };
+	LyrI: number;
+	layerSettings: {
+		enab?: boolean;
+		Ofst?: { Hrzn: number; Vrtc: number; };
+		FXRefPoint?: { Hrzn: number; Vrtc: number; };
+		compList: number[];
+	}[];
+}
+
 addHandler(
 	'shmd',
 	target => target.timestamp !== undefined || target.animationFrames !== undefined ||
-		target.animationFrameFlags !== undefined || target.timeline !== undefined,
+		target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined,
 	(reader, target, left, _, options) => {
 		const count = readUint32(reader);
 
@@ -798,8 +785,25 @@ addHandler(
 
 					target.timeline = timeline;
 					// console.log('tmln:result', target.name, target.id, require('util').inspect(timeline, false, 99, true));
+				} else if (key === 'cmls') {
+					const desc = readVersionAndDescriptor(reader) as CmlsDescriptor;
+					// console.log('cmls', require('util').inspect(desc, false, 99, true));
+
+					target.comps = {
+						settings: [],
+					};
+
+					if (desc.origFXRefPoint) target.comps.originalEffectsReferencePoint = { x: desc.origFXRefPoint.Hrzn, y: desc.origFXRefPoint.Vrtc };
+
+					for (const item of desc.layerSettings) {
+						target.comps.settings.push({ compList: item.compList });
+						const t = target.comps.settings[target.comps.settings.length - 1];
+						if ('enab' in item) t.enabled = item.enab;
+						if (item.Ofst) t.offset = { x: item.Ofst.Hrzn, y: item.Ofst.Vrtc };
+						if (item.FXRefPoint) t.effectsReferencePoint = { x: item.FXRefPoint.Hrzn, y: item.FXRefPoint.Vrtc };
+					}
 				} else {
-					options.logDevFeatures && console.log('Unhandled "shmd" section key', key);
+					options.logMissingFeatures && console.log('Unhandled "shmd" section key', key);
 				}
 
 				skipBytes(reader, left());
@@ -809,13 +813,14 @@ addHandler(
 		skipBytes(reader, left());
 	},
 	(writer, target, _, options) => {
-		const { animationFrames, animationFrameFlags, timestamp, timeline } = target;
+		const { animationFrames, animationFrameFlags, timestamp, timeline, comps } = target;
 
 		let count = 0;
 		if (animationFrames) count++;
 		if (animationFrameFlags) count++;
 		if (timeline) count++;
 		if (timestamp !== undefined) count++;
+		if (comps) count++;
 		writeUint32(writer, count);
 
 		if (animationFrames) {
@@ -883,7 +888,7 @@ addHandler(
 					desc.trackList = serializeTrackList(timeline.tracks);
 				}
 
-				const id = options.layerToId.get(target) || target.id || 0;
+				const id = options.layerToId.get(target) || target.id;
 				if (!id) throw new Error('You need to provide layer.id value whan writing document with animations');
 				desc.LyrI = id;
 
@@ -904,6 +909,38 @@ addHandler(
 				writeVersionAndDescriptor(writer, '', 'metadata', desc);
 			}, true);
 		}
+
+		if (comps) {
+			writeSignature(writer, '8BIM');
+			writeSignature(writer, 'cmls');
+			writeUint8(writer, 0); // copy (always false)
+			writeZeros(writer, 3);
+			writeSection(writer, 2, () => {
+				const id = options.layerToId.get(target) || target.id;
+				if (!id) throw new Error('You need to provide layer.id value whan writing document with layer comps');
+
+				const desc: CmlsDescriptor = {} as any;
+
+				if (comps.originalEffectsReferencePoint) {
+					desc.origFXRefPoint = { Hrzn: comps.originalEffectsReferencePoint.x, Vrtc: comps.originalEffectsReferencePoint.y };
+				}
+
+				desc.LyrI = id;
+				desc.layerSettings = [];
+
+				for (const item of comps.settings) {
+					const t: CmlsDescriptor['layerSettings'][0] = {} as any;
+					if (item.enabled !== undefined) t.enab = item.enabled;
+					if (item.offset) t.Ofst = { Hrzn: item.offset.x, Vrtc: item.offset.y };
+					if (item.effectsReferencePoint) t.FXRefPoint = { Hrzn: item.effectsReferencePoint.x, Vrtc: item.effectsReferencePoint.y };
+					t.compList = item.compList;
+					desc.layerSettings.push(t);
+				}
+
+				// console.log('cmls', require('util').inspect(desc, false, 99, true));
+				writeVersionAndDescriptor(writer, '', 'null', desc);
+			}, true);
+		}
 	},
 );
 
@@ -3304,6 +3341,52 @@ addHandler(
 	},
 );
 
+addHandler(
+	'Lr16',
+	() => false,
+	(reader, _target, _left, psd, options) => {
+		readLayerInfo(reader, psd, options);
+	},
+	(_writer, _target) => {
+	},
+);
+
+addHandler(
+	'LMsk',
+	hasKey('userMask'),
+	(reader, target) => {
+		target.userMask = {
+			colorSpace: readColor(reader),
+			opacity: readUint16(reader) / 0xff,
+		};
+		const flag = readUint8(reader);
+		if (flag !== 128) throw new Error('Invalid flag value');
+		skipBytes(reader, 1);
+	},
+	(writer, target) => {
+		const userMask = target.userMask!;
+		writeColor(writer, userMask.colorSpace);
+		writeUint16(writer, clamp(userMask.opacity, 0, 1) * 0xff);
+		writeUint8(writer, 128);
+		writeZeros(writer, 1);
+	},
+);
+
+if (MOCK_HANDLERS) {
+	addHandler(
+		'vowv', // appears with Lr16 section ?
+		_ => false,
+		(reader, target, left) => {
+			const value = readUint32(reader); // 2 ????
+			reader; target;
+			console.log('vowv', { value }, left());
+		},
+		(_writer, _target) => {
+			// TODO: write
+		},
+	);
+}
+
 if (MOCK_HANDLERS) {
 	addHandler(
 		'Patt',
@@ -3614,30 +3697,33 @@ addHandlerAlias('lnkD', 'lnk2');
 addHandlerAlias('lnk3', 'lnk2');
 addHandlerAlias('lnkE', 'lnk2');
 
-interface ExtensionDesc {
-	generatorSettings: {
-		generator_45_assets: { json: string; };
-		layerTime: number;
-	};
+interface PthsDescriptor {
+	pathList: {
+		_classID: 'pathInfoClass';
+		pathUnicodeName: string;
+		pathSymmetryClass: {
+			_classID: 'pathSymmetryClass';
+			pathSymmetryMode: string; // 'pathSymmetryModeEnum.pathSymmetryModeBasicPath'
+		};
+	}[];
 }
 
 addHandler(
 	'pths',
 	hasKey('pathList'),
 	(reader, target) => {
-		const descriptor = readVersionAndDescriptor(reader);
-
-		target.pathList = []; // TODO: read paths (find example with non-empty list)
-
-		descriptor;
-		// console.log('pths', descriptor); // TODO: remove this
+		const desc = readVersionAndDescriptor(reader, true) as PthsDescriptor;
+		// console.log(require('util').inspect(desc, false, 99, true));
+		// if (options.throwForMissingFeatures && desc?.pathList?.length) throw new Error('non-empty pathList in `pths`');
+		desc;
+		target.pathList = []; // TODO: read paths
 	},
 	(writer, _target) => {
-		const descriptor = {
+		const desc: PthsDescriptor = {
 			pathList: [], // TODO: write paths
 		};
 
-		writeVersionAndDescriptor(writer, '', 'pathsDataClass', descriptor);
+		writeVersionAndDescriptor(writer, '', 'pathsDataClass', desc);
 	},
 );
 
@@ -4804,6 +4890,13 @@ addHandler(
 	},
 );
 
+interface ExtensionDesc {
+	generatorSettings: {
+		generator_45_assets: { json: string; };
+		layerTime: number;
+	};
+}
+
 // extension settings ?, ignore it
 addHandler(
 	'extn',

package/src/descriptor.ts

@@ -136,6 +136,8 @@ const fieldToExtType: ExtTypeDict = {
 	sdwM: makeType('Parameters', 'adaptCorrectTones'),
 	hglM: makeType('Parameters', 'adaptCorrectTones'),
 	customShape: makeType('', 'customShape'),
+	origFXRefPoint: nullType,
+	FXRefPoint: nullType,
 };
 
 const fieldToArrayExtType: ExtTypeDict = {
@@ -167,6 +169,8 @@ const fieldToArrayExtType: ExtTypeDict = {
 	puppetShapeList: makeType('', 'puppetShape'),
 	channelDenoise: makeType('', 'channelDenoiseParams'),
 	ShrP: makeType('', 'Pnt '),
+	layerSettings: nullType,
+	list: nullType,
 };
 
 const typeToField: { [key: string]: string[]; } = {
@@ -174,7 +178,7 @@ 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', 'preset', 'KnNm', 'FPth',
+		'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment',
 	],
 	'tdta': [
 		'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
@@ -192,7 +196,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset', 'filterID', 'meshQuality',
 		'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',
+		'HrzS', 'VrtS', 'NmbR', 'EdgF', 'Ang1', 'Ang2', 'Ang3', 'Ang4', 'lastAppliedComp', 'capturedInfo',
 	],
 	'enum': [
 		'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
@@ -237,7 +241,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
 		'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
 		'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
-		'channelDenoise', 'Mtrx',
+		'channelDenoise', 'Mtrx', 'layerSettings', 'list', 'compList',
 	],
 	'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
 	'obj ': ['null', 'Chnl'],
@@ -285,6 +289,7 @@ const fieldToArrayType: Dict = {
 	ShrP: 'Objc',
 	channelDenoise: 'Objc',
 	Mtrx: 'long',
+	compList: 'long',
 };
 
 const fieldToType: Dict = {};
@@ -336,7 +341,7 @@ export function readAsciiStringOrClassId(reader: PsdReader) {
 }
 
 function writeAsciiStringOrClassId(writer: PsdWriter, value: string) {
-	if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold') {
+	if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list') {
 		// write classId
 		writeInt32(writer, 0);
 		writeSignature(writer, value);
@@ -473,9 +478,9 @@ function readOSType(reader: PsdReader, type: string, includeClass: boolean) {
 			const items: any[] = [];
 
 			for (let i = 0; i < length; i++) {
-				const type = readSignature(reader);
-				// console.log('  >', type);
-				items.push(readOSType(reader, type, includeClass));
+				const itemType = readSignature(reader);
+				// console.log('  >', itemType);
+				items.push(readOSType(reader, itemType, includeClass));
 			}
 
 			return items;
@@ -497,9 +502,9 @@ function readOSType(reader: PsdReader, type: string, includeClass: boolean) {
 		case 'TEXT': // String
 			return readUnicodeString(reader);
 		case 'enum': { // Enumerated
-			const type = readAsciiStringOrClassId(reader);
+			const enumType = readAsciiStringOrClassId(reader);
 			const value = readAsciiStringOrClassId(reader);
-			return `${type}.${value}`;
+			return `${enumType}.${value}`;
 		}
 		case 'long': // Integer
 			return readInt32(reader);

package/src/helpers.ts

@@ -1,6 +1,6 @@
 import { fromByteArray } from 'base64-js';
 import { deflate } from 'pako';
-import { Layer, BlendMode, LayerColor } from './psd';
+import { Layer, BlendMode, LayerColor, PixelData, PixelArray } from './psd';
 
 export const MOCK_HANDLERS = false;
 export const RAW_IMAGE_DATA = false;
@@ -138,14 +138,6 @@ export interface LayerChannelData {
 	mask?: Bounds;
 }
 
-export type PixelArray = Uint8ClampedArray | Uint8Array;
-
-export interface PixelData {
-	data: PixelArray;
-	width: number;
-	height: number;
-}
-
 export function offsetForChannel(channelId: ChannelID, cmyk: boolean) {
 	switch (channelId) {
 		case ChannelID.Color0: return 0;
@@ -174,26 +166,51 @@ export function hasAlpha(data: PixelData) {
 }
 
 export function resetImageData({ data }: PixelData) {
-	const buffer = new Uint32Array(data.buffer);
-	const size = buffer.length | 0;
+	const alpha = (data instanceof Uint32Array) ? (0xffffffff >>> 0) : ((data instanceof Uint16Array) ? 0xffff : 0xff);
+
+	for (let p = 0, size = data.length | 0; p < size; p = (p + 4) | 0) {
+		data[p + 0] = 0;
+		data[p + 1] = 0;
+		data[p + 2] = 0;
+		data[p + 3] = alpha;
+	}
+}
 
-	for (let p = 0; p < size; p = (p + 1) | 0) {
-		buffer[p] = 0xff000000;
+export function imageDataToCanvas(pixelData: PixelData) {
+	const canvas = createCanvas(pixelData.width, pixelData.height);
+	let imageData: ImageData;
+
+	if (pixelData.data instanceof Uint8ClampedArray) {
+		imageData = pixelData as ImageData;
+	} else {
+		imageData = createImageData(pixelData.width, pixelData.height);
+		const src = pixelData.data;
+		const dst = imageData.data;
+		const shift = (src instanceof Uint32Array) ? 24 : ((src instanceof Uint16Array) ? 8 : 0);
+
+		for (let i = 0, size = src.length; i < size; i++) {
+			dst[i] = src[i] >>> shift;
+		}
 	}
+
+	canvas.getContext('2d')!.putImageData(imageData, 0, 0);
+	return canvas;
 }
 
 export function decodeBitmap(input: PixelArray, output: PixelArray, width: number, height: number) {
+	if (input instanceof Uint32Array || input instanceof Uint16Array) throw new Error('Invalid bit depth');
+
 	for (let y = 0, p = 0, o = 0; y < height; y++) {
 		for (let x = 0; x < width;) {
 			let b = input[o++];
 
-			for (let i = 0; i < 8 && x < width; i++, x++) {
+			for (let i = 0; i < 8 && x < width; i++, x++, p += 4) {
 				const v = b & 0x80 ? 0 : 255;
 				b = b << 1;
-				output[p++] = v;
-				output[p++] = v;
-				output[p++] = v;
-				output[p++] = 255;
+				output[p + 0] = v;
+				output[p + 1] = v;
+				output[p + 2] = v;
+				output[p + 3] = 255;
 			}
 		}
 	}

package/src/imageResources.ts

@@ -566,6 +566,59 @@ addHandler(
 	},
 );
 
+interface LayerCompsDescriptor {
+	list: {
+		_classID: 'Comp';
+		'Nm  ': string;
+		compID: number;
+		capturedInfo: number;
+		comment?: string;
+	}[];
+	lastAppliedComp?: number;
+}
+
+addHandler(
+	1065, // Layer Comps
+	target => target.layerComps !== undefined,
+	(reader, target) => {
+		const desc = readVersionAndDescriptor(reader, true) as LayerCompsDescriptor;
+		// console.log('CompList', require('util').inspect(desc, false, 99, true));
+
+		target.layerComps = { list: [] };
+
+		for (const item of desc.list) {
+			target.layerComps.list.push({
+				id: item.compID,
+				name: item['Nm  '],
+				capturedInfo: item.capturedInfo,
+			});
+
+			if ('comment' in item) target.layerComps.list[target.layerComps.list.length - 1].comment = item.comment;
+		}
+
+		if ('lastAppliedComp' in desc) target.layerComps.lastApplied = desc.lastAppliedComp;
+	},
+	(writer, target) => {
+		const layerComps = target.layerComps!;
+		const desc: LayerCompsDescriptor = { list: [] };
+
+		for (const item of layerComps.list) {
+			const t: LayerCompsDescriptor['list'][0] = {} as any;
+			t._classID = 'Comp';
+			t['Nm  '] = item.name;
+			if ('comment' in item) t.comment = item.comment;
+			t.compID = item.id;
+			t.capturedInfo = item.capturedInfo;
+			desc.list.push(t);
+		}
+
+		if ('lastApplied' in layerComps) desc.lastAppliedComp = layerComps.lastApplied;
+
+		// console.log('CompList', require('util').inspect(desc, false, 99, true));
+		writeVersionAndDescriptor(writer, '', 'CompList', desc);
+	},
+);
+
 MOCK_HANDLERS && addHandler(
 	1092, // ???
 	target => (target as any)._ir1092 !== undefined,

package/src/psd.ts

@@ -24,7 +24,7 @@ export const enum SectionDividerType {
 
 export type RGBA = { r: number; g: number; b: number; a: number; }; // values from 0 to 255
 export type RGB = { r: number; g: number; b: number; }; // values from 0 to 255
-export type FRGB = { fr: number; fg: number; fb: number; }; // values from 0 to 1 (can be above 1)
+export type FRGB = { fr: number; fg: number; fb: number; }; // values from 0 to 1 (can be above 1, can be negative)
 export type HSB = { h: number; s: number; b: number; }; // values from 0 to 1
 export type CMYK = { c: number; m: number; y: number; k: number; }; // values from 0 to 255
 export type LAB = { l: number; a: number; b: number; }; // values `l` from 0 to 1; `a` and `b` from -1 to 1
@@ -222,6 +222,14 @@ export interface LayerEffectsInfo {
 	patternOverlay?: LayerEffectPatternOverlay; // not supported yet because of `Patt` section not implemented
 }
 
+export type PixelArray = Uint8ClampedArray | Uint8Array | Uint16Array | Uint32Array;
+
+export interface PixelData {
+	data: PixelArray; // type depends on document bit depth
+	width: number;
+	height: number;
+}
+
 export interface LayerMaskData {
 	top?: number;
 	left?: number;
@@ -236,7 +244,7 @@ export interface LayerMaskData {
 	vectorMaskDensity?: number;
 	vectorMaskFeather?: number;
 	canvas?: HTMLCanvasElement;
-	imageData?: ImageData;
+	imageData?: PixelData;
 }
 
 export type TextGridding = 'none' | 'round'; // TODO: other values (no idea where to set it up in Photoshop)
@@ -416,7 +424,6 @@ export interface LayerTextData {
 	shapeType?: 'point' | 'box';
 	pointBase?: number[];
 	boxBounds?: number[];
-	
 	bounds?: UnitsBounds;
 	boundingBox?: UnitsBounds;
 }
@@ -1385,12 +1392,32 @@ export interface LayerAdditionalInfo {
 			data: Uint8Array;
 		};
 	}[];
+	comps?: {
+		originalEffectsReferencePoint?: { x: number; y: number; };
+		settings: {
+			enabled?: boolean;
+			compList: number[];
+			offset?: { x: number; y: number; };
+			effectsReferencePoint?: { x: number; y: number; };
+		}[];
+	};
+	userMask?: {
+		colorSpace: Color;
+		opacity: number;
+	};
 
 	// Base64 encoded raw EngineData, currently just kept in original state to support
 	// loading and modifying PSD file without breaking text layers.
 	engineData?: string;
 }
 
+export enum LayerCompCapturedInfo {
+	None = 0,
+	Visibility = 1,
+	Position = 2,
+	Appearance = 4,
+}
+
 export interface ImageResources {
 	layerState?: number;
 	layersGroup?: number[];
@@ -1564,6 +1591,15 @@ export interface ImageResources {
 			rightOutset?: number;
 		}[];
 	}[];
+	layerComps?: {
+		list: {
+			id: number;
+			name: string;
+			comment?: string;
+			capturedInfo: LayerCompCapturedInfo;
+		}[];
+		lastApplied?: number;
+	};
 }
 
 export interface GlobalLayerMaskInfo {
@@ -1600,7 +1636,7 @@ export interface Layer extends LayerAdditionalInfo {
 	hidden?: boolean;
 	clipping?: boolean;
 	canvas?: HTMLCanvasElement;
-	imageData?: ImageData;
+	imageData?: PixelData;
 	children?: Layer[];
 	/** Applies only for layer groups. */
 	opened?: boolean;
@@ -1614,7 +1650,7 @@ export interface Psd extends LayerAdditionalInfo {
 	colorMode?: ColorMode;
 	children?: Layer[];
 	canvas?: HTMLCanvasElement;
-	imageData?: ImageData;
+	imageData?: PixelData;
 	imageResources?: ImageResources;
 	linkedFiles?: LinkedFile[]; // used in smart objects
 	artboards?: {