ag-psd 32.0.0 → 34.0.0

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/jpeg.ts

@@ -761,7 +761,7 @@ function parse(data: Uint8Array) {
             };
           }
         }
-        // TODO APP1 - Exif
+        // APP1 - Exif
         if (fileMarker === 0xFFE1) {
           if (appData[0] === 0x45 &&
             appData[1] === 0x78 &&
@@ -952,11 +952,11 @@ function parse(data: Uint8Array) {
   // set each frame's components quantization table
   for (let i = 0; i < frames.length; i++) {
     const cp = frames[i].components;
-    for (let j in cp) { // TODO: don't use `in`
-      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 ???
+    for (const key of Object.keys(cp)) {
+      const component = cp[+key];
+      const table = quantizationTables[component.quantizationIdx!];
+      if (!table) throw new Error(`Missing quantization table ${component.quantizationIdx}`);
+      component.quantizationTable = table;
     }
   }
 
@@ -1021,8 +1021,8 @@ function getData(decoded: Decoded) {
       break;
     }
     case 3: {
-      // The default transform for three components is true, the adobe transform marker overrides it
-      colorTransform = decoded.adobe ? !!decoded.adobe.transformCode : true;
+      // The default transform for three components is true, JFIF marker implies YCbCr, otherwise the adobe transform marker overrides it
+      colorTransform = decoded.jfif ? true : decoded.adobe ? !!decoded.adobe.transformCode : true;
 
       const component1 = decoded.components[0];
       const component2 = decoded.components[1];

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;
@@ -40,8 +48,7 @@ export interface EffectContour {
 
 export interface EffectPattern {
 	name: string;
-	id: string;
-	// TODO: add fields
+	id: string; // pattern data is stored in `patterns` field of the document
 }
 
 export interface LayerEffectShadow {
@@ -70,12 +77,15 @@ export interface LayerEffectsOuterGlow {
 	blendMode?: BlendMode;
 	opacity?: number;
 	source?: GlowSource;
+	technique?: GlowTechnique;
 	antialiased?: boolean;
 	noise?: number;
 	range?: number;
 	choke?: UnitsValue;
 	jitter?: number;
 	contour?: EffectContour;
+	gradient?: EffectSolidGradient | EffectNoiseGradient;
+	interpolationMethod?: InterpolationMethod;
 }
 
 export interface LayerEffectInnerGlow {
@@ -94,6 +104,8 @@ export interface LayerEffectInnerGlow {
 	choke?: UnitsValue; // spread
 	jitter?: number;
 	contour?: EffectContour;
+	gradient?: EffectSolidGradient | EffectNoiseGradient;
+	interpolationMethod?: InterpolationMethod;
 }
 
 export interface LayerEffectBevel {
@@ -118,7 +130,10 @@ export interface LayerEffectBevel {
 	useTexture?: boolean;
 	useShape?: boolean;
 	antialiasGloss?: boolean;
-	contour?: EffectContour;
+	contour?: EffectContour; // gloss contour
+	shapeContour?: EffectContour; // contour of the bevel shape, used when `useShape` is enabled
+	range?: number;
+	antialiased?: boolean;
 }
 
 export interface LayerEffectSolidFill {
@@ -142,7 +157,7 @@ export interface LayerEffectStroke {
 	opacity?: number;
 	color?: Color;
 	gradient?: (EffectSolidGradient | EffectNoiseGradient) & ExtraGradientInfo;
-	pattern?: EffectPattern & {}; // TODO: additional pattern info
+	pattern?: EffectPattern & ExtraPatternInfo;
 }
 
 export interface LayerEffectSatin {
@@ -160,7 +175,6 @@ export interface LayerEffectSatin {
 	contour?: EffectContour;
 }
 
-// not supported yet because of `Patt` section not implemented
 export interface LayerEffectPatternOverlay {
 	present?: boolean;
 	showInDialog?: boolean;
@@ -168,6 +182,7 @@ export interface LayerEffectPatternOverlay {
 	blendMode?: BlendMode;
 	opacity?: number;
 	scale?: number;
+	angle?: number;
 	pattern?: EffectPattern;
 	phase?: { x: number; y: number; };
 	align?: boolean;
@@ -222,7 +237,7 @@ export interface LayerEffectsInfo {
 	satin?: LayerEffectSatin;
 	stroke?: LayerEffectStroke[];
 	gradientOverlay?: LayerEffectGradientOverlay[];
-	patternOverlay?: LayerEffectPatternOverlay; // not supported yet because of `Patt` section not implemented
+	patternOverlay?: LayerEffectPatternOverlay; // pattern is referenced only by name/id
 }
 
 export type PixelArray = Uint8ClampedArray | Uint8Array | Uint16Array | Float32Array;
@@ -250,7 +265,7 @@ export interface LayerMaskData {
 	imageData?: PixelData;
 }
 
-export type TextGridding = 'none' | 'round'; // TODO: other values (no idea where to set it up in Photoshop)
+export type TextGridding = 'none' | 'round';
 export type Orientation = 'horizontal' | 'vertical';
 export type AntiAlias = 'none' | 'sharp' | 'crisp' | 'strong' | 'smooth' | 'platform' | 'platformLCD';
 export type WarpStyle =
@@ -497,6 +512,8 @@ export interface ExtraGradientInfo {
 export interface ExtraPatternInfo {
 	linked?: boolean;
 	phase?: { x: number; y: number; };
+	scale?: number;
+	angle?: number;
 }
 
 export type VectorContent = { type: 'color'; color: Color; } |
@@ -506,7 +523,7 @@ export type VectorContent = { type: 'color'; color: Color; } |
 
 export type RenderingIntent = 'perceptual' | 'saturation' | 'relative colorimetric' | 'absolute colorimetric';
 
-export type Units = 'Pixels' | 'Points' | 'Picas' | 'Millimeters' | 'Centimeters' | 'Inches' | 'None' | 'Density';
+export type Units = 'Pixels' | 'Points' | 'Picas' | 'Millimeters' | 'Centimeters' | 'Inches' | 'None' | 'Density' | 'Distance'; // Distance is in points (1/72 inch)
 
 export interface UnitsValue {
 	units: Units;
@@ -538,22 +555,21 @@ export interface PresetInfo {
 
 export interface LevelsAdjustment extends PresetInfo {
 	type: 'levels';
-	// TODO: change to generic array of channels (because of other document type CMYK, Lab, etc)
-	rgb?: LevelsAdjustmentChannel;
-	red?: LevelsAdjustmentChannel;
-	green?: LevelsAdjustmentChannel;
-	blue?: LevelsAdjustmentChannel;
+	// levels 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 channels use default values (no change)
+	channels?: LevelsAdjustmentChannel[];
 }
 
 export type CurvesAdjustmentChannel = { input: number; output: number; }[];
 
 export interface CurvesAdjustment extends PresetInfo {
 	type: 'curves';
-	// TODO: change to generic array of channels (because of other document type CMYK, Lab, etc)
-	rgb?: CurvesAdjustmentChannel;
-	red?: CurvesAdjustmentChannel;
-	green?: CurvesAdjustmentChannel;
-	blue?: CurvesAdjustmentChannel;
+	// 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 {
@@ -581,7 +597,17 @@ export interface HueSaturationAdjustmentChannel {
 
 export interface HueSaturationAdjustment extends PresetInfo {
 	type: 'hue/saturation';
-	master?: HueSaturationAdjustmentChannel;
+	colorize?: boolean;
+	colorization?: {
+		hue: number; // 0..360
+		saturation: number; // 0..100
+		lightness: number; // -100..100
+	};
+	master?: {
+		hue: number;
+		saturation: number;
+		lightness: number;
+	};
 	reds?: HueSaturationAdjustmentChannel;
 	yellows?: HueSaturationAdjustmentChannel;
 	greens?: HueSaturationAdjustmentChannel;
@@ -670,6 +696,7 @@ export interface ColorStop {
 	color: Color;
 	location: number;
 	midpoint: number;
+	type?: 'foreground' | 'background'; // stop uses foreground/background color (`color` is the color at the time of saving)
 }
 
 export interface OpacityStop {
@@ -737,6 +764,15 @@ export type LinkedFile = {
 	};
 }
 
+export interface LevelsFilterAdjustment {
+	channels: ('composite' | 'red' | 'green' | 'blue')[];
+	shadowInput?: number; // 0..255
+	highlightInput?: number; // 0..255
+	shadowOutput?: number; // 0..255
+	highlightOutput?: number; // 0..255
+	midtoneInput?: number; // gamma, 1 by default
+}
+
 type FilterVariant = {
 	type: 'average' | 'blur' | 'blur more';
 } | {
@@ -1164,7 +1200,7 @@ type FilterVariant = {
 } | {
 	type: 'curves';
 	filter: {
-		presetKind: 'custom' | 'default';
+		presetKind?: 'custom' | 'default';
 		adjustments?: ({
 			channels: ('composite' | 'red' | 'green' | 'blue')[];
 			curve: { x: number; y: number; curved?: boolean; }[];
@@ -1173,6 +1209,12 @@ type FilterVariant = {
 			values: number[];
 		})[];
 	};
+} | {
+	type: 'levels';
+	filter: {
+		presetKind?: 'custom' | 'default';
+		adjustments?: LevelsFilterAdjustment[];
+	};
 } | {
 	type: 'invert';
 } | {
@@ -1182,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;
@@ -1234,6 +1343,7 @@ export interface PlacedLayer {
 	id: string; // id of linked image file (psd.linkedFiles), must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)
 	placed?: string; // unique id
 	type: PlacedLayerType;
+	external?: boolean; // linked smart object (linked file is stored outside of the document)
 	pageNumber?: number;
 	totalPages?: number;
 	frameStep?: { numerator: number; denominator: number; };
@@ -1258,11 +1368,12 @@ 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;
-	keyOriginType?: number;
+	keyOriginType?: number; // shape type: 1 - rectangle, 2 - rounded rectangle, 4 - line, 5 - ellipse, 8 - polygon
 	keyOriginResolution?: number;
 	keyOriginRRectRadii?: {
 		topRight: UnitsValue;
@@ -1280,10 +1391,7 @@ export interface KeyDescriptorItem {
 	transform?: number[]; // 2d transform matrix [xx, xy, yx, yy, tx, ty]
 }
 
-export interface LayerVectorMask {
-	invert?: boolean;
-	notLink?: boolean;
-	disable?: boolean;
+export interface VectorPathData {
 	fillStartsWithAllPixels?: boolean;
 	clipboard?: {
 		top: number;
@@ -1295,6 +1403,20 @@ export interface LayerVectorMask {
 	paths: BezierPath[];
 }
 
+export interface LayerVectorMask extends VectorPathData {
+	invert?: boolean;
+	notLink?: boolean;
+	disable?: boolean;
+}
+
+export interface SavedPath extends VectorPathData {
+	name: string;
+	symmetryMode?: string; // raw enum value, e.g. 'pathSymmetryModeBasicPath'
+	vectorOrigination?: {
+		keyDescriptorList: KeyDescriptorItem[];
+	};
+}
+
 export interface AnimationFrame {
 	frames: number[]; // IDs of frames that this modifiers applies to
 	enable?: boolean;
@@ -1371,11 +1493,13 @@ export interface LayerAdditionalInfo {
 	blendInteriorElements?: boolean;
 	knockout?: boolean;
 	layerMaskAsGlobalMask?: boolean;
+	vectorMaskAsGlobalMask?: boolean;
 	protected?: {
 		transparency?: boolean;
 		composite?: boolean;
 		position?: boolean;
 		artboards?: boolean;
+		all?: boolean;
 	};
 	layerColor?: LayerColor;
 	referencePoint?: {
@@ -1393,7 +1517,7 @@ export interface LayerAdditionalInfo {
 	};
 	effects?: LayerEffectsInfo;
 	text?: LayerTextData;
-	patterns?: PatternInfo[]; // not supported yet
+	patterns?: PatternInfo[];
 	vectorFill?: VectorContent;
 	vectorStroke?: {
 		strokeEnabled?: boolean;
@@ -1415,9 +1539,15 @@ export interface LayerAdditionalInfo {
 	vectorMask?: LayerVectorMask;
 	usingAlignedRendering?: boolean;
 	timestamp?: number; // seconds
-	pathList?: {
-		// TODO: ...
-	}[];
+	generatorSettings?: { // Generator (Export As) settings
+		exportAs?: {
+			exportOption?: string; // JSON string
+			scaleSettings?: string; // JSON string
+		};
+		assets?: string; // JSON string, Generator image assets settings (only on document)
+		layerTime?: number; // seconds
+		crema?: string; // JSON string, Export As document settings (only on document)
+	};
 	adjustment?: AdjustmentLayer;
 	placedLayer?: PlacedLayer;
 	vectorOrigination?: {
@@ -1492,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; };
@@ -1525,6 +1675,20 @@ export enum LayerCompCapturedInfo {
 	Appearance = 4,
 }
 
+export interface HalftoneScreen {
+	frequency: number;
+	frequencyUnits: 'lines/inch' | 'lines/cm';
+	angle: number; // degrees
+	shape: 'round' | 'ellipse' | 'line' | 'square' | 'cross' | 'diamond';
+	accurateScreens: boolean;
+	printerDefaultScreens: boolean;
+}
+
+export interface PrintTransferFunction {
+	curve: number[]; // 13 points, values 0..1000 (0% - 100%), -1 for missing points (first and last point are always set)
+	override: boolean;
+}
+
 export interface ImageResources {
 	layerState?: number;
 	layerSelectionIds?: number[];
@@ -1554,6 +1718,8 @@ export interface ImageResources {
 		guides?: {
 			location: number;
 			direction: 'horizontal' | 'vertical';
+			color?: RGB; // Photoshop default is cyan (74, 255, 255)
+			id?: string; // unique id (GUID)
 		}[];
 	};
 	resolutionInfo?: {
@@ -1578,6 +1744,7 @@ export interface ImageResources {
 		printerManagesColors?: boolean;
 		printerName?: string;
 		printerProfile?: string;
+		printerProfileColorSpace?: 'rgb' | 'grayscale'; // color space of printer profile, missing value means 'rgb'
 		printSixteenBit?: boolean;
 		renderingIntent?: RenderingIntent;
 		hardProof?: boolean;
@@ -1605,7 +1772,76 @@ export interface ImageResources {
 		printFlags?: boolean;
 	};
 	iccUntaggedProfile?: boolean;
+	colorSamplers?: {
+		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
+	exifData?: Uint8Array; // raw EXIF data (TIFF format)
+	iptcData?: Uint8Array; // raw IPTC-NAA record
+	windowsDevMode?: Uint8Array; // raw Windows DEVMODE structure (printer settings)
+	outputSettings?: any; // Save for Web output settings (raw descriptor)
+	colorHalftoneScreens?: HalftoneScreen[]; // cyan, magenta, yellow and black
+	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;
+		registrationMarks?: boolean;
+		cornerCropMarks?: boolean;
+		centerCropMarks?: boolean;
+		labels?: boolean;
+		negative?: boolean;
+		emulsionDown?: boolean;
+		interpolate?: boolean;
+		backgroundColor?: Color;
+		border?: UnitsValue;
+		bleed?: UnitsValue;
+		resolution?: UnitsValue;
+		vectorData?: boolean;
+		pagePosition?: string; // 'centered' or raw enum value
+		left?: UnitsValue;
+		top?: UnitsValue;
+		scale?: number; // 0..1
+		cropWhenPrinting?: boolean;
+		cropRect?: { top: number; left: number; bottom: number; right: number; };
+	};
+	printFlagsInfo?: {
+		centerCropMarks: boolean;
+		bleedWidth: number;
+		bleedWidthScale: number;
+	};
+	indexedColorCount?: number; // number of used colors in indexed color palette
+	transparencyIndex?: number; // index of transparent color in indexed color palette
+	alphaChannelDisplayInfo?: {
+		color?: Color;
+		rawColor?: { colorSpace: number; values: number[]; }; // color in color space not supported by this library (instead of `color`)
+		opacity: number; // 0..1
+		kind: 'selected' | 'protected' | 'spot'; // color indicates selected areas, protected (masked) areas or spot color
+	}[];
 	pathSelectionState?: string[];
+	savedPaths?: SavedPath[]; // paths from the paths panel
+	workPath?: VectorPathData;
+	clippingPath?: {
+		name: string; // name of the saved path used as clipping path
+		flatness: number; // device pixels, 0 for printer default
+	};
 	imageReadyVariables?: string;
 	imageReadyDataSets?: string;
 	animations?: Animations;
@@ -1794,7 +2030,7 @@ export interface Psd extends LayerAdditionalInfo {
 	imageData?: PixelData;
 	rawCompositeData?: Uint8Array;
 	/** Information needed to decode `rawCompositeData` (see `getCompositeImageData`) */
-	rawCompositeDataInfo?: { large: boolean; globalAlpha: boolean; };
+	rawCompositeDataInfo?: { large: boolean; globalAlpha: boolean; layersInGlobalInfo?: boolean; };
 	imageResources?: ImageResources;
 	linkedFiles?: LinkedFile[]; // used in smart objects
 	artboards?: {
@@ -1865,4 +2101,7 @@ export interface WriteOptions {
 	/** Uses zip compression when writing PSD file, will result in smaller file size but may be incompatible
 	 *  with some software. It may also be significantly slower. */
 	compress?: boolean;
+
+	/** Used only for development. */
+	log?: (...args: any[]) => void;
 }