ag-psd 31.0.3 → 32.0.0

package/src/helpers.ts

@@ -1,6 +1,7 @@
 import { deflate as deflateSync } from 'pako';
 import { Layer, BlendMode, LayerColor, PixelData, PixelArray, ChannelID, Compression } from './psd';
 import { decodeJpeg } from './jpeg';
+import { PsdReader } from './psdReader';
 
 export const MOCK_HANDLERS = false;
 export const RAW_IMAGE_DATA = false;
@@ -146,6 +147,15 @@ export function offsetForChannel(channelId: ChannelID, cmyk: boolean) {
 	}
 }
 
+// Lab a/b components are stored in -128..127 range (multiplied by scale), normalized values are in -1..1 range
+export function normalizeLabAB(value: number, scale = 1) {
+	return value < 0 ? (value / (128 * scale)) : (value / (127 * scale));
+}
+
+export function denormalizeLabAB(value: number, scale = 1) {
+	return value < 0 ? (value * (128 * scale)) : (value * (127 * scale));
+}
+
 export function clamp(value: number, min: number, max: number) {
 	return value < min ? min : (value > max ? max : value);
 }
@@ -236,8 +246,9 @@ export function writeDataRaw(data: PixelData, offset: number, width: number, hei
 	return array;
 }
 
+// returns view into the buffer, the buffer has to fit worst case size (see getRLEChannelBound), throws if it doesn't
 export function writeDataRLE(buffer: Uint8Array, { data, width, height }: PixelData, offsets: number[], large: boolean) {
-	if (!width || !height) return undefined;
+	if (!width || !height) return buffer.subarray(0, 0);
 
 	const stride = (4 * width) | 0;
 
@@ -320,6 +331,9 @@ export function writeDataRLE(buffer: Uint8Array, { data, width, height }: PixelD
 				}
 			}
 
+			// writes past the end of typed array are ignored, so it's enough to check the size after each row
+			if (o > buffer.length) throw new Error(`RLE buffer too small (${buffer.length})`);
+
 			const length = o - startOffset;
 
 			if (large) {
@@ -332,7 +346,8 @@ export function writeDataRLE(buffer: Uint8Array, { data, width, height }: PixelD
 		}
 	}
 
-	return buffer.slice(0, o);
+	// returns view of the buffer, copy the data if the buffer is going to be reused
+	return buffer.subarray(0, o);
 }
 
 export function writeDataZipWithoutPrediction({ data, width, height }: PixelData, offsets: number[]) {
@@ -366,7 +381,7 @@ export function writeDataZipWithoutPrediction({ data, width, height }: PixelData
 	}
 }
 
-export function createCanvasFromData(data: Uint8Array): HTMLCanvasElement {
+export function createCanvasFromData(data: Uint8Array, reader: Pick<PsdReader, 'log'>): HTMLCanvasElement {
 	const canvas = createCanvas(100, 100);
 
 	try {
@@ -376,7 +391,7 @@ export function createCanvasFromData(data: Uint8Array): HTMLCanvasElement {
 		canvas.height = imageData.height;
 		context.putImageData(imageData, 0, 0);
 	} catch (e: any) {
-		console.error('JPEG decompression error', e.message);
+		reader.log('JPEG decompression error', e.message);
 	}
 
 	return canvas;

package/src/imageResources.ts

@@ -4,7 +4,7 @@ import { PsdReader, readUnicodeString, readUint32, readUint16, readUint8, readFl
 import { PsdWriter, writeUnicodeString, writeUint32, writeUint8, writeFloat64, writeUint16, writeBytes, writeInt16, writeFloat32, writeFixedPoint32, writeUnicodeStringWithPadding, writeColor, writeSignature, writeSection, writeInt32, writeAsciiString, } from './psdWriter';
 import { createCanvasFromData, createEnum, MOCK_HANDLERS } from './helpers';
 import { decodeString, encodeString } from './utf8';
-import { ESliceBGColorType, ESliceHorzAlign, ESliceOrigin, ESliceType, ESliceVertAlign, frac, FractionDescriptor, parseTrackList, readVersionAndDescriptor, serializeTrackList, TimelineTrackDescriptor, TimeScopeDescriptor, writeVersionAndDescriptor } from './descriptor';
+import { ESliceBGColorType, ESliceHorzAlign, ESliceOrigin, ESliceType, ESliceVertAlign, frac, FractionDescriptor, parseTrackList, pathSelectionStateToReference, readVersionAndDescriptor, serializeTrackList, TimelineTrackDescriptor, TimeScopeDescriptor, writeVersionAndDescriptor } from './descriptor';
 
 export interface InternalImageResources extends ImageResources {
 	layersGroup?: number[];
@@ -57,6 +57,20 @@ function writeUtf8String(writer: PsdWriter, value: string) {
 	writeBytes(writer, buffer);
 }
 
+let gbkDecoder: TextDecoder | null | undefined;
+
+function getGbkDecoder() {
+	if (gbkDecoder === undefined) {
+		try {
+			gbkDecoder = new TextDecoder('gbk');
+		} catch {
+			gbkDecoder = null;
+		}
+	}
+
+	return gbkDecoder;
+}
+
 function readEncodedString(reader: PsdReader) {
 	const length = readUint8(reader);
 	const buffer = readBytes(reader, length);
@@ -70,10 +84,13 @@ function readEncodedString(reader: PsdReader) {
 	}
 
 	if (notAscii) {
-		try {
-			const decoder = new TextDecoder('gbk');
-			return decoder.decode(buffer)
-		} catch { }
+		const decoder = getGbkDecoder();
+
+		if (decoder) {
+			try {
+				return decoder.decode(buffer);
+			} catch { }
+		}
 	}
 
 	return decodeString(buffer);
@@ -82,10 +99,15 @@ function readEncodedString(reader: PsdReader) {
 function writeEncodedString(writer: PsdWriter, value: string) {
 	let ascii = '';
 
-	for (let i = 0, code = value.codePointAt(i++); code !== undefined; code = value.codePointAt(i++)) {
-		ascii += code > 0x7f ? '?' : String.fromCodePoint(code);
+	for (let i = 0; i < value.length;) {
+		const code = value.codePointAt(i)!;
+		ascii += code > 0x7f ? '?' : String.fromCharCode(code);
+		i += code > 0xffff ? 2 : 1; // skip low surrogate of astral characters
 	}
 
+	// length is stored in a single byte
+	if (ascii.length > 255) ascii = ascii.substring(0, 255);
+
 	const buffer = encodeString(ascii);
 	writeUint8(writer, buffer.byteLength);
 	writeBytes(writer, buffer);
@@ -616,7 +638,7 @@ addHandler(
 
 		for (let i = 0; i < count; i++) {
 			target.gridAndGuidesInformation.guides!.push({
-				location: readUint32(reader) / 32,
+				location: readInt32(reader) / 32,
 				direction: readUint8(reader) ? 'horizontal' : 'vertical'
 			});
 		}
@@ -627,12 +649,12 @@ addHandler(
 		const guides = info.guides || [];
 
 		writeUint32(writer, 1);
-		writeUint32(writer, grid.horizontal);
-		writeUint32(writer, grid.vertical);
+		writeUint32(writer, Math.round(grid.horizontal));
+		writeUint32(writer, Math.round(grid.vertical));
 		writeUint32(writer, guides.length);
 
 		for (const g of guides) {
-			writeUint32(writer, g.location * 32);
+			writeInt32(writer, Math.round(g.location * 32));
 			writeUint8(writer, g.direction === 'horizontal' ? 1 : 0);
 		}
 	},
@@ -665,10 +687,10 @@ addHandler(
 				capturedInfo: item.capturedInfo,
 			});
 
-			if ('comment' in item) target.layerComps.list[target.layerComps.list.length - 1].comment = item.comment;
+			if (item.comment !== undefined) target.layerComps.list[target.layerComps.list.length - 1].comment = item.comment;
 		}
 
-		if ('lastAppliedComp' in desc) target.layerComps.lastApplied = desc.lastAppliedComp;
+		if (desc.lastAppliedComp !== undefined) target.layerComps.lastApplied = desc.lastAppliedComp;
 	},
 	(writer, target) => {
 		const layerComps = target.layerComps!;
@@ -678,13 +700,13 @@ addHandler(
 			const t: LayerCompsDescriptor['list'][0] = {} as any;
 			t._classID = 'Comp';
 			t['Nm  '] = item.name;
-			if ('comment' in item) t.comment = item.comment;
+			if (item.comment !== undefined) t.comment = item.comment;
 			t.compID = item.id;
 			t.capturedInfo = item.capturedInfo;
 			desc.list.push(t);
 		}
 
-		if ('lastApplied' in layerComps) desc.lastAppliedComp = layerComps.lastApplied;
+		if (layerComps.lastApplied !== undefined) desc.lastAppliedComp = layerComps.lastApplied;
 
 		// console.log('CompList', require('util').inspect(desc, false, 99, true));
 		writeVersionAndDescriptor(writer, '', 'CompList', desc);
@@ -747,8 +769,8 @@ addHandler(
 			numBefore: onionSkins.framesBefore,
 			numAfter: onionSkins.framesAfter,
 			Spcn: onionSkins.frameSpacing,
-			minOpacity: (onionSkins.minOpacity * 100) | 0,
-			maxOpacity: (onionSkins.maxOpacity * 100) | 0,
+			minOpacity: Math.round(onionSkins.minOpacity * 100),
+			maxOpacity: Math.round(onionSkins.maxOpacity * 100),
 			BlnM: Math.max(0, onionSkinsBlendModes.indexOf(onionSkins.blendMode)),
 		};
 
@@ -855,7 +877,7 @@ addHandler(
 			LCnt: timeline.repeats,
 			globalTrackList: serializeTrackList(timeline.globalTracks),
 			audioClipGroupList: {
-				audioClipGroupList: timeline.audioClipGroups?.map(a => ({
+				audioClipGroupList: (timeline.audioClipGroups ?? []).map(a => ({
 					groupID: a.id,
 					muted: a.muted,
 					audioClipList: a.audioClips.map<TimelineAudioClipDescriptor>(c => ({
@@ -1072,8 +1094,13 @@ addHandler(
 			}
 			if (leftBytes()) {
 				const desc = readVersionAndDescriptor(reader) as SlicesDesc;
+				const slicesById = new Map<number, typeof slices[0]>();
+				for (const s of slices) {
+					if (!slicesById.has(s.id)) slicesById.set(s.id, s);
+				}
+
 				desc.slices.forEach(d => {
-					const slice = slices.find(s => d.sliceID == s.id);
+					const slice = slicesById.get(d.sliceID);
 					if (slice) {
 						slice.topOutset = d.topOutset;
 						slice.leftOutset = d.leftOutset;
@@ -1272,7 +1299,7 @@ addHandler(
 		if (reader.useRawThumbnail) {
 			target.thumbnailRaw = { width, height, data };
 		} else if (data.byteLength) {
-			target.thumbnail = createCanvasFromData(data);
+			target.thumbnail = createCanvasFromData(data, reader);
 		}
 	},
 	(writer, target) => {
@@ -1386,7 +1413,7 @@ addHandler(
 		target.pathSelectionState = desc['null'];
 	},
 	(writer, target) => {
-		const desc: Descriptor1088 = { 'null': target.pathSelectionState! };
+		const desc: Descriptor1088 = { 'null': pathSelectionStateToReference(target.pathSelectionState!) };
 		writeVersionAndDescriptor(writer, '', 'null', desc);
 	},
 );
@@ -1498,7 +1525,7 @@ addHandler(
 						const frame: AnimationFrameDescriptor = {
 							FrID: f.id,
 						} as any;
-						if (f.delay) frame.FrDl = (f.delay * 100) | 0;
+						if (f.delay) frame.FrDl = Math.round(f.delay * 100);
 						frame.FrDs = FrmD.encode(f.dispose);
 						// if (i === 0) frame.FrGA = 30; // ???
 						desc.FrIn.push(frame);

package/src/index.ts

@@ -43,5 +43,6 @@ export function writePsdBuffer(psd: Psd, options?: WriteOptions): Buffer {
 		throw new Error('Buffer not supported on this platform');
 	}
 
+	// copy, so the buffer doesn't hold on to the unused part of the writer's buffer
 	return Buffer.from(writePsdUint8Array(psd, options));
 }

package/src/jpeg.ts

@@ -88,6 +88,8 @@ const maxMemoryUsageBytes = 64 * 1024 * 1024; // Don't decode if memory footprin
 let totalBytesAllocated = 0; // avoid unexpected OOMs from untrusted content.
 
 function requestMemoryAllocation(increaseAmount: number) {
+  if (!isFinite(increaseAmount) || increaseAmount < 0) throw new Error(`Invalid memory allocation size (${increaseAmount})`);
+
   const totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
   if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
     const exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
@@ -169,7 +171,9 @@ function decodeScan(
     return bitsData >>> 7;
   }
 
-  function decodeHuffman(tree: number[] | number[][]) {
+  function decodeHuffman(tree: number[] | number[][] | undefined) {
+    if (!tree) throw new Error('Missing Huffman table');
+
     let node: number | number[] | number[][] = tree;
 
     while (true) {
@@ -359,6 +363,8 @@ function decodeScan(
     mcuExpected = mcusPerLine * frame.mcusPerColumn;
   }
 
+  if (!isFinite(mcuExpected) || mcuExpected < 0) throw new Error('Invalid number of MCUs');
+
   if (!resetInterval) resetInterval = mcuExpected;
 
   let h: number;
@@ -375,6 +381,9 @@ function decodeScan(
       for (let n = 0; n < resetInterval; n++) {
         decodeBlock(component, decodeFn, mcu);
         mcu++;
+
+        // If we've reached our expected MCU's, stop decoding
+        if (mcu === mcuExpected) break;
       }
     } else {
       for (let n = 0; n < resetInterval; n++) {
@@ -438,7 +447,8 @@ function buildComponentData(component: Component) {
   //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
   //   988-991.
   function quantizeAndInverse(zz: Int32Array, dataOut: Uint8Array, dataIn: Int32Array) {
-    const qt = component.quantizationTable!;
+    const qt = component.quantizationTable;
+    if (!qt) throw new Error('Missing quantization table');
     const p = dataIn;
 
     // dequant
@@ -823,11 +833,13 @@ function parse(data: Uint8Array) {
         }
 
         const componentsCount = data[offset++];
+        if (!componentsCount) throw new Error('SOF: no components in frame');
 
         for (let i = 0; i < componentsCount; i++) {
           const componentId = data[offset];
           const h = data[offset + 1] >> 4;
           const v = data[offset + 1] & 15;
+          if (h < 1 || h > 4 || v < 1 || v > 4) throw new Error(`SOF: invalid sampling factors (${h}x${v})`);
           const qId = data[offset + 2];
           frame!.componentsOrder.push(componentId);
           frame!.components[componentId] = {
@@ -881,11 +893,14 @@ function parse(data: Uint8Array) {
         readUint16() // Ignore this data since it represents the image height
         break;
       case 0xFFDA: { // SOS (Start of Scan)
+        if (!frame) throw new Error('SOS: scan before frame header (SOF)');
         readUint16(); // skip data length
         const selectorsCount = data[offset++];
         const components: Component[] = [];
         for (let i = 0; i < selectorsCount; i++) {
-          const component = frame!.components[data[offset++]];
+          const componentId = data[offset++];
+          const component = frame.components[componentId];
+          if (!component) throw new Error(`SOS: component ${componentId} not found in frame`);
           const tableSpec = data[offset++];
           component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
           component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
@@ -895,7 +910,7 @@ function parse(data: Uint8Array) {
         const spectralEnd = data[offset++];
         const successiveApproximation = data[offset++];
         const processed = decodeScan(
-          data, offset, frame!, components, resetInterval, spectralStart, spectralEnd,
+          data, offset, frame, components, resetInterval, spectralStart, spectralEnd,
           successiveApproximation >> 4, successiveApproximation & 15);
         offset += processed;
         break;
@@ -938,7 +953,9 @@ function parse(data: Uint8Array) {
   for (let i = 0; i < frames.length; i++) {
     const cp = frames[i].components;
     for (let j in cp) { // TODO: don't use `in`
-      cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx!];
+      const table = quantizationTables[cp[j].quantizationIdx!];
+      if (!table) throw new Error(`Missing quantization table ${cp[j].quantizationIdx}`);
+      cp[j].quantizationTable = table;
       delete cp[j].quantizationIdx; // TODO: why ???
     }
   }
@@ -1004,10 +1021,8 @@ function getData(decoded: Decoded) {
       break;
     }
     case 3: {
-      // The default transform for three components is true
-      colorTransform = true;
-      // The adobe transform marker overrides any previous setting
-      if (decoded.adobe && decoded.adobe.transformCode) colorTransform = true;
+      // The default transform for three components is true, the adobe transform marker overrides it
+      colorTransform = decoded.adobe ? !!decoded.adobe.transformCode : true;
 
       const component1 = decoded.components[0];
       const component2 = decoded.components[1];

package/src/psd.ts

@@ -411,7 +411,7 @@ export interface TextPath {
 		textRange: number[];
 		rowGutter?: number;
 		columnGutter?: number;
-		BaselineAlignment?: {
+		baselineAlignment?: {
 			flag?: number;
 			min?: number;
 		};
@@ -1793,6 +1793,8 @@ export interface Psd extends LayerAdditionalInfo {
 	canvas?: HTMLCanvasElement;
 	imageData?: PixelData;
 	rawCompositeData?: Uint8Array;
+	/** Information needed to decode `rawCompositeData` (see `getCompositeImageData`) */
+	rawCompositeDataInfo?: { large: boolean; globalAlpha: boolean; };
 	imageResources?: ImageResources;
 	linkedFiles?: LinkedFile[]; // used in smart objects
 	artboards?: {