ag-psd 20.0.0 → 20.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-psd",
-  "version": "20.0.0",
+  "version": "20.1.1",
   "description": "Library for reading and writing PSD files",
   "main": "dist/index.js",
   "module": "dist-es/index.js",
@@ -34,19 +34,19 @@
   "author": "Agamnentzar",
   "license": "MIT",
   "devDependencies": {
-    "@types/mocha": "^9.1.1",
+    "@types/mocha": "^10.0.6",
     "@types/node": "^18.11.18",
+    "@types/pako": "^2.0.3",
     "browserify": "^17.0.0",
     "canvas": "^2.11.0",
     "chai": "^4.3.7",
-    "mocha": "^6.2.0",
+    "mocha": "^10.4.0",
+    "source-map-support": "^0.5.21",
     "tslint": "^6.1.3",
-    "typescript": "^4.9.4",
-    "source-map-support": "^0.5.21"
+    "typescript": "^4.9.4"
   },
   "dependencies": {
     "@types/base64-js": "^1.3.0",
-    "@types/pako": "^2.0.0",
     "base64-js": "^1.5.1",
     "pako": "^2.1.0"
   }

package/src/additionalInfo.ts

@@ -3351,6 +3351,16 @@ addHandler(
 	},
 );
 
+addHandler(
+	'Lr32',
+	() => false,
+	(reader, _target, _left, psd, options) => {
+		readLayerInfo(reader, psd, options);
+	},
+	(_writer, _target) => {
+	},
+);
+
 addHandler(
 	'LMsk',
 	hasKey('userMask'),
@@ -4634,9 +4644,11 @@ addHandler(
 		const data = readBytes(reader, left());
 		target.engineData = fromByteArray(data);
 		// const engineData = parseEngineData(data);
+		// const engineData2 = decodeEngineData2(engineData);
 		// console.log(require('util').inspect(engineData, false, 99, true));
-		// require('fs').writeFileSync('resources/engineData2Simple.txt', require('util').inspect(engineData, false, 99, false), 'utf8');
-		// require('fs').writeFileSync('test_data.json', JSON.stringify(ed, null, 2), 'utf8');
+		// require('fs').writeFileSync('test_data.bin', data);
+		// require('fs').writeFileSync('test_data.txt', require('util').inspect(engineData, false, 99, false), 'utf8');
+		// require('fs').writeFileSync('test_data.json', JSON.stringify(engineData2, null, 2), 'utf8');
 	},
 	(writer, target) => {
 		const buffer = toByteArray(target.engineData!);

package/src/engineData2.ts

@@ -0,0 +1,367 @@
+/// Engine data 2 experiments
+// /test/engineData2.json:1109 is character codes
+
+interface KeysDict {
+	[key: string]: {
+		name?: string;
+		uproot?: boolean;
+		children?: KeysDict;
+	};
+}
+
+const keysColor: KeysDict = {
+	'0': {
+		uproot: true,
+		children: {
+			'0': { name: 'Type' },
+			'1': { name: 'Values' },
+		},
+	},
+};
+
+const keysStyleSheet: KeysDict = {
+	'0': { name: 'Font' },
+	'1': { name: 'FontSize' },
+	'2': { name: 'FauxBold' },
+	'3': { name: 'FauxItalic' },
+	'4': { name: 'AutoLeading' },
+	'5': { name: 'Leading' },
+	'6': { name: 'HorizontalScale' },
+	'7': { name: 'VerticalScale' },
+	'8': { name: 'Tracking' },
+	'9': { name: 'BaselineShift' },
+	// '10': ???
+	'11': { name: 'Kerning?' }, // different value than EngineData
+	'12': { name: 'FontCaps' },
+	'13': { name: 'FontBaseline' },
+
+	'15': { name: 'Strikethrough?' }, // number instead of bool
+	'16': { name: 'Underline?' }, // number instead of bool
+
+	'18': { name: 'Ligatures' },
+	'19': { name: 'DLigatures' },
+	// '20': ???
+	// '21': ???
+	// '22': ???
+	'23': { name: 'Fractions' }, // not present in EngineData
+	'24': { name: 'Ordinals' }, // not present in EngineData
+	// '25': ???
+	// '26': ???
+	// '27': ???
+	'28': { name: 'StylisticAlternates' }, // not present in EngineData
+	// '29': ???
+	'30': { name: 'OldStyle?' }, // OpenType > OldStyle, number instead of bool, not present in EngineData
+
+	'35': { name: 'BaselineDirection' },
+
+	'38': { name: 'Language' },
+
+	'52': { name: 'NoBreak' },
+	'53': { name: 'FillColor', children: keysColor },
+	'54': { name: 'StrokeColor?', children: keysColor },
+	'55': { children: { '99': { uproot: true } } },
+
+	// '68': ???
+
+	// '70': ???
+	// '71': ???
+	// '72': ???
+	// '73': ???
+
+	'79': { children: keysColor },
+
+	// '85': ???
+
+	// '87': ???
+	// '88': ???
+};
+
+const keysParagraph: KeysDict = {
+	'0': { name: 'Justification' },
+	'1': { name: 'FirstLineIndent' },
+	'2': { name: 'StartIndent' },
+	'3': { name: 'EndIndent' },
+	'4': { name: 'SpaceBefore' },
+	'5': { name: 'SpaceAfter' },
+
+	'7': { name: 'AutoLeading' },
+
+	'9': { name: 'AutoHyphenate' },
+	'10': { name: 'HyphenatedWordSize' },
+	'11': { name: 'PreHyphen' },
+	'12': { name: 'PostHyphen' },
+	'13': { name: 'ConsecutiveHyphens?' }, // different value than EngineData
+	'14': { name: 'Zone' },
+	'15': { name: 'HypenateCapitalizedWords' }, // not present in EngineData
+
+	'17': { name: 'WordSpacing' },
+	'18': { name: 'LetterSpacing' },
+	'19': { name: 'GlyphSpacing' },
+
+	'32': { name: 'StyleSheet', children: keysStyleSheet },
+};
+
+const keysStyleSheetData: KeysDict[''] = {
+	name: 'StyleSheetData',
+	children: keysStyleSheet,
+};
+
+const keysRoot: KeysDict = {
+	'0': {
+		name: 'ResourceDict',
+		children: {
+			'1': {
+				name: 'FontSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': {
+										uproot: true,
+										children: {
+											'0': { name: 'Name' },
+											'2': { name: 'FontType' },
+										},
+									},
+								},
+							}
+						},
+					},
+				},
+			},
+			'2': {
+				name: '2',
+				children: {},
+			},
+			'3': {
+				name: 'MojiKumiSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': { name: 'InternalName' },
+								},
+							},
+						},
+					},
+				},
+			},
+			'4': {
+				name: 'KinsokuSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': { name: 'Name' },
+									'5': {
+										uproot: true,
+										children: {
+											'0': { name: 'NoStart' },
+											'1': { name: 'NoEnd' },
+											'2': { name: 'Keep' },
+											'3': { name: 'Hanging' },
+											'4': { name: 'Name' },
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			'5': {
+				name: 'StyleSheetSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': { name: 'Name' },
+									'6': keysStyleSheetData,
+								},
+							},
+						},
+					},
+				},
+			},
+			'6': {
+				name: 'ParagraphSheetSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': { name: 'Name' },
+									'5': {
+										name: 'Properties',
+										children: keysParagraph,
+									},
+									'6': { name: 'DefaultStyleSheet' },
+								},
+							},
+						},
+					},
+				},
+			},
+			'8': {
+				name: '8',
+				children: {},
+			},
+			'9': {
+				name: 'Predefined',
+				children: {
+					'0': {
+						children: { '0': { uproot: true } },
+					},
+					'1': {
+						children: { '0': { uproot: true } },
+					},
+				},
+			},
+		},
+	},
+	'1': {
+		name: 'EngineDict',
+		children: {
+			'0': {
+				name: '0',
+				children: {
+					// 0: ???
+					// 1: ???
+					// 2: ???
+					'3': { name: 'SuperscriptSize' },
+					'4': { name: 'SuperscriptPosition' },
+					'5': { name: 'SubscriptSize' },
+					'6': { name: 'SubscriptPosition' },
+					'7': { name: 'SmallCapSize' },
+					'8': { name: 'UseFractionalGlyphWidths' }, // ???
+
+					'15': { children: { '0': { uproot: true } } },
+					// 16: ???
+					// 17: ???
+				},
+			},
+			'1': {
+				name: 'Editors?',
+				children: {
+					'0': {
+						name: 'Editor',
+						children: {
+							'0': { name: 'Text' },
+							'5': {
+								name: 'ParagraphRun',
+								children: {
+									'0': {
+										name: 'RunArray',
+										children: {
+											'0': {
+												name: 'ParagraphSheet',
+												children: {
+													'0': {
+														uproot: true,
+														children: {
+															'0': { name: '0' },
+															'5': {
+																name: '5',
+																children: keysParagraph,
+															},
+															'6': { name: '6' },
+														},
+													},
+												},
+											},
+											'1': { name: 'RunLength' },
+										},
+									},
+								},
+							},
+							'6': {
+								name: 'StyleRun',
+								children: {
+									'0': {
+										name: 'RunArray',
+										children: {
+											'0': {
+												name: 'StyleSheet',
+												children: {
+													'0': {
+														uproot: true,
+														children: {
+															'6': keysStyleSheetData,
+														},
+													},
+												},
+											},
+											'1': { name: 'RunLength' },
+										},
+									},
+								},
+							},
+						},
+					},
+					'1': {
+						name: 'FontVectorData ???',
+						// children: {
+						// 	'0': {},
+						// 	'2': {
+						// 		// '5'
+						// 		// '6'
+						// 	},
+						// }
+					},
+				},
+			},
+			'2': {
+				name: 'StyleSheet',
+				children: keysStyleSheet,
+			},
+			'3': {
+				name: 'ParagraphSheet',
+				children: keysParagraph,
+			},
+		},
+	},
+};
+
+function decodeObj(obj: any, keys: KeysDict): any {
+	if (obj === null) return obj;
+	if (Array.isArray(obj)) return obj.map(x => decodeObj(x, keys));
+	if (typeof obj !== 'object') return obj;
+
+	let result: any = {};
+
+	for (const key of Object.keys(obj)) {
+		if (keys[key]) {
+			if (keys[key].uproot) {
+				if (key !== '99') result = decodeObj(obj[key], keys[key].children ?? {});
+				if (obj['99']) result._type = obj['99'];
+				break;
+			} else {
+				result[keys[key].name || key] = decodeObj(obj[key], keys[key].children ?? {});
+			}
+		} else if (key === '99') {
+			result._type = obj[key];
+		} else {
+			result[key] = decodeObj(obj[key], {});
+		}
+	}
+
+	return result;
+}
+
+export function decodeEngineData2(data: any) {
+	return decodeObj(data, keysRoot);
+}

package/src/helpers.ts

@@ -1,5 +1,5 @@
 import { fromByteArray } from 'base64-js';
-import { deflate } from 'pako';
+import { deflate as deflateSync } from 'pako';
 import { Layer, BlendMode, LayerColor, PixelData, PixelArray } from './psd';
 
 export const MOCK_HANDLERS = false;
@@ -166,7 +166,7 @@ export function hasAlpha(data: PixelData) {
 }
 
 export function resetImageData({ data }: PixelData) {
-	const alpha = (data instanceof Uint32Array) ? (0xffffffff >>> 0) : ((data instanceof Uint16Array) ? 0xffff : 0xff);
+	const alpha = (data instanceof Float32Array) ? 1.0 : ((data instanceof Uint16Array) ? 0xffff : 0xff);
 
 	for (let p = 0, size = data.length | 0; p < size; p = (p + 4) | 0) {
 		data[p + 0] = 0;
@@ -186,10 +186,20 @@ export function imageDataToCanvas(pixelData: PixelData) {
 		imageData = createImageData(pixelData.width, pixelData.height);
 		const src = pixelData.data;
 		const dst = imageData.data;
-		const shift = (src instanceof Uint32Array) ? 24 : ((src instanceof Uint16Array) ? 8 : 0);
 
-		for (let i = 0, size = src.length; i < size; i++) {
-			dst[i] = src[i] >>> shift;
+		if (src instanceof Float32Array) {
+			for (let i = 0, size = src.length; i < size; i += 4) {
+				dst[i + 0] = Math.round(Math.pow(src[i + 0], 1.0 / 2.2) * 255);
+				dst[i + 1] = Math.round(Math.pow(src[i + 1], 1.0 / 2.2) * 255);
+				dst[i + 2] = Math.round(Math.pow(src[i + 2], 1.0 / 2.2) * 255);
+				dst[i + 3] = Math.round(src[i + 3] * 255);
+			}
+		} else {
+			const shift = (src instanceof Uint16Array) ? 8 : 0;
+
+			for (let i = 0, size = src.length; i < size; i++) {
+				dst[i] = src[i] >>> shift;
+			}
 		}
 	}
 
@@ -198,7 +208,7 @@ export function imageDataToCanvas(pixelData: PixelData) {
 }
 
 export function decodeBitmap(input: PixelArray, output: PixelArray, width: number, height: number) {
-	if (input instanceof Uint32Array || input instanceof Uint16Array) throw new Error('Invalid bit depth');
+	if (!(input instanceof Uint8Array || input instanceof Uint8ClampedArray)) throw new Error('Invalid bit depth');
 
 	for (let y = 0, p = 0, o = 0; y < height; y++) {
 		for (let x = 0; x < width;) {
@@ -339,7 +349,7 @@ export function writeDataZipWithoutPrediction({ data, width, height }: PixelData
 			channel[i] = data[o];
 		}
 
-		const buffer = deflate(channel);
+		const buffer = deflateSync(channel);
 		buffers.push(buffer);
 		totalLength += buffer.byteLength;
 	}

package/src/imageResources.ts

@@ -98,8 +98,12 @@ addHandler(
 addHandler(
 	1060,
 	target => target.xmpMetadata !== undefined,
-	(reader, target, left) => target.xmpMetadata = readUtf8String(reader, left()),
-	(writer, target) => writeUtf8String(writer, target.xmpMetadata!),
+	(reader, target, left) => {
+		target.xmpMetadata = readUtf8String(reader, left());
+	},
+	(writer, target) => {
+		writeUtf8String(writer, target.xmpMetadata!);
+	},
 );
 
 const Inte = createEnum<RenderingIntent>('Inte', 'perceptual', {

package/src/psd.ts

@@ -222,7 +222,7 @@ export interface LayerEffectsInfo {
 	patternOverlay?: LayerEffectPatternOverlay; // not supported yet because of `Patt` section not implemented
 }
 
-export type PixelArray = Uint8ClampedArray | Uint8Array | Uint16Array | Uint32Array;
+export type PixelArray = Uint8ClampedArray | Uint8Array | Uint16Array | Float32Array;
 
 export interface PixelData {
 	data: PixelArray; // type depends on document bit depth

package/src/psdReader.ts

@@ -1,4 +1,4 @@
-import { inflate } from 'pako';
+import { inflate as inflateSync } from 'pako';
 import { Psd, Layer, ColorMode, SectionDividerType, LayerAdditionalInfo, ReadOptions, LayerMaskData, Color, PatternInfo, GlobalLayerMaskInfo, RGB, PixelData, PixelArray } from './psd';
 import { resetImageData, offsetForChannel, decodeBitmap, createImageData, toBlendMode, ChannelID, Compression, LayerMaskFlags, MaskParams, ColorSpace, RAW_IMAGE_DATA, largeAdditionalInfoKeys, imageDataToCanvas } from './helpers';
 import { infoHandlersMap } from './additionalInfo';
@@ -230,7 +230,16 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 
 	// color mode data
 	readSection(reader, 1, left => {
-		if (options.throwForMissingFeatures) throw new Error('Color mode data not supported');
+		if (!left()) return;
+
+		// const numbers: number[] = [];
+		// console.log('color mode', left());
+		// while (left()) {
+		// 	numbers.push(readUint32(reader));
+		// }
+		// console.log('color mode', numbers);
+
+		// if (options.throwForMissingFeatures) throw new Error('Color mode data not supported');
 		skipBytes(reader, left());
 	});
 
@@ -661,7 +670,7 @@ function createImageDataBitDepth(width: number, height: number, bitDepth: number
 	} else if (bitDepth === 16) {
 		return { width, height, data: new Uint16Array(width * height * 4) };
 	} else if (bitDepth === 32) {
-		return { width, height, data: new Uint32Array(width * height * 4) };
+		return { width, height, data: new Float32Array(width * height * 4) };
 	} else {
 		throw new Error(`Invalid bitDepth (${bitDepth})`);
 	}
@@ -682,13 +691,15 @@ function readImageData(reader: PsdReader, psd: Psd, options: ReadOptionsExt) {
 
 	switch (psd.colorMode) {
 		case ColorMode.Bitmap: {
+			if (bitsPerChannel !== 1) throw new Error('Invalid bitsPerChannel for bitmap color mode');
+
 			let bytes: Uint8Array;
 
 			if (compression === Compression.RawData) {
 				bytes = readBytes(reader, Math.ceil(psd.width / 8) * psd.height);
 			} else if (compression === Compression.RleCompressed) {
 				bytes = new Uint8Array(psd.width * psd.height);
-				readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, bitsPerChannel, 1, [0], options.large);
+				readDataRLE(reader, { data: bytes, width: psd.width, height: psd.height }, psd.width, psd.height, 8, 1, [0], options.large);
 			} else {
 				throw new Error(`Bitmap compression not supported: ${compression}`);
 			}
@@ -828,11 +839,11 @@ function bytesToArray(bytes: Uint8Array, bitDepth: number) {
 		}
 	} else if (bitDepth === 32) {
 		if (bytes.byteOffset % 4) {
-			const result = new Uint32Array(bytes.byteLength / 4);
+			const result = new Float32Array(bytes.byteLength / 4);
 			new Uint8Array(result.buffer, result.byteOffset, result.byteLength).set(bytes);
 			return result;
 		} else {
-			return new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+			return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
 		}
 	} else {
 		throw new Error(`Invalid bitDepth (${bitDepth})`)
@@ -850,6 +861,20 @@ function copyChannelToPixelData(pixelData: PixelData, channel: PixelArray, offse
 
 function readDataRaw(reader: PsdReader, pixelData: PixelData | undefined, width: number, height: number, bitDepth: number, step: number, offset: number) {
 	const buffer = readBytes(reader, width * height * Math.floor(bitDepth / 8));
+
+	if (bitDepth == 32) {
+		for (let i = 0; i < buffer.byteLength; i += 4) {
+			const a = buffer[i + 0];
+			const b = buffer[i + 1];
+			const c = buffer[i + 2];
+			const d = buffer[i + 3];
+			buffer[i + 0] = d;
+			buffer[i + 1] = c;
+			buffer[i + 2] = b;
+			buffer[i + 3] = a;
+		}
+	}
+
 	const array = bytesToArray(buffer, bitDepth);
 
 	if (pixelData && offset < step) {
@@ -869,7 +894,7 @@ function decodePredicted(data: Uint8Array | Uint16Array, width: number, height:
 
 export function readDataZip(reader: PsdReader, length: number, pixelData: PixelData | undefined, width: number, height: number, bitDepth: number, step: number, offset: number, prediction: boolean) {
 	const compressed = readBytes(reader, length);
-	const decompressed = inflate(compressed);
+	const decompressed = inflateSync(compressed);
 
 	if (pixelData && offset < step) {
 		const array = bytesToArray(decompressed, bitDepth);
@@ -881,8 +906,21 @@ export function readDataZip(reader: PsdReader, length: number, pixelData: PixelD
 			if (prediction) decodePredicted(array as Uint16Array, width, height, 0x10000);
 			copyChannelToPixelData(pixelData, array, offset, step);
 		} else if (bitDepth === 32) {
-			if (prediction) decodePredicted(decompressed, width, height, 0x100);
-			copyChannelToPixelData(pixelData, array, offset, step);
+			if (prediction) decodePredicted(decompressed, width * 4, height, 0x100);
+
+			let di = offset;
+			const dst = new Uint32Array(pixelData.data.buffer, pixelData.data.byteOffset, pixelData.data.length);
+
+			for (let y = 0; y < height; y++) {
+				let a = width * 4 * y;
+
+				for (let x = 0; x < width; x++, a++, di += step) {
+					const b = a + width;
+					const c = b + width;
+					const d = c + width;
+					dst[di] = ((decompressed[a] << 24) | (decompressed[b] << 16) | (decompressed[c] << 8) | decompressed[d]) >>> 0;
+				}
+			}
 		} else {
 			throw new Error('Invalid bitDepth');
 		}

package/src/utf8.ts

@@ -87,6 +87,10 @@ export function encodeStringTo(buffer: Uint8Array | Buffer, offset: number, valu
 }
 
 export function encodeString(value: string): Uint8Array {
+	if (value.length > 1000 && typeof TextEncoder !== 'undefined') {
+		return (new TextEncoder()).encode(value);
+	}
+
 	const buffer = new Uint8Array(stringLengthInBytes(value));
 	encodeStringTo(buffer, 0, value);
 	return buffer;
@@ -107,7 +111,11 @@ function continuationByte(buffer: Uint8Array, index: number): number {
 }
 
 export function decodeString(value: Uint8Array): string {
-	let result = '';
+	if (value.byteLength > 1000 && typeof TextDecoder !== 'undefined') {
+		return (new TextDecoder()).decode(value);
+	}
+
+	let result: string[] = [];
 
 	for (let i = 0; i < value.length;) {
 		const byte1 = value[i++];
@@ -149,12 +157,12 @@ export function decodeString(value: Uint8Array): string {
 
 		if (code > 0xffff) {
 			code -= 0x10000;
-			result += String.fromCharCode(code >>> 10 & 0x3ff | 0xd800);
+			result.push(String.fromCharCode(code >>> 10 & 0x3ff | 0xd800));
 			code = 0xdc00 | code & 0x3ff;
 		}
 
-		result += String.fromCharCode(code);
+		result.push(String.fromCharCode(code));
 	}
 
-	return result;
+	return result.join('');
 }