ag-psd 31.0.2 → 32.0.0

package/src/psdWriter.ts

@@ -1,5 +1,5 @@
 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 { hasAlpha, createCanvas, writeDataRLE, LayerChannelData, ChannelData, offsetForChannel, createImageData, fromBlendMode, clamp, LayerMaskFlags, MaskParams, ColorSpace, Bounds, largeAdditionalInfoKeys, RAW_IMAGE_DATA, writeDataZipWithoutPrediction, imageDataToCanvas, denormalizeLabAB } from './helpers';
 import { ExtendedWriteOptions, infoHandlers } from './additionalInfo';
 import { InternalImageResources, resourceHandlers } from './imageResources';
 
@@ -153,39 +153,45 @@ export function writeUnicodeStringWithPadding(writer: PsdWriter, text: string) {
 	writeUint16(writer, 0);
 }
 
-function getLargestLayerSize(layers: Layer[] = []): number {
+// Worst-case size of writeDataRLE output for a single channel: per row the byte count (2 bytes, 4 for PSB)
+// plus PackBits data, which in the worst case is all literal runs of up to 128 bytes, each with 1 header byte.
+export function getRLEChannelBound(width: number, height: number, large: boolean) {
+	return height * ((large ? 4 : 2) + width + Math.ceil(width / 128));
+}
+
+function getLargestLayerSize(layers: Layer[] = [], large: boolean): number {
 	let max = 0;
 
 	for (const layer of layers) {
-		const { width, height } = getLayerDimentions(layer);
-		max = Math.max(max, 2 * height + 2 * width * height);
-
-		if (layer.mask) {
-			const { width, height } = getLayerDimentions(layer.mask);
-			max = Math.max(max, 2 * height + 2 * width * height);
-		}
-
-		if (layer.realMask) {
-			const { width, height } = getLayerDimentions(layer.realMask);
-			max = Math.max(max, 2 * height + 2 * width * height);
+		for (const target of [layer, layer.mask, layer.realMask]) {
+			if (target) {
+				const { width, height } = getLayerDimentions(target);
+				max = Math.max(max, getRLEChannelBound(width, height, large));
+			}
 		}
 
 		if (layer.children) {
-			max = Math.max(max, getLargestLayerSize(layer.children));
+			max = Math.max(max, getLargestLayerSize(layer.children, large));
 		}
 	}
 
 	return max;
 }
 
+export function writeUint64(writer: PsdWriter, value: number) {
+	writeUint32(writer, Math.floor(value / 0x100000000));
+	writeUint32(writer, value >>> 0);
+}
+
 export function writeSection(writer: PsdWriter, round: number, func: () => void, writeTotalLength = false, large = false) {
-	if (large) writeUint32(writer, 0);
 	const offset = writer.offset;
+	if (large) writeUint32(writer, 0);
 	writeUint32(writer, 0);
+	const start = writer.offset;
 
 	func();
 
-	let length = writer.offset - offset - 4;
+	let length = writer.offset - start;
 	let len = length;
 
 	while (len % round) {
@@ -193,32 +199,34 @@ export function writeSection(writer: PsdWriter, round: number, func: () => void,
 		len++;
 	}
 
-	// while (writer.offset % round) {
-	// 	writeUint8(writer, 0);
-	// 	len++;
-	// }
-
 	if (writeTotalLength) {
 		length = len;
 	}
 
-	writer.view.setUint32(offset, length, false);
+	if (large) {
+		writer.view.setUint32(offset, Math.floor(length / 0x100000000), false);
+		writer.view.setUint32(offset + 4, length >>> 0, false);
+	} else {
+		if (length > 0xffffffff) throw new Error('Section too large, use PSB format instead');
+		writer.view.setUint32(offset, length, false);
+	}
+}
+
+function verifyPixelData(data: PixelData | undefined, name: string) {
+	// check element size instead of instanceof, so arrays from other realms (iframes, workers, vm) are accepted
+	const bytesPerElement = data && (data.data as any).BYTES_PER_ELEMENT;
+	if (bytesPerElement !== undefined && bytesPerElement !== 1) {
+		throw new Error(`${name} has incorrect bitDepth (only 8-bit Uint8Array or Uint8ClampedArray data is supported for writing)`);
+	}
 }
 
 function verifyBitCount(target: Psd | Layer) {
 	target.children?.forEach(verifyBitCount);
 
-	const data = target.imageData;
-	if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
-		throw new Error('imageData has incorrect bitDepth');
-	}
+	verifyPixelData(target.imageData, 'imageData');
 
-	if ('mask' in target && target.mask) {
-		const data = target.mask.imageData;
-		if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
-			throw new Error('mask imageData has incorrect bitDepth');
-		}
-	}
+	if ('mask' in target) verifyPixelData(target.mask?.imageData, 'mask imageData');
+	if ('realMask' in target) verifyPixelData(target.realMask?.imageData, 'realMask imageData');
 }
 
 export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}) {
@@ -233,6 +241,10 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 	if (bitsPerChannel !== 8)
 		throw new Error('bitsPerChannel other than 8 are not supported for writing');
 
+	const layers: Layer[] = [];
+	addChildren(layers, psd.children);
+	if (!layers.length) layers.push({});
+
 	verifyBitCount(psd);
 
 	const imageResources: InternalImageResources = { ...psd.imageResources };
@@ -252,8 +264,8 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 		throw new Error('Document canvas must have the same size as document');
 
 	const globalAlpha = !!imageData && hasAlpha(imageData);
-	const maxBufferSize = Math.max(getLargestLayerSize(psd.children), 4 * 2 * psd.width * psd.height + 2 * psd.height);
-	writer.tempBuffer = new Uint8Array(maxBufferSize);
+	// only used for encoding a single layer channel at a time, composite image is encoded directly into the writer buffer
+	writer.tempBuffer = new Uint8Array(getLargestLayerSize(psd.children, !!options.psb));
 
 	// header
 	writeSignature(writer, '8BPS');
@@ -276,10 +288,6 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 		// TODO: other data?
 	});
 
-	const layers: Layer[] = [];
-	addChildren(layers, psd.children);
-	if (!layers.length) layers.push({});
-
 	// image resources
 
 	imageResources.layersGroup = layers.map(l => l.linkGroup || 0);
@@ -305,38 +313,49 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 		writeAdditionalLayerInfo(writer, psd, psd, opt);
 	}, undefined, !!opt.psb);
 
-	// image data
-	const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
-	const width = imageData ? imageData.width : psd.width;
-	const height = imageData ? imageData.height : psd.height;
-	const data: PixelData = { data: new Uint8Array(width * height * 4), width, height };
+	writer.tempBuffer = undefined;
 
+	// image data
 	writeUint16(writer, Compression.RleCompressed); // Photoshop doesn't support zip compression of composite image data
 
 	if (RAW_IMAGE_DATA && (psd as any).imageDataRaw) {
 		console.log('writing raw image data');
 		writeBytes(writer, (psd as any).imageDataRaw);
 	} else {
-		if (imageData) data.data.set(new Uint8Array(imageData.data.buffer, imageData.data.byteOffset, imageData.data.byteLength));
-
-		// add weird white matte
-		if (globalAlpha) {
-			const size = data.width * data.height * 4;
-			const p = data.data;
-			for (let i = 0; i < size; i += 4) {
-				const pa = p[i + 3];
-				if (pa != 0 && pa != 255) {
-					const a = pa / 255;
-					const ra = 255 * (1 - a);
-					p[i + 0] = p[i + 0] * a + ra;
-					p[i + 1] = p[i + 1] * a + ra;
-					p[i + 2] = p[i + 2] * a + ra;
-				}
+		const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
+		const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
+
+		// encode directly into the writer buffer
+		const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
+		ensureSize(writer, writer.offset + maxSize);
+		const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
+		writer.offset += writeDataRLE(buffer, data, channels, !!options.psb).length;
+	}
+}
+
+function getCompositeData(imageData: PixelData | undefined, width: number, height: number, globalAlpha: boolean): PixelData {
+	if (!imageData) return { data: new Uint8Array(width * height * 4), width, height };
+
+	const size = width * height * 4;
+	const src = imageData.data;
+	let dst: Uint8Array | undefined = undefined;
+
+	// add weird white matte (copy the data only if there are semi-transparent pixels)
+	if (globalAlpha) {
+		for (let i = 0; i < size; i += 4) {
+			const pa = src[i + 3];
+			if (pa != 0 && pa != 255) {
+				if (!dst) dst = new Uint8Array(src.buffer, src.byteOffset, size).slice();
+				const a = pa / 255;
+				const ra = 255 * (1 - a);
+				dst[i + 0] = src[i + 0] * a + ra;
+				dst[i + 1] = src[i + 1] * a + ra;
+				dst[i + 2] = src[i + 2] * a + ra;
 			}
 		}
-
-		writeBytes(writer, writeDataRLE(writer.tempBuffer, data, channels, !!options.psb));
 	}
+
+	return dst ? { data: dst, width, height } : imageData;
 }
 
 function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlpha: boolean, options: ExtendedWriteOptions) {
@@ -357,8 +376,11 @@ function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlph
 
 			for (const c of channels) {
 				writeInt16(writer, c.id);
-				if (options.psb) writeUint32(writer, 0);
-				writeUint32(writer, c.length);
+				if (options.psb) {
+					writeUint64(writer, c.length);
+				} else {
+					writeUint32(writer, c.length);
+				}
 			}
 
 			writeSignature(writer, '8BIM');
@@ -398,7 +420,7 @@ function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlph
 }
 
 function writeLayerMaskData(writer: PsdWriter, { mask, realMask }: Layer, layerData: LayerChannelData) {
-	writeSection(writer, 1, () => {
+	writeSection(writer, 4, () => {
 		if (!mask && !realMask) return;
 
 		let params = 0, flags = 0, realFlags = 0;
@@ -444,9 +466,7 @@ function writeLayerMaskData(writer: PsdWriter, { mask, realMask }: Layer, layerD
 			if (mask.vectorMaskDensity !== undefined) writeUint8(writer, Math.round(mask.vectorMaskDensity * 0xff));
 			if (mask.vectorMaskFeather !== undefined) writeFloat64(writer, mask.vectorMaskFeather);
 		}
-
-		writeZeros(writer, 2);
-	});
+	}, true); // photoshop pads mask data to multiple of 4 bytes and includes padding in the length
 }
 
 function writerBlendingRange(writer: PsdWriter, range: number[]) {
@@ -480,7 +500,7 @@ function writeGlobalLayerMaskInfo(writer: PsdWriter, info: GlobalLayerMaskInfo |
 			writeUint16(writer, info.colorSpace2);
 			writeUint16(writer, info.colorSpace3);
 			writeUint16(writer, info.colorSpace4);
-			writeUint16(writer, Math.round(info.opacity * 0xff));
+			writeUint16(writer, Math.round(clamp(info.opacity, 0, 1) * 100)); // 0-100
 			writeUint8(writer, info.kind);
 			writeZeros(writer, 3);
 		}
@@ -497,7 +517,7 @@ function writeAdditionalLayerInfo(writer: PsdWriter, target: LayerAdditionalInfo
 		if (handler.has(target)) {
 			const large = options.psb && largeAdditionalInfoKeys.indexOf(key) !== -1;
 			const writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn' && key !== 'CAI ' && key !== 'OCIO';
-			const fourBytes = key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
+			const fourBytes = key === 'levl' || key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
 				key === 'vogk' || key === 'SoLd' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
 				key === 'lmfx' || key === 'lrFX' || key === 'cinf' || key === 'PlLd' || key === 'Anno' || key === 'CAI ' || key === 'OCIO' || key === 'GenI' || key === 'FEid' || key === 'curv' || key === 'CgEd' || key === 'vibA' || key === 'blwh' || key === 'grdm';
 
@@ -555,11 +575,8 @@ function addChildren(layers: Layer[], children: Layer[] | undefined) {
 }
 
 function resizeBuffer(writer: PsdWriter, size: number) {
-	let newLength = writer.buffer.byteLength;
-
-	do {
-		newLength *= 2;
-	} while (size > newLength);
+	// grow at least 2x to keep small writes fast, but don't overshoot large reservations (like composite image data)
+	const newLength = Math.max(writer.buffer.byteLength * 2, size);
 
 	const newBuffer = new ArrayBuffer(newLength);
 	const newBytes = new Uint8Array(newBuffer);
@@ -587,11 +604,11 @@ function createThumbnail(psd: Psd) {
 
 	if (psd.width > psd.height) {
 		canvas.width = 160;
-		canvas.height = Math.floor(psd.height * (canvas.width / psd.width));
+		canvas.height = Math.max(1, Math.floor(psd.height * (canvas.width / psd.width)));
 		scale = canvas.width / psd.width;
 	} else {
 		canvas.height = 160;
-		canvas.width = Math.floor(psd.width * (canvas.height / psd.height));
+		canvas.width = Math.max(1, Math.floor(psd.width * (canvas.height / psd.height)));
 		scale = canvas.height / psd.height;
 	}
 
@@ -639,7 +656,7 @@ function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, la
 		buffer = writeDataZipWithoutPrediction(imageData, [0]);
 		compression = Compression.ZipWithoutPrediction;
 	} else {
-		buffer = writeDataRLE(tempBuffer, imageData, [0], !!options.psb)!;
+		buffer = writeDataRLE(tempBuffer, imageData, [0], !!options.psb).slice(); // copy, temp buffer is reused
 		compression = Compression.RleCompressed;
 	}
 
@@ -768,7 +785,7 @@ function getLayerChannels(tempBuffer: Uint8Array, layer: Layer, background: bool
 			data = writeDataZipWithoutPrediction(imageData, [offset]);
 			compression = Compression.ZipWithoutPrediction;
 		} else {
-			data = writeDataRLE(tempBuffer, imageData, [offset], !!options.psb)!;
+			data = writeDataRLE(tempBuffer, imageData, [offset], !!options.psb).slice(); // copy, temp buffer is reused
 			compression = Compression.RleCompressed;
 		}
 
@@ -841,8 +858,8 @@ export function writeColor(writer: PsdWriter, color: Color | undefined) {
 	} else if ('l' in color) {
 		writeUint16(writer, ColorSpace.Lab);
 		writeInt16(writer, Math.round(color.l * 10000));
-		writeInt16(writer, Math.round(color.a < 0 ? (color.a * 12800) : (color.a * 12700)));
-		writeInt16(writer, Math.round(color.b < 0 ? (color.b * 12800) : (color.b * 12700)));
+		writeInt16(writer, Math.round(denormalizeLabAB(color.a, 100)));
+		writeInt16(writer, Math.round(denormalizeLabAB(color.b, 100)));
 		writeUint16(writer, 0);
 	} else if ('h' in color) {
 		writeUint16(writer, ColorSpace.HSB);
@@ -899,6 +916,10 @@ export function writePattern(writer: PsdWriter, pattern: PatternInfo) {
 
 	writeUint32(writer, 24); // channels count
 
+	// ponytail: pattern channels always use small (2-byte) RLE scanline headers, matching
+	// readPattern which reads them as non-large
+	const buffer = new Uint8Array(getRLEChannelBound(width, height, false));
+
 	// 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);
@@ -908,11 +929,7 @@ export function writePattern(writer: PsdWriter, pattern: PatternInfo) {
 			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)!;
+		const data = writeDataRLE(buffer, pixelData, [offset], false);
 
 		writeUint32(writer, 1); // has
 		writeUint32(writer, data.length + 4 + 16 + 2 + 1); // length

package/src/text.ts

@@ -1,4 +1,5 @@
 import type { TextStyle, LayerTextData, ParagraphStyle, Font, AntiAlias, TextGridInfo, Justification, Color, TextPath } from './psd';
+import { clamp } from './helpers';
 
 interface Adjustments {
 	Axis: number[];
@@ -300,13 +301,43 @@ function decodeColor(color: TypeValues): Color {
 	}
 }
 
+// h, s, b in 0..1 range, returns r, g, b in 0..1 range
+function hsbToRgb(h: number, s: number, v: number): [number, number, number] {
+	h = clamp(h || 0, 0, 1);
+	s = clamp(s || 0, 0, 1);
+	v = clamp(v || 0, 0, 1);
+
+	const h6 = (h * 6) % 6;
+	const i = Math.floor(h6);
+	const f = h6 - i;
+	const p = v * (1 - s);
+	const q = v * (1 - s * f);
+	const t = v * (1 - s * (1 - f));
+
+	switch (i) {
+		case 0: return [v, t, p];
+		case 1: return [q, v, p];
+		case 2: return [p, v, t];
+		case 3: return [p, q, v];
+		case 4: return [t, p, v];
+		default: return [v, p, q];
+	}
+}
+
 function encodeColor(color: Color | undefined): TypeValues {
 	if (!color) {
 		return { Type: 1, Values: [0, 0, 0, 0] };
 	} else if ('r' in color) {
 		return { Type: 1, Values: ['a' in color ? color.a / 255 : 1, color.r / 255, color.g / 255, color.b / 255] };
+	} else if ('fr' in color) {
+		return { Type: 1, Values: [1, clamp(color.fr || 0, 0, 1), clamp(color.fg || 0, 0, 1), clamp(color.fb || 0, 0, 1)] };
+	} else if ('h' in color) {
+		const [r, g, b] = hsbToRgb(color.h, color.s, color.b);
+		return { Type: 1, Values: [1, r, g, b] };
 	} else if ('c' in color) {
 		return { Type: 2, Values: [1, color.c / 255, color.m / 255, color.y / 255, color.k / 255] };
+	} else if ('l' in color) {
+		throw new Error('LAB colors are not supported in text layers, use RGB, CMYK or grayscale color instead');
 	} else if ('k' in color) {
 		return { Type: 0, Values: [1, color.k / 255] };
 	} else {
@@ -346,9 +377,10 @@ function decodeObject(obj: any, keys: string[], fonts: Font[]) {
 		if (obj[Key] === undefined) continue;
 
 		if (key === 'justification') {
-			result[key] = justification[obj[Key]];
+			result[key] = justification[obj[Key]] ?? 'left';
 		} else if (key === 'font') {
-			result[key] = fonts[obj[Key]];
+			const font = fonts[obj[Key]];
+			if (font) result[key] = font; // invalid font index, leave the font unset so it falls back to default
 		} else if (key === 'fillColor' || key === 'strokeColor') {
 			result[key] = decodeColor(obj[Key]);
 		} else {
@@ -368,7 +400,7 @@ function encodeObject(obj: any, keys: string[], fonts: Font[]) {
 		if (obj[key] === undefined) continue;
 
 		if (key === 'justification') {
-			result[Key] = justification.indexOf(obj[key] ?? 'left');
+			result[Key] = Math.max(0, justification.indexOf(obj[key] ?? 'left')); // default to 'left' for unknown values
 		} else if (key === 'font') {
 			result[Key] = findOrAddFont(fonts, obj[key]);
 		} else if (key === 'fillColor' || key === 'strokeColor') {
@@ -443,6 +475,39 @@ function deduplicateValues<T>(base: T, runs: { style: T; }[], keys: (keyof T)[])
 	}
 }
 
+function isDefaultGridColor(color: Color | undefined) {
+	// Photoshop writes default grid colors as blue with 0 alpha, ignore alpha when comparing
+	return !!color && 'r' in color && color.r === 0 && color.g === 0 && color.b === 255;
+}
+
+function decodeGridColor(color: TypeValues | undefined, defaultColor: Color): Color {
+	try {
+		return color ? decodeColor(color) : defaultColor;
+	} catch {
+		return defaultColor; // don't fail whole text layer because of invalid grid color
+	}
+}
+
+function decodeGridInfo(grid: EngineData['EngineDict']['GridInfo'] | undefined): TextGridInfo | undefined {
+	if (!grid || typeof grid !== 'object') return undefined;
+
+	const result: TextGridInfo = {
+		isOn: !!grid.GridIsOn,
+		show: !!grid.ShowGrid,
+		size: grid.GridSize ?? defaultGridInfo.size,
+		leading: grid.GridLeading ?? defaultGridInfo.leading,
+		color: decodeGridColor(grid.GridColor, defaultGridInfo.color!),
+		leadingFillColor: decodeGridColor(grid.GridLeadingFillColor, defaultGridInfo.leadingFillColor!),
+		alignLineHeightToGridFlags: !!grid.AlignLineHeightToGridFlags,
+	};
+
+	const isDefault = !result.isOn && !result.show && result.size === defaultGridInfo.size &&
+		result.leading === defaultGridInfo.leading && !result.alignLineHeightToGridFlags &&
+		isDefaultGridColor(result.color) && isDefaultGridColor(result.leadingFillColor);
+
+	return isDefault ? undefined : result;
+}
+
 export function decodeEngineData(engineData: EngineData) {
 	// console.log('engineData', require('util').inspect(engineData, false, 99, true));
 	const engineDict = engineData.EngineDict;
@@ -458,9 +523,11 @@ export function decodeEngineData(engineData: EngineData) {
 	let text = engineDict.Editor.Text.replace(/\r/g, '\n');
 	let removedCharacters = 0;
 
-	while (/\n$/.test(text)) {
+	// Photoshop always appends exactly one trailing \r (and encoder adds one back), any additional
+	// trailing new lines are empty paragraphs that are part of the text
+	if (/\n$/.test(text)) {
 		text = text.substring(0, text.length - 1);
-		removedCharacters++;
+		removedCharacters = 1;
 	}
 
 	const result: LayerTextData = {
@@ -484,6 +551,11 @@ export function decodeEngineData(engineData: EngineData) {
 		if (photoshop.BoxBounds) result.boxBounds = photoshop.BoxBounds;
 	}
 
+	// grid info (only included when it differs from defaults, to avoid noise in common case)
+
+	const gridInfo = decodeGridInfo(engineDict.GridInfo);
+	if (gridInfo) result.gridInfo = gridInfo;
+
 	// paragraph style
 
 	// const theNormalParagraphSheet = resourceDict.TheNormalParagraphSheet;
@@ -522,13 +594,18 @@ export function decodeEngineData(engineData: EngineData) {
 	// const styleSheetData = styleSheetSet[theNormalStyleSheet].StyleSheetData;
 	const styleRun = engineDict.StyleRun;
 
+	// style runs without a font use the font of the normal style sheet
+	const normalStyleSheet = resourceDict.StyleSheetSet?.[resourceDict.TheNormalStyleSheet ?? 0]?.StyleSheetData;
+	const normalFontIndex = normalStyleSheet?.Font;
+	const normalFont = (normalFontIndex !== undefined ? fonts[normalFontIndex] : undefined) ?? fonts[0];
+
 	result.style = {}; // decodeStyle(styleSheetData, fonts);
 	result.styleRuns = [];
 
 	for (let i = 0; i < styleRun.RunArray.length; i++) {
 		const length = styleRun.RunLengthArray[i];
 		const style = decodeStyle(styleRun.RunArray[i].StyleSheet.StyleSheetData, fonts);
-		if (!style.font) style.font = fonts[0];
+		if (!style.font && normalFont) style.font = normalFont;
 		result.styleRuns.push({ length, style });
 	}
 
@@ -545,8 +622,38 @@ export function decodeEngineData(engineData: EngineData) {
 	return result;
 }
 
+// Adjusts run lengths (specified in terms of the original text) for characters removed from the text
+// (\r characters of \r\n pairs that are collapsed into single \r)
+function adjustRunLengths<T extends { length: number; }>(runs: T[] | undefined, removed: number[]): T[] | undefined {
+	if (!runs || !removed.length) return runs;
+
+	let start = 0;
+	let removedIndex = 0;
+
+	return runs.map(run => {
+		const length = Math.max(0, run.length || 0);
+		const end = start + length;
+		let count = 0;
+
+		while (removedIndex < removed.length && removed[removedIndex] < end) {
+			if (removed[removedIndex] >= start) count++;
+			removedIndex++;
+		}
+
+		start = end;
+		return { ...run, length: length - count };
+	});
+}
+
 export function encodeEngineData(data: LayerTextData) {
-	const text = `${(data.text || '').replace(/\r?\n/g, '\r')}\r`;
+	const sourceText = data.text || '';
+	const removedIndices: number[] = []; // indices of \r characters removed from \r\n pairs
+
+	for (let i = 0; i < sourceText.length - 1; i++) {
+		if (sourceText.charCodeAt(i) === 13 && sourceText.charCodeAt(i + 1) === 10) removedIndices.push(i);
+	}
+
+	const text = `${sourceText.replace(/\r?\n/g, '\r')}\r`;
 
 	const fonts: Font[] = [
 		{ name: 'AdobeInvisFont', script: 0, type: 0, synthetic: 0 },
@@ -555,7 +662,7 @@ export function encodeEngineData(data: LayerTextData) {
 	const defFont = data.style?.font || data.styleRuns?.find(s => s.style.font)?.style.font || defaultFont;
 	const paragraphRunArray: ParagraphRun[] = [];
 	const paragraphRunLengthArray: number[] = [];
-	const paragraphRuns = data.paragraphStyleRuns;
+	const paragraphRuns = adjustRunLengths(data.paragraphStyleRuns, removedIndices);
 
 	if (paragraphRuns && paragraphRuns.length) {
 		let leftLength = text.length;
@@ -609,7 +716,9 @@ export function encodeEngineData(data: LayerTextData) {
 	}
 
 	const styleSheetData = encodeStyle({ ...defaultStyle, font: defFont }, fonts);
-	const styleRuns = data.styleRuns || [{ length: text.length, style: data.style || {} }];
+	const styleRuns = data.styleRuns?.length ?
+		adjustRunLengths(data.styleRuns, removedIndices)! :
+		[{ length: text.length, style: data.style || {} }];
 	const styleRunArray: StyleRun[] = [];
 	const styleRunLengthArray: number[] = [];
 
@@ -642,7 +751,7 @@ export function encodeEngineData(data: LayerTextData) {
 	}
 
 	// add extra run to the end if existing ones didn't fill it up
-	if (leftLength && styleRuns.length) {
+	if (leftLength) {
 		styleRunLengthArray.push(leftLength);
 		styleRunArray.push({
 			StyleSheet: {
@@ -657,6 +766,7 @@ export function encodeEngineData(data: LayerTextData) {
 	}
 
 	const gridInfo = { ...defaultGridInfo, ...data.gridInfo };
+	const antiAliasIndex = antialias.indexOf(data.antiAlias ?? 'sharp');
 	const WritingDirection = data.orientation === 'vertical' ? 2 : 0;
 	const Procession = data.orientation === 'vertical' ? 1 : 0;
 	const ShapeType = data.shapeType === 'box' ? 1 : 0;
@@ -753,10 +863,10 @@ export function encodeEngineData(data: LayerTextData) {
 				GridSize: gridInfo.size ?? 18,
 				GridLeading: gridInfo.leading ?? 22,
 				GridColor: encodeColor(gridInfo.color),
-				GridLeadingFillColor: encodeColor(gridInfo.color),
+				GridLeadingFillColor: encodeColor(gridInfo.leadingFillColor),
 				AlignLineHeightToGridFlags: !!gridInfo.alignLineHeightToGridFlags,
 			},
-			AntiAlias: antialias.indexOf(data.antiAlias ?? 'sharp'),
+			AntiAlias: antiAliasIndex === -1 ? antialias.indexOf('sharp') : antiAliasIndex,
 			UseFractionalGlyphWidths: data.useFractionalGlyphWidths ?? true,
 			Rendered: {
 				Version: 1,

package/src/utf8.ts

@@ -10,36 +10,48 @@ function charLengthInBytes(code: number): number {
 	}
 }
 
-// Reads a scalar value at index `i`, replacing unpaired surrogates with U+FFFD,
+// Returns scalar value at index `i` (combining surrogate pairs), replacing unpaired surrogates with U+FFFD,
 // matching how TextEncoder converts a string to a sequence of Unicode scalar values.
-function codePointAt(value: string, i: number): { code: number; size: number } {
+// Values above 0xffff always take 2 UTF-16 code units.
+function codePointAt(value: string, i: number): number {
 	const code = value.charCodeAt(i);
 
+	if (code < 0xd800 || code > 0xdfff) return code;
+
 	// high surrogate
-	if (code >= 0xd800 && code <= 0xdbff && (i + 1) < value.length) {
+	if (code <= 0xdbff && (i + 1) < value.length) {
 		const extra = value.charCodeAt(i + 1);
 
 		// low surrogate
 		if (extra >= 0xdc00 && extra <= 0xdfff) {
-			return { code: ((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000, size: 2 };
+			return ((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
 		}
 	}
 
 	// unpaired surrogate (lone high or lone low)
-	if (code >= 0xd800 && code <= 0xdfff) {
-		return { code: 0xfffd, size: 1 };
-	}
-
-	return { code, size: 1 };
+	return 0xfffd;
 }
 
 export function stringLengthInBytes(value: string): number {
 	let result = 0;
 
-	for (let i = 0; i < value.length;) {
-		const { code, size } = codePointAt(value, i);
-		result += charLengthInBytes(code);
-		i += size;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+
+		if (code < 0x80) {
+			result += 1;
+		} else if (code < 0x800) {
+			result += 2;
+		} else {
+			const scalar = codePointAt(value, i);
+
+			if (scalar > 0xffff) {
+				result += 4;
+				i++;
+			} else {
+				result += 3;
+			}
+		}
 	}
 
 	return result;
@@ -73,10 +85,16 @@ function writeCharacter(buffer: Uint8Array | Buffer, offset: number, code: numbe
 }
 
 export function encodeStringTo(buffer: Uint8Array | Buffer, offset: number, value: string): number {
-	for (let i = 0; i < value.length;) {
-		const { code, size } = codePointAt(value, i);
-		offset += writeCharacter(buffer, offset, code);
-		i += size;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+
+		if (code < 0x80) {
+			buffer[offset++] = code;
+		} else {
+			const scalar = codePointAt(value, i);
+			if (scalar > 0xffff) i++;
+			offset += writeCharacter(buffer, offset, scalar);
+		}
 	}
 
 	return offset;