ag-psd 30.1.1 → 31.0.0

package/src/psd.ts

@@ -1788,6 +1788,7 @@ export interface Psd extends LayerAdditionalInfo {
 	children?: Layer[];
 	canvas?: HTMLCanvasElement;
 	imageData?: PixelData;
+	rawCompositeData?: Uint8Array;
 	imageResources?: ImageResources;
 	linkedFiles?: LinkedFile[]; // used in smart objects
 	artboards?: {
@@ -1814,6 +1815,8 @@ export interface ReadOptions {
 	skipThumbnail?: boolean;
 	/** Does not load linked files (used in smart-objects). */
 	skipLinkedFilesData?: boolean;
+	/** Total memory limit to use when decoding bitmaps (default: 2GB). */
+	totalMemoryLimit?: number;
 	/** Throws exception if features are missing. */
 	throwForMissingFeatures?: boolean;
 	/** Logs if features are missing. */
@@ -1822,6 +1825,7 @@ export interface ReadOptions {
 	 * (image data will appear in `imageData` fields instead of `canvas` fields)
 	 * This avoids issues with canvas premultiplied alpha corrupting image data. */
 	useImageData?: boolean;
+	/** Skips decoding layer and composite bitmaps, they can be later decoded using helper functions */
 	useRawData?: boolean;
 	/** Loads thumbnail raw data instead of decoding it's content into canvas.
 	 * `thumnailRaw` field is used instead. */

package/src/psdReader.ts

@@ -234,6 +234,7 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 	Object.assign(reader, readOptions);
 	reader.large = version === 2;
 	reader.globalAlpha = false;
+	if (!reader.totalMemoryLimit) reader.totalMemoryLimit = 2 * 1024 * 1024 * 1024; // default 2GB memory limit
 
 	// color mode data
 	readSection(reader, 1, left => {
@@ -327,7 +328,16 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 	const skipComposite = reader.skipCompositeImageData && (reader.skipLayerImageData || hasChildren);
 
 	if (!skipComposite) {
-		readImageData(reader, psd);
+		if (reader.useRawData) {
+			psd.rawCompositeData = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset);
+		} else {
+			const imageData = readImageData(reader, psd);
+			if (reader.useImageData) {
+				psd.imageData = imageData;
+			} else {
+				psd.canvas = imageDataToCanvas(imageData);
+			}
+		}
 	}
 
 	// TODO: show converted color mode instead of original PSD file color mode
@@ -556,7 +566,7 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 	}
 
 	if (!reader.useRawData) {
-		decodeLayerImageData(layer, !!reader.useImageData, !!reader.throwForMissingFeatures);
+		decodeLayerImageData(layer, reader);
 	}
 }
 
@@ -571,8 +581,91 @@ function resetAlpha({ data }: PixelData, cmyk: boolean) {
 	}
 }
 
-export function decodeLayerImageData(layer: Layer, useImageData?: boolean, throwForMissingFeatures?: boolean) {
-	if (!layer.rawData) return;
+export function getCompositeImageData(psd: Psd) {
+	const data = psd.rawCompositeData;
+	if (!data) return undefined;
+
+	const reader = createReader(data.buffer, data.byteOffset, data.byteLength);
+	const imageData = readImageData(reader, psd);
+	return imageData;
+}
+
+export function getCompositeCanvas(psd: Psd) {
+	return imageDataToCanvasSafe(getCompositeImageData(psd));
+}
+
+export function getLayerImageData(layer: Layer) {
+	return getDataFromLayer(layer, LayerDataType.Layer, false, undefined);
+}
+
+export function getLayerMaskImageData(layer: Layer) {
+	return getDataFromLayer(layer, LayerDataType.Mask, false, undefined);
+}
+
+export function getLayerRealMaskImageData(layer: Layer) {
+	return getDataFromLayer(layer, LayerDataType.RealMask, false, undefined);
+}
+
+export function getLayerCanvas(layer: Layer) {
+	return imageDataToCanvasSafe(getLayerImageData(layer));
+}
+
+export function getLayerMaskCanvas(layer: Layer) {
+	return imageDataToCanvasSafe(getLayerMaskImageData(layer));
+}
+
+export function getLayerRealMaskCanvas(layer: Layer) {
+	return imageDataToCanvasSafe(getLayerRealMaskImageData(layer));
+}
+
+function imageDataToCanvasSafe(imageData: PixelData | undefined) {
+	return imageData && imageDataToCanvas(imageData);
+}
+
+function setImageDataOrCanvas(obj: Layer | LayerMaskData, imageData: PixelData | undefined, useImageData: boolean | undefined) {
+	if (!imageData) return;
+
+	if (useImageData) {
+		obj.imageData = imageData;
+	} else {
+		obj.canvas = imageDataToCanvas(imageData);
+	}
+}
+
+export function decodeLayerPixels(layer: Layer, useImageData?: boolean) {
+	decodeLayerImageData(layer, { useImageData });
+}
+
+function decodeLayerImageData(layer: Layer, options: { useImageData?: boolean, throwForMissingFeatures?: boolean, memoryLimit?: number }) {
+	let { throwForMissingFeatures, useImageData } = options;
+
+	const imageData = getDataFromLayer(layer, LayerDataType.Layer, throwForMissingFeatures, options.memoryLimit);
+	setImageDataOrCanvas(layer, imageData, useImageData);
+	if (options.memoryLimit !== undefined) options.memoryLimit -= imageData?.data.byteLength ?? 0;
+
+	if (layer.mask) {
+		const maskData = getDataFromLayer(layer, LayerDataType.Mask, throwForMissingFeatures, options.memoryLimit);
+		setImageDataOrCanvas(layer.mask, maskData, useImageData);
+		if (options.memoryLimit !== undefined) options.memoryLimit -= maskData?.data.byteLength ?? 0;
+	}
+
+	if (layer.realMask) {
+		const maskData = getDataFromLayer(layer, LayerDataType.RealMask, throwForMissingFeatures, options.memoryLimit);
+		setImageDataOrCanvas(layer.realMask, maskData, useImageData);
+		if (options.memoryLimit !== undefined) options.memoryLimit -= maskData?.data.byteLength ?? 0;
+	}
+
+	delete layer.rawData;
+}
+
+enum LayerDataType {
+	Layer,
+	Mask,
+	RealMask,
+}
+
+function getDataFromLayer(layer: Layer, read: LayerDataType, throwForMissingFeatures?: boolean, memoryLimit?: number) {
+	if (!layer.rawData) return undefined;
 
 	const { colorMode, bitsPerChannel, channels, large } = layer.rawData;
 	const layerWidth = (layer.right || 0) - (layer.left || 0);
@@ -580,14 +673,15 @@ export function decodeLayerImageData(layer: Layer, useImageData?: boolean, throw
 	const cmyk = colorMode === ColorMode.CMYK;
 
 	let imageData: PixelData | undefined;
+	let maskData: PixelData | undefined;
 	let initializedAlpha = false;
 
-	if (layerWidth && layerHeight) {
+	if (layerWidth && layerHeight && read === LayerDataType.Layer) {
 		if (cmyk) {
 			if (bitsPerChannel !== 8) throw new Error('bitsPerChannel Not supproted');
 			imageData = { width: layerWidth, height: layerHeight, data: new Uint8ClampedArray(layerWidth * layerHeight * 5) } as any as ImageData;
 		} else {
-			imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel);
+			imageData = createImageDataBitDepth(layerWidth, layerHeight, bitsPerChannel, 4, memoryLimit);
 		}
 	}
 
@@ -602,6 +696,9 @@ export function decodeLayerImageData(layer: Layer, useImageData?: boolean, throw
 		const dataReader = createReader(data.buffer, data.byteOffset, data.byteLength);
 
 		if (id === ChannelID.UserMask || id === ChannelID.RealUserMask) {
+			if (id === ChannelID.UserMask && read !== LayerDataType.Mask) continue;
+			if (id === ChannelID.RealUserMask && read !== LayerDataType.RealMask) continue;
+
 			const mask = id === ChannelID.UserMask ? layer.mask : layer.realMask;
 			if (!mask) throw new Error(`Missing layer ${id === ChannelID.UserMask ? 'mask' : 'real mask'} data`);
 
@@ -610,10 +707,8 @@ export function decodeLayerImageData(layer: Layer, useImageData?: boolean, throw
 			if (maskWidth < 0 || maskHeight < 0 || maskWidth > 30000 || maskHeight > 30000) throw new Error('Invalid mask size');
 
 			if (maskWidth && maskHeight) {
-				const maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel);
-
+				maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel, 4, memoryLimit);
 				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;
@@ -623,17 +718,12 @@ export function decodeLayerImageData(layer: Layer, useImageData?: boolean, throw
 						(layer as any).realMaskDataRaw = data;
 					}
 				}
-
 				setupGrayscale(maskData);
 				resetAlpha(maskData, false);
-
-				if (useImageData) {
-					mask.imageData = maskData;
-				} else {
-					mask.canvas = imageDataToCanvas(maskData);
-				}
 			}
 		} else {
+			if (read !== LayerDataType.Layer) continue;
+
 			const offset = offsetForChannel(id, cmyk);
 			let targetData = imageData;
 
@@ -670,15 +760,9 @@ export function decodeLayerImageData(layer: Layer, useImageData?: boolean, throw
 			imageData = createImageData(cmykData.width, cmykData.height);
 			cmykToRgb(cmykData, imageData, false);
 		}
-
-		if (useImageData) {
-			layer.imageData = imageData;
-		} else {
-			layer.canvas = imageDataToCanvas(imageData);
-		}
 	}
 
-	delete layer.rawData;
+	return read === LayerDataType.Layer ? imageData : maskData;
 }
 
 function readData(reader: PsdReader, length: number, pixels: PixelData | undefined, compression: Compression, width: number, height: number, bitDepth: number, offset: number, large: boolean, step: number) {
@@ -774,7 +858,10 @@ export function readAdditionalLayerInfo(reader: PsdReader, target: LayerAddition
 	}, false, u64);
 }
 
-export function createImageDataBitDepth(width: number, height: number, bitDepth: number, channels = 4): PixelData {
+function createImageDataBitDepth(width: number, height: number, bitDepth: number, channels: number, memoryLimit: number | undefined): PixelData {
+	const sizeInBytes = width * height * channels * Math.max(1, bitDepth / 8);
+	if (memoryLimit !== undefined && sizeInBytes > memoryLimit) throw new Error('Exceeded memory limit');
+
 	if (bitDepth === 1 || bitDepth === 8) {
 		if (channels === 4) {
 			return createImageData(width, height);
@@ -800,7 +887,8 @@ function readImageData(reader: PsdReader, psd: Psd) {
 	if (compression !== Compression.RawData && compression !== Compression.RleCompressed)
 		throw new Error(`Compression type not supported: ${compression}`);
 
-	const imageData = createImageDataBitDepth(psd.width, psd.height, bitsPerChannel);
+	const imageData = createImageDataBitDepth(psd.width, psd.height, bitsPerChannel, 4, reader.totalMemoryLimit);
+	if (reader.totalMemoryLimit !== undefined) reader.totalMemoryLimit -= imageData.data.byteLength;
 	resetImageData(imageData);
 
 	switch (psd.colorMode) {
@@ -815,7 +903,7 @@ function readImageData(reader: PsdReader, psd: Psd) {
 				bytes = new Uint8Array(psd.width * psd.height);
 				readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, 8, 1, [0], reader.large);
 			} else {
-				throw new Error(`Bitmap compression not supported: ${compression}`);
+				throw new Error(`Compression not supported: ${compression}`);
 			}
 
 			decodeBitmap(bytes, imageData.data, psd.width, psd.height);
@@ -843,6 +931,8 @@ function readImageData(reader: PsdReader, psd: Psd) {
 				const start = reader.offset;
 				readDataRLE(reader, imageData, psd.width, psd.height, bitsPerChannel, 4, channels, reader.large);
 				if (RAW_IMAGE_DATA) (psd as any).imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+			} else {
+				throw new Error(`Compression not supported: ${compression}`);
 			}
 
 			if (psd.colorMode === ColorMode.Grayscale) {
@@ -856,7 +946,7 @@ function readImageData(reader: PsdReader, psd: Psd) {
 			if (!psd.palette) throw new Error('Missing color palette');
 
 			if (compression === Compression.RawData) {
-				throw new Error(`Not implemented`);
+				throw new Error(`Compression not supported: ${compression}`);
 			} else if (compression === Compression.RleCompressed) {
 				const indexedImageData: PixelData = {
 					width: imageData.width,
@@ -866,7 +956,7 @@ function readImageData(reader: PsdReader, psd: Psd) {
 				readDataRLE(reader, indexedImageData, psd.width, psd.height, bitsPerChannel, 1, [0], reader.large);
 				indexedToRgb(indexedImageData, imageData, psd.palette);
 			} else {
-				throw new Error(`Not implemented`);
+				throw new Error(`Compression not supported: ${compression}`);
 			}
 
 			break;
@@ -879,7 +969,7 @@ function readImageData(reader: PsdReader, psd: Psd) {
 			if (reader.globalAlpha) channels.push(4);
 
 			if (compression === Compression.RawData) {
-				throw new Error(`Not implemented`);
+				throw new Error(`Compression not supported: ${compression}`);
 				// TODO: ...
 				// for (let i = 0; i < channels.length; i++) {
 				// 	readDataRaw(reader, imageData, channels[i], psd.width, psd.height);
@@ -897,7 +987,7 @@ function readImageData(reader: PsdReader, psd: Psd) {
 
 				if (RAW_IMAGE_DATA) (psd as any).imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
 			} else {
-				throw new Error(`Not implemented`);
+				throw new Error(`Compression not supported: ${compression}`);
 			}
 
 			break;
@@ -923,11 +1013,7 @@ function readImageData(reader: PsdReader, psd: Psd) {
 		}
 	}
 
-	if (reader.useImageData) {
-		psd.imageData = imageData;
-	} else {
-		psd.canvas = imageDataToCanvas(imageData);
-	}
+	return imageData;
 }
 
 function cmykToRgb(cmyk: PixelData, rgb: PixelData, reverseAlpha: boolean) {
@@ -1310,9 +1396,7 @@ export function readPattern(reader: PsdReader): PatternInfo {
 						data[dst + ch] = cdata[src];
 					}
 				}
-			}
-
-			if (colorMode === ColorMode.Grayscale && ch < 1) {
+			} 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;
@@ -1323,11 +1407,20 @@ export function readPattern(reader: PsdReader): PatternInfo {
 						data[dst + 2] = value;
 					}
 				}
-			}
-
-			if (colorMode === ColorMode.Indexed) {
-				// TODO:
-				throw new Error('Indexed pattern color mode not implemented');
+			} 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');
 			}
 		} else if (compressionMode === 1) {
 			const pixelData: PixelData = { data, width, height };

package/src/psdWriter.ts

@@ -1,4 +1,4 @@
-import { Psd, Layer, LayerAdditionalInfo, ColorMode, SectionDividerType, WriteOptions, Color, GlobalLayerMaskInfo, PixelData, LayerMaskData, Compression, ChannelID } from './psd';
+import { Psd, Layer, LayerAdditionalInfo, ColorMode, SectionDividerType, WriteOptions, Color, GlobalLayerMaskInfo, PixelData, LayerMaskData, Compression, ChannelID, PatternInfo } from './psd';
 import { hasAlpha, createCanvas, writeDataRLE, LayerChannelData, ChannelData, offsetForChannel, createImageData, fromBlendMode, clamp, LayerMaskFlags, MaskParams, ColorSpace, Bounds, largeAdditionalInfoKeys, RAW_IMAGE_DATA, writeDataZipWithoutPrediction, imageDataToCanvas } from './helpers';
 import { ExtendedWriteOptions, infoHandlers } from './additionalInfo';
 import { InternalImageResources, resourceHandlers } from './imageResources';
@@ -348,7 +348,7 @@ function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlph
 			writeUint16(writer, channels.length);
 
 			for (const c of channels) {
-				writeInt16(writer, c.channelId);
+				writeInt16(writer, c.id);
 				if (options.psb) writeUint32(writer, 0);
 				writeUint32(writer, c.length);
 			}
@@ -381,8 +381,8 @@ function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlph
 			for (const channel of layerData.channels) {
 				writeUint16(writer, channel.compression);
 
-				if (channel.buffer) {
-					writeBytes(writer, channel.buffer);
+				if (channel.data) {
+					writeBytes(writer, channel.data);
 				}
 			}
 		}
@@ -635,12 +635,31 @@ function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, la
 		compression = Compression.RleCompressed;
 	}
 
-	layerData.channels.push({ channelId: realMask ? ChannelID.RealUserMask : ChannelID.UserMask, compression, buffer, length: 2 + buffer.length });
+	layerData.channels.push({ id: realMask ? ChannelID.RealUserMask : ChannelID.UserMask, compression, data: buffer, length: 2 + buffer.length });
 
 	layerData[realMask ? 'realMask' : 'mask'] = { top, left, right, bottom };
 }
 
+function bounds(obj: { top?: number; left?: number; bottom?: number; right?: number; } | undefined) {
+	return obj ? {
+		top: obj.top || 0,
+		left: obj.left || 0,
+		right: obj.right || 0,
+		bottom: obj.bottom || 0,
+	} : undefined;
+}
+
 function getChannels(tempBuffer: Uint8Array, layer: Layer, background: boolean, options: WriteOptions): LayerChannelData {
+	if (layer.rawData) {
+		return {
+			layer,
+			channels: layer.rawData.channels.map(c => ({ ...c, length: 2 + (c.data?.byteLength ?? 0) })),
+			...bounds(layer)!,
+			mask: bounds(layer.mask),
+			realMask: bounds(layer.realMask),
+		};
+	}
+
 	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);
@@ -683,10 +702,10 @@ function getLayerChannels(tempBuffer: Uint8Array, layer: Layer, background: bool
 	let right = (layer.right as any) | 0;
 	let bottom = (layer.bottom as any) | 0;
 	let channels: ChannelData[] = [
-		{ channelId: ChannelID.Transparency, compression: Compression.RawData, buffer: undefined, length: 2 },
-		{ channelId: ChannelID.Color0, compression: Compression.RawData, buffer: undefined, length: 2 },
-		{ channelId: ChannelID.Color1, compression: Compression.RawData, buffer: undefined, length: 2 },
-		{ channelId: ChannelID.Color2, compression: Compression.RawData, buffer: undefined, length: 2 },
+		{ id: ChannelID.Transparency, compression: Compression.RawData, data: undefined, length: 2 },
+		{ id: ChannelID.Color0, compression: Compression.RawData, data: undefined, length: 2 },
+		{ id: ChannelID.Color1, compression: Compression.RawData, data: undefined, length: 2 },
+		{ id: ChannelID.Color2, compression: Compression.RawData, data: undefined, length: 2 },
 	];
 	let { width, height } = getLayerDimentions(layer);
 
@@ -699,22 +718,22 @@ function getLayerChannels(tempBuffer: Uint8Array, layer: Layer, background: bool
 	right = left + width;
 	bottom = top + height;
 
-	let data = layer.imageData || layer.canvas!.getContext('2d')!.getImageData(0, 0, width, height);
+	let imageData = layer.imageData || layer.canvas!.getContext('2d')!.getImageData(0, 0, width, height);
 
 	if (options.trimImageData) {
-		const trimmed = trimData(data);
+		const trimmed = trimData(imageData);
 
-		if (trimmed.left !== 0 || trimmed.top !== 0 || trimmed.right !== data.width || trimmed.bottom !== data.height) {
+		if (trimmed.left !== 0 || trimmed.top !== 0 || trimmed.right !== imageData.width || trimmed.bottom !== imageData.height) {
 			left += trimmed.left;
 			top += trimmed.top;
-			right -= (data.width - trimmed.right);
-			bottom -= (data.height - trimmed.bottom);
+			right -= (imageData.width - trimmed.right);
+			bottom -= (imageData.height - trimmed.bottom);
 			width = right - left;
 			height = bottom - top;
 
 			if (!width || !height) return { layer, top, left, right, bottom, channels };
 
-			data = cropImageData(data, trimmed.left, trimmed.top, width, height);
+			imageData = cropImageData(imageData, trimmed.left, trimmed.top, width, height);
 		}
 	}
 
@@ -724,28 +743,28 @@ function getLayerChannels(tempBuffer: Uint8Array, layer: Layer, background: bool
 		ChannelID.Color2,
 	];
 
-	if (!background || options.noBackground || layer.mask || hasAlpha(data) || (RAW_IMAGE_DATA && (layer as any).imageDataRaw?.['-1'])) {
+	if (!background || options.noBackground || layer.mask || hasAlpha(imageData) || (RAW_IMAGE_DATA && (layer as any).imageDataRaw?.['-1'])) {
 		channelIds.unshift(ChannelID.Transparency);
 	}
 
-	channels = channelIds.map(channelId => {
-		const offset = offsetForChannel(channelId, false); // TODO: psd.colorMode === ColorMode.CMYK);
-		let buffer: Uint8Array;
+	channels = channelIds.map(id => {
+		const offset = offsetForChannel(id, false); // TODO: psd.colorMode === ColorMode.CMYK);
+		let data: Uint8Array;
 		let compression: Compression;
 
 		if (RAW_IMAGE_DATA && (layer as any).imageDataRaw) {
 			// console.log('written raw layer image data');
-			buffer = (layer as any).imageDataRaw[channelId];
-			compression = (layer as any).imageDataRawCompression[channelId];
+			data = (layer as any).imageDataRaw[id];
+			compression = (layer as any).imageDataRawCompression[id];
 		} else if (options.compress) {
-			buffer = writeDataZipWithoutPrediction(data, [offset]);
+			data = writeDataZipWithoutPrediction(imageData, [offset]);
 			compression = Compression.ZipWithoutPrediction;
 		} else {
-			buffer = writeDataRLE(tempBuffer, data, [offset], !!options.psb)!;
+			data = writeDataRLE(tempBuffer, imageData, [offset], !!options.psb)!;
 			compression = Compression.RleCompressed;
 		}
 
-		return { channelId, compression, buffer, length: 2 + buffer.length };
+		return { id, compression, data, length: 2 + data.length };
 	});
 
 	return { layer, top, left, right, bottom, channels };
@@ -835,3 +854,78 @@ export function writeColor(writer: PsdWriter, color: Color | undefined) {
 		writeZeros(writer, 6);
 	}
 }
+
+// ponytail: only round-trips RGB 8-bit patterns; source colorMode (16-bit/Indexed) is not preserved,
+// since readPattern already converted everything to RGBA. Upgrade if pattern colorMode must survive write.
+export function writePattern(writer: PsdWriter, pattern: PatternInfo) {
+	const width = pattern.bounds.w;
+	const height = pattern.bounds.h;
+	const pixelData: PixelData = { width, height, data: pattern.data };
+
+	writeUint32(writer, 0); // length, fixed up below
+	const pattsOffset = writer.offset;
+
+	writeUint32(writer, 1); // version
+	writeUint32(writer, ColorMode.RGB); // color mode - rgb only
+
+	writeInt16(writer, pattern.x);
+	writeInt16(writer, pattern.y);
+
+	writeUnicodeString(writer, pattern.name + '\0'); // name
+	writePascalString(writer, pattern.id, 1); // id
+
+	// virtual memory array list
+	writeUint32(writer, 3); // version
+	writeUint32(writer, 0); // length, fixed up below
+	const vlOffset = writer.offset;
+
+	const top = pattern.bounds.y;
+	const left = pattern.bounds.x;
+	const bottom = top + height;
+	const right = left + width;
+
+	writeUint32(writer, top);
+	writeUint32(writer, left);
+	writeUint32(writer, bottom);
+	writeUint32(writer, right);
+
+	writeUint32(writer, 24); // channels count
+
+	// channels: RGB at indices 0,1,2 and alpha at index 25
+	for (let i = 0; i < 24 + 2; i++) {
+		const offset = i < 3 ? i : (i === 25 ? 3 : -1);
+
+		if (offset < 0) {
+			writeUint32(writer, 0); // has
+			continue;
+		}
+
+		// worst-case RLE size for a single channel: width + 1 per scanline, plus scanline length headers
+		const buffer = new Uint8Array(width * height + 2 * height + 2 * width + 16);
+		// ponytail: pattern channels always use small (2-byte) RLE scanline headers, matching
+		// readPattern which reads them as non-large; `large` here only affects the header width.
+		const data = writeDataRLE(buffer, pixelData, [offset], false)!;
+
+		writeUint32(writer, 1); // has
+		writeUint32(writer, data.length + 4 + 16 + 2 + 1); // length
+		writeUint32(writer, 8); // pixelDepth
+		writeUint32(writer, top);
+		writeUint32(writer, left);
+		writeUint32(writer, bottom);
+		writeUint32(writer, right);
+		writeUint16(writer, 8); // pixelDepth2
+		writeUint8(writer, 1); // compressionMode - rle
+		writeBytes(writer, data);
+	}
+
+	const vlLength = writer.offset - vlOffset;
+	let pattsLength = writer.offset - pattsOffset;
+
+	while (pattsLength % 4) {
+		writeZeros(writer, 1);
+		pattsLength++;
+	}
+
+	writer.view.setUint32(vlOffset - 4, vlLength, false);
+	writer.view.setUint32(pattsOffset - 4, pattsLength, false);
+}

package/tsconfig-es6.json

@@ -1,7 +1,8 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "module": "es6",
+    "module": "Node16",
+    "moduleResolution": "Node16",
 		"outDir": "dist-es"
   }
 }

package/tsconfig.json

@@ -1,17 +1,19 @@
 {
 	"compilerOptions": {
-		"moduleResolution": "node",
-		"target": "es5",
-		"module": "commonjs",
+		"moduleResolution": "node16",
+		"target": "es2016",
+		"module": "node16",
 		"lib": ["es2016", "dom"],
 		"noUnusedLocals": true,
 		"noUnusedParameters": true,
 		"preserveConstEnums": true,
 		"declaration": true,
 		"useUnknownInCatchVariables": false,
+		"types": ["node", "mocha"],
 		"strict": true,
 		"sourceMap": true,
 		"sourceRoot": "../src",
+		"rootDir": "src",
 		"outDir": "dist"
 	},
 	"include": [