ag-psd 24.0.0 → 26.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-psd",
-  "version": "24.0.0",
+  "version": "26.0.0",
   "description": "Library for reading and writing PSD files",
   "main": "dist/index.js",
   "module": "dist-es/index.js",

package/src/additionalInfo.ts

@@ -357,6 +357,17 @@ addHandler(
 addHandlerAlias('vsms', 'vmsk');
 // addHandlerAlias('vmsk', 'vsms');
 
+addHandler(
+	'vowv', // something with vectors?
+	hasKey('vowv'),
+	(reader, target) => {
+		target.vowv = readUint32(reader); // always 2 ????
+	},
+	(writer, target) => {
+		writeUint32(writer, target.vowv!);
+	},
+);
+
 interface VogkDescriptor {
 	keyDescriptorList: {
 		keyShapeInvalidated?: boolean;
@@ -447,62 +458,59 @@ addHandler(
 		for (let i = 0; i < orig.keyDescriptorList.length; i++) {
 			const item = orig.keyDescriptorList[i];
 
-			if (item.keyShapeInvalidated) {
-				desc.keyDescriptorList.push({ keyShapeInvalidated: true, keyOriginIndex: i });
-			} else {
-				desc.keyDescriptorList.push({} as any); // we're adding keyOriginIndex at the end
-
-				const out = desc.keyDescriptorList[desc.keyDescriptorList.length - 1];
+			desc.keyDescriptorList.push({} as any); // we're adding keyOriginIndex at the end
 
-				if (item.keyOriginType != null) out.keyOriginType = item.keyOriginType;
-				if (item.keyOriginResolution != null) out.keyOriginResolution = item.keyOriginResolution;
+			const out = desc.keyDescriptorList[desc.keyDescriptorList.length - 1];
 
-				const radii = item.keyOriginRRectRadii;
-				if (radii) {
-					out.keyOriginRRectRadii = {
-						unitValueQuadVersion: 1,
-						topRight: unitsValue(radii.topRight, 'topRight'),
-						topLeft: unitsValue(radii.topLeft, 'topLeft'),
-						bottomLeft: unitsValue(radii.bottomLeft, 'bottomLeft'),
-						bottomRight: unitsValue(radii.bottomRight, 'bottomRight'),
-					};
-				}
+			if (item.keyOriginType != null) out.keyOriginType = item.keyOriginType;
+			if (item.keyOriginResolution != null) out.keyOriginResolution = item.keyOriginResolution;
 
-				const box = item.keyOriginShapeBoundingBox;
-				if (box) {
-					out.keyOriginShapeBBox = {
-						unitValueQuadVersion: 1,
-						'Top ': unitsValue(box.top, 'top'),
-						Left: unitsValue(box.left, 'left'),
-						Btom: unitsValue(box.bottom, 'bottom'),
-						Rght: unitsValue(box.right, 'right'),
-					};
-				}
+			const radii = item.keyOriginRRectRadii;
+			if (radii) {
+				out.keyOriginRRectRadii = {
+					unitValueQuadVersion: 1,
+					topRight: unitsValue(radii.topRight, 'topRight'),
+					topLeft: unitsValue(radii.topLeft, 'topLeft'),
+					bottomLeft: unitsValue(radii.bottomLeft, 'bottomLeft'),
+					bottomRight: unitsValue(radii.bottomRight, 'bottomRight'),
+				};
+			}
 
-				const corners = item.keyOriginBoxCorners;
-				if (corners && corners.length === 4) {
-					out.keyOriginBoxCorners = {
-						rectangleCornerA: { Hrzn: corners[0].x, Vrtc: corners[0].y },
-						rectangleCornerB: { Hrzn: corners[1].x, Vrtc: corners[1].y },
-						rectangleCornerC: { Hrzn: corners[2].x, Vrtc: corners[2].y },
-						rectangleCornerD: { Hrzn: corners[3].x, Vrtc: corners[3].y },
-					};
-				}
+			const box = item.keyOriginShapeBoundingBox;
+			if (box) {
+				out.keyOriginShapeBBox = {
+					unitValueQuadVersion: 1,
+					'Top ': unitsValue(box.top, 'top'),
+					Left: unitsValue(box.left, 'left'),
+					Btom: unitsValue(box.bottom, 'bottom'),
+					Rght: unitsValue(box.right, 'right'),
+				};
+			}
 
-				const transform = item.transform;
-				if (transform && transform.length === 6) {
-					out.Trnf = {
-						xx: transform[0],
-						xy: transform[1],
-						yx: transform[2],
-						yy: transform[3],
-						tx: transform[4],
-						ty: transform[5],
-					};
-				}
+			const corners = item.keyOriginBoxCorners;
+			if (corners && corners.length === 4) {
+				out.keyOriginBoxCorners = {
+					rectangleCornerA: { Hrzn: corners[0].x, Vrtc: corners[0].y },
+					rectangleCornerB: { Hrzn: corners[1].x, Vrtc: corners[1].y },
+					rectangleCornerC: { Hrzn: corners[2].x, Vrtc: corners[2].y },
+					rectangleCornerD: { Hrzn: corners[3].x, Vrtc: corners[3].y },
+				};
+			}
 
-				out.keyOriginIndex = i;
+			const transform = item.transform;
+			if (transform && transform.length === 6) {
+				out.Trnf = {
+					xx: transform[0],
+					xy: transform[1],
+					yx: transform[2],
+					yy: transform[3],
+					tx: transform[4],
+					ty: transform[5],
+				};
 			}
+
+			if (item.keyShapeInvalidated != null) out.keyShapeInvalidated = item.keyShapeInvalidated;
+			out.keyOriginIndex = i;
 		}
 
 		writeInt32(writer, 1); // version
@@ -1128,7 +1136,13 @@ function encodeWarp(warp: Warp): WarpDescriptor {
 		warpPerspective: warp.perspective || 0,
 		warpPerspectiveOther: warp.perspectiveOther || 0,
 		warpRotate: Ornt.encode(warp.rotate),
-		bounds: {
+		bounds: /*1 ? { // testing
+			_classID: 'classFloatRect',
+			'Top ': bounds && bounds.top && bounds.top.value || 0,
+			Left: bounds && bounds.left && bounds.left.value || 0,
+			Btom: bounds && bounds.bottom && bounds.bottom.value || 0,
+			Rght: bounds && bounds.right && bounds.right.value || 0,
+		} :*/ {
 			'Top ': unitsValue(bounds && bounds.top || { units: 'Pixels', value: 0 }, 'bounds.top'),
 			Left: unitsValue(bounds && bounds.left || { units: 'Pixels', value: 0 }, 'bounds.left'),
 			Btom: unitsValue(bounds && bounds.bottom || { units: 'Pixels', value: 0 }, 'bounds.bottom'),
@@ -1315,7 +1329,7 @@ type SoLdDescriptorFilterItem = {
 } | {
 	filterID: 1198747202;
 	Fltr: {
-		_name: 'Gaussian Blur';
+		_name: 'Gaussian Blur' | '高斯模糊';
 		_classID: 'GsnB';
 		'Rds ': DescriptorUnitsValue;
 	};
@@ -2636,6 +2650,7 @@ function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
 		case 'gaussian blur': return {
 			...base,
 			Fltr: {
+				// _name: '高斯模糊', // Testing
 				_name: 'Gaussian Blur',
 				_classID: 'GsnB',
 				'Rds ': uvRadius(f.filter),
@@ -3542,21 +3557,6 @@ addHandler(
 	},
 );
 
-if (MOCK_HANDLERS) {
-	addHandler(
-		'vowv', // appears with Lr16 section ?
-		_ => false,
-		(reader, target, left) => {
-			const value = readUint32(reader); // always 2 ????
-			reader; target;
-			console.log('vowv', { value }, left());
-		},
-		(_writer, _target) => {
-			// TODO: write
-		},
-	);
-}
-
 if (MOCK_HANDLERS) {
 	addHandler(
 		'Patt',

package/src/descriptor.ts

@@ -56,12 +56,14 @@ function makeType(name: string, classID: string) {
 
 const nullType = makeType('', 'null');
 
+const USE_CHINESE = false; // Testing
+
 const fieldToExtType: ExtTypeDict = {
 	strokeStyleContent: makeType('', 'solidColorLayer'),
-	// printProofSetup: makeType('校样设置', 'proofSetup'), // TESTING
-	printProofSetup: makeType('Proof Setup', 'proofSetup'),
+	printProofSetup: makeType(USE_CHINESE ? '校样设置' : 'Proof Setup', 'proofSetup'),
+	Grad: makeType(USE_CHINESE ? '渐变' : 'Gradient', 'Grdn'),
+	Trnf: makeType(USE_CHINESE ? '变换' : 'Transform', 'Trnf'),
 	patternFill: makeType('', 'patternFill'),
-	Grad: makeType('Gradient', 'Grdn'),
 	ebbl: makeType('', 'ebbl'),
 	SoFi: makeType('', 'SoFi'),
 	GrFl: makeType('', 'GrFl'),
@@ -103,7 +105,6 @@ const fieldToExtType: ExtTypeDict = {
 	rectangleCornerC: makeType('', 'Pnt '),
 	rectangleCornerD: makeType('', 'Pnt '),
 	compInfo: nullType,
-	Trnf: makeType('Transform', 'Trnf'),
 	quiltWarp: makeType('', 'quiltWarp'),
 	generatorSettings: nullType,
 	crema: nullType,
@@ -208,7 +209,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
 		'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
 		'vertAlign', 'bgColorType', 'shapeOperation', 'UndA', 'Wvtp', 'Drct', 'WndM', 'Edg ', 'FlCl', 'IntE',
-		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion',
+		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod',
 	],
 	'bool': [
 		'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -879,11 +880,12 @@ export interface DescriptorColorContent {
 }
 
 export interface DescriptorGradientContent {
-	Grad: DesciptorGradient;
-	Type: string;
 	Dthr?: boolean;
-	Rvrs?: boolean;
+	gradientsInterpolationMethod?: string; // 'gradientInterpolationMethodType.Smoo'
 	Angl?: DescriptorUnitsValue;
+	Type: string;
+	Grad: DesciptorGradient;
+	Rvrs?: boolean;
 	'Scl '?: DescriptorUnitsValue;
 	Algn?: boolean;
 	Ofst?: { Hrzn: DescriptorUnitsValue; Vrtc: DescriptorUnitsValue; };
@@ -1611,6 +1613,7 @@ 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.gradientsInterpolationMethod !== undefined) result.interpolationMethod = gradientInterpolationMethodType.decode(descriptor.gradientsInterpolationMethod);
 	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 ']);
@@ -1650,6 +1653,7 @@ export function parseVectorContent(descriptor: DescriptorVectorContent): VectorC
 function serializeGradientContent(content: (EffectSolidGradient | EffectNoiseGradient) & ExtraGradientInfo) {
 	const result: DescriptorGradientContent = {} as any;
 	if (content.dither !== undefined) result.Dthr = content.dither;
+	if (content.interpolationMethod !== undefined) result.gradientsInterpolationMethod = gradientInterpolationMethodType.encode(content.interpolationMethod);
 	if (content.reverse !== undefined) result.Rvrs = content.reverse;
 	if (content.angle !== undefined) result.Angl = unitsAngle(content.angle);
 	result.Type = GrdT.encode(content.style);

package/src/helpers.ts

@@ -136,6 +136,7 @@ export interface LayerChannelData {
 	right: number;
 	bottom: number;
 	mask?: Bounds;
+	realMask?: Bounds;
 }
 
 export function offsetForChannel(channelId: ChannelID, cmyk: boolean) {

package/src/imageResources.ts

@@ -1,22 +1,10 @@
 import { toByteArray } from 'base64-js';
 import { BlendMode, ImageResources, RenderingIntent } from './psd';
-import {
-	PsdReader, readPascalString, readUnicodeString, readUint32, readUint16, readUint8, readFloat64,
-	readBytes, skipBytes, readFloat32, readInt16, readFixedPoint32, readSignature, checkSignature,
-	readSection, readColor, readInt32
-} from './psdReader';
-import {
-	PsdWriter, writePascalString, writeUnicodeString, writeUint32, writeUint8, writeFloat64, writeUint16,
-	writeBytes, writeInt16, writeFloat32, writeFixedPoint32, writeUnicodeStringWithPadding, writeColor, writeSignature,
-	writeSection, writeInt32,
-} from './psdWriter';
+import { PsdReader, readUnicodeString, readUint32, readUint16, readUint8, readFloat64, readBytes, skipBytes, readFloat32, readInt16, readFixedPoint32, readSignature, checkSignature, readSection, readColor, readInt32 } from './psdReader';
+import { PsdWriter, writeUnicodeString, writeUint32, writeUint8, writeFloat64, writeUint16, writeBytes, writeInt16, writeFloat32, writeFixedPoint32, writeUnicodeStringWithPadding, writeColor, writeSignature, writeSection, writeInt32, } from './psdWriter';
 import { createCanvasFromData, createEnum, MOCK_HANDLERS } from './helpers';
 import { decodeString, encodeString } from './utf8';
-import {
-	ESliceBGColorType, ESliceHorzAlign, ESliceOrigin, ESliceType, ESliceVertAlign, frac,
-	FractionDescriptor, parseTrackList, readVersionAndDescriptor, serializeTrackList, TimelineTrackDescriptor,
-	TimeScopeDescriptor, writeVersionAndDescriptor
-} from './descriptor';
+import { ESliceBGColorType, ESliceHorzAlign, ESliceOrigin, ESliceType, ESliceVertAlign, frac, FractionDescriptor, parseTrackList, readVersionAndDescriptor, serializeTrackList, TimelineTrackDescriptor, TimeScopeDescriptor, writeVersionAndDescriptor } from './descriptor';
 
 export interface ResourceHandler {
 	key: number;
@@ -62,6 +50,38 @@ function writeUtf8String(writer: PsdWriter, value: string) {
 	writeBytes(writer, buffer);
 }
 
+function readEncodedString(reader: PsdReader) {
+	const length = readUint8(reader);
+	const buffer = readBytes(reader, length);
+
+	let notAscii = false;
+	for (let i = 0; i < buffer.byteLength; i++) {
+		if (buffer[i] & 0x80) {
+			notAscii = true;
+			break;
+		}
+	}
+
+	if (notAscii) {
+		const decoder = new TextDecoder('gbk');
+		return decoder.decode(buffer)
+	} else {
+		return decodeString(buffer);
+	}
+}
+
+function writeEncodedString(writer: PsdWriter, value: string) {
+	let ascii = '';
+
+	for (let i = 0, code = value.codePointAt(i++); code !== undefined; code = value.codePointAt(i++)) {
+		ascii += code > 0x7f ? '?' : String.fromCodePoint(code);
+	}
+
+	const buffer = encodeString(ascii);
+	writeUint8(writer, buffer.byteLength);
+	writeBytes(writer, buffer);
+}
+
 MOCK_HANDLERS && addHandler(
 	1028, // IPTC-NAA record
 	target => (target as any)._ir1028 !== undefined,
@@ -273,16 +293,22 @@ addHandler(
 	1006,
 	target => target.alphaChannelNames !== undefined,
 	(reader, target, left) => {
-		target.alphaChannelNames = [];
+		if (!target.alphaChannelNames) { // skip if the unicode versions are already read
+			target.alphaChannelNames = [];
 
-		while (left() > 0) {
-			const value = readPascalString(reader, 1);
-			target.alphaChannelNames.push(value);
+			while (left() > 0) {
+				const value = readEncodedString(reader);
+				// const value = readPascalString(reader, 1);
+				target.alphaChannelNames.push(value);
+			}
+		} else {
+			skipBytes(reader, left());
 		}
 	},
 	(writer, target) => {
 		for (const name of target.alphaChannelNames!) {
-			writePascalString(writer, name, 1);
+			writeEncodedString(writer, name);
+			// writePascalString(writer, name, 1);
 		}
 	},
 );

package/src/psd.ts

@@ -264,7 +264,7 @@ export type Justification = 'left' | 'right' | 'center' | 'justify-left' | 'just
 export type LineCapType = 'butt' | 'round' | 'square';
 export type LineJoinType = 'miter' | 'round' | 'bevel';
 export type LineAlignment = 'inside' | 'center' | 'outside';
-export type InterpolationMethod = 'classic' | 'perceptual' | 'linear';
+export type InterpolationMethod = 'classic' | 'perceptual' | 'linear' | 'smooth';
 
 export interface Warp {
 	style?: WarpStyle;
@@ -457,6 +457,7 @@ export interface ExtraGradientInfo {
 	scale?: number;
 	angle?: number;
 	dither?: boolean;
+	interpolationMethod?: InterpolationMethod;
 	reverse?: boolean;
 	align?: boolean;
 	offset?: { x: number; y: number; };
@@ -1322,6 +1323,7 @@ export interface LayerAdditionalInfo {
 	id?: number; // layer id
 	version?: number; // layer version
 	mask?: LayerMaskData;
+	realMask?: LayerMaskData;
 	blendClippendElements?: boolean; // has to be set to `true` when using `color burn` blend mode (otherwise `transparencyShapesLayer` is set incorrectly)
 	blendInteriorElements?: boolean;
 	knockout?: boolean;
@@ -1441,6 +1443,12 @@ export interface LayerAdditionalInfo {
 		colorSpace: Color;
 		opacity: number;
 	};
+	blendingRanges?: {
+		compositeGrayBlendSource: number[];
+		compositeGraphBlendDestinationRange: number[];
+		ranges: { sourceRange: number[]; destRange: number[]; }[];
+	};
+	vowv?: number; // ???
 
 	// Base64 encoded raw EngineData, currently just kept in original state to support
 	// loading and modifying PSD file without breaking text layers.

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,10 +443,10 @@ 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);
+		const blendingRanges = readLayerBlendingRanges(reader);
+		if (blendingRanges) layer.blendingRanges = blendingRanges;
 		layer.name = readPascalString(reader, 1); // should be padded to 4, but is not sometimes
 
 		// HACK: fix for sometimes layer.name string not being padded correctly, just skip until we get valid signature
@@ -460,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);
@@ -476,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;
@@ -484,37 +502,23 @@ 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;
 	});
 }
 
+function readBlendingRange(reader: PsdReader) {
+	return [readUint8(reader), readUint8(reader), readUint8(reader), readUint8(reader)];
+}
+
 function readLayerBlendingRanges(reader: PsdReader) {
 	return readSection(reader, 1, left => {
-		const compositeGrayBlendSource = readUint32(reader);
-		const compositeGraphBlendDestinationRange = readUint32(reader);
-		const ranges = [];
+		const compositeGrayBlendSource = readBlendingRange(reader);
+		const compositeGraphBlendDestinationRange = readBlendingRange(reader);
+		const ranges: { sourceRange: number[]; destRange: number[]; }[] = [];
 
 		while (left() > 0) {
-			const sourceRange = readUint32(reader);
-			const destRange = readUint32(reader);
+			const sourceRange = readBlendingRange(reader);
+			const destRange = readBlendingRange(reader);
 			ranges.push({ sourceRange, destRange });
 		}
 
@@ -567,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);
@@ -583,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);
@@ -595,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;