ag-psd 33.0.0 → 34.0.0

package/src/imageResources.ts

@@ -1,5 +1,5 @@
 import { toByteArray } from 'base64-js';
-import { BlendMode, HalftoneScreen, ImageResources, KeyDescriptorItem, PrintTransferFunction, RenderingIntent, SavedPath } from './psd';
+import { BlendMode, Color, HalftoneScreen, ImageResources, KeyDescriptorItem, PrintTransferFunction, RenderingIntent, SavedPath } from './psd';
 import { KeyDescriptorListDescriptor, parseKeyDescriptorList, readVectorMask, serializeKeyDescriptorList, writeVectorMask } from './additionalInfo';
 import { PsdReader, readUnicodeString, readUint32, readUint16, readUint8, readFloat64, readBytes, skipBytes, readFloat32, readInt16, readFixedPoint32, readSignature, checkSignature, readSection, readColor, readInt32, readAsciiString, decodeUtf8, getUtf8StrictDecoder, getGbkStrictDecoder } from './psdReader';
 import { PsdWriter, writeUnicodeString, writeUint32, writeUint8, writeFloat64, writeUint16, writeBytes, writeInt16, writeFloat32, writeFixedPoint32, writeUnicodeStringWithPadding, writeColor, writeSignature, writeSection, writeInt32, writeAsciiString, writeZeros } from './psdWriter';
@@ -734,6 +734,50 @@ function writeTransferFunctions(writer: PsdWriter, functions: PrintTransferFunct
 	}
 }
 
+addHandler(
+	1014, // Duotone halftoning information
+	target => target.duotoneHalftoneScreens !== undefined,
+	(reader, target, left) => target.duotoneHalftoneScreens = readHalftoneScreens(reader, left),
+	(writer, target) => writeHalftoneScreens(writer, target.duotoneHalftoneScreens!),
+);
+
+addHandler(
+	1017, // Duotone transfer functions
+	target => target.duotoneTransferFunctions !== undefined,
+	(reader, target, left) => target.duotoneTransferFunctions = readTransferFunctions(reader, left),
+	(writer, target) => writeTransferFunctions(writer, target.duotoneTransferFunctions!),
+);
+
+addHandler(
+	1018, // Duotone image information
+	target => target.duotoneImageInformation !== undefined,
+	(reader, target, left) => target.duotoneImageInformation = readBytes(reader, left()),
+	(writer, target) => writeBytes(writer, target.duotoneImageInformation),
+);
+
+addHandler(
+	1066, // Alternate duotone colors
+	target => target.alternateDuotoneColors !== undefined,
+	(reader, target, left) => {
+		if (readUint16(reader) !== 1) throw new Error('Invalid alternate duotone colors version');
+		const colors: Color[] = [];
+		const count = readUint16(reader);
+		for (let i = 0; i < count && left() >= 10; i++) colors.push(readColor(reader));
+		const labCount = readUint16(reader);
+		if (labCount * 3 > left()) throw new Error('Invalid alternate duotone colors Lab table size');
+		const labColors = readBytes(reader, labCount * 3);
+		target.alternateDuotoneColors = { colors, labColors };
+	},
+	(writer, target) => {
+		const { colors, labColors } = target.alternateDuotoneColors!;
+		writeUint16(writer, 1); // version
+		writeUint16(writer, colors.length);
+		for (const color of colors) writeColor(writer, color);
+		writeUint16(writer, Math.floor(labColors.byteLength / 3));
+		writeBytes(writer, labColors.subarray(0, Math.floor(labColors.byteLength / 3) * 3));
+	},
+);
+
 addHandler(
 	1015, // Grayscale and multichannel transfer function
 	target => target.grayscaleTransferFunctions !== undefined,
@@ -1161,7 +1205,7 @@ addHandler(
 			workOutTime: frac(desc.workOutTime),
 			repeats: desc.LCnt,
 			hasMotion: desc.hasMotion,
-			globalTracks: parseTrackList(desc.globalTrackList, !!reader.logMissingFeatures),
+			globalTracks: parseTrackList(desc.globalTrackList, reader),
 		};
 
 		if (desc.audioClipGroupList?.audioClipGroupList?.length) {
@@ -1201,7 +1245,7 @@ addHandler(
 			workInTime: timeline.workInTime,
 			workOutTime: timeline.workOutTime,
 			LCnt: timeline.repeats,
-			globalTrackList: serializeTrackList(timeline.globalTracks),
+			globalTrackList: serializeTrackList(timeline.globalTracks, writer),
 			audioClipGroupList: {
 				audioClipGroupList: (timeline.audioClipGroups ?? []).map(a => ({
 					groupID: a.id,
@@ -1600,10 +1644,11 @@ addHandler(
 
 addHandler(
 	1038, // Color samplers (Photoshop 5.0, replaced by 1073 in CS3)
-	target => target.colorSamplers !== undefined,
+	target => target.colorSamplers !== undefined && !target.colorSamplers.some(s => s.depth !== undefined),
 	(reader, target, left) => {
 		const version = readUint32(reader);
 		if (version !== 1) throw new Error(`Invalid color samplers version: ${version}`);
+		if (target.colorSamplers?.some(s => s.depth !== undefined)) return skipBytes(reader, left()); // already read from 1073
 		const count = readUint32(reader);
 		target.colorSamplers = [];
 
@@ -1628,6 +1673,64 @@ addHandler(
 	},
 );
 
+addHandler(
+	1073, // Color samplers (Photoshop CS3)
+	target => target.colorSamplers !== undefined && target.colorSamplers.some(s => s.depth !== undefined),
+	(reader, target, left) => {
+		const version = readUint32(reader);
+		if (version < 1 || version > 3) throw new Error(`Invalid color samplers version: ${version}`);
+		const count = readUint32(reader);
+		target.colorSamplers = [];
+
+		for (let i = 0; i < count && left() >= 10; i++) {
+			// position is fixed point value for sampler version 1 (stored the same way as in 1038 resource) or float for version 2
+			const samplerVersion = version === 3 ? readUint32(reader) : version;
+			const y = samplerVersion === 1 ? readInt32(reader) / 16 : readFloat32(reader);
+			const x = samplerVersion === 1 ? readInt32(reader) / 16 : readFloat32(reader);
+			const colorSpace = readInt16(reader);
+			const depth = version >= 2 ? readInt16(reader) : 1;
+			target.colorSamplers.push({ x, y, colorSpace, depth });
+		}
+	},
+	(writer, target) => {
+		writeUint32(writer, 3); // version
+		writeUint32(writer, target.colorSamplers!.length);
+
+		for (const sampler of target.colorSamplers!) {
+			writeUint32(writer, 1); // sampler version
+			writeInt32(writer, Math.round(sampler.y * 16));
+			writeInt32(writer, Math.round(sampler.x * 16));
+			writeInt16(writer, sampler.colorSpace);
+			writeInt16(writer, sampler.depth ?? 1);
+		}
+	},
+);
+
+addHandler(
+	1022, // Quick Mask information
+	target => target.quickMaskInfo !== undefined,
+	(reader, target) => {
+		const channelId = readUint16(reader);
+		const initiallyEmpty = !!readUint8(reader);
+		target.quickMaskInfo = { channelId, initiallyEmpty };
+	},
+	(writer, target) => {
+		writeUint16(writer, target.quickMaskInfo!.channelId);
+		writeUint8(writer, target.quickMaskInfo!.initiallyEmpty ? 1 : 0);
+	},
+);
+
+addHandler(
+	1074, // Measurement scale
+	target => target.measurementScale !== undefined,
+	(reader, target, left) => {
+		target.measurementScale = readBytes(reader, left());
+	},
+	(writer, target) => {
+		writeBytes(writer, target.measurementScale);
+	},
+);
+
 addHandler(
 	1042, // Effects visible (only present when effects are hidden)
 	target => target.effectsVisible !== undefined,

package/src/index.ts

@@ -5,6 +5,7 @@ import { fromByteArray } from 'base64-js';
 
 export * from './abr';
 export * from './csh';
+export * from './ase';
 export { initializeCanvas } from './helpers';
 export * from './psd';
 export type { PsdReader, PsdWriter };

package/src/psd.ts

@@ -31,7 +31,15 @@ export type HSB = { h: number; s: number; b: number; }; // values from 0 to 1
 export type CMYK = { c: number; m: number; y: number; k: number; }; // values from 0 to 255
 export type LAB = { l: number; a: number; b: number; }; // values `l` from 0 to 1; `a` and `b` from -1 to 1
 export type Grayscale = { k: number }; // values from 0 to 255
-export type Color = RGBA | RGB | FRGB | HSB | CMYK | LAB | Grayscale;
+export interface ColorBookInfo {
+	book: string; // name of the color book (e.g. 'PANTONE+® Solid Coated')
+	name: string; // name of the color in the book (e.g. 'PANTONE 688 C')
+	bookID: number;
+	bookKey: string; // unique key of the color in the book
+}
+// `book` is only present for colors picked from color books (Pantone, etc.) in descriptors, color values are the
+// book color converted to document color space
+export type Color = (RGBA | RGB | FRGB | HSB | CMYK | LAB | Grayscale) & { book?: ColorBookInfo; };
 
 export interface EffectContour {
 	name: string;
@@ -559,6 +567,9 @@ export interface CurvesAdjustment extends PresetInfo {
 	// curve for each channel, index 0 is composite channel, followed by document color channels (red, green, blue for RGB,
 	// cyan, magenta, yellow, black for CMYK, gray for Grayscale), missing or empty curve means no change to the channel
 	channels?: CurvesAdjustmentChannel[];
+	// curves drawn with pencil tool, lookup table of 256 output values (0-255) for each channel (same indexing as
+	// `channels`), missing or empty table means no change to the channel, used instead of `channels` when present
+	values?: number[][];
 }
 
 export interface ExposureAdjustment extends PresetInfo {
@@ -1213,8 +1224,75 @@ type FilterVariant = {
 		contrast: number;
 		useLegacy: boolean;
 	};
+} | {
+	type: 'camera raw';
+	filter: CameraRawFilterSettings;
 };
 
+export type CameraRawCurvePoint = { input: number; output: number; };
+export type CameraRawColors = { red?: number; orange?: number; yellow?: number; green?: number; aqua?: number; blue?: number; purple?: number; magenta?: number; };
+export type CameraRawColorGradingWheel = { hue?: number; saturation?: number; luminance?: number; };
+
+// Camera Raw Filter settings (missing values use Camera Raw defaults), settings that are not supported are not preserved
+export interface CameraRawFilterSettings {
+	version?: string; // Camera Raw version (e.g. '18.4')
+	processVersion?: number;
+	processVersionCode?: number;
+	whiteBalance?: string; // raw white balance value (e.g. 'Cst ' for custom)
+	temperature?: number;
+	tint?: number;
+	exposure?: number;
+	contrast?: number;
+	highlights?: number;
+	shadows?: number;
+	whites?: number;
+	blacks?: number;
+	texture?: number;
+	clarity?: number;
+	dehaze?: number;
+	vibrance?: number;
+	saturation?: number;
+	parametricCurve?: {
+		shadows?: number;
+		darks?: number;
+		lights?: number;
+		highlights?: number;
+		shadowSplit?: number;
+		midtoneSplit?: number;
+		highlightSplit?: number;
+	};
+	pointCurve?: {
+		composite?: CameraRawCurvePoint[];
+		red?: CameraRawCurvePoint[];
+		green?: CameraRawCurvePoint[];
+		blue?: CameraRawCurvePoint[];
+	};
+	hsl?: {
+		hue?: CameraRawColors;
+		saturation?: CameraRawColors;
+		luminance?: CameraRawColors;
+	};
+	colorGrading?: {
+		shadows?: CameraRawColorGradingWheel;
+		midtones?: CameraRawColorGradingWheel;
+		highlights?: CameraRawColorGradingWheel;
+		global?: CameraRawColorGradingWheel;
+		blending?: number;
+		balance?: number;
+	};
+	sharpening?: { amount?: number; radius?: number; detail?: number; masking?: number; };
+	noiseReduction?: {
+		luminance?: number;
+		luminanceDetail?: number;
+		luminanceContrast?: number;
+		color?: number;
+		colorDetail?: number;
+		colorSmoothness?: number;
+	};
+	grain?: { amount?: number; size?: number; roughness?: number; };
+	postCropVignette?: { amount?: number; midpoint?: number; feather?: number; roundness?: number; };
+}
+
 /*
 export interface Position3D {
 	x: number;
@@ -1290,7 +1368,8 @@ export type AdjustmentLayer = BrightnessAdjustment | LevelsAdjustment | CurvesAd
 	InvertAdjustment | PosterizeAdjustment | ThresholdAdjustment | GradientMapAdjustment |
 	SelectiveColorAdjustment;
 
-export type LayerColor = 'none' | 'red' | 'orange' | 'yellow' | 'green' | 'blue' | 'violet' | 'gray';
+export type LayerColor = 'none' | 'red' | 'orange' | 'yellow' | 'green' | 'blue' | 'violet' | 'gray' |
+	'seafoam' | 'indigo' | 'magenta' | 'fuchsia';
 
 export interface KeyDescriptorItem {
 	keyShapeInvalidated?: boolean;
@@ -1414,6 +1493,7 @@ export interface LayerAdditionalInfo {
 	blendInteriorElements?: boolean;
 	knockout?: boolean;
 	layerMaskAsGlobalMask?: boolean;
+	vectorMaskAsGlobalMask?: boolean;
 	protected?: {
 		transparency?: boolean;
 		composite?: boolean;
@@ -1542,6 +1622,26 @@ export interface LayerAdditionalInfo {
 		ranges: { sourceRange: number[]; destRange: number[]; }[];
 	};
 	vowv?: number; // ???
+	foreignEffectId?: number; // foreign effect ID (Photoshop 6.0)
+	framedGroup?: { // frame tool group (frame layer)
+		rect: { top: number; left: number; bottom: number; right: number; };
+		type: number; // 1 - rectangle, 2 - ellipse
+		lockPPI?: boolean;
+		preferredResolution?: number;
+		savedIteratedName?: string;
+	};
+	animationEffects?: Uint8Array; // animation effects (Photoshop CS6, raw descriptor data)
+	patternData?: { // pattern data (Photoshop 6.0)
+		signature: string;
+		key: string;
+		copyOnSheetDuplication: boolean;
+		patterns: {
+			colorHandling: 'convert' | 'avoid conversion' | 'luminance only';
+			name: string;
+			id: string;
+		}[];
+	}[];
+	pixelSourceData?: Uint8Array[]; // pixel source data of video layers (raw data of each entry)
 	pixelSource?: {
 		type: 'vdPS';
 		origin: { x: number; y: number; };
@@ -1676,6 +1776,7 @@ export interface ImageResources {
 		x: number; // pixels
 		y: number; // pixels
 		colorSpace: number; // -1 - actual color, 0 - RGB, 1 - HSB, 2 - CMYK, 7 - Lab, 8 - grayscale, ...
+		depth?: number; // sample size (Photoshop CS3 format), samplers are written in Photoshop 5 format if missing
 	}[];
 	effectsVisible?: boolean; // global flag to show or hide all layer effects
 	iccProfile?: Uint8Array; // raw ICC profile data
@@ -1687,6 +1788,18 @@ export interface ImageResources {
 	grayscaleHalftoneScreens?: HalftoneScreen[];
 	colorTransferFunctions?: PrintTransferFunction[]; // one for each of 4 printing plates
 	grayscaleTransferFunctions?: PrintTransferFunction[];
+	duotoneHalftoneScreens?: HalftoneScreen[];
+	duotoneTransferFunctions?: PrintTransferFunction[];
+	duotoneImageInformation?: Uint8Array; // raw data
+	alternateDuotoneColors?: {
+		colors: Color[];
+		labColors: Uint8Array; // Lab color table (usually 256 colors), 3 bytes for each color (L, a, b)
+	};
+	quickMaskInfo?: {
+		channelId: number;
+		initiallyEmpty: boolean;
+	};
+	measurementScale?: Uint8Array; // raw descriptor data
 	printStyle?: {
 		caption?: boolean;
 		calibrationBars?: boolean;