ag-psd 25.0.0 → 27.0.0

package/src/psdReader.ts

@@ -326,7 +326,7 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 			}
 
 			if (left() >= 12) {
-				readAdditionalLayerInfo(reader, psd, psd,);
+				readAdditionalLayerInfo(reader, psd, psd);
 			} else {
 				// opt.logMissingFeatures && console.log('skipping leftover bytes', left());
 				skipBytes(reader, left());
@@ -443,8 +443,7 @@ function readLayerRecord(reader: PsdReader, psd: Psd) {
 	skipBytes(reader, 1);
 
 	readSection(reader, 1, left => {
-		const mask = readLayerMaskData(reader);
-		if (mask) layer.mask = mask;
+		readLayerMaskData(reader, layer);
 
 		const blendingRanges = readLayerBlendingRanges(reader);
 		if (blendingRanges) layer.blendingRanges = blendingRanges;
@@ -461,11 +460,13 @@ function readLayerRecord(reader: PsdReader, psd: Psd) {
 	return { layer, channels };
 }
 
-function readLayerMaskData(reader: PsdReader) {
+function readLayerMaskData(reader: PsdReader, layer: Layer) {
 	return readSection<LayerMaskData | undefined>(reader, 1, left => {
 		if (!left()) return undefined;
 
 		const mask: LayerMaskData = {};
+		layer.mask = mask;
+
 		mask.top = readInt32(reader);
 		mask.left = readInt32(reader);
 		mask.bottom = readInt32(reader);
@@ -477,6 +478,22 @@ function readLayerMaskData(reader: PsdReader) {
 		mask.disabled = (flags & LayerMaskFlags.LayerMaskDisabled) !== 0;
 		mask.fromVectorData = (flags & LayerMaskFlags.LayerMaskFromRenderingOtherData) !== 0;
 
+		if (left() >= 18) {
+			const realMask: LayerMaskData = {};
+			layer.realMask = realMask;
+
+			const realFlags = readUint8(reader);
+			realMask.positionRelativeToLayer = (realFlags & LayerMaskFlags.PositionRelativeToLayer) !== 0;
+			realMask.disabled = (realFlags & LayerMaskFlags.LayerMaskDisabled) !== 0;
+			realMask.fromVectorData = (realFlags & LayerMaskFlags.LayerMaskFromRenderingOtherData) !== 0;
+
+			realMask.defaultColor = readUint8(reader); // Real user mask background. 0 or 255.
+			realMask.top = readInt32(reader);
+			realMask.left = readInt32(reader);
+			realMask.bottom = readInt32(reader);
+			realMask.right = readInt32(reader);
+		}
+
 		if (flags & LayerMaskFlags.MaskHasParametersAppliedToIt) {
 			const params = readUint8(reader);
 			if (params & MaskParams.UserMaskDensity) mask.userMaskDensity = readUint8(reader) / 0xff;
@@ -485,25 +502,7 @@ function readLayerMaskData(reader: PsdReader) {
 			if (params & MaskParams.VectorMaskFeather) mask.vectorMaskFeather = readFloat64(reader);
 		}
 
-		if (left() > 2) {
-			// TODO: handle these values, this is RealUserMask
-			/*const realFlags = readUint8(reader);
-			const realUserMaskBackground = readUint8(reader);
-			const top2 = readInt32(reader);
-			const left2 = readInt32(reader);
-			const bottom2 = readInt32(reader);
-			const right2 = readInt32(reader);
-
-			// TEMP
-			(mask as any)._real = { realFlags, realUserMaskBackground, top2, left2, bottom2, right2 };*/
-
-			if (reader.logMissingFeatures) {
-				reader.log('Unhandled extra real user mask params');
-			}
-		}
-
 		skipBytes(reader, left());
-		return mask;
 	});
 }
 
@@ -572,13 +571,13 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 
 		if (compression > 3) throw new Error(`Invalid compression: ${compression}`);
 
-		if (channel.id === ChannelID.UserMask) {
-			const mask = layer.mask;
-
-			if (!mask) throw new Error(`Missing layer mask data`);
+		if (channel.id === ChannelID.UserMask || channel.id === ChannelID.RealUserMask) {
+			const mask = channel.id === ChannelID.UserMask ? layer.mask : layer.realMask;
+			if (!mask) throw new Error(`Missing layer ${channel.id === ChannelID.UserMask ? 'mask' : 'real mask'} data`);
 
 			const maskWidth = (mask.right || 0) - (mask.left || 0);
 			const maskHeight = (mask.bottom || 0) - (mask.top || 0);
+			if (maskWidth < 0 || maskHeight < 0 || maskWidth > 30000 || maskHeight > 30000) throw new Error('Invalid mask size');
 
 			if (maskWidth && maskHeight) {
 				const maskData = createImageDataBitDepth(maskWidth, maskHeight, psd.bitsPerChannel ?? 8);
@@ -588,8 +587,13 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 				readData(reader, channel.length, maskData, compression, maskWidth, maskHeight, psd.bitsPerChannel ?? 8, 0, reader.large, 4);
 
 				if (RAW_IMAGE_DATA) {
-					(layer as any).maskDataRawCompression = compression;
-					(layer as any).maskDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+					if (channel.id === ChannelID.UserMask) {
+						(layer as any).maskDataRawCompression = compression;
+						(layer as any).maskDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+					} else {
+						(layer as any).realMaskDataRawCompression = compression;
+						(layer as any).realMaskDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+					}
 				}
 
 				setupGrayscale(maskData);
@@ -600,12 +604,6 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 					mask.canvas = imageDataToCanvas(maskData);
 				}
 			}
-		} else if (channel.id === ChannelID.RealUserMask) {
-			if (reader.logMissingFeatures) {
-				reader.log(`RealUserMask not supported`);
-			}
-
-			reader.offset = start + channel.length;
 		} else {
 			const offset = offsetForChannel(channel.id, cmyk);
 			let targetData = imageData;

package/src/psdWriter.ts

@@ -1,4 +1,4 @@
-import { Psd, Layer, LayerAdditionalInfo, ColorMode, SectionDividerType, WriteOptions, Color, GlobalLayerMaskInfo, PixelData } from './psd';
+import { Psd, Layer, LayerAdditionalInfo, ColorMode, SectionDividerType, WriteOptions, Color, GlobalLayerMaskInfo, PixelData, LayerMaskData } from './psd';
 import { hasAlpha, createCanvas, writeDataRLE, LayerChannelData, ChannelData, offsetForChannel, createImageData, fromBlendMode, ChannelID, Compression, clamp, LayerMaskFlags, MaskParams, ColorSpace, Bounds, largeAdditionalInfoKeys, RAW_IMAGE_DATA, writeDataZipWithoutPrediction, imageDataToCanvas } from './helpers';
 import { ExtendedWriteOptions, infoHandlers } from './additionalInfo';
 import { resourceHandlers } from './imageResources';
@@ -354,7 +354,7 @@ function writeLayerInfo(writer: PsdWriter, psd: Psd, globalAlpha: boolean, optio
 			let flags = 0x08; // 1 for Photoshop 5.0 and later, tells if bit 4 has useful information
 			if (layer.transparencyProtected) flags |= 0x01;
 			if (layer.hidden) flags |= 0x02;
-			if (layer.vectorMask || (layer.sectionDivider && layer.sectionDivider.type !== SectionDividerType.Other)) {
+			if (layer.vectorMask || (layer.sectionDivider && layer.sectionDivider.type !== SectionDividerType.Other) || layer.adjustment) {
 				flags |= 0x10; // pixel data irrelevant to appearance of document
 			}
 			if (layer.effectsOpen) flags |= 0x20;
@@ -382,42 +382,54 @@ function writeLayerInfo(writer: PsdWriter, psd: Psd, globalAlpha: boolean, optio
 	}, true, options.psb);
 }
 
-function writeLayerMaskData(writer: PsdWriter, { mask }: Layer, layerData: LayerChannelData) {
+function writeLayerMaskData(writer: PsdWriter, { mask, realMask }: Layer, layerData: LayerChannelData) {
 	writeSection(writer, 1, () => {
-		if (!mask) return;
+		if (!mask && !realMask) return;
+
+		let params = 0, flags = 0, realFlags = 0;
+
+		if (mask) {
+			if (mask.userMaskDensity !== undefined) params |= MaskParams.UserMaskDensity;
+			if (mask.userMaskFeather !== undefined) params |= MaskParams.UserMaskFeather;
+			if (mask.vectorMaskDensity !== undefined) params |= MaskParams.VectorMaskDensity;
+			if (mask.vectorMaskFeather !== undefined) params |= MaskParams.VectorMaskFeather;
+
+			if (mask.disabled) flags |= LayerMaskFlags.LayerMaskDisabled;
+			if (mask.positionRelativeToLayer) flags |= LayerMaskFlags.PositionRelativeToLayer;
+			if (mask.fromVectorData) flags |= LayerMaskFlags.LayerMaskFromRenderingOtherData;
+			if (params) flags |= LayerMaskFlags.MaskHasParametersAppliedToIt;
+		}
 
 		const m = layerData.mask || {} as Partial<Bounds>;
 		writeInt32(writer, m.top || 0);
 		writeInt32(writer, m.left || 0);
 		writeInt32(writer, m.bottom || 0);
 		writeInt32(writer, m.right || 0);
-		writeUint8(writer, mask.defaultColor || 0);
-
-		let params = 0;
-		if (mask.userMaskDensity !== undefined) params |= MaskParams.UserMaskDensity;
-		if (mask.userMaskFeather !== undefined) params |= MaskParams.UserMaskFeather;
-		if (mask.vectorMaskDensity !== undefined) params |= MaskParams.VectorMaskDensity;
-		if (mask.vectorMaskFeather !== undefined) params |= MaskParams.VectorMaskFeather;
-
-		let flags = 0;
-		if (mask.disabled) flags |= LayerMaskFlags.LayerMaskDisabled;
-		if (mask.positionRelativeToLayer) flags |= LayerMaskFlags.PositionRelativeToLayer;
-		if (mask.fromVectorData) flags |= LayerMaskFlags.LayerMaskFromRenderingOtherData;
-		if (params) flags |= LayerMaskFlags.MaskHasParametersAppliedToIt;
-
+		writeUint8(writer, mask && mask.defaultColor || 0);
 		writeUint8(writer, flags);
 
-		if (params) {
-			writeUint8(writer, params);
+		if (realMask) {
+			if (realMask.disabled) realFlags |= LayerMaskFlags.LayerMaskDisabled;
+			if (realMask.positionRelativeToLayer) realFlags |= LayerMaskFlags.PositionRelativeToLayer;
+			if (realMask.fromVectorData) realFlags |= LayerMaskFlags.LayerMaskFromRenderingOtherData;
+
+			const r = layerData.realMask || {} as Partial<Bounds>;
+			writeUint8(writer, realFlags);
+			writeUint8(writer, realMask.defaultColor || 0);
+			writeInt32(writer, r.top || 0);
+			writeInt32(writer, r.left || 0);
+			writeInt32(writer, r.bottom || 0);
+			writeInt32(writer, r.right || 0);
+		}
 
+		if (params && mask) {
+			writeUint8(writer, params);
 			if (mask.userMaskDensity !== undefined) writeUint8(writer, Math.round(mask.userMaskDensity * 0xff));
 			if (mask.userMaskFeather !== undefined) writeFloat64(writer, mask.userMaskFeather);
 			if (mask.vectorMaskDensity !== undefined) writeUint8(writer, Math.round(mask.vectorMaskDensity * 0xff));
 			if (mask.vectorMaskFeather !== undefined) writeFloat64(writer, mask.vectorMaskFeather);
 		}
 
-		// TODO: handle rest of the fields
-
 		writeZeros(writer, 2);
 	});
 }
@@ -485,8 +497,8 @@ function writeAdditionalLayerInfo(writer: PsdWriter, target: LayerAdditionalInfo
 function addChildren(layers: Layer[], children: Layer[] | undefined) {
 	if (!children) return;
 
-	// const layerIds = [];
-	// const timestamps = []
+	// const layerIds: number[] = [2];
+	// const timestamps: number[] = [1740120767.0230637];
 
 	for (const c of children) {
 		if (c.children && c.canvas) throw new Error(`Invalid layer, cannot have both 'canvas' and 'children' properties`);
@@ -498,6 +510,7 @@ function addChildren(layers: Layer[], children: Layer[] | undefined) {
 				sectionDivider: {
 					type: SectionDividerType.BoundingSectionDivider,
 				},
+				// blendingRanges: children[0].blendingRanges,
 				// nameSource: 'lset',
 				// id: layerIds.shift(),
 				// protected: {
@@ -505,12 +518,9 @@ function addChildren(layers: Layer[], children: Layer[] | undefined) {
 				// 	composite: false,
 				// 	position: false,
 				// },
-				// layerColor: 'none',
+				// layerColor: 'red',
 				// timestamp: timestamps.shift(),
-				// referencePoint: {
-				// 	x: 0,
-				// 	y: 0,
-				// },
+				// referencePoint: { x: 0, y: 0 },
 			});
 			addChildren(layers, c.children);
 			layers.push({
@@ -581,54 +591,50 @@ function createThumbnail(psd: Psd) {
 	return canvas;
 }
 
-function getChannels(
-	tempBuffer: Uint8Array, layer: Layer, background: boolean, options: WriteOptions
-): LayerChannelData {
-	const layerData = getLayerChannels(tempBuffer, layer, background, options);
-	const mask = layer.mask;
-
-	if (mask) {
-		let top = (mask.top as any) | 0;
-		let left = (mask.left as any) | 0;
-		let right = (mask.right as any) | 0;
-		let bottom = (mask.bottom as any) | 0;
-		let { width, height } = getLayerDimentions(mask);
-		let imageData = mask.imageData;
-
-		if (!imageData && mask.canvas && width && height) {
-			imageData = mask.canvas.getContext('2d')!.getImageData(0, 0, width, height);
-		}
+function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, layer: Layer, mask: LayerMaskData, options: WriteOptions, realMask: boolean) {
+	let top = (mask.top as any) | 0;
+	let left = (mask.left as any) | 0;
+	let right = (mask.right as any) | 0;
+	let bottom = (mask.bottom as any) | 0;
+	let { width, height } = getLayerDimentions(mask);
+	let imageData = mask.imageData;
 
-		if (width && height && imageData) {
-			right = left + width;
-			bottom = top + height;
+	if (!imageData && mask.canvas && width && height) {
+		imageData = mask.canvas.getContext('2d')!.getImageData(0, 0, width, height);
+	}
 
-			if (imageData.width !== width || imageData.height !== height) {
-				throw new Error('Invalid imageData dimentions');
-			}
+	if (width && height && imageData) {
+		right = left + width;
+		bottom = top + height;
 
-			let buffer: Uint8Array;
-			let compression: Compression;
-
-			if (RAW_IMAGE_DATA && (layer as any).maskDataRaw) {
-				// console.log('written raw layer image data');
-				buffer = (layer as any).maskDataRaw;
-				compression = (layer as any).maskDataRawCompression;
-			} else if (options.compress) {
-				buffer = writeDataZipWithoutPrediction(imageData, [0]);
-				compression = Compression.ZipWithoutPrediction;
-			} else {
-				buffer = writeDataRLE(tempBuffer, imageData, [0], !!options.psb)!;
-				compression = Compression.RleCompressed;
-			}
+		if (imageData.width !== width || imageData.height !== height) {
+			throw new Error('Invalid imageData dimentions');
+		}
+
+		let buffer: Uint8Array;
+		let compression: Compression;
 
-			layerData.mask = { top, left, right, bottom };
-			layerData.channels.push({ channelId: ChannelID.UserMask, compression, buffer, length: 2 + buffer.length });
+		if (RAW_IMAGE_DATA && (layer as any)[realMask ? 'realMaskDataRaw' : 'maskDataRaw']) {
+			buffer = (layer as any)[realMask ? 'realMaskDataRaw' : 'maskDataRaw'];
+			compression = (layer as any)[realMask ? 'realMaskDataRawCompression' : 'maskDataRawCompression'];
+		} else if (options.compress) {
+			buffer = writeDataZipWithoutPrediction(imageData, [0]);
+			compression = Compression.ZipWithoutPrediction;
 		} else {
-			layerData.mask = { top: 0, left: 0, right: 0, bottom: 0 };
+			buffer = writeDataRLE(tempBuffer, imageData, [0], !!options.psb)!;
+			compression = Compression.RleCompressed;
 		}
+
+		layerData.channels.push({ channelId: realMask ? ChannelID.RealUserMask : ChannelID.UserMask, compression, buffer, length: 2 + buffer.length });
 	}
 
+	layerData[realMask ? 'realMask' : 'mask'] = { top, left, right, bottom };
+}
+
+function getChannels(tempBuffer: Uint8Array, layer: Layer, background: boolean, options: WriteOptions): LayerChannelData {
+	const layerData = getLayerChannels(tempBuffer, layer, background, options);
+	if (layer.mask) getMaskChannels(tempBuffer, layerData, layer, layer.mask, options, false);
+	if (layer.realMask) getMaskChannels(tempBuffer, layerData, layer, layer.realMask, options, true);
 	return layerData;
 }
 

package/src/text.ts

@@ -1,4 +1,4 @@
-import { TextStyle, LayerTextData, ParagraphStyle, Font, AntiAlias, TextGridInfo, Justification, Color } from './psd';
+import type { TextStyle, LayerTextData, ParagraphStyle, Font, AntiAlias, TextGridInfo, Justification, Color, TextPath } from './psd';
 
 interface Adjustments {
 	Axis: number[];
@@ -120,7 +120,7 @@ interface PhotoshopNode {
 	};
 }
 
-interface EngineData {
+export interface EngineData {
 	EngineDict: {
 		Editor: { Text: string; };
 		ParagraphRun: {
@@ -165,6 +165,20 @@ interface EngineData {
 	DocumentResources: ResourceDict;
 }
 
+export interface GlobalEngineData {
+	ResourceDict: {
+		FontSet: any[]; // TODO
+		StyleSheetSet: any[]; // TODO
+		ParagraphSheetSet: any[]; // TODO
+		TextFrameSet?: {
+			path: TextPath;
+		}[];
+	};
+	EngineDict: {
+		// TODO
+	};
+}
+
 const defaultFont: Font = {
 	name: 'MyriadPro-Regular',
 	script: 0,