ag-psd 15.0.4 → 15.0.5

package/src/effectsHelpers.ts

@@ -0,0 +1,305 @@
+import { LayerEffectsInfo, BevelStyle, LayerEffectShadow } from './psd';
+import { toBlendMode, fromBlendMode } from './helpers';
+import {
+	PsdReader, checkSignature, readSignature, skipBytes, readUint16, readUint8,
+	readUint32, readFixedPoint32, readColor
+} from './psdReader';
+import {
+	PsdWriter, writeSignature, writeUint16, writeZeros, writeFixedPoint32,
+	writeUint8, writeUint32, writeColor
+} from './psdWriter';
+
+const bevelStyles: BevelStyle[] = [
+	undefined as any, 'outer bevel', 'inner bevel', 'emboss', 'pillow emboss', 'stroke emboss'
+];
+
+function readBlendMode(reader: PsdReader) {
+	checkSignature(reader, '8BIM');
+	return toBlendMode[readSignature(reader)] || 'normal';
+}
+
+function writeBlendMode(writer: PsdWriter, mode: string | undefined) {
+	writeSignature(writer, '8BIM');
+	writeSignature(writer, fromBlendMode[mode!] || 'norm');
+}
+
+function readFixedPoint8(reader: PsdReader) {
+	return readUint8(reader) / 0xff;
+}
+
+function writeFixedPoint8(writer: PsdWriter, value: number) {
+	writeUint8(writer, Math.round(value * 0xff) | 0);
+}
+
+export function readEffects(reader: PsdReader) {
+	const version = readUint16(reader);
+	if (version !== 0) throw new Error(`Invalid effects layer version: ${version}`);
+
+	const effectsCount = readUint16(reader);
+	const effects: LayerEffectsInfo = <any>{};
+
+	for (let i = 0; i < effectsCount; i++) {
+		checkSignature(reader, '8BIM');
+		const type = readSignature(reader);
+
+		switch (type) {
+			case 'cmnS': { // common state (see See Effects layer, common state info)
+				const size = readUint32(reader);
+				const version = readUint32(reader);
+				const visible = !!readUint8(reader);
+				skipBytes(reader, 2);
+
+				if (size !== 7 || version !== 0 || !visible) throw new Error(`Invalid effects common state`);
+				break;
+			}
+			case 'dsdw': // drop shadow (see See Effects layer, drop shadow and inner shadow info)
+			case 'isdw': { // inner shadow (see See Effects layer, drop shadow and inner shadow info)
+				const blockSize = readUint32(reader);
+				const version = readUint32(reader);
+
+				if (blockSize !== 41 && blockSize !== 51) throw new Error(`Invalid shadow size: ${blockSize}`);
+				if (version !== 0 && version !== 2) throw new Error(`Invalid shadow version: ${version}`);
+
+				const size = readFixedPoint32(reader);
+				readFixedPoint32(reader); // intensity
+				const angle = readFixedPoint32(reader);
+				const distance = readFixedPoint32(reader);
+				const color = readColor(reader);
+				const blendMode = readBlendMode(reader);
+				const enabled = !!readUint8(reader);
+				const useGlobalLight = !!readUint8(reader);
+				const opacity = readFixedPoint8(reader);
+				if (blockSize >= 51) readColor(reader); // native color
+				const shadowInfo: LayerEffectShadow = {
+					size: { units: 'Pixels', value: size },
+					distance: { units: 'Pixels', value: distance },
+					angle, color, blendMode, enabled, useGlobalLight, opacity
+				};
+
+				if (type === 'dsdw') {
+					effects.dropShadow = [shadowInfo];
+				} else {
+					effects.innerShadow = [shadowInfo];
+				}
+				break;
+			}
+			case 'oglw': { // outer glow (see See Effects layer, outer glow info)
+				const blockSize = readUint32(reader);
+				const version = readUint32(reader);
+
+				if (blockSize !== 32 && blockSize !== 42) throw new Error(`Invalid outer glow size: ${blockSize}`);
+				if (version !== 0 && version !== 2) throw new Error(`Invalid outer glow version: ${version}`);
+
+				const size = readFixedPoint32(reader);
+				readFixedPoint32(reader); // intensity
+				const color = readColor(reader);
+				const blendMode = readBlendMode(reader);
+				const enabled = !!readUint8(reader);
+				const opacity = readFixedPoint8(reader);
+				if (blockSize >= 42) readColor(reader); // native color
+
+				effects.outerGlow = {
+					size: { units: 'Pixels', value: size },
+					color, blendMode, enabled, opacity
+				};
+				break;
+			}
+			case 'iglw': { // inner glow (see See Effects layer, inner glow info)
+				const blockSize = readUint32(reader);
+				const version = readUint32(reader);
+
+				if (blockSize !== 32 && blockSize !== 43) throw new Error(`Invalid inner glow size: ${blockSize}`);
+				if (version !== 0 && version !== 2) throw new Error(`Invalid inner glow version: ${version}`);
+
+				const size = readFixedPoint32(reader);
+				readFixedPoint32(reader); // intensity
+				const color = readColor(reader);
+				const blendMode = readBlendMode(reader);
+				const enabled = !!readUint8(reader);
+				const opacity = readFixedPoint8(reader);
+
+				if (blockSize >= 43) {
+					readUint8(reader); // inverted
+					readColor(reader); // native color
+				}
+
+				effects.innerGlow = {
+					size: { units: 'Pixels', value: size },
+					color, blendMode, enabled, opacity
+				};
+				break;
+			}
+			case 'bevl': { // bevel (see See Effects layer, bevel info)
+				const blockSize = readUint32(reader);
+				const version = readUint32(reader);
+
+				if (blockSize !== 58 && blockSize !== 78) throw new Error(`Invalid bevel size: ${blockSize}`);
+				if (version !== 0 && version !== 2) throw new Error(`Invalid bevel version: ${version}`);
+
+				const angle = readFixedPoint32(reader);
+				const strength = readFixedPoint32(reader);
+				const size = readFixedPoint32(reader);
+				const highlightBlendMode = readBlendMode(reader);
+				const shadowBlendMode = readBlendMode(reader);
+				const highlightColor = readColor(reader);
+				const shadowColor = readColor(reader);
+				const style = bevelStyles[readUint8(reader)] || 'inner bevel';
+				const highlightOpacity = readFixedPoint8(reader);
+				const shadowOpacity = readFixedPoint8(reader);
+				const enabled = !!readUint8(reader);
+				const useGlobalLight = !!readUint8(reader);
+				const direction = readUint8(reader) ? 'down' : 'up';
+
+				if (blockSize >= 78) {
+					readColor(reader); // real highlight color
+					readColor(reader); // real shadow color
+				}
+
+				effects.bevel = {
+					size: { units: 'Pixels', value: size },
+					angle, strength, highlightBlendMode, shadowBlendMode, highlightColor, shadowColor,
+					style, highlightOpacity, shadowOpacity, enabled, useGlobalLight, direction,
+				};
+				break;
+			}
+			case 'sofi': { // solid fill (Photoshop 7.0) (see See Effects layer, solid fill (added in Photoshop 7.0))
+				const size = readUint32(reader);
+				const version = readUint32(reader);
+
+				if (size !== 34) throw new Error(`Invalid effects solid fill info size: ${size}`);
+				if (version !== 2) throw new Error(`Invalid effects solid fill info version: ${version}`);
+
+				const blendMode = readBlendMode(reader);
+				const color = readColor(reader);
+				const opacity = readFixedPoint8(reader);
+				const enabled = !!readUint8(reader);
+				readColor(reader); // native color
+
+				effects.solidFill = [{ blendMode, color, opacity, enabled }];
+				break;
+			}
+			default:
+				throw new Error(`Invalid effect type: '${type}'`);
+		}
+	}
+
+	return effects;
+}
+
+function writeShadowInfo(writer: PsdWriter, shadow: LayerEffectShadow) {
+	writeUint32(writer, 51);
+	writeUint32(writer, 2);
+	writeFixedPoint32(writer, shadow.size && shadow.size.value || 0);
+	writeFixedPoint32(writer, 0); // intensity
+	writeFixedPoint32(writer, shadow.angle || 0);
+	writeFixedPoint32(writer, shadow.distance && shadow.distance.value || 0);
+	writeColor(writer, shadow.color);
+	writeBlendMode(writer, shadow.blendMode);
+	writeUint8(writer, shadow.enabled ? 1 : 0);
+	writeUint8(writer, shadow.useGlobalLight ? 1 : 0);
+	writeFixedPoint8(writer, shadow.opacity ?? 1);
+	writeColor(writer, shadow.color); // native color
+}
+
+export function writeEffects(writer: PsdWriter, effects: LayerEffectsInfo) {
+	const dropShadow = effects.dropShadow?.[0];
+	const innerShadow = effects.innerShadow?.[0];
+	const outerGlow = effects.outerGlow;
+	const innerGlow = effects.innerGlow;
+	const bevel = effects.bevel;
+	const solidFill = effects.solidFill?.[0];
+
+	let count = 1;
+	if (dropShadow) count++;
+	if (innerShadow) count++;
+	if (outerGlow) count++;
+	if (innerGlow) count++;
+	if (bevel) count++;
+	if (solidFill) count++;
+
+	writeUint16(writer, 0);
+	writeUint16(writer, count);
+
+	writeSignature(writer, '8BIM');
+	writeSignature(writer, 'cmnS');
+	writeUint32(writer, 7); // size
+	writeUint32(writer, 0); // version
+	writeUint8(writer, 1); // visible
+	writeZeros(writer, 2);
+
+	if (dropShadow) {
+		writeSignature(writer, '8BIM');
+		writeSignature(writer, 'dsdw');
+		writeShadowInfo(writer, dropShadow);
+	}
+
+	if (innerShadow) {
+		writeSignature(writer, '8BIM');
+		writeSignature(writer, 'isdw');
+		writeShadowInfo(writer, innerShadow);
+	}
+
+	if (outerGlow) {
+		writeSignature(writer, '8BIM');
+		writeSignature(writer, 'oglw');
+		writeUint32(writer, 42);
+		writeUint32(writer, 2);
+		writeFixedPoint32(writer, outerGlow.size?.value || 0);
+		writeFixedPoint32(writer, 0); // intensity
+		writeColor(writer, outerGlow.color);
+		writeBlendMode(writer, outerGlow.blendMode);
+		writeUint8(writer, outerGlow.enabled ? 1 : 0);
+		writeFixedPoint8(writer, outerGlow.opacity || 0);
+		writeColor(writer, outerGlow.color);
+	}
+
+	if (innerGlow) {
+		writeSignature(writer, '8BIM');
+		writeSignature(writer, 'iglw');
+		writeUint32(writer, 43);
+		writeUint32(writer, 2);
+		writeFixedPoint32(writer, innerGlow.size?.value || 0);
+		writeFixedPoint32(writer, 0); // intensity
+		writeColor(writer, innerGlow.color);
+		writeBlendMode(writer, innerGlow.blendMode);
+		writeUint8(writer, innerGlow.enabled ? 1 : 0);
+		writeFixedPoint8(writer, innerGlow.opacity || 0);
+		writeUint8(writer, 0); // inverted
+		writeColor(writer, innerGlow.color);
+	}
+
+	if (bevel) {
+		writeSignature(writer, '8BIM');
+		writeSignature(writer, 'bevl');
+		writeUint32(writer, 78);
+		writeUint32(writer, 2);
+		writeFixedPoint32(writer, bevel.angle || 0);
+		writeFixedPoint32(writer, bevel.strength || 0);
+		writeFixedPoint32(writer, bevel.size?.value || 0);
+		writeBlendMode(writer, bevel.highlightBlendMode);
+		writeBlendMode(writer, bevel.shadowBlendMode);
+		writeColor(writer, bevel.highlightColor);
+		writeColor(writer, bevel.shadowColor);
+		const style = bevelStyles.indexOf(bevel.style!);
+		writeUint8(writer, style <= 0 ? 1 : style);
+		writeFixedPoint8(writer, bevel.highlightOpacity || 0);
+		writeFixedPoint8(writer, bevel.shadowOpacity || 0);
+		writeUint8(writer, bevel.enabled ? 1 : 0);
+		writeUint8(writer, bevel.useGlobalLight ? 1 : 0);
+		writeUint8(writer, bevel.direction === 'down' ? 1 : 0);
+		writeColor(writer, bevel.highlightColor);
+		writeColor(writer, bevel.shadowColor);
+	}
+
+	if (solidFill) {
+		writeSignature(writer, '8BIM');
+		writeSignature(writer, 'sofi');
+		writeUint32(writer, 34);
+		writeUint32(writer, 2);
+		writeBlendMode(writer, solidFill.blendMode);
+		writeColor(writer, solidFill.color);
+		writeFixedPoint8(writer, solidFill.opacity || 0);
+		writeUint8(writer, solidFill.enabled ? 1 : 0);
+		writeColor(writer, solidFill.color);
+	}
+}

package/src/engineData.ts

@@ -0,0 +1,359 @@
+function isWhitespace(char: number) {
+	// ' ', '\n', '\r', '\t'
+	return char === 32 || char === 10 || char === 13 || char === 9;
+}
+
+function isNumber(char: number) {
+	// 0123456789.-
+	return (char >= 48 && char <= 57) || char === 46 || char === 45;
+}
+
+export function parseEngineData(data: number[] | Uint8Array) {
+	let index = 0;
+
+	function skipWhitespace() {
+		while (index < data.length && isWhitespace(data[index])) {
+			index++;
+		}
+	}
+
+	function getTextByte() {
+		let byte = data[index];
+		index++;
+
+		if (byte === 92) { // \
+			byte = data[index];
+			index++;
+		}
+
+		return byte;
+	}
+
+	function getText() {
+		let result = '';
+
+		if (data[index] === 41) { // )
+			index++;
+			return result;
+		}
+
+		// Strings start with utf-16 BOM
+		if (data[index] !== 0xFE || data[index + 1] !== 0xFF) {
+			throw new Error('Invalid utf-16 BOM');
+		}
+
+		index += 2;
+
+		// ), ( and \ characters are escaped in ascii manner, remove the escapes before interpreting
+		// the bytes as utf-16
+		while (index < data.length && data[index] !== 41) { // )
+			const high = getTextByte();
+			const low = getTextByte();
+			const char = (high << 8) | low;
+			result += String.fromCharCode(char);
+		}
+
+		index++;
+		return result;
+	}
+
+	let root: any = null;
+	const stack: any[] = [];
+
+	function pushContainer(value: any) {
+		if (!stack.length) {
+			stack.push(value);
+			root = value;
+		} else {
+			pushValue(value);
+			stack.push(value);
+		}
+	}
+
+	function pushValue(value: any) {
+		if (!stack.length) throw new Error('Invalid data');
+
+		const top = stack[stack.length - 1];
+
+		if (typeof top === 'string') {
+			stack[stack.length - 2][top] = value;
+			pop();
+		} else if (Array.isArray(top)) {
+			top.push(value);
+		} else {
+			throw new Error('Invalid data');
+		}
+	}
+
+	function pushProperty(name: string) {
+		if (!stack.length) pushContainer({});
+
+		const top = stack[stack.length - 1];
+
+		if (top && typeof top === 'string') {
+			if (name === 'nil') {
+				pushValue(null);
+			} else {
+				pushValue(`/${name}`);
+			}
+		} else if (top && typeof top === 'object') {
+			stack.push(name);
+		} else {
+			throw new Error('Invalid data');
+		}
+	}
+
+	function pop() {
+		if (!stack.length) throw new Error('Invalid data');
+		stack.pop();
+	}
+
+	skipWhitespace();
+
+	while (index < data.length) {
+		const i = index;
+		const char = data[i];
+
+		if (char === 60 && data[i + 1] === 60) { // <<
+			index += 2;
+			pushContainer({});
+		} else if (char === 62 && data[i + 1] === 62) { // >>
+			index += 2;
+			pop();
+		} else if (char === 47) { // /
+			index += 1;
+			const start = index;
+
+			while (index < data.length && !isWhitespace(data[index])) {
+				index++;
+			}
+
+			let name = '';
+
+			for (let i = start; i < index; i++) {
+				name += String.fromCharCode(data[i]);
+			}
+
+			pushProperty(name);
+		} else if (char === 40) { // (
+			index += 1;
+			pushValue(getText());
+		} else if (char === 91) { // [
+			index += 1;
+			pushContainer([]);
+		} else if (char === 93) { // ]
+			index += 1;
+			pop();
+		} else if (char === 110 && data[i + 1] === 117 && data[i + 2] === 108 && data[i + 3] === 108) { // null
+			index += 4;
+			pushValue(null);
+		} else if (char === 116 && data[i + 1] === 114 && data[i + 2] === 117 && data[i + 3] === 101) { // true
+			index += 4;
+			pushValue(true);
+		} else if (char === 102 && data[i + 1] === 97 && data[i + 2] === 108 && data[i + 3] === 115 && data[i + 4] === 101) { // false
+			index += 5;
+			pushValue(false);
+		} else if (isNumber(char)) {
+			let value = '';
+
+			while (index < data.length && isNumber(data[index])) {
+				value += String.fromCharCode(data[index]);
+				index++;
+			}
+
+			pushValue(parseFloat(value));
+		} else {
+			index += 1;
+			console.log(`Invalid token ${String.fromCharCode(char)} at ${index}`);
+			// ` near ${String.fromCharCode.apply(null, data.slice(index - 10, index + 20) as any)}` +
+			// `data [${Array.from(data.slice(index - 10, index + 20)).join(', ')}]`
+		}
+
+		skipWhitespace();
+	}
+
+	return root;
+}
+
+const floatKeys = [
+	'Axis', 'XY', 'Zone', 'WordSpacing', 'FirstLineIndent', 'GlyphSpacing', 'StartIndent', 'EndIndent', 'SpaceBefore',
+	'SpaceAfter', 'LetterSpacing', 'Values', 'GridSize', 'GridLeading', 'PointBase', 'BoxBounds', 'TransformPoint0', 'TransformPoint1',
+	'TransformPoint2', 'FontSize', 'Leading', 'HorizontalScale', 'VerticalScale', 'BaselineShift', 'Tsume',
+	'OutlineWidth', 'AutoLeading',
+];
+
+const intArrays = ['RunLengthArray'];
+
+// TODO: handle /nil
+export function serializeEngineData(data: any, condensed = false) {
+	let buffer = new Uint8Array(1024);
+	let offset = 0;
+	let indent = 0;
+
+	function write(value: number) {
+		if (offset >= buffer.length) {
+			const newBuffer = new Uint8Array(buffer.length * 2);
+			newBuffer.set(buffer);
+			buffer = newBuffer;
+		}
+
+		buffer[offset] = value;
+		offset++;
+	}
+
+	function writeString(value: string) {
+		for (let i = 0; i < value.length; i++) {
+			write(value.charCodeAt(i));
+		}
+	}
+
+	function writeIndent() {
+		if (condensed) {
+			writeString(' ');
+		} else {
+			for (let i = 0; i < indent; i++) {
+				writeString('\t');
+			}
+		}
+	}
+
+	function writeProperty(key: string, value: any) {
+		writeIndent();
+		writeString(`/${key}`);
+		writeValue(value, key, true);
+		if (!condensed) writeString('\n');
+	}
+
+	function serializeInt(value: number) {
+		return value.toString();
+	}
+
+	function serializeFloat(value: number) {
+		return value.toFixed(5)
+			.replace(/(\d)0+$/g, '$1')
+			.replace(/^0+\.([1-9])/g, '.$1')
+			.replace(/^-0+\.0(\d)/g, '-.0$1');
+	}
+
+	function serializeNumber(value: number, key?: string) {
+		const isFloat = (key && floatKeys.indexOf(key) !== -1) || (value | 0) !== value;
+		return isFloat ? serializeFloat(value) : serializeInt(value);
+	}
+
+	function getKeys(value: any) {
+		const keys = Object.keys(value);
+
+		if (keys.indexOf('98') !== -1)
+			keys.unshift(...keys.splice(keys.indexOf('99'), 1));
+
+		if (keys.indexOf('99') !== -1)
+			keys.unshift(...keys.splice(keys.indexOf('99'), 1));
+
+		return keys;
+	}
+
+	function writeStringByte(value: number) {
+		if (value === 40 || value === 41 || value === 92) { // ( ) \
+			write(92); // \
+		}
+
+		write(value);
+	}
+
+	function writeValue(value: any, key?: string, inProperty = false) {
+		function writePrefix() {
+			if (inProperty) {
+				writeString(' ');
+			} else {
+				writeIndent();
+			}
+		}
+
+		if (value === null) {
+			writePrefix();
+			writeString(condensed ? '/nil' : 'null');
+		} else if (typeof value === 'number') {
+			writePrefix();
+			writeString(serializeNumber(value, key));
+		} else if (typeof value === 'boolean') {
+			writePrefix();
+			writeString(value ? 'true' : 'false');
+		} else if (typeof value === 'string') {
+			writePrefix();
+
+			if ((key === '99' || key === '98') && value.charAt(0) === '/') {
+				writeString(value);
+			} else {
+				writeString('(');
+				write(0xfe);
+				write(0xff);
+
+				for (let i = 0; i < value.length; i++) {
+					const code = value.charCodeAt(i);
+					writeStringByte((code >> 8) & 0xff);
+					writeStringByte(code & 0xff);
+				}
+
+				writeString(')');
+			}
+		} else if (Array.isArray(value)) {
+			writePrefix();
+
+			if (value.every(x => typeof x === 'number')) {
+				writeString('[');
+
+				const intArray = intArrays.indexOf(key!) !== -1;
+
+				for (const x of value) {
+					writeString(' ');
+					writeString(intArray ? serializeNumber(x) : serializeFloat(x));
+				}
+
+				writeString(' ]');
+			} else {
+				writeString('[');
+				if (!condensed) writeString('\n');
+
+				for (const x of value) {
+					writeValue(x, key);
+					if (!condensed) writeString('\n');
+				}
+
+				writeIndent();
+				writeString(']');
+			}
+		} else if (typeof value === 'object') {
+			if (inProperty && !condensed) writeString('\n');
+
+			writeIndent();
+			writeString('<<');
+
+			if (!condensed) writeString('\n');
+
+			indent++;
+
+			for (const key of getKeys(value)) {
+				writeProperty(key, value[key]);
+			}
+
+			indent--;
+			writeIndent();
+			writeString('>>');
+		}
+
+		return undefined;
+	}
+
+	if (condensed) {
+		if (typeof data === 'object') {
+			for (const key of getKeys(data)) {
+				writeProperty(key, data[key]);
+			}
+		}
+	} else {
+		writeString('\n\n');
+		writeValue(data);
+	}
+
+	return buffer.slice(0, offset);
+}