ag-psd 32.0.0 → 34.0.0

package/src/psdReader.ts

@@ -1,7 +1,8 @@
 import { Inflate } from 'pako';
 import { Psd, Layer, ColorMode, SectionDividerType, LayerAdditionalInfo, ReadOptions, LayerMaskData, Color, PatternInfo, GlobalLayerMaskInfo, RGB, PixelData, PixelArray, ChannelID, Compression } from './psd';
-import { resetImageData, offsetForChannel, decodeBitmap, createImageData, toBlendMode, LayerMaskFlags, MaskParams, ColorSpace, RAW_IMAGE_DATA, largeAdditionalInfoKeys, imageDataToCanvas, normalizeLabAB } from './helpers';
+import { resetImageData, offsetForChannel, decodeBitmap, createImageData, toBlendMode, LayerMaskFlags, MaskParams, ColorSpace, largeAdditionalInfoKeys, largeAdditionalInfoKeysObserved, imageDataToCanvas, normalizeLabAB, cmykToRgbValues } from './helpers';
 import { infoHandlersMap } from './additionalInfo';
+import { decodeString } from './utf8';
 import { InternalImageResources, resourceHandlersMap } from './imageResources';
 
 interface ChannelInfo {
@@ -9,7 +10,7 @@ interface ChannelInfo {
 	length: number;
 }
 
-export const supportedColorModes = [ColorMode.Bitmap, ColorMode.Grayscale, ColorMode.RGB, ColorMode.Indexed];
+export const supportedColorModes = [ColorMode.Bitmap, ColorMode.Grayscale, ColorMode.RGB, ColorMode.Indexed, ColorMode.CMYK];
 const colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', '', '', 'multichannel', 'duotone', 'lab'];
 
 function setupGrayscale(data: PixelData) {
@@ -27,7 +28,44 @@ export interface PsdReader extends ReadOptions {
 	view: DataView;
 	large: boolean;
 	globalAlpha: boolean;
+	layersInGlobalInfo?: boolean; // layers were read from Lr16/Lr32/Layr global additional info
 	log(...args: any[]): void;
+	// text decoders, created lazily (null if not supported)
+	utf8Decoder?: TextDecoder | null;
+	utf8StrictDecoder?: TextDecoder | null;
+	gbkDecoder?: TextDecoder | null;
+}
+
+function createTextDecoder(label: string, options?: TextDecoderOptions) {
+	try {
+		return typeof TextDecoder !== 'undefined' ? new TextDecoder(label, options) : null;
+	} catch {
+		return null; // encoding not supported
+	}
+}
+
+// non-fatal UTF-8 decoder, malformed byte sequences are replaced with U+FFFD
+export function getUtf8Decoder(reader: PsdReader) {
+	if (reader.utf8Decoder === undefined) reader.utf8Decoder = createTextDecoder('utf-8', { ignoreBOM: true });
+	return reader.utf8Decoder;
+}
+
+// UTF-8 decoder that throws on malformed byte sequences
+export function getUtf8StrictDecoder(reader: PsdReader) {
+	if (reader.utf8StrictDecoder === undefined) reader.utf8StrictDecoder = createTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+	return reader.utf8StrictDecoder;
+}
+
+// GBK decoder that throws on malformed byte sequences
+export function getGbkStrictDecoder(reader: PsdReader) {
+	if (reader.gbkDecoder === undefined) reader.gbkDecoder = createTextDecoder('gbk', { fatal: true });
+	return reader.gbkDecoder;
+}
+
+export function decodeUtf8(reader: PsdReader, buffer: Uint8Array) {
+	// native decoder is faster only for longer strings
+	const decoder = buffer.byteLength > 1000 ? getUtf8Decoder(reader) : null;
+	return decoder ? decoder.decode(buffer) : decodeString(buffer);
 }
 
 export function createReader(buffer: ArrayBufferLike, offset?: number, length?: number): PsdReader {
@@ -147,6 +185,8 @@ export function readUnicodeString(reader: PsdReader) {
 }
 
 const STRING_CHUNK_SIZE = 0x2000;
+// shorter strings (most descriptor keys, OSTypes and names) are faster to build with simple loop than String.fromCharCode.apply
+const SHORT_STRING_LENGTH = 64;
 
 function checkReadBounds(reader: PsdReader, size: number) {
 	if (reader.offset < 0 || (reader.offset + size) > reader.view.byteLength) {
@@ -160,10 +200,21 @@ function readUtf16String(reader: PsdReader, length: number, littleEndian: boolea
 	checkReadBounds(reader, length * 2);
 
 	const view = reader.view;
-	const codes = new Uint16Array(Math.min(length, STRING_CHUNK_SIZE));
 	let offset = reader.offset;
 	let text = '';
 
+	if (length <= SHORT_STRING_LENGTH) {
+		for (let i = 0; i < length; i++, offset += 2) {
+			text += String.fromCharCode(view.getUint16(offset, littleEndian));
+		}
+
+		reader.offset = offset;
+		if (text.charCodeAt(text.length - 1) === 0) text = text.substring(0, text.length - 1);
+		return text;
+	}
+
+	const codes = new Uint16Array(Math.min(length, STRING_CHUNK_SIZE));
+
 	for (let i = 0; i < length; i += STRING_CHUNK_SIZE) {
 		const count = Math.min(STRING_CHUNK_SIZE, length - i);
 
@@ -203,6 +254,19 @@ export function readUnicodeStringWithLengthLE(reader: PsdReader, length: number)
 export function readAsciiString(reader: PsdReader, length: number) {
 	if (!(length > 0)) return '';
 	checkReadBounds(reader, length);
+
+	if (length <= SHORT_STRING_LENGTH) {
+		const view = reader.view;
+		let text = '';
+
+		for (let i = 0, offset = reader.offset; i < length; i++, offset++) {
+			text += String.fromCharCode(view.getUint8(offset));
+		}
+
+		reader.offset += length;
+		return text;
+	}
+
 	const text = bytesToString(new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length));
 	reader.offset += length;
 	return text;
@@ -222,7 +286,16 @@ export function checkSignature(reader: PsdReader, a: string, b?: string) {
 }
 
 function readShortString(reader: PsdReader, length: number) {
-	return bytesToString(readBytes(reader, length));
+	const bytes = readBytes(reader, length);
+	if (length > SHORT_STRING_LENGTH) return bytesToString(bytes);
+
+	let text = '';
+
+	for (let i = 0; i < bytes.length; i++) {
+		text += String.fromCharCode(bytes[i]);
+	}
+
+	return text;
 }
 
 function isValidSignature(sig: string) {
@@ -244,7 +317,8 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 	const maxSize = version === 1 ? 30000 : 300000;
 
 	if (width > maxSize || height > maxSize) throw new Error(`Invalid size: ${width}x${height}`);
-	if (channels < 1 || channels > 56) throw new Error(`Invalid channel count: ${channels}`);
+	// up to 56 channels plus transparency of composite image (Photoshop CS3 writes 57 channels for 53 alpha channels)
+	if (channels < 1 || channels > 57) throw new Error(`Invalid channel count: ${channels}`);
 	if (![1, 8, 16, 32].includes(bitsPerChannel)) throw new Error(`Invalid bitsPerChannel: ${bitsPerChannel}`);
 	if (supportedColorModes.indexOf(colorMode) === -1) throw new Error(`Color mode not supported: ${colorModes[colorMode] ?? colorMode}`);
 
@@ -253,6 +327,7 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 	Object.assign(reader, readOptions);
 	reader.large = version === 2;
 	reader.globalAlpha = false;
+	reader.layersInGlobalInfo = false;
 	if (!('totalMemoryLimit' in reader)) { // setting totalMemoryLimit to undefined explicitly disables memory limit
 		reader.totalMemoryLimit = 2 * 1024 * 1024 * 1024; // default 2GB memory limit
 	}
@@ -280,12 +355,16 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 	// image resources
 
 	const imageResources: InternalImageResources = {};
+	let unreadResourceBytes = 0;
 
 	readSection(reader, 1, left => {
-		while (left() > 0) {
-			realignWithSignature(reader, isValidSignature);
+		// stop if there's not enough data left for resource header (some files have few trailing bytes in this section)
+		while (left() >= 12) {
+			const signature = realignWithSignature(reader, isValidSignature);
 			const id = readUint16(reader);
-			readPascalString(reader, 2); // name
+			const nameLength = readUint8(reader);
+			const name = readBytes(reader, nameLength);
+			skipBytes(reader, (nameLength + 1) % 2); // pad to even size
 
 			readSection(reader, 2, left => {
 				const handler = resourceHandlersMap[id];
@@ -293,20 +372,29 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 
 				if (handler && !skip) {
 					try {
-						handler.read(reader, imageResources, left);
+						handler.read(reader, imageResources, left, { signature, id, name, width, height });
 					} catch (e) {
 						if (reader.throwForMissingFeatures) throw e;
 						skipBytes(reader, left());
 					}
 				} else {
-					// options.logMissingFeatures && console.log(`Unhandled image resource: ${id} (${left()})`);
+					reader.logMissingFeatures && reader.log(`Unhandled image resource: ${id} (${left()})`);
 					skipBytes(reader, left());
 				}
 			});
 		}
+
+		unreadResourceBytes = left();
+		skipBytes(reader, left());
 	});
 
-	const { layersGroup, layerGroupsEnabledId, ...rest } = imageResources;
+	// some files have image resources section length few bytes larger than the data, layer and mask info section
+	// starts right after the last resource in that case
+	if (unreadResourceBytes && !sectionFits(reader, reader.offset) && sectionFits(reader, reader.offset - unreadResourceBytes)) {
+		reader.offset -= unreadResourceBytes;
+	}
+
+	const { layersGroup, layerGroupsEnabledId, savedPathsOrigination, ...rest } = imageResources;
 
 	if (Object.keys(rest).length) {
 		psd.imageResources = rest;
@@ -354,6 +442,7 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 			const rawCompositeData = new Uint8Array(reader.view.buffer, reader.view.byteOffset + rawOffset, reader.view.byteLength - rawOffset);
 			psd.rawCompositeData = rawCompositeData;
 			psd.rawCompositeDataInfo = { large: reader.large, globalAlpha: reader.globalAlpha };
+			if (reader.layersInGlobalInfo) psd.rawCompositeDataInfo.layersInGlobalInfo = true;
 		} else {
 			const imageData = readImageData(reader, psd);
 			if (reader.useImageData) {
@@ -364,10 +453,6 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 		}
 	}
 
-	// TODO: show converted color mode instead of original PSD file color mode
-	//       but add option to preserve file color mode (need to return image data instead of canvas in that case)
-	// psd.colorMode = ColorMode.RGB; // we convert all color modes to RGB
-
 	return psd;
 }
 
@@ -408,6 +493,10 @@ export function readLayerInfo(reader: PsdReader, psd: Psd, imageResources: Inter
 			l.opened = type === SectionDividerType.OpenFolder;
 			l.children = [];
 
+			// group layers can't have image data, some broken files have it, ignore it like Photoshop does
+			delete l.canvas;
+			delete l.imageData;
+
 			if (l.sectionDivider?.key) {
 				l.blendMode = toBlendMode[l.sectionDivider.key] ?? l.blendMode;
 			}
@@ -452,8 +541,11 @@ function readLayerRecord(reader: PsdReader, psd: Psd, imageResources: InternalIm
 
 	checkSignature(reader, '8BIM');
 	const blendMode = readSignature(reader);
-	if (!toBlendMode[blendMode]) throw new Error(`Invalid blend mode: '${blendMode}'`);
-	layer.blendMode = toBlendMode[blendMode];
+	if (!toBlendMode[blendMode]) {
+		if (reader.throwForMissingFeatures) throw new Error(`Invalid blend mode: '${blendMode}'`);
+		reader.logMissingFeatures && reader.log(`Unknown blend mode: '${blendMode}', using normal blend mode`);
+	}
+	layer.blendMode = toBlendMode[blendMode] || 'normal';
 
 	layer.opacity = readUint8(reader) / 0xff;
 	layer.clipping = readUint8(reader) === 1;
@@ -487,11 +579,20 @@ function readLayerRecord(reader: PsdReader, psd: Psd, imageResources: InternalIm
 	return { layer, channels };
 }
 
+// negative sizes are treated as empty (Photoshop writes them for some empty layers, like 0,0,-1,0 bounds of fill layer)
+// checks if length of section (layer and mask info) at given offset fits in the file
+function sectionFits(reader: PsdReader, offset: number) {
+	const lengthSize = reader.large ? 8 : 4;
+	if (offset < 0 || offset + lengthSize > reader.view.byteLength) return false;
+	const length = reader.large ? reader.view.getUint32(offset) * 0x100000000 + reader.view.getUint32(offset + 4) : reader.view.getUint32(offset);
+	return offset + lengthSize + length <= reader.view.byteLength;
+}
+
 function isValidBoxSize(box: { top?: number; left?: number; bottom?: number; right?: number; }, reader: PsdReader) {
 	const width = (box.right || 0) - (box.left || 0);
 	const height = (box.bottom || 0) - (box.top || 0);
 	const maxSize = reader.large ? 300000 : 30000;
-	return width >= 0 && height >= 0 && width <= maxSize && height <= maxSize;
+	return width <= maxSize && height <= maxSize;
 }
 
 function readLayerMaskData(reader: PsdReader, layer: Layer) {
@@ -613,8 +714,8 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 		let compression = Compression.RawData;
 		let data: Uint8Array | undefined = undefined;
 
-		if (channel.length === 1) throw new Error('Invalid channel length');
-		if (channel.length) {
+		// channel length of 1 is invalid (should be 0 or at least 2), skip the byte and treat channel as empty
+		if (channel.length >= 2) {
 			compression = readUint16(reader) as Compression;
 			// try to fix broken files where there's 1 byte shift of channel
 			if (compression > 3) {
@@ -622,9 +723,9 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 				compression = readUint16(reader) as Compression;
 			}
 
-			// try to fix broken files where there's 1 byte shift of channel
+			// try to fix broken files where there's 1 byte shift of channel (in the other direction)
 			if (compression > 3) {
-				reader.offset -= 3;
+				reader.offset -= 4;
 				compression = readUint16(reader) as Compression;
 			}
 
@@ -640,7 +741,14 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 	}
 
 	if (!reader.useRawData) {
-		decodeLayerImageData(layer, reader);
+		try {
+			decodeLayerImageData(layer, reader);
+		} catch (e) {
+			// corrupted image data of one layer shouldn't prevent reading rest of the file
+			if (reader.throwForMissingFeatures || (e as Error).message === 'Exceeded memory limit') throw e;
+			reader.logMissingFeatures && reader.log(`Failed to decode layer image data: ${(e as Error).message}`);
+			delete layer.rawData;
+		}
 	}
 }
 
@@ -665,6 +773,7 @@ export function getCompositeImageData(psd: Psd) {
 	if (info) {
 		reader.large = info.large;
 		reader.globalAlpha = info.globalAlpha;
+		reader.layersInGlobalInfo = !!info.layersInGlobalInfo;
 	}
 
 	return readImageData(reader, psd);
@@ -760,18 +869,13 @@ function getDataFromLayer(layer: Layer, read: LayerDataType, throwForMissingFeat
 
 	if (layerWidth && layerHeight && read === LayerDataType.Layer) {
 		if (cmyk) {
-			if (bitsPerChannel !== 8) throw new Error('bitsPerChannel not supported');
-			imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) } as any as ImageData;
+			if (bitsPerChannel !== 8 && bitsPerChannel !== 16) throw new Error('bitsPerChannel not supported');
+			imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel, 5, memoryLimit);
 		} else {
 			imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel, 4, memoryLimit);
 		}
 	}
 
-	if (RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-		(layer as any).imageDataRaw = [];
-		(layer as any).imageDataRawCompression = [];
-	}
-
 	for (const { id, compression, data } of channels) {
 		if (!data) continue;
 
@@ -794,15 +898,6 @@ function getDataFromLayer(layer: Layer, read: LayerDataType, throwForMissingFeat
 				maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel, 4, memoryLimit);
 				if (memoryLimit !== undefined) dataReader.totalMemoryLimit = Math.max(0, dataReader.totalMemoryLimit! - maskData.data.byteLength);
 				readData(dataReader, data.byteLength, maskData, compression, maskWidth, maskHeight, bitsPerChannel, 0, large, 4);
-				if (RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-					if (id === ChannelID.UserMask) {
-						(layer as any).maskDataRawCompression = compression;
-						(layer as any).maskDataRaw = data;
-					} else {
-						(layer as any).realMaskDataRawCompression = compression;
-						(layer as any).realMaskDataRaw = data;
-					}
-				}
 				setupGrayscale(maskData);
 				resetAlpha(maskData, false);
 			}
@@ -821,12 +916,6 @@ function getDataFromLayer(layer: Layer, read: LayerDataType, throwForMissingFeat
 			}
 
 			readData(dataReader, data.byteLength, targetData, compression, layerWidth, layerHeight, bitsPerChannel, offset, large, cmyk ? 5 : 4);
-
-			if (RAW_IMAGE_DATA) { // TODO: use layer.rawData instead
-				(layer as any).imageDataRawCompression[id] = compression;
-				(layer as any).imageDataRaw[id] = data;
-			}
-
 		}
 
 		if (id === ChannelID.Transparency) {
@@ -840,7 +929,8 @@ function getDataFromLayer(layer: Layer, read: LayerDataType, throwForMissingFeat
 
 		if (cmyk) {
 			const cmykData = imageData;
-			imageData = createImageData(cmykData.width, cmykData.height);
+			const rgbMemoryLimit = memoryLimit === undefined ? undefined : Math.max(0, memoryLimit - cmykData.data.byteLength);
+			imageData = createImageDataBitDepth(cmykData.width, cmykData.height, bitsPerChannel, 4, rgbMemoryLimit);
 			cmykToRgb(cmykData, imageData, false);
 		}
 	}
@@ -880,7 +970,7 @@ export function readGlobalLayerMaskInfo(reader: PsdReader) {
 		const colorSpace2 = readUint16(reader);
 		const colorSpace3 = readUint16(reader);
 		const colorSpace4 = readUint16(reader);
-		const opacity = readUint16(reader) / 100; // 0 - 100
+		const opacity = Math.min(readUint16(reader), 100) / 100; // 0 - 100 (some files have values out of range)
 		const kind = readUint8(reader);
 		skipBytes(reader, left()); // 3 bytes of padding ?
 		return { overlayColorSpace, colorSpace1, colorSpace2, colorSpace3, colorSpace4, opacity, kind };
@@ -918,7 +1008,16 @@ export function readAdditionalLayerInfo(reader: PsdReader, target: LayerAddition
 	const key = readSignature(reader);
 
 	// `largeAdditionalInfoKeys` fallback, because some keys don't have 8B64 signature even when they are 64bit
-	const u64 = sig === '8B64' || (reader.large && largeAdditionalInfoKeys.indexOf(key) !== -1);
+	let u64 = sig === '8B64' || (reader.large && largeAdditionalInfoKeys.indexOf(key) !== -1);
+
+	// these keys were written by older versions of this library with 32bit length and 8BIM signature,
+	// 64bit length always has high 32bits set to 0 (lengths over 4GB are not supported)
+	if (reader.large && sig === '8BIM' && largeAdditionalInfoKeysObserved.indexOf(key) !== -1) {
+		// 32bit length of 0 is followed by signature of the next block, 64bit length would continue with its low 32bits
+		const next = reader.offset + 8 <= reader.view.byteLength ? reader.view.getUint32(reader.offset + 4) : 0;
+		const nextIsSignature = next === 0x3842494d /* 8BIM */ || next === 0x38423634 /* 8B64 */;
+		u64 = reader.view.getUint32(reader.offset) === 0 && !nextIsSignature;
+	}
 
 	readSection(reader, 2, left => {
 		const handler = infoHandlersMap[key];
@@ -930,7 +1029,7 @@ export function readAdditionalLayerInfo(reader: PsdReader, target: LayerAddition
 				if (reader.throwForMissingFeatures) throw e;
 			}
 		} else {
-			reader.logMissingFeatures && reader.log(`Unhandled additional info: ${key}`);
+			reader.logMissingFeatures && key !== 'GenI' && key !== 'OCIO' && key !== 'CAI ' && reader.log(`Unhandled additional info: ${key}`);
 			skipBytes(reader, left());
 		}
 
@@ -996,14 +1095,8 @@ function readImageData(reader: PsdReader, psd: Psd) {
 		case ColorMode.Grayscale: {
 			const colorChannels = psd.colorMode === ColorMode.Grayscale ? 1 : 3;
 			const offsets = compositeChannelOffsets(reader, psd, colorChannels, 3);
-			const start = reader.offset;
-
 			readCompositeChannels(reader, compression, imageData, bitsPerChannel, 4, offsets);
 
-			if (RAW_IMAGE_DATA && compression === Compression.RleCompressed) {
-				(psd as any).imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
-			}
-
 			if (psd.colorMode === ColorMode.Grayscale) {
 				setupGrayscale(imageData);
 			}
@@ -1016,29 +1109,25 @@ function readImageData(reader: PsdReader, psd: Psd) {
 			const offsets = compositeChannelOffsets(reader, psd, 1, -1);
 			const indexedImageData: PixelData = { width, height, data: new Uint8Array(width * height) };
 			readCompositeChannels(reader, compression, indexedImageData, 8, 1, offsets);
-			indexedToRgb(indexedImageData, imageData, psd.palette);
+			indexedToRgb(indexedImageData, imageData, psd.palette, psd.imageResources?.transparencyIndex ?? -1);
 			break;
 		}
 		case ColorMode.CMYK: {
-			if (bitsPerChannel !== 8) throw new Error('bitsPerChannel not supported');
+			if (bitsPerChannel !== 8 && bitsPerChannel !== 16) throw new Error('bitsPerChannel not supported');
 
 			const offsets = compositeChannelOffsets(reader, psd, 4, 4);
-			const cmykImageData: PixelData = { width, height, data: new Uint8Array(width * height * 5) };
-			const start = reader.offset;
+			const cmykImageData = createImageDataBitDepth(width, height, bitsPerChannel, 5, reader.totalMemoryLimit);
 
-			readCompositeChannels(reader, compression, cmykImageData, 8, 5, offsets);
-			cmykToRgb(cmykImageData, imageData, true);
-
-			if (RAW_IMAGE_DATA && compression === Compression.RleCompressed) {
-				(psd as any).imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
-			}
+			resetAlpha(cmykImageData, true);
+			readCompositeChannels(reader, compression, cmykImageData, bitsPerChannel, 5, offsets);
+			cmykToRgb(cmykImageData, imageData, !!reader.globalAlpha);
 			break;
 		}
 		default: throw new Error(`Color mode not supported: ${psd.colorMode}`);
 	}
 
-	// remove weird white matte
-	if (reader.globalAlpha) {
+	// remove weird white matte (already removed when converting from CMYK)
+	if (reader.globalAlpha && psd.colorMode !== ColorMode.CMYK) {
 		removeWhiteMatte(imageData);
 	}
 
@@ -1053,8 +1142,12 @@ function compositeChannelOffsets(reader: PsdReader, psd: Psd, colorChannels: num
 	// First extra channel is transparency if document has global alpha (negative layer count). Some non-Photoshop
 	// applications write transparency channel without setting global alpha, in that case extra channel is not
 	// listed in alpha channel names (Photoshop names all user alpha channels / saved selections).
-	const namedChannels = psd.imageResources?.alphaChannelNames?.length ?? 0;
-	const hasTransparency = reader.globalAlpha || (channelCount - colorChannels) > namedChannels;
+	// Photoshop also lists merged transparency as first alpha channel named "Transparency" (in documents marked with
+	// Mtrn/Mt16/Mt32 additional info, or in some 16bit documents with layers stored in Lr16 without any other mark)
+	const alphaNames = psd.imageResources?.alphaChannelNames ?? [];
+	const namedChannels = alphaNames.length;
+	const namedTransparency = !!reader.layersInGlobalInfo && alphaNames[0] === 'Transparency' && namedChannels === channelCount - colorChannels;
+	const hasTransparency = reader.globalAlpha || namedTransparency || (channelCount - colorChannels) > namedChannels;
 	const offsets: number[] = [];
 
 	for (let i = 0; i < channelCount; i++) {
@@ -1138,45 +1231,61 @@ function removeWhiteMatte({ data, width, height }: PixelData) {
 	}
 }
 
-function cmykToRgb(cmyk: PixelData, rgb: PixelData, reverseAlpha: boolean) {
+// converts value in 0-255 range to target range, rounding and clamping it
+function toRange(value: number, max: number) {
+	value = Math.round(value * (max / 255));
+	return value <= 0 ? 0 : (value >= max ? max : value);
+}
+
+// converts CMYK data to RGB using approximation of U.S. Web Coated (SWOP) v2 profile (see cmykToRgbValues)
+// cmyk - 8 or 16 bit data with 5 channels (cmyka), rgb - 8 or 16 bit data with 4 channels (rgba)
+// removeMatte - colors are blended with white (no ink), used for composite image of documents with global alpha
+function cmykToRgb(cmyk: PixelData, rgb: PixelData, removeMatte: boolean) {
 	const size = rgb.width * rgb.height * 4;
 	const srcData = cmyk.data;
 	const dstData = rgb.data;
+	const srcMax = srcData instanceof Uint16Array ? 0xffff : 0xff;
+	const dstMax = dstData instanceof Uint16Array ? 0xffff : 0xff;
+	const out = [0, 0, 0];
 
 	for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
-		const c = srcData[src];
-		const m = srcData[src + 1];
-		const y = srcData[src + 2];
-		const k = srcData[src + 3];
-		dstData[dst] = ((((c * k) | 0) / 255) | 0);
-		dstData[dst + 1] = ((((m * k) | 0) / 255) | 0);
-		dstData[dst + 2] = ((((y * k) | 0) / 255) | 0);
-		dstData[dst + 3] = reverseAlpha ? 255 - srcData[src + 4] : srcData[src + 4];
-	}
-
-	// for (let src = 0, dst = 0; dst < size; src += 5, dst += 4) {
-	// 	const c = 1 - (srcData[src + 0] / 255);
-	// 	const m = 1 - (srcData[src + 1] / 255);
-	// 	const y = 1 - (srcData[src + 2] / 255);
-	// 	// const k = srcData[src + 3] / 255;
-	// 	dstData[dst + 0] = ((1 - c * 0.8) * 255) | 0;
-	// 	dstData[dst + 1] = ((1 - m * 0.8) * 255) | 0;
-	// 	dstData[dst + 2] = ((1 - y * 0.8) * 255) | 0;
-	// 	dstData[dst + 3] = reverseAlpha ? 255 - srcData[src + 4] : srcData[src + 4];
-	// }
-}
-
-function indexedToRgb(indexed: PixelData, rgb: PixelData, palette: RGB[]) {
+		const a = srcData[src + 4];
+
+		// image data stores inverted values (0 = 100% ink)
+		let c = 1 - srcData[src] / srcMax;
+		let m = 1 - srcData[src + 1] / srcMax;
+		let y = 1 - srcData[src + 2] / srcMax;
+		let k = 1 - srcData[src + 3] / srcMax;
+
+		if (removeMatte && a > 0 && a < srcMax) {
+			const ra = srcMax / a;
+			c = Math.min(1, c * ra);
+			m = Math.min(1, m * ra);
+			y = Math.min(1, y * ra);
+			k = Math.min(1, k * ra);
+		}
+
+		cmykToRgbValues(c, m, y, k, out);
+		dstData[dst] = toRange(out[0], dstMax);
+		dstData[dst + 1] = toRange(out[1], dstMax);
+		dstData[dst + 2] = toRange(out[2], dstMax);
+		dstData[dst + 3] = srcMax === dstMax ? a : Math.round(a * dstMax / srcMax);
+	}
+}
+
+// transparencyIndex - palette index of transparent color (-1 if there's none)
+function indexedToRgb(indexed: PixelData, rgb: PixelData, palette: RGB[], transparencyIndex: number) {
 	const size = indexed.width * indexed.height;
 	const srcData = indexed.data;
 	const dstData = rgb.data;
 
 	for (let src = 0, dst = 0; src < size; src++, dst += 4) {
-		const c = palette[srcData[src]];
+		const index = srcData[src];
+		const c = palette[index];
 		dstData[dst + 0] = c.r;
 		dstData[dst + 1] = c.g;
 		dstData[dst + 2] = c.b;
-		dstData[dst + 3] = 255;
+		dstData[dst + 3] = index === transparencyIndex ? 0 : 255;
 	}
 }
 
@@ -1342,8 +1451,8 @@ export function readDataZip(
 	}
 }
 
-// decodes single PackBits row, returns number of decoded values
-function decodeRLERow(src: Uint8Array, i: number, end: number, dst: PixelArray, p: number, step: number, count: number) {
+// decodes single PackBits row into byte buffer, returns number of decoded bytes
+function decodeRLERow(src: Uint8Array, i: number, end: number, dst: Uint8Array, count: number) {
 	let x = 0;
 
 	while (i < end && x < count) {
@@ -1355,19 +1464,15 @@ function decodeRLERow(src: Uint8Array, i: number, end: number, dst: PixelArray,
 			const value = src[i++];
 			let n = 257 - header;
 			if (n > count - x) n = count - x;
+			dst.fill(value, x, x + n);
 			x += n;
-
-			for (; n > 0; n--, p += step) {
-				dst[p] = value;
-			}
 		} else if (header < 128) {
 			let n = header + 1;
 			if (n > count - x) n = count - x;
 			if (n > end - i) n = end - i;
-			x += n;
 
-			for (; n > 0; n--, p += step) {
-				dst[p] = src[i++];
+			for (; n > 0; n--) {
+				dst[x++] = src[i++];
 			}
 		} else {
 			// ignore 128
@@ -1377,6 +1482,51 @@ function decodeRLERow(src: Uint8Array, i: number, end: number, dst: PixelArray,
 	return x;
 }
 
+// decodes RLE rows of single 8bit channel, writing values to `data` with `step`
+// (kept as single function with the loops, inlining row decoder into readDataRLE makes V8 generate much slower code)
+function decodeRLEChannel8(
+	src: Uint8Array, lengths: Uint16Array | Uint32Array, li: number, pos: number, width: number, height: number,
+	data: PixelArray, offset: number, step: number
+) {
+	const srcEnd = src.length | 0;
+
+	for (let y = 0; y < height; y++, li++) {
+		let i = (pos < srcEnd ? pos : srcEnd) | 0;
+		pos += lengths[li];
+		const end = (pos < srcEnd ? pos : srcEnd) | 0;
+		let p = (offset + y * width * step) | 0;
+		let x = 0;
+
+		while (i < end && x < width) {
+			const header = src[i++] | 0;
+
+			if (header > 128) {
+				if (i >= end) break;
+
+				const value = src[i++] | 0;
+				let n = (257 - header) | 0;
+				if (n > width - x) n = (width - x) | 0;
+				x = (x + n) | 0;
+
+				for (const pe = (p + n * step) | 0; p < pe; p = (p + step) | 0) {
+					data[p] = value;
+				}
+			} else if (header < 128) {
+				let n = (header + 1) | 0;
+				if (n > width - x) n = (width - x) | 0;
+				if (n > end - i) n = (end - i) | 0;
+				x = (x + n) | 0;
+
+				for (const ie = (i + n) | 0; i < ie; i = (i + 1) | 0, p = (p + step) | 0) {
+					data[p] = src[i];
+				}
+			} else {
+				// ignore 128
+			}
+		}
+	}
+}
+
 // converts big-endian 16/32-bit values from bytes and writes them to `data` starting at `p` with `step`
 function scatterValues(bytes: Uint8Array, count: number, bpv: number, data: PixelArray, p: number, step: number) {
 	if (bpv === 2) {
@@ -1392,10 +1542,10 @@ function scatterValues(bytes: Uint8Array, count: number, bpv: number, data: Pixe
 	}
 }
 
-// decodes RLE rows of single channel, each row starts at the beginning of the image row
-function decodeRLEChannel(
+// decodes RLE rows of single 16bit or 32bit channel, each row is decoded into `row` buffer and then converted to values
+function decodeRLEChannelWide(
 	src: Uint8Array, lengths: Uint16Array | Uint32Array, li: number, pos: number, width: number, height: number,
-	data: PixelArray, offset: number, step: number, bpv: number, row: Uint8Array | undefined
+	data: PixelArray, offset: number, step: number, bpv: number, row: Uint8Array
 ) {
 	const srcEnd = src.length;
 	const rowSize = width * bpv;
@@ -1407,12 +1557,8 @@ function decodeRLEChannel(
 
 		if (rowStart >= rowEnd) continue;
 
-		if (bpv === 1) {
-			decodeRLERow(src, rowStart, rowEnd, data, offset + y * width * step, step, width);
-		} else {
-			const decoded = decodeRLERow(src, rowStart, rowEnd, row!, 0, 1, rowSize);
-			scatterValues(row!, Math.floor(decoded / bpv), bpv, data, offset + y * width * step, step);
-		}
+		const decoded = decodeRLERow(src, rowStart, rowEnd, row, rowSize);
+		scatterValues(row, Math.floor(decoded / bpv), bpv, data, offset + y * width * step, step);
 	}
 }
 
@@ -1420,15 +1566,19 @@ export function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined,
 	const data = pixelData && pixelData.data;
 	const rows = offsets.length * height;
 	const lengthSize = large ? 4 : 2;
+	const lengthsMemory = rows * lengthSize;
+	const srcEnd = reader.view.byteLength;
+	const bpv = bytesPerValue(bitDepth); // throws before consuming memory
+	let lengths: Uint16Array | Uint32Array;
 
-	consumeMemory(reader, rows * lengthSize);
+	consumeMemory(reader, lengthsMemory);
 
 	try {
-		if ((reader.offset + rows * lengthSize) > reader.view.byteLength) {
+		if ((reader.offset + lengthsMemory) > srcEnd) {
 			throw new Error('RLE row lengths exceed buffer length');
 		}
 
-		const lengths = large ? new Uint32Array(rows) : new Uint16Array(rows);
+		lengths = large ? new Uint32Array(rows) : new Uint16Array(rows);
 		let total = 0;
 
 		if (large) {
@@ -1437,36 +1587,39 @@ export function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined,
 			for (let i = 0; i < rows; i++) total += (lengths[i] = readUint16(reader));
 		}
 
-		const start = reader.offset;
-		const srcEnd = reader.view.byteLength;
-
-		if (total > (srcEnd - start)) {
+		if (total > (srcEnd - reader.offset)) {
 			// broken or truncated file, decode only data that is available
 			warnOrThrow(reader, 'RLE data exceeds buffer length');
 		}
 
-		const bpv = bytesPerValue(bitDepth);
 		if (data) verifyArrayType(data, bpv);
+	} catch (e) {
+		recoverMemory(reader, lengthsMemory);
+		throw e;
+	}
 
-		const src = new Uint8Array(reader.view.buffer, reader.view.byteOffset, srcEnd);
-		const row = (data && bpv > 1) ? new Uint8Array(width * bpv) : undefined;
-		let pos = start;
+	// decoding can't throw, it's kept outside of try block because V8 generates much slower code for loops inlined into try block
+	const src = new Uint8Array(reader.view.buffer, reader.view.byteOffset, srcEnd);
+	const row = (data && bpv > 1) ? new Uint8Array(width * bpv) : undefined;
+	let pos = reader.offset;
 
-		for (let c = 0, li = 0; c < offsets.length; c++, li += height) {
-			const offset = offsets[c] | 0;
-			const channelStart = pos;
+	for (let c = 0, li = 0; c < offsets.length; c++, li += height) {
+		const offset = offsets[c] | 0;
+		const channelStart = pos;
 
-			for (let y = 0; y < height; y++) pos += lengths[li + y];
+		for (let y = 0; y < height; y++) pos += lengths[li + y];
 
-			if (data && offset >= 0 && offset < step) {
-				decodeRLEChannel(src, lengths, li, channelStart, width, height, data, offset, step, bpv, row);
+		if (data && offset >= 0 && offset < step) {
+			if (bpv === 1) {
+				decodeRLEChannel8(src, lengths, li, channelStart, width, height, data, offset, step);
+			} else {
+				decodeRLEChannelWide(src, lengths, li, channelStart, width, height, data, offset, step, bpv, row!);
 			}
 		}
-
-		reader.offset = pos;
-	} finally {
-		recoverMemory(reader, rows * lengthSize);
 	}
+
+	reader.offset = pos;
+	recoverMemory(reader, lengthsMemory);
 }
 
 export function readSection<T>(
@@ -1520,11 +1673,11 @@ export function readColor(reader: PsdReader): Color {
 			skipBytes(reader, 2);
 			return { h, s, b };
 		}
-		case ColorSpace.CMYK: {
-			const c = readUint16(reader) / 257;
-			const m = readUint16(reader) / 257;
-			const y = readUint16(reader) / 257;
-			const k = readUint16(reader) / 257;
+		case ColorSpace.CMYK: { // 0 = 100% ink
+			const c = (0xffff - readUint16(reader)) / 257;
+			const m = (0xffff - readUint16(reader)) / 257;
+			const y = (0xffff - readUint16(reader)) / 257;
+			const k = (0xffff - readUint16(reader)) / 257;
 			return { c, m, y, k };
 		}
 		case ColorSpace.Lab: {
@@ -1546,6 +1699,24 @@ export function readColor(reader: PsdReader): Color {
 	}
 }
 
+const MAX_PATTERN_SIZE = 30000;
+
+// reads pattern, unsupported or invalid patterns are skipped (returns undefined) unless throwForMissingFeatures is set
+export function readPatternSafe(reader: PsdReader): PatternInfo | undefined {
+	let length = reader.view.getUint32(reader.offset);
+	while (length % 4) length++;
+	const end = reader.offset + 4 + length;
+
+	try {
+		return readPattern(reader);
+	} catch (e) {
+		if (reader.throwForMissingFeatures) throw e;
+		reader.logMissingFeatures && reader.log(`Skipped pattern: ${(e as Error).message}`);
+		reader.offset = end;
+		return undefined;
+	}
+}
+
 export function readPattern(reader: PsdReader): PatternInfo {
 	let length = readUint32(reader);
 	while (length % 4) length++;
@@ -1557,8 +1728,8 @@ export function readPattern(reader: PsdReader): PatternInfo {
 	const x = readInt16(reader);
 	const y = readInt16(reader);
 
-	// we only support RGB and grayscale for now
-	if (colorMode !== ColorMode.RGB && colorMode !== ColorMode.Grayscale && colorMode !== ColorMode.Indexed) {
+	// we only support RGB, grayscale, indexed and CMYK for now
+	if (colorMode !== ColorMode.RGB && colorMode !== ColorMode.Grayscale && colorMode !== ColorMode.Indexed && colorMode !== ColorMode.CMYK) {
 		throw new Error(`Unsupported pattern color mode: ${colorMode}`);
 	}
 
@@ -1575,7 +1746,8 @@ export function readPattern(reader: PsdReader): PatternInfo {
 			})
 		}
 
-		skipBytes(reader, 4); // no idea what this is
+		// some writers follow the palette with 4 extra bytes (unknown)
+		if (reader.view.getUint32(reader.offset) !== 3) skipBytes(reader, 4);
 	}
 
 	// virtual memory array list
@@ -1590,19 +1762,28 @@ export function readPattern(reader: PsdReader): PatternInfo {
 	const channelsCount = readUint32(reader);
 	const width = right - left;
 	const height = bottom - top;
-	const size = width * height * 4;
-	consumeMemory(reader, size);
-	const data = new Uint8Array(size);
-
-	for (let i = 3; i < data.byteLength; i += 4) {
-		data[i] = 255;
-	}
-
-	for (let i = 0, ch = 0; i < (channelsCount + 2); i++) {
+	if (width < 0 || height < 0) throw new Error('Invalid pattern bounds');
+	if (width > MAX_PATTERN_SIZE || height > MAX_PATTERN_SIZE) throw new Error(`Pattern too large (${width}x${height})`);
+	if (channelsCount > 64) throw new Error(`Invalid pattern channel count: ${channelsCount}`);
+	// channels cover whole pattern, each 2 bytes of RLE data can produce at most 128 bytes
+	if (width * height > (Math.min(end, reader.view.byteLength) - reader.offset) * 64) throw new Error('Pattern data out of bounds');
+
+	// first written arrays are color channels, next one is transparency (Photoshop stores it in the last, sheet mask, array)
+	const colorChannels = colorMode === ColorMode.RGB ? 3 : (colorMode === ColorMode.CMYK ? 4 : 1);
+	const isCmyk = colorMode === ColorMode.CMYK;
+	const alphaTarget = isCmyk ? 4 : 3;
+	const channels: { target: number; depth: number; compressionMode: number; cdata: Uint8Array; ctop: number; cleft: number; w: number; h: number; rowBytes: number; channelSize: number; }[] = [];
+	let maxDecodeSize = 0;
+
+	// validate all channels before allocating any image data
+	for (let i = 0, ch = 0; i < (channelsCount + 2) && reader.offset + 4 <= end; i++) {
 		const has = readUint32(reader);
 		if (!has) continue;
 
 		const length = readUint32(reader);
+		if (!length) continue;
+		if (length < 23) throw new Error('Invalid pattern channel length');
+
 		const pixelDepth = readUint32(reader);
 		const ctop = readUint32(reader);
 		const cleft = readUint32(reader);
@@ -1610,105 +1791,143 @@ export function readPattern(reader: PsdReader): PatternInfo {
 		const cright = readUint32(reader);
 		const pixelDepth2 = readUint16(reader);
 		const compressionMode = readUint8(reader); // 0 - raw, 1 - rle
-		const dataLength = length - (4 + 16 + 2 + 1);
-		const cdata = readBytes(reader, dataLength);
+		const cdata = readBytes(reader, length - 23);
+		const depth = (pixelDepth2 === 8 || pixelDepth2 === 16 || pixelDepth2 === 32) ? pixelDepth2 : pixelDepth;
+
+		if (depth !== 8 && depth !== 16 && depth !== 32) throw new Error(`Unsupported pattern pixel depth: ${depth}`);
 
-		if (pixelDepth !== 8 || pixelDepth2 !== 8) {
-			throw new Error('16bit pixel depth not supported for patterns');
+		if (ctop < top || cleft < left || cbottom > bottom || cright > right || cbottom < ctop || cright < cleft) {
+			throw new Error('Pattern channel bounds outside of pattern bounds');
 		}
 
+		const target = ch < colorChannels ? ch : (ch === colorChannels ? alphaTarget : -1);
+		ch++;
+
+		if (target === -1) continue;
+
 		const w = cright - cleft;
 		const h = cbottom - ctop;
-		const ox = cleft - left;
-		const oy = ctop - top;
+		const rowBytes = w * (depth / 8);
+		const channelSize = rowBytes * h;
 
 		if (compressionMode === 0) {
-			if (colorMode === ColorMode.RGB && ch < 3) {
-				for (let y = 0; y < h; y++) {
-					for (let x = 0; x < w; x++) {
-						const src = x + y * w;
-						const dst = (ox + x + (y + oy) * width) * 4;
-						data[dst + ch] = cdata[src];
-					}
-				}
-			} else if (colorMode === ColorMode.Grayscale && ch < 1) {
-				for (let y = 0; y < h; y++) {
-					for (let x = 0; x < w; x++) {
-						const src = x + y * w;
-						const dst = (ox + x + (y + oy) * width) * 4;
-						const value = cdata[src];
-						data[dst + 0] = value;
-						data[dst + 1] = value;
-						data[dst + 2] = value;
-					}
-				}
-			} else if (colorMode === ColorMode.Indexed) {
-				for (let y = 0; y < h; y++) {
-					for (let x = 0; x < w; x++) {
-						const src = x + y * w;
-						const dst = (ox + x + (y + oy) * width) * 4;
-						const index = cdata[src];
-						const color = palette[index];
-						data[dst + 0] = color.r;
-						data[dst + 1] = color.g;
-						data[dst + 2] = color.b;
-					}
-				}
-			} else {
-				if (reader.throwForMissingFeatures) throw new Error('Invalid color pattern');
-			}
+			if (cdata.byteLength < channelSize) throw new Error('Pattern channel data out of bounds');
 		} else if (compressionMode === 1) {
-			consumeMemory(reader, w * h);
+			// each 2 bytes of RLE data can produce at most 128 bytes
+			if (channelSize > cdata.byteLength * 64) throw new Error('Pattern channel data out of bounds');
+			maxDecodeSize = Math.max(maxDecodeSize, channelSize);
+		} else {
+			throw new Error('Invalid pattern compression mode');
+		}
+
+		channels.push({ target, depth, compressionMode, cdata, ctop, cleft, w, h, rowBytes, channelSize });
+	}
 
-			const pixelData: PixelData = { data, width, height };
-			const tempData: PixelData = { data: new Uint8Array(w * h), width: w, height: h };
+	// check peak memory up front (image data, CMYK buffer and largest RLE decode buffer),
+	// image data is consumed only after successful decoding so failed patterns don't reduce the limit
+	const size = width * height * 4;
+	const cmykSize = isCmyk ? width * height * 5 : 0;
+	consumeMemory(reader, size + cmykSize + maxDecodeSize);
+	recoverMemory(reader, size + cmykSize + maxDecodeSize);
+
+	const data = new Uint8Array(size);
+
+	for (let i = 3; i < data.byteLength; i += 4) {
+		data[i] = 255;
+	}
+
+	// CMYK channels are decoded into separate buffer (5 values per pixel, inverted, 0 = 100% ink) and converted to RGB at the end
+	const cmyk = isCmyk ? new Uint8Array(cmykSize).fill(255) : undefined;
+
+	for (const { target, depth, compressionMode, cdata, ctop, cleft, w, h, rowBytes, channelSize } of channels) {
+		let bytes = cdata;
+
+		if (compressionMode === 1) {
+			bytes = new Uint8Array(channelSize);
 			const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
+			readDataRLE(cdataReader, { data: bytes, width: rowBytes, height: h }, rowBytes, h, 8, 1, [0], false);
+		}
 
-			if (colorMode === ColorMode.RGB && ch < 3) {
-				readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
-				copyChannelToRGBA(tempData, pixelData, ox, oy, ch);
-			}
+		if (depth !== 8) bytes = patternChannelTo8bit(bytes, w * h, depth);
 
-			if (colorMode === ColorMode.Grayscale && ch < 1) {
-				readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
-				copyChannelToRGBA(tempData, pixelData, ox, oy, 0);
-				setupGrayscale(pixelData);
-			}
+		const ox = cleft - left;
+		const oy = ctop - top;
 
-			if (colorMode === ColorMode.Indexed) {
-				// TODO:
-				throw new Error('Indexed pattern color mode not implemented');
+		if (cmyk) {
+			copyPatternChannel(bytes, cmyk, w, h, (ox + oy * width) * 5 + target, width * 5, 5);
+		} else if (target === 3 || colorMode === ColorMode.RGB) {
+			copyPatternChannel(bytes, data, w, h, (ox + oy * width) * 4 + target, width * 4, 4);
+		} else if (colorMode === ColorMode.Indexed) {
+			const colors = new Uint8Array(256 * 3);
+
+			for (let i = 0; i < 256; i++) {
+				colors[i * 3 + 0] = palette[i].r;
+				colors[i * 3 + 1] = palette[i].g;
+				colors[i * 3 + 2] = palette[i].b;
 			}
 
-			recoverMemory(reader, w * h);
-		} else {
-			throw new Error('Invalid pattern compression mode');
+			for (let y = 0; y < h; y++) {
+				for (let x = 0, src = y * w, dst = (ox + (y + oy) * width) * 4; x < w; x++, src++, dst += 4) {
+					const index = bytes[src] * 3;
+					data[dst + 0] = colors[index + 0];
+					data[dst + 1] = colors[index + 1];
+					data[dst + 2] = colors[index + 2];
+				}
+			}
+		} else { // grayscale
+			for (let y = 0; y < h; y++) {
+				for (let x = 0, src = y * w, dst = (ox + (y + oy) * width) * 4; x < w; x++, src++, dst += 4) {
+					const value = bytes[src];
+					data[dst + 0] = value;
+					data[dst + 1] = value;
+					data[dst + 2] = value;
+				}
+			}
 		}
+	}
 
-		ch++;
+	if (cmyk) {
+		cmykToRgb({ width, height, data: cmyk }, { width, height, data }, false);
 	}
 
+	consumeMemory(reader, size);
 	reader.offset = end;
 
 	return { id, name, x, y, bounds: { x: left, y: top, w: width, h: height }, data };
 }
 
-function copyChannelToRGBA(srcData: PixelData, dstData: PixelData, ox: number, oy: number, offset: number) {
-	const w = srcData.width;
-	const h = srcData.height;
-	const width = dstData.width;
+// converts big-endian 16bit or 32bit (float) values to 8bit values
+function patternChannelTo8bit(bytes: Uint8Array, count: number, depth: number) {
+	const result = new Uint8Array(count);
 
-	for (let y = 0; y < h; y++) {
-		for (let x = 0; x < w; x++) {
-			const src = x + y * w;
-			const dst = (ox + x + (y + oy) * width) * 4;
-			const value = srcData.data[src];
-			dstData.data[dst + offset] = value;
+	if (depth === 16) {
+		for (let i = 0; i < count; i++) {
+			result[i] = Math.round(((bytes[i * 2] << 8) | bytes[i * 2 + 1]) / 257);
+		}
+	} else {
+		const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+		for (let i = 0; i < count; i++) {
+			const value = view.getFloat32(i * 4, false);
+			result[i] = value > 0 ? (value < 1 ? Math.round(value * 255) : 255) : 0;
+		}
+	}
+
+	return result;
+}
+
+// copies w x h channel values into interleaved data starting at `offset`
+function copyPatternChannel(bytes: Uint8Array, data: Uint8Array, w: number, h: number, offset: number, stride: number, step: number) {
+	for (let y = 0, src = 0; y < h; y++) {
+		for (let x = 0, dst = offset + y * stride; x < w; x++, src++, dst += step) {
+			data[dst] = bytes[src];
 		}
 	}
 }
 
-function consumeMemory(reader: PsdReader, size: number) {
+export function consumeMemory(reader: PsdReader, size: number) {
+	if (!(size >= 0)) throw new Error('Invalid size');
+
 	if (reader.totalMemoryLimit !== undefined) {
 		if (reader.totalMemoryLimit < size) throw new Error('Exceeded memory limit');
 		reader.totalMemoryLimit -= size;