ag-psd 32.0.0 → 34.0.0

package/src/additionalInfo.ts

@@ -1,16 +1,18 @@
 import { fromByteArray, toByteArray } from 'base64-js';
 import { readEffects, writeEffects } from './effectsHelpers';
 import { clamp, createEnum, layerColors, MOCK_HANDLERS, normalizeLabAB } from './helpers';
-import { LayerAdditionalInfo, BezierPath, Psd, BrightnessAdjustment, ExposureAdjustment, VibranceAdjustment, ColorBalanceAdjustment, BlackAndWhiteAdjustment, PhotoFilterAdjustment, ChannelMixerChannel, ChannelMixerAdjustment, PosterizeAdjustment, ThresholdAdjustment, GradientMapAdjustment, CMYK, SelectiveColorAdjustment, ColorLookupAdjustment, LevelsAdjustmentChannel, LevelsAdjustment, CurvesAdjustment, CurvesAdjustmentChannel, HueSaturationAdjustment, HueSaturationAdjustmentChannel, PresetInfo, Color, ColorBalanceValues, WriteOptions, LinkedFile, PlacedLayerType, Warp, KeyDescriptorItem, BooleanOperation, LayerEffectsInfo, Annotation, LayerVectorMask, AnimationFrame, Timeline, PlacedLayerFilter, UnitsValue, Filter, PlacedLayer, ReadOptions, Layer } from './psd';
-import { PsdReader, readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16, readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32, readPascalString, readUnicodeStringWithLength, readAsciiString, readPattern, readLayerInfo } from './psdReader';
+import { LayerAdditionalInfo, LevelsFilterAdjustment, BezierPath, Psd, BrightnessAdjustment, ExposureAdjustment, VibranceAdjustment, ColorBalanceAdjustment, BlackAndWhiteAdjustment, PhotoFilterAdjustment, ChannelMixerChannel, ChannelMixerAdjustment, PosterizeAdjustment, ThresholdAdjustment, GradientMapAdjustment, CMYK, SelectiveColorAdjustment, ColorLookupAdjustment, LevelsAdjustmentChannel, LevelsAdjustment, CurvesAdjustment, CurvesAdjustmentChannel, HueSaturationAdjustment, HueSaturationAdjustmentChannel, PresetInfo, Color, ColorBalanceValues, WriteOptions, LinkedFile, PlacedLayerType, Warp, KeyDescriptorItem, BooleanOperation, LayerEffectsInfo, Annotation, VectorPathData, AnimationFrame, Timeline, PlacedLayerFilter, UnitsValue, Filter, PlacedLayer, Layer, CameraRawColors, CameraRawCurvePoint, CameraRawFilterSettings } from './psd';
+import { PsdReader, readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16, readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32, readPascalString, readUnicodeStringWithLength, readAsciiString, readPatternSafe, readLayerInfo } from './psdReader';
 import { PsdWriter, writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32, writePattern, writeUint64 } from './psdWriter';
-import { Annt, BlnM, DescriptorColor, DescriptorUnitsValue, parsePercent, parseUnits, parseUnitsOrNumber, QuiltWarpDescriptor, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, TextDescriptor, textGridding, unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor, FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, FractionDescriptor, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy, Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd, unitsPercentF, frac, ClrS, descBoundsToBounds, boundsToDescBounds, presetKindType, gradientInterpolationMethodType, PxScDescriptor } from './descriptor';
+import { Annt, BlnM, DescriptorColor, DescriptorUnitsValue, parsePercent, parseUnits, parseUnitsOrNumber, QuiltWarpDescriptor, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, TextDescriptor, textGridding, unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor, FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, FractionDescriptor, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy, Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd, unitsPercentF, frac, ClrS, descBoundsToBounds, boundsToDescBounds, presetKindType, gradientInterpolationMethodType, PxScDescriptor, cameraRawFilterClassID, patternColorHandling } from './descriptor';
 import { serializeEngineData, parseEngineData } from './engineData';
-import { encodeEngineData, decodeEngineData } from './text';
+import { encodeEngineData, decodeEngineData, decodeLegacyTextData, LegacyTextData } from './text';
 import { decodeEngineData2 } from './engineData2';
 import type { InternalImageResources } from './imageResources';
 
 export interface ExtendedWriteOptions extends WriteOptions {
+	colorMode?: number; // color mode of written document
+	bitsPerChannel?: number; // bit depth of written document
 	layerIds: Set<number>;
 	layerToId: Map<any, number>;
 	explicitLayerIds?: Set<number>; // ids set on layers in the document (generated ids can't use them)
@@ -103,7 +105,8 @@ addHandler(
 			// require('fs').writeFileSync('after.txt', require('util').inspect(after, false, 99, false), 'utf8');
 
 			// console.log(require('util').inspect(parseEngineData(text.EngineData), false, 99, true));
-			target.text = { ...target.text, ...textData };
+			// descriptor anti-alias value is more reliable than the one from engine data
+			target.text = { ...target.text, ...textData, antiAlias: target.text!.antiAlias ?? textData.antiAlias };
 			// console.log(require('util').inspect(target.text, false, 99, true));
 		}
 
@@ -146,15 +149,95 @@ addHandler(
 	},
 );
 
+// type tool info from Photoshop 5.0 and 5.5, converted to regular text data (written as 'TySh')
+addHandler(
+	'tySh',
+	() => false,
+	(reader, target, left) => {
+		if (readInt16(reader) !== 1) throw new Error(`Invalid tySh version`);
+
+		const transform: number[] = [];
+		for (let i = 0; i < 6; i++) transform.push(readFloat64(reader));
+
+		if (readInt16(reader) !== 6) throw new Error(`Invalid tySh font version`);
+
+		const data: LegacyTextData = { transform, faces: [], styles: [], lines: [], color: { r: 0, g: 0, b: 0 }, antiAlias: false };
+		const facesCount = readInt16(reader);
+
+		for (let i = 0; i < facesCount; i++) {
+			const mark = readInt16(reader);
+			readInt32(reader); // font type
+			const name = readPascalString(reader, 1);
+			const familyName = readPascalString(reader, 1);
+			const styleName = readPascalString(reader, 1);
+			const script = readInt16(reader);
+			const axesCount = readInt32(reader);
+			if (axesCount < 0 || axesCount * 4 > left()) throw new Error(`Invalid tySh design axes count`);
+			skipBytes(reader, axesCount * 4);
+			data.faces.push({ mark, name, familyName, styleName, script });
+		}
+
+		const stylesCount = readInt16(reader);
+
+		for (let i = 0; i < stylesCount; i++) {
+			const mark = readInt16(reader);
+			const faceMark = readInt16(reader);
+			const size = readInt32(reader);
+			const tracking = readInt32(reader);
+			const kerning = readInt32(reader);
+			const leading = readInt32(reader);
+			const baselineShift = readInt32(reader);
+			const autoKerning = !!readUint8(reader);
+			readUint8(reader); // rotate
+			data.styles.push({ mark, faceMark, size, tracking, kerning, leading, baselineShift, autoKerning });
+		}
+
+		readInt16(reader); // type (0 = point, 1 = paragraph)
+		readInt32(reader); // scaling factor
+		readInt32(reader); // character count
+		readInt32(reader); // horizontal placement
+		readInt32(reader); // vertical placement
+		readInt32(reader); // select start
+		readInt32(reader); // select end
+
+		const linesCount = readInt16(reader);
+
+		for (let i = 0; i < linesCount; i++) {
+			const charCount = readInt32(reader);
+			const orientation = readInt16(reader);
+			const alignment = readInt16(reader);
+			if (charCount < 0 || charCount * 4 > left()) throw new Error(`Invalid tySh character count`);
+			const chars: { code: number; style: number; }[] = [];
+
+			for (let j = 0; j < charCount; j++) {
+				const code = readUint16(reader);
+				const style = readInt16(reader);
+				chars.push({ code, style });
+			}
+
+			data.lines.push({ orientation, alignment, chars });
+		}
+
+		data.color = readColor(reader);
+		data.antiAlias = !!readUint8(reader);
+
+		if (!target.text) target.text = decodeLegacyTextData(data);
+
+		skipBytes(reader, left());
+	},
+	() => { },
+);
+
 // vector fills
 
 addHandler(
 	'SoCo',
 	target => target.vectorFill !== undefined && target.vectorStroke === undefined &&
 		target.vectorFill.type === 'color',
-	(reader, target) => {
+	(reader, target, left) => {
 		const descriptor = readVersionAndDescriptor(reader);
 		target.vectorFill = parseVectorContent(descriptor);
+		skipBytes(reader, left());
 	},
 	(writer, target) => {
 		const { descriptor } = serializeVectorContent(target.vectorFill!);
@@ -228,7 +311,7 @@ function writeBezierKnot(writer: PsdWriter, points: number[], width: number, hei
 
 export const booleanOperations: BooleanOperation[] = ['exclude', 'combine', 'subtract', 'intersect'];
 
-export function readVectorMask(reader: PsdReader, vectorMask: LayerVectorMask, width: number, height: number, size: number) {
+export function readVectorMask(reader: PsdReader, vectorMask: VectorPathData, width: number, height: number, size: number) {
 	const end = reader.offset + size;
 	const paths = vectorMask.paths;
 	let path: BezierPath | undefined = undefined;
@@ -283,6 +366,51 @@ export function readVectorMask(reader: PsdReader, vectorMask: LayerVectorMask, w
 	return paths;
 }
 
+// componentIndices - write index of path component for each subpath (Photoshop writes them for layer vector masks)
+export function writeVectorMask(writer: PsdWriter, vectorMask: VectorPathData, width: number, height: number, componentIndices = false) {
+	// initial entry
+	writeUint16(writer, 6);
+	writeZeros(writer, 24);
+
+	const clipboard = vectorMask.clipboard;
+	if (clipboard) {
+		writeUint16(writer, 7);
+		writeFixedPointPath32(writer, clipboard.top);
+		writeFixedPointPath32(writer, clipboard.left);
+		writeFixedPointPath32(writer, clipboard.bottom);
+		writeFixedPointPath32(writer, clipboard.right);
+		writeFixedPointPath32(writer, clipboard.resolution);
+		writeZeros(writer, 4);
+	}
+
+	writeUint16(writer, 8);
+	writeUint16(writer, vectorMask.fillStartsWithAllPixels ? 1 : 0);
+	writeZeros(writer, 22);
+
+	let componentIndex = -1;
+
+	for (const path of vectorMask.paths) {
+		// subpaths without operation are part of the same path component as previous subpath
+		if (path.operation || componentIndex < 0) componentIndex++;
+
+		writeUint16(writer, path.open ? 3 : 0);
+		writeUint16(writer, path.knots.length);
+		writeUint16(writer, path.operation ? booleanOperations.indexOf(path.operation) : -1); // -1 for undefined
+		writeUint16(writer, path.fillRule === 'non-zero' ? 2 : 1);
+		writeZeros(writer, 4);
+		writeUint32(writer, componentIndices ? componentIndex : 0);
+		writeZeros(writer, 10);
+
+		const linkedKnot = path.open ? 4 : 1;
+		const unlinkedKnot = path.open ? 5 : 2;
+
+		for (const { linked, points } of path.knots) {
+			writeUint16(writer, linked ? linkedKnot : unlinkedKnot);
+			writeBezierKnot(writer, points, width, height);
+		}
+	}
+}
+
 addHandler(
 	'vmsk',
 	hasKey('vectorMask'),
@@ -312,45 +440,11 @@ addHandler(
 
 		writeUint32(writer, 3); // version
 		writeUint32(writer, flags);
-
-		// initial entry
-		writeUint16(writer, 6);
-		writeZeros(writer, 24);
-
-		const clipboard = vectorMask.clipboard;
-		if (clipboard) {
-			writeUint16(writer, 7);
-			writeFixedPointPath32(writer, clipboard.top);
-			writeFixedPointPath32(writer, clipboard.left);
-			writeFixedPointPath32(writer, clipboard.bottom);
-			writeFixedPointPath32(writer, clipboard.right);
-			writeFixedPointPath32(writer, clipboard.resolution);
-			writeZeros(writer, 4);
-		}
-
-		writeUint16(writer, 8);
-		writeUint16(writer, vectorMask.fillStartsWithAllPixels ? 1 : 0);
-		writeZeros(writer, 22);
-
-		for (const path of vectorMask.paths) {
-			writeUint16(writer, path.open ? 3 : 0);
-			writeUint16(writer, path.knots.length);
-			writeUint16(writer, path.operation ? booleanOperations.indexOf(path.operation) : -1); // -1 for undefined
-			writeUint16(writer, path.fillRule === 'non-zero' ? 2 : 1);
-			writeZeros(writer, 18); // TODO: these are sometimes non-zero
-
-			const linkedKnot = path.open ? 4 : 1;
-			const unlinkedKnot = path.open ? 5 : 2;
-
-			for (const { linked, points } of path.knots) {
-				writeUint16(writer, linked ? linkedKnot : unlinkedKnot);
-				writeBezierKnot(writer, points, width, height);
-			}
-		}
+		writeVectorMask(writer, vectorMask, width, height, true);
 	},
 );
 
-// TODO: need to write vmsk if has outline ?
+// written instead of 'vmsk' for layers with vector stroke ('vscg' section)
 addHandlerAlias('vsms', 'vmsk');
 // addHandlerAlias('vmsk', 'vsms');
 
@@ -365,7 +459,7 @@ addHandler(
 	},
 );
 
-interface VogkDescriptor {
+export interface KeyDescriptorListDescriptor {
 	keyDescriptorList: {
 		keyShapeInvalidated?: boolean;
 		keyOriginType?: number;
@@ -395,121 +489,128 @@ interface VogkDescriptor {
 	}[];
 }
 
-addHandler(
-	'vogk',
-	hasKey('vectorOrigination'),
-	(reader, target, left) => {
-		if (readInt32(reader) !== 1) throw new Error(`Invalid vogk version`);
-		const desc = readVersionAndDescriptor(reader) as VogkDescriptor;
-		// console.log(require('util').inspect(desc, false, 99, true));
-
-		target.vectorOrigination = { keyDescriptorList: [] };
+export function parseKeyDescriptorList(desc: KeyDescriptorListDescriptor) {
+	const keyDescriptorList: KeyDescriptorItem[] = [];
+
+	for (const i of desc.keyDescriptorList) {
+		const item: KeyDescriptorItem = {};
+
+		if (i.keyShapeInvalidated != null) item.keyShapeInvalidated = i.keyShapeInvalidated;
+		if (i.keyOriginType != null) item.keyOriginType = i.keyOriginType;
+		if (i.keyOriginResolution != null) item.keyOriginResolution = i.keyOriginResolution;
+		if (i.keyOriginShapeBBox) {
+			item.keyOriginShapeBoundingBox = {
+				top: parseUnitsOrNumber(i.keyOriginShapeBBox['Top ']),
+				left: parseUnitsOrNumber(i.keyOriginShapeBBox.Left),
+				bottom: parseUnitsOrNumber(i.keyOriginShapeBBox.Btom),
+				right: parseUnitsOrNumber(i.keyOriginShapeBBox.Rght),
+			};
+		}
+		const rectRadii = i.keyOriginRRectRadii;
+		if (rectRadii) {
+			item.keyOriginRRectRadii = {
+				topRight: parseUnits(rectRadii.topRight),
+				topLeft: parseUnits(rectRadii.topLeft),
+				bottomLeft: parseUnits(rectRadii.bottomLeft),
+				bottomRight: parseUnits(rectRadii.bottomRight),
+			};
+		}
+		const corners = i.keyOriginBoxCorners;
+		if (corners) {
+			item.keyOriginBoxCorners = [
+				{ x: corners.rectangleCornerA.Hrzn, y: corners.rectangleCornerA.Vrtc },
+				{ x: corners.rectangleCornerB.Hrzn, y: corners.rectangleCornerB.Vrtc },
+				{ x: corners.rectangleCornerC.Hrzn, y: corners.rectangleCornerC.Vrtc },
+				{ x: corners.rectangleCornerD.Hrzn, y: corners.rectangleCornerD.Vrtc },
+			];
+		}
+		const trnf = i.Trnf;
+		if (trnf) {
+			item.transform = [trnf.xx, trnf.xy, trnf.yx, trnf.yy, trnf.tx, trnf.ty];
+		}
 
-		for (const i of desc.keyDescriptorList) {
-			const item: KeyDescriptorItem = {};
+		keyDescriptorList.push(item);
+	}
 
-			if (i.keyShapeInvalidated != null) item.keyShapeInvalidated = i.keyShapeInvalidated;
-			if (i.keyOriginType != null) item.keyOriginType = i.keyOriginType;
-			if (i.keyOriginResolution != null) item.keyOriginResolution = i.keyOriginResolution;
-			if (i.keyOriginShapeBBox) {
-				item.keyOriginShapeBoundingBox = {
-					top: parseUnitsOrNumber(i.keyOriginShapeBBox['Top ']),
-					left: parseUnitsOrNumber(i.keyOriginShapeBBox.Left),
-					bottom: parseUnitsOrNumber(i.keyOriginShapeBBox.Btom),
-					right: parseUnitsOrNumber(i.keyOriginShapeBBox.Rght),
-				};
-			}
-			const rectRadii = i.keyOriginRRectRadii;
-			if (rectRadii) {
-				item.keyOriginRRectRadii = {
-					topRight: parseUnits(rectRadii.topRight),
-					topLeft: parseUnits(rectRadii.topLeft),
-					bottomLeft: parseUnits(rectRadii.bottomLeft),
-					bottomRight: parseUnits(rectRadii.bottomRight),
-				};
-			}
-			const corners = i.keyOriginBoxCorners;
-			if (corners) {
-				item.keyOriginBoxCorners = [
-					{ x: corners.rectangleCornerA.Hrzn, y: corners.rectangleCornerA.Vrtc },
-					{ x: corners.rectangleCornerB.Hrzn, y: corners.rectangleCornerB.Vrtc },
-					{ x: corners.rectangleCornerC.Hrzn, y: corners.rectangleCornerC.Vrtc },
-					{ x: corners.rectangleCornerD.Hrzn, y: corners.rectangleCornerD.Vrtc },
-				];
-			}
-			const trnf = i.Trnf;
-			if (trnf) {
-				item.transform = [trnf.xx, trnf.xy, trnf.yx, trnf.yy, trnf.tx, trnf.ty];
-			}
+	return keyDescriptorList;
+}
 
-			target.vectorOrigination.keyDescriptorList.push(item);
-		}
+export function serializeKeyDescriptorList(keyDescriptorList: KeyDescriptorItem[]) {
+	const desc: KeyDescriptorListDescriptor = { keyDescriptorList: [] };
 
-		skipBytes(reader, left());
-	},
-	(writer, target) => {
-		target;
-		const orig = target.vectorOrigination!;
-		const desc: VogkDescriptor = { keyDescriptorList: [] };
+	for (let i = 0; i < keyDescriptorList.length; i++) {
+		const item = keyDescriptorList[i];
 
-		for (let i = 0; i < orig.keyDescriptorList.length; i++) {
-			const item = orig.keyDescriptorList[i];
+		desc.keyDescriptorList.push({} as any); // we're adding keyOriginIndex at the end
 
-			desc.keyDescriptorList.push({} as any); // we're adding keyOriginIndex at the end
+		const out = desc.keyDescriptorList[desc.keyDescriptorList.length - 1];
 
-			const out = desc.keyDescriptorList[desc.keyDescriptorList.length - 1];
+		if (item.keyOriginType != null) out.keyOriginType = item.keyOriginType;
+		if (item.keyOriginResolution != null) out.keyOriginResolution = item.keyOriginResolution;
 
-			if (item.keyOriginType != null) out.keyOriginType = item.keyOriginType;
-			if (item.keyOriginResolution != null) out.keyOriginResolution = item.keyOriginResolution;
+		const radii = item.keyOriginRRectRadii;
+		if (radii) {
+			out.keyOriginRRectRadii = {
+				unitValueQuadVersion: 1,
+				topRight: unitsValue(radii.topRight, 'topRight'),
+				topLeft: unitsValue(radii.topLeft, 'topLeft'),
+				bottomLeft: unitsValue(radii.bottomLeft, 'bottomLeft'),
+				bottomRight: unitsValue(radii.bottomRight, 'bottomRight'),
+			};
+		}
 
-			const radii = item.keyOriginRRectRadii;
-			if (radii) {
-				out.keyOriginRRectRadii = {
-					unitValueQuadVersion: 1,
-					topRight: unitsValue(radii.topRight, 'topRight'),
-					topLeft: unitsValue(radii.topLeft, 'topLeft'),
-					bottomLeft: unitsValue(radii.bottomLeft, 'bottomLeft'),
-					bottomRight: unitsValue(radii.bottomRight, 'bottomRight'),
-				};
-			}
+		const box = item.keyOriginShapeBoundingBox;
+		if (box) {
+			out.keyOriginShapeBBox = {
+				unitValueQuadVersion: 1,
+				'Top ': unitsValue(box.top, 'top'),
+				Left: unitsValue(box.left, 'left'),
+				Btom: unitsValue(box.bottom, 'bottom'),
+				Rght: unitsValue(box.right, 'right'),
+			};
+		}
 
-			const box = item.keyOriginShapeBoundingBox;
-			if (box) {
-				out.keyOriginShapeBBox = {
-					unitValueQuadVersion: 1,
-					'Top ': unitsValue(box.top, 'top'),
-					Left: unitsValue(box.left, 'left'),
-					Btom: unitsValue(box.bottom, 'bottom'),
-					Rght: unitsValue(box.right, 'right'),
-				};
-			}
+		const corners = item.keyOriginBoxCorners;
+		if (corners && corners.length === 4) {
+			out.keyOriginBoxCorners = {
+				rectangleCornerA: { Hrzn: corners[0].x, Vrtc: corners[0].y },
+				rectangleCornerB: { Hrzn: corners[1].x, Vrtc: corners[1].y },
+				rectangleCornerC: { Hrzn: corners[2].x, Vrtc: corners[2].y },
+				rectangleCornerD: { Hrzn: corners[3].x, Vrtc: corners[3].y },
+			};
+		}
 
-			const corners = item.keyOriginBoxCorners;
-			if (corners && corners.length === 4) {
-				out.keyOriginBoxCorners = {
-					rectangleCornerA: { Hrzn: corners[0].x, Vrtc: corners[0].y },
-					rectangleCornerB: { Hrzn: corners[1].x, Vrtc: corners[1].y },
-					rectangleCornerC: { Hrzn: corners[2].x, Vrtc: corners[2].y },
-					rectangleCornerD: { Hrzn: corners[3].x, Vrtc: corners[3].y },
-				};
-			}
+		const transform = item.transform;
+		if (transform && transform.length === 6) {
+			out.Trnf = {
+				xx: transform[0],
+				xy: transform[1],
+				yx: transform[2],
+				yy: transform[3],
+				tx: transform[4],
+				ty: transform[5],
+			};
+		}
 
-			const transform = item.transform;
-			if (transform && transform.length === 6) {
-				out.Trnf = {
-					xx: transform[0],
-					xy: transform[1],
-					yx: transform[2],
-					yy: transform[3],
-					tx: transform[4],
-					ty: transform[5],
-				};
-			}
+		if (item.keyShapeInvalidated != null) out.keyShapeInvalidated = item.keyShapeInvalidated;
+		out.keyOriginIndex = i;
+	}
 
-			if (item.keyShapeInvalidated != null) out.keyShapeInvalidated = item.keyShapeInvalidated;
-			out.keyOriginIndex = i;
-		}
+	return desc;
+}
 
+addHandler(
+	'vogk',
+	hasKey('vectorOrigination'),
+	(reader, target, left) => {
+		if (readInt32(reader) !== 1) throw new Error(`Invalid vogk version`);
+		const desc = readVersionAndDescriptor(reader) as KeyDescriptorListDescriptor;
+		// console.log(require('util').inspect(desc, false, 99, true));
+		target.vectorOrigination = { keyDescriptorList: parseKeyDescriptorList(desc) };
+		skipBytes(reader, left());
+	},
+	(writer, target) => {
+		const desc = serializeKeyDescriptorList(target.vectorOrigination!.keyDescriptorList);
 		writeInt32(writer, 1); // version
 		writeVersionAndDescriptor(writer, '', 'null', desc);
 	}
@@ -517,7 +618,7 @@ addHandler(
 
 addHandler(
 	'lmfx',
-	target => target.effects !== undefined && hasMultiEffects(target.effects),
+	target => target.effects !== undefined && !isGroupLayer(target) && hasMultiEffects(target.effects),
 	(reader, target, left) => {
 		const version = readUint32(reader);
 		if (version !== 0) throw new Error('Invalid lmfx version');
@@ -526,12 +627,12 @@ addHandler(
 		// console.log('READ', require('util').inspect(desc, false, 99, true));
 
 		// discard if read in 'lrFX' or 'lfx2' section
-		target.effects = parseEffects(desc, !!reader.logMissingFeatures);
+		target.effects = parseEffects(desc, reader);
 
 		skipBytes(reader, left());
 	},
-	(writer, target, _, options) => {
-		const desc = serializeEffects(target.effects!, !!options.logMissingFeatures, true);
+	(writer, target) => {
+		const desc = serializeEffects(target.effects!, writer, true);
 		// console.log('WRITE', require('util').inspect(desc, false, 99, true));
 
 		writeUint32(writer, 0); // version
@@ -621,7 +722,12 @@ addHandler(
 
 		if (target.id !== undefined) {
 			id = target.id;
-			while (options.layerIds.has(id)) id += 100; // make sure we don't have duplicate layer ids
+
+			if (options.layerIds.has(id)) {
+				// make sure we don't have duplicate layer ids (and don't take id explicitly set on another layer)
+				const explicitIds = getExplicitLayerIds(psd, options);
+				while (options.layerIds.has(id) || explicitIds.has(id)) id += 100;
+			}
 		} else {
 			// generate id for layers that don't have it, if it's referenced by other sections
 			const explicitIds = getExplicitLayerIds(psd, options);
@@ -721,6 +827,82 @@ addHandler(
 	},
 );
 
+addHandler(
+	'vmgm',
+	hasKey('vectorMaskAsGlobalMask'),
+	(reader, target) => {
+		target.vectorMaskAsGlobalMask = !!readUint8(reader);
+		skipBytes(reader, 3);
+	},
+	(writer, target) => {
+		writeUint8(writer, target.vectorMaskAsGlobalMask ? 1 : 0);
+		writeZeros(writer, 3);
+	},
+);
+
+addHandler(
+	'ffxi',
+	hasKey('foreignEffectId'),
+	(reader, target) => {
+		target.foreignEffectId = readInt32(reader);
+	},
+	(writer, target) => {
+		writeInt32(writer, target.foreignEffectId!);
+	},
+);
+
+addHandler(
+	'shpa',
+	hasKey('patternData'),
+	(reader, target, left) => {
+		if (readInt32(reader) !== 0) throw new Error(`Invalid shpa version`);
+
+		const count = readInt32(reader);
+		target.patternData = [];
+
+		for (let i = 0; i < count && left() > 0; i++) {
+			const signature = readSignature(reader);
+			const key = readSignature(reader);
+			const patternsCount = readInt32(reader);
+			const copyOnSheetDuplication = !!readUint8(reader);
+			skipBytes(reader, 3);
+			const patterns: NonNullable<LayerAdditionalInfo['patternData']>[number]['patterns'] = [];
+
+			for (let j = 0; j < patternsCount && left() > 0; j++) {
+				const colorHandling = patternColorHandling.decode('.' + readSignature(reader));
+				readPascalString(reader, 1); // name
+				const name = readUnicodeString(reader);
+				const id = readPascalString(reader, 1);
+				patterns.push({ colorHandling, name, id });
+			}
+
+			target.patternData.push({ signature, key, copyOnSheetDuplication, patterns });
+		}
+
+		skipBytes(reader, left());
+	},
+	(writer, target) => {
+		const sets = target.patternData!;
+		writeInt32(writer, 0); // version
+		writeInt32(writer, sets.length);
+
+		for (const set of sets) {
+			writeSignature(writer, set.signature);
+			writeSignature(writer, set.key);
+			writeInt32(writer, set.patterns.length);
+			writeUint8(writer, set.copyOnSheetDuplication ? 1 : 0);
+			writeZeros(writer, 3);
+
+			for (const pattern of set.patterns) {
+				writeSignature(writer, patternColorHandling.encode(pattern.colorHandling).split('.')[1]);
+				writePascalString(writer, pattern.name.replace(/[^\x20-\x7e]/g, '?'), 1);
+				writeUnicodeString(writer, pattern.name);
+				writePascalString(writer, pattern.id, 1);
+			}
+		}
+	},
+);
+
 addHandler(
 	'lspf',
 	hasKey('protected'),
@@ -733,15 +915,17 @@ addHandler(
 		};
 
 		if (flags & 0x08) target.protected.artboards = true;
+		if (flags & 0x80000000) target.protected.all = true;
 	},
 	(writer, target) => {
 		const flags =
 			(target.protected!.transparency ? 0x01 : 0) |
 			(target.protected!.composite ? 0x02 : 0) |
 			(target.protected!.position ? 0x04 : 0) |
-			(target.protected!.artboards ? 0x08 : 0);
+			(target.protected!.artboards ? 0x08 : 0) |
+			(target.protected!.all ? 0x80000000 : 0);
 
-		writeUint32(writer, flags);
+		writeUint32(writer, flags >>> 0);
 	},
 );
 
@@ -764,6 +948,62 @@ interface CustomDescriptor {
 	layerTime?: number;
 }
 
+interface GeneratorSettingsDescriptor {
+	generatorSettings?: {
+		_name: '';
+		_classID: string; // 'null' or 'generatorSettings'
+		exportAs?: {
+			_name: '';
+			_classID: 'null';
+			exportOption?: string; // JSON
+			scaleSettings?: string; // JSON
+		};
+		generator_45_assets?: { _name: ''; _classID: string; json: string; };
+		layerTime?: number;
+		crema?: { _name: ''; _classID: string; json: string; };
+	};
+}
+
+function parseGeneratorSettings(settings: NonNullable<GeneratorSettingsDescriptor['generatorSettings']>) {
+	const result: NonNullable<LayerAdditionalInfo['generatorSettings']> = {};
+
+	if (settings.exportAs) {
+		result.exportAs = {};
+		if (settings.exportAs.exportOption !== undefined) result.exportAs.exportOption = settings.exportAs.exportOption;
+		if (settings.exportAs.scaleSettings !== undefined) result.exportAs.scaleSettings = settings.exportAs.scaleSettings;
+	}
+
+	if (settings.generator_45_assets) result.assets = settings.generator_45_assets.json;
+	if (settings.layerTime !== undefined) result.layerTime = settings.layerTime;
+	if (settings.crema) result.crema = settings.crema.json;
+
+	return result;
+}
+
+function serializeGeneratorSettings(generatorSettings: NonNullable<LayerAdditionalInfo['generatorSettings']>): GeneratorSettingsDescriptor {
+	const settings: GeneratorSettingsDescriptor['generatorSettings'] = {
+		_name: '',
+		_classID: generatorSettings.assets !== undefined ? 'generatorSettings' : 'null',
+	};
+
+	if (generatorSettings.exportAs) {
+		settings.exportAs = { _name: '', _classID: 'null' };
+		if (generatorSettings.exportAs.exportOption !== undefined) settings.exportAs.exportOption = generatorSettings.exportAs.exportOption;
+		if (generatorSettings.exportAs.scaleSettings !== undefined) settings.exportAs.scaleSettings = generatorSettings.exportAs.scaleSettings;
+	}
+
+	if (generatorSettings.assets !== undefined) settings.generator_45_assets = { _name: '', _classID: 'generatorSettings', json: generatorSettings.assets };
+	if (generatorSettings.layerTime !== undefined) settings.layerTime = generatorSettings.layerTime;
+	if (generatorSettings.crema !== undefined) settings.crema = { _name: '', _classID: 'null', json: generatorSettings.crema };
+
+	return { generatorSettings: settings };
+}
+
+// document (Psd object) stores generator settings in 'extn' section instead of 'shmd' section
+function isDocument(target: LayerAdditionalInfo) {
+	return (target as Psd).width !== undefined;
+}
+
 interface CmlsDescriptor {
 	origFXRefPoint?: { Hrzn: number; Vrtc: number; };
 	LyrI: number;
@@ -777,112 +1017,113 @@ interface CmlsDescriptor {
 
 addHandler(
 	'shmd', // Metadata setting
-	target => target.timestamp !== undefined || target.animationFrames !== undefined || target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined,
+	target => target.timestamp !== undefined || target.animationFrames !== undefined || target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined ||
+		(target.generatorSettings !== undefined && !isDocument(target)),
 	(reader, target, left) => {
 		const count = readUint32(reader);
 
 		for (let i = 0; i < count; i++) {
-			checkSignature(reader, '8BIM');
+			const signature = readSignature(reader);
+			if (signature !== '8BIM' && signature !== '8ELE') throw new Error(`Invalid shmd signature: '${signature}'`); // 8ELE in Photoshop Elements
 			const key = readSignature(reader);
 			readUint8(reader); // copy
 			skipBytes(reader, 3);
 
-			readSection(reader, 1, left => {
-				if (key === 'cust') {
-					const desc = readVersionAndDescriptor(reader) as CustomDescriptor;
-					// console.log('cust', target.name, require('util').inspect(desc, false, 99, true));
-					if (desc.layerTime !== undefined) target.timestamp = desc.layerTime;
-				} else if (key === 'mlst') {
-					const desc = readVersionAndDescriptor(reader) as FrameListDescriptor;
-					// console.log('mlst', target.name, require('util').inspect(desc, false, 99, true));
-
-					target.animationFrames = [];
-
-					for (let i = 0; i < desc.LaSt.length; i++) {
-						const f = desc.LaSt[i];
-						const frame: AnimationFrame = { frames: f.FrLs };
-						if (f.enab !== undefined) frame.enable = f.enab;
-						if (f.Ofst) frame.offset = horzVrtcToXY(f.Ofst);
-						if (f.FXRf) frame.referencePoint = horzVrtcToXY(f.FXRf);
-						if (f.Lefx) frame.effects = parseEffects(f.Lefx, !!reader.logMissingFeatures);
-						if (f.blendOptions && f.blendOptions.Opct) frame.opacity = parsePercent(f.blendOptions.Opct);
-						target.animationFrames.push(frame);
-					}
-				} else if (key === 'mdyn') {
-					// frame flags
-					readUint16(reader); // unknown
-					const propagate = readUint8(reader);
-					const flags = readUint8(reader);
-
-					target.animationFrameFlags = {
-						propagateFrameOne: !propagate,
-						unifyLayerPosition: (flags & 1) !== 0,
-						unifyLayerStyle: (flags & 2) !== 0,
-						unifyLayerVisibility: (flags & 4) !== 0,
-					};
-				} else if (key === 'tmln') {
-					const desc = readVersionAndDescriptor(reader) as TimelineDescriptor;
-					const timeScope = desc.timeScope;
-					// console.log('tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
-
-					const timeline: Timeline = {
-						start: frac(timeScope.Strt),
-						duration: frac(timeScope.duration),
-						inTime: frac(timeScope.inTime),
-						outTime: frac(timeScope.outTime),
-						autoScope: desc.autoScope,
-						audioLevel: desc.audioLevel,
-					};
+			const end = reader.offset + 4 + reader.view.getUint32(reader.offset);
+
+			try {
+				readSection(reader, 1, left => {
+					if (key === 'cust') {
+						const desc = readVersionAndDescriptor(reader) as CustomDescriptor;
+						// console.log('cust', target.name, require('util').inspect(desc, false, 99, true));
+						if (desc.layerTime !== undefined) target.timestamp = desc.layerTime;
+					} else if (key === 'mlst') {
+						const desc = readVersionAndDescriptor(reader) as FrameListDescriptor;
+						// console.log('mlst', target.name, require('util').inspect(desc, false, 99, true));
+
+						target.animationFrames = [];
+
+						for (let i = 0; i < desc.LaSt.length; i++) {
+							const f = desc.LaSt[i];
+							const frame: AnimationFrame = { frames: f.FrLs };
+							if (f.enab !== undefined) frame.enable = f.enab;
+							if (f.Ofst) frame.offset = horzVrtcToXY(f.Ofst);
+							if (f.FXRf) frame.referencePoint = horzVrtcToXY(f.FXRf);
+							if (f.Lefx) frame.effects = parseEffects(f.Lefx, reader);
+							if (f.blendOptions && f.blendOptions.Opct) frame.opacity = parsePercent(f.blendOptions.Opct);
+							target.animationFrames.push(frame);
+						}
+					} else if (key === 'mdyn') {
+						// frame flags
+						readUint16(reader); // unknown
+						const propagate = readUint8(reader);
+						const flags = readUint8(reader);
+
+						target.animationFrameFlags = {
+							propagateFrameOne: !propagate,
+							unifyLayerPosition: (flags & 1) !== 0,
+							unifyLayerStyle: (flags & 2) !== 0,
+							unifyLayerVisibility: (flags & 4) !== 0,
+						};
+					} else if (key === 'tmln') {
+						const desc = readVersionAndDescriptor(reader) as TimelineDescriptor;
+						const timeScope = desc.timeScope;
+						// console.log('tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
+
+						const timeline: Timeline = {
+							start: frac(timeScope.Strt),
+							duration: frac(timeScope.duration),
+							inTime: frac(timeScope.inTime),
+							outTime: frac(timeScope.outTime),
+							autoScope: desc.autoScope,
+							audioLevel: desc.audioLevel,
+						};
 
-					if (desc.trackList) {
-						timeline.tracks = parseTrackList(desc.trackList, !!reader.logMissingFeatures);
-					}
+						if (desc.trackList) {
+							timeline.tracks = parseTrackList(desc.trackList, reader);
+						}
 
-					target.timeline = timeline;
-					// console.log('tmln:result', target.name, target.id, require('util').inspect(timeline, false, 99, true));
-				} else if (key === 'cmls') {
-					const desc = readVersionAndDescriptor(reader) as CmlsDescriptor;
-					// console.log('cmls', require('util').inspect(desc, false, 99, true));
+						target.timeline = timeline;
+						// console.log('tmln:result', target.name, target.id, require('util').inspect(timeline, false, 99, true));
+					} else if (key === 'cmls') {
+						const desc = readVersionAndDescriptor(reader) as CmlsDescriptor;
+						// console.log('cmls', require('util').inspect(desc, false, 99, true));
 
-					target.comps = {
-						settings: [],
-					};
+						target.comps = {
+							settings: [],
+						};
 
-					if (desc.origFXRefPoint) target.comps.originalEffectsReferencePoint = { x: desc.origFXRefPoint.Hrzn, y: desc.origFXRefPoint.Vrtc };
+						if (desc.origFXRefPoint) target.comps.originalEffectsReferencePoint = { x: desc.origFXRefPoint.Hrzn, y: desc.origFXRefPoint.Vrtc };
 
-					for (const item of desc.layerSettings) {
-						target.comps.settings.push({ compList: item.compList });
-						const t = target.comps.settings[target.comps.settings.length - 1];
-						if ('enab' in item) t.enabled = item.enab;
-						if (item.Ofst) t.offset = { x: item.Ofst.Hrzn, y: item.Ofst.Vrtc };
-						if (item.FXRefPoint) t.effectsReferencePoint = { x: item.FXRefPoint.Hrzn, y: item.FXRefPoint.Vrtc };
-					}
-				} else if (key === 'extn') {
-					interface ExtnDescriptor {
-						generatorSettings: {
-							exportAs: {
-								exportOption: string;
-							};
-							layerTime: number;
-						};
+						for (const item of desc.layerSettings) {
+							target.comps.settings.push({ compList: item.compList });
+							const t = target.comps.settings[target.comps.settings.length - 1];
+							if ('enab' in item) t.enabled = item.enab;
+							if (item.Ofst) t.offset = { x: item.Ofst.Hrzn, y: item.Ofst.Vrtc };
+							if (item.FXRefPoint) t.effectsReferencePoint = { x: item.FXRefPoint.Hrzn, y: item.FXRefPoint.Vrtc };
+						}
+					} else if (key === 'extn') {
+						const desc = readVersionAndDescriptor(reader) as GeneratorSettingsDescriptor;
+						if (desc.generatorSettings) target.generatorSettings = parseGeneratorSettings(desc.generatorSettings);
+					} else {
+						reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
 					}
 
-					const desc = readVersionAndDescriptor(reader) as ExtnDescriptor;
-					// console.log(require('util').inspect(desc, false, 99, true));
-					desc; // TODO: save this
-					reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
-				} else {
-					reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
-				}
-
-				skipBytes(reader, left());
-			});
+					skipBytes(reader, left());
+				});
+			} catch (e) {
+				// failure to read one item shouldn't drop all other items
+				if (reader.throwForMissingFeatures) throw e;
+				reader.logMissingFeatures && reader.log(`Failed to read "shmd" section key ${key}: ${(e as Error).message}`);
+				reader.offset = end;
+			}
 		}
 
 		skipBytes(reader, left());
 	},
 	(writer, target, _, options) => {
 		const { animationFrames, animationFrameFlags, timestamp, timeline, comps } = target;
+		const generatorSettings = isDocument(target) ? undefined : target.generatorSettings;
 
 		let count = 0;
 		if (animationFrames) count++;
@@ -890,6 +1131,7 @@ addHandler(
 		if (timeline) count++;
 		if (timestamp !== undefined) count++;
 		if (comps) count++;
+		if (generatorSettings) count++;
 		writeUint32(writer, count);
 
 		if (animationFrames) {
@@ -910,8 +1152,8 @@ addHandler(
 					frame.FrLs = f.frames;
 					if (f.offset) frame.Ofst = xyToHorzVrtc(f.offset);
 					if (f.referencePoint) frame.FXRf = xyToHorzVrtc(f.referencePoint);
-					if (f.effects) frame.Lefx = serializeEffects(f.effects, false, false);
-					if (f.opacity !== undefined) frame.blendOptions = { Opct: unitsPercent(f.opacity) };
+					if (f.effects) frame.Lefx = serializeEffects(f.effects, writer, hasMultiEffects(f.effects));
+					if (f.opacity !== undefined) frame.blendOptions = { Opct: unitsPercentF(f.opacity) };
 					desc.LaSt.push(frame);
 				}
 
@@ -954,7 +1196,7 @@ addHandler(
 				} as any;
 
 				if (timeline.tracks) {
-					desc.trackList = serializeTrackList(timeline.tracks);
+					desc.trackList = serializeTrackList(timeline.tracks, writer);
 				}
 
 				desc.LyrI = getLayerId(target, options);
@@ -1005,6 +1247,16 @@ addHandler(
 				writeVersionAndDescriptor(writer, '', 'null', desc);
 			}, true);
 		}
+
+		if (generatorSettings) {
+			writeSignature(writer, '8BIM');
+			writeSignature(writer, 'extn');
+			writeUint8(writer, 0); // copy (always false)
+			writeZeros(writer, 3);
+			writeSection(writer, 2, () => {
+				writeVersionAndDescriptor(writer, '', 'null', serializeGeneratorSettings(generatorSettings));
+			}, true);
+		}
 	},
 );
 
@@ -1096,7 +1348,7 @@ addHandler(
 			lineAlignment: strokeStyleLineAlignment.decode(desc.strokeStyleLineAlignment),
 			scaleLock: desc.strokeStyleScaleLock,
 			strokeAdjust: desc.strokeStyleStrokeAdjust,
-			lineDashSet: desc.strokeStyleLineDashSet.map(parseUnits),
+			lineDashSet: (desc.strokeStyleLineDashSet || []).map(parseUnits),
 			blendMode: BlnM.decode(desc.strokeStyleBlendMode),
 			opacity: parsePercent(desc.strokeStyleOpacity),
 			content: parseVectorContent(desc.strokeStyleContent),
@@ -1135,8 +1387,8 @@ interface ArtbDescriptor {
 	artboardRect: { 'Top ': number; Left: number; Btom: number; Rght: number; };
 	guideIndeces: any[];
 	artboardPresetName: string;
-	'Clr ': DescriptorColor;
-	artboardBackgroundType: number;
+	'Clr '?: DescriptorColor;
+	artboardBackgroundType?: number;
 }
 
 addHandler(
@@ -1149,10 +1401,11 @@ addHandler(
 			rect: { top: rect['Top '], left: rect.Left, bottom: rect.Btom, right: rect.Rght },
 			guideIndices: desc.guideIndeces,
 			presetName: desc.artboardPresetName,
-			color: parseColor(desc['Clr ']),
-			backgroundType: desc.artboardBackgroundType,
 		};
 
+		if (desc['Clr ']) target.artboard.color = parseColor(desc['Clr ']);
+		if (desc.artboardBackgroundType !== undefined) target.artboard.backgroundType = desc.artboardBackgroundType;
+
 		skipBytes(reader, left());
 	},
 	(writer, target) => {
@@ -1299,13 +1552,13 @@ function encodeWarp(warp: Warp): WarpDescriptor {
 
 addHandler(
 	'PlLd',
-	hasKey('placedLayer'),
+	target => !!target.placedLayer && !target.placedLayer.external, // linked smart objects are stored in SoLE
 	(reader, target, left) => {
 		if (readSignature(reader) !== 'plcL') throw new Error(`Invalid PlLd signature`);
 		if (readInt32(reader) !== 3) throw new Error(`Invalid PlLd version`);
 		const id = readPascalString(reader, 1);
 		const pageNumber = readInt32(reader);
-		const totalPages = readInt32(reader); // TODO: check how this works ?
+		const totalPages = readInt32(reader); // for multi-page documents (PDF)
 		readInt32(reader); // anitAliasPolicy 16
 		const placedLayerType = readInt32(reader); // 0 = unknown, 1 = vector, 2 = raster, 3 = image stack
 		if (!placedLayerTypes[placedLayerType]) throw new Error('Invalid PlLd type');
@@ -1857,7 +2110,7 @@ type SoLdDescriptorFilterItem = {
 		'Fl  ': string;
 	};
 } | {
-	filterID: 991 | 943; // TODO: why 2 different IDs? do we need to handle them separately?
+	filterID: 991 | 943; // 943 in older Photoshop versions (2021), 991 in newer ones, settings are the same
 	Fltr: {
 		_name: 'Rigid Transform';
 		_classID: 'rigidTransform';
@@ -2036,7 +2289,7 @@ type SoLdDescriptorFilterItem = {
 	Fltr: {
 		_name: 'Curves';
 		_classID: 'Crvs';
-		presetKind: string; // 'presetKindType.presetKindCustom';
+		presetKind?: string; // 'presetKindType.presetKindCustom';
 		Adjs?: {
 			_name: '';
 			_classID: 'CrvA';
@@ -2045,6 +2298,14 @@ type SoLdDescriptorFilterItem = {
 			Mpng?: number[];
 		}[];
 	};
+} | {
+	filterID: 1282829427;
+	Fltr: {
+		_name: 'Levels';
+		_classID: 'Lvls';
+		presetKind?: string; // 'presetKindType.presetKindCustom';
+		Adjs?: FilterLevelsAdjustment[];
+	};
 } | {
 	filterID: 1231976050;
 } | {
@@ -2066,6 +2327,18 @@ interface FilterCurvesCurvePoint {
 	Cnty?: boolean;
 }
 
+interface FilterLevelsAdjustment {
+	_name: '';
+	_classID: 'LvlA';
+	Chnl: string[]; // 'Chnl.Cmps' | 'Chnl.Rd  ' | 'Chnl.Grn ' | 'Chnl.Bl  '
+	Inpt?: number[]; // shadow, highlight
+	Otpt?: number[]; // shadow, highlight
+	'Gmm '?: number;
+}
+
+const levelsFilterKeys = ['_name', '_classID', 'presetKind', 'Adjs'];
+const levelsFilterAdjustmentKeys = ['_name', '_classID', 'Chnl', 'Inpt', 'Otpt', 'Gmm '];
+
 interface SoLdDescriptorFilter {
 	_name: '',
 	_classID: 'filterFXStyle',
@@ -2129,7 +2402,92 @@ function pointToHrznVrtc(point: { x: UnitsValue; y: UnitsValue; }): HrznVrtcDesc
 	};
 }
 
-function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): Filter | undefined {
+// Camera Raw Filter setting paths (in CameraRawFilterSettings) and their descriptor keys
+const cameraRawColorKeys: [keyof CameraRawColors, string][] = [
+	['red', 'R'], ['orange', 'O'], ['yellow', 'Y'], ['green', 'G'], ['aqua', 'A'], ['blue', 'B'], ['purple', 'P'], ['magenta', 'M'],
+];
+
+const cameraRawSettings: [string, string][] = [
+	['version', 'CrVe'], ['processVersion', 'PrVN'], ['processVersionCode', 'PrVe'], ['whiteBalance', 'WBal'],
+	['temperature', 'Temp'], ['tint', 'Tint'], ['exposure', 'Ex12'], ['contrast', 'Cr12'], ['highlights', 'Hi12'],
+	['shadows', 'Sh12'], ['whites', 'Wh12'], ['blacks', 'Bk12'], ['texture', 'CrTx'], ['clarity', 'Cl12'],
+	['dehaze', 'Dhze'], ['vibrance', 'Vibr'], ['saturation', 'Strt'],
+	['parametricCurve.shadows', 'PC_S'], ['parametricCurve.darks', 'PC_D'], ['parametricCurve.lights', 'PC_L'],
+	['parametricCurve.highlights', 'PC_H'], ['parametricCurve.shadowSplit', 'PC_1'], ['parametricCurve.midtoneSplit', 'PC_2'],
+	['parametricCurve.highlightSplit', 'PC_3'],
+	['pointCurve.composite', 'Crv '], ['pointCurve.red', 'CrvR'], ['pointCurve.green', 'CrvG'], ['pointCurve.blue', 'CrvB'],
+	...cameraRawColorKeys.map(([name, key]) => [`hsl.hue.${name}`, `HA_${key}`] as [string, string]),
+	...cameraRawColorKeys.map(([name, key]) => [`hsl.saturation.${name}`, `SA_${key}`] as [string, string]),
+	...cameraRawColorKeys.map(([name, key]) => [`hsl.luminance.${name}`, `LA_${key}`] as [string, string]),
+	['colorGrading.shadows.hue', 'STSH'], ['colorGrading.shadows.saturation', 'STSS'], ['colorGrading.shadows.luminance', 'CgSL'],
+	['colorGrading.midtones.hue', 'CgMH'], ['colorGrading.midtones.saturation', 'CgMS'], ['colorGrading.midtones.luminance', 'CgML'],
+	['colorGrading.highlights.hue', 'STHH'], ['colorGrading.highlights.saturation', 'STHS'], ['colorGrading.highlights.luminance', 'CgHL'],
+	['colorGrading.global.hue', 'CgGH'], ['colorGrading.global.saturation', 'CgGS'], ['colorGrading.global.luminance', 'CgGL'],
+	['colorGrading.blending', 'CgBl'], ['colorGrading.balance', 'STB '],
+	['sharpening.amount', 'Shrp'], ['sharpening.radius', 'ShpR'], ['sharpening.detail', 'ShpD'], ['sharpening.masking', 'ShpM'],
+	['noiseReduction.luminance', 'LNR '], ['noiseReduction.luminanceDetail', 'LNRD'], ['noiseReduction.luminanceContrast', 'LNRC'],
+	['noiseReduction.color', 'CNR '], ['noiseReduction.colorDetail', 'CNRD'], ['noiseReduction.colorSmoothness', 'CNRS'],
+	['grain.amount', 'GRNA'], ['grain.size', 'GRNS'], ['grain.roughness', 'GRNF'],
+	['postCropVignette.amount', 'PCVA'], ['postCropVignette.midpoint', 'PCVM'], ['postCropVignette.feather', 'PCVF'],
+	['postCropVignette.roundness', 'PCVR'],
+];
+
+const cameraRawCurveKeys = ['Crv ', 'CrvR', 'CrvG', 'CrvB'];
+const cameraRawFilterID = 2783;
+
+function parseCameraRawSettings(desc: any, reader: PsdReader) {
+	const settings: any = {};
+
+	for (const [path, key] of cameraRawSettings) {
+		let value = desc[key];
+		if (value === undefined) continue;
+
+		if (key === 'WBal') {
+			value = (value as string).split('.')[1];
+		} else if (cameraRawCurveKeys.includes(key)) {
+			const values = value as number[];
+			value = [];
+			for (let i = 0; i + 1 < values.length; i += 2) value.push({ input: values[i], output: values[i + 1] });
+		}
+
+		const parts = path.split('.');
+		let target = settings;
+		for (let i = 0; i < parts.length - 1; i++) target = target[parts[i]] = target[parts[i]] ?? {};
+		target[parts[parts.length - 1]] = value;
+	}
+
+	for (const key of Object.keys(desc)) {
+		if (key !== '_name' && key !== '_classID' && !cameraRawSettings.some(s => s[1] === key)) {
+			reader.logMissingFeatures && reader.log(`Unhandled Camera Raw Filter setting: ${key}`);
+		}
+	}
+
+	return settings as CameraRawFilterSettings;
+}
+
+function serializeCameraRawSettings(settings: CameraRawFilterSettings) {
+	const desc: any = { _name: '', _classID: cameraRawFilterClassID };
+
+	for (const [path, key] of cameraRawSettings) {
+		let value: any = settings;
+		for (const part of path.split('.')) value = value?.[part];
+		if (value === undefined) continue;
+
+		if (key === 'WBal') {
+			value = `WBal.${value}`;
+		} else if (cameraRawCurveKeys.includes(key)) {
+			value = (value as CameraRawCurvePoint[]).flatMap(p => [Math.round(p.input), Math.round(p.output)]);
+		} else if (typeof value === 'number' && key !== 'Ex12' && key !== 'ShpR') {
+			value = Math.round(value);
+		}
+
+		desc[key] = value;
+	}
+
+	return desc;
+}
+
+function parseFilterFXItem(f: SoLdDescriptorFilterItem, reader: PsdReader): Filter | undefined {
 	const base: Omit<Filter, 'type' | 'filter'> = {
 		name: f['Nm  '],
 		opacity: parsePercent(f.blendOptions.Opct),
@@ -2140,6 +2498,10 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 		backgroundColor: parseColor(f.BckC),
 	};
 
+	if ('Fltr' in f && (f.Fltr._classID as string) === cameraRawFilterClassID) {
+		return { ...base, type: 'camera raw', filter: parseCameraRawSettings(f.Fltr, reader) };
+	}
+
 	if ('Fltr' in f) {
 		switch (f.Fltr._classID) {
 			case 'boxblur': return {
@@ -2209,7 +2571,7 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 					undefinedAreas: UndA.decode(f.Fltr.UndA),
 					displacementFile: {
 						signature: f.Fltr.DspF.sig,
-						path: f.Fltr.DspF.path, // TODO: this is decoded incorrectly ???
+						path: f.Fltr.DspF.path,
 					},
 				},
 			};
@@ -2544,8 +2906,7 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 					],
 					puppetShapeList: (f.Fltr.puppetShapeList || []).map(p => ({
 						rigidType: p.rigidType,
-						// TODO: VrsM
-						// TODO: VrsN
+						// VrsM / VrsN - version (always 1.0)
 						originalVertexArray: uint8ToPoints(p.originalVertexArray),
 						deformedVertexArray: uint8ToPoints(p.deformedVertexArray),
 						indexArray: Array.from(uint8ToUint32(p.indexArray)),
@@ -2664,7 +3025,8 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 					...base,
 					type: 'curves',
 					filter: {
-						presetKind: presetKindType.decode(f.Fltr.presetKind),
+						// Photoshop doesn't write preset kind for filters with explicit values
+						...(f.Fltr.presetKind !== undefined ? { presetKind: presetKindType.decode(f.Fltr.presetKind) } : {}),
 						...(f.Fltr.Adjs ? {
 							adjustments: f.Fltr.Adjs.map(a => {
 								const channels = a.Chnl.map(Chnl.decode);
@@ -2687,6 +3049,40 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 					},
 				};
 			};
+			case 'Lvls': {
+				const adjustments = f.Fltr.Adjs;
+				const isKnown = (obj: object, keys: string[]) => Object.keys(obj).every(k => keys.indexOf(k) !== -1);
+
+				// skip filter with settings we don't know about
+				if (!isKnown(f.Fltr, levelsFilterKeys) || (adjustments && !adjustments.every(a => isKnown(a, levelsFilterAdjustmentKeys)))) {
+					if (reader.throwForMissingFeatures) throw new Error('Unknown levels filter settings');
+					reader.logMissingFeatures && reader.log(`Skipped levels smart filter with unknown settings`);
+					return undefined;
+				}
+
+				return {
+					...base,
+					type: 'levels',
+					filter: {
+						...(f.Fltr.presetKind !== undefined ? { presetKind: presetKindType.decode(f.Fltr.presetKind) } : {}),
+						...(adjustments ? {
+							adjustments: adjustments.map(a => {
+								const result: LevelsFilterAdjustment = { channels: a.Chnl.map(Chnl.decode) };
+								if (a.Inpt) {
+									result.shadowInput = a.Inpt[0];
+									result.highlightInput = a.Inpt[1];
+								}
+								if (a.Otpt) {
+									result.shadowOutput = a.Otpt[0];
+									result.highlightOutput = a.Otpt[1];
+								}
+								if (a['Gmm '] !== undefined) result.midtoneInput = a['Gmm '];
+								return result;
+							}),
+						} : {}),
+					},
+				};
+			};
 			case 'BrgC': {
 				return {
 					...base,
@@ -2699,10 +3095,11 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 				};
 			};
 			default:
-				if (options.throwForMissingFeatures) {
+				if (reader.throwForMissingFeatures) {
 					// console.log('FILTER', require('util').inspect(f, false, 99, true));
 					throw new Error(`Unknown filter classId: ${(f as any).Fltr._classID}`);
 				}
+				reader.logMissingFeatures && reader.log(`Unhandled smart filter: ${(f as any).Fltr._classID} (${f['Nm  ']})`);
 				return undefined;
 		}
 	} else {
@@ -2721,22 +3118,24 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 			case 1314149187: return { ...base, type: 'ntsc colors' };
 			case 1231976050: return { ...base, type: 'invert' }
 			default:
-				if (options.throwForMissingFeatures) {
+				if (reader.throwForMissingFeatures) {
 					// console.log('FILTER', require('util').inspect(f, false, 99, true));
 					throw new Error(`Unknown filterID: ${(f as any).filterID}`);
 				}
+				reader.logMissingFeatures && reader.log(`Unhandled smart filter: ${(f as any).filterID} (${f['Nm  ']})`);
+				return undefined;
 		}
 	}
 }
 
-function parseFilterFX(desc: SoLdDescriptorFilter, options: ReadOptions): PlacedLayerFilter {
+function parseFilterFX(desc: SoLdDescriptorFilter, reader: PsdReader): PlacedLayerFilter {
 	return {
 		enabled: desc.enab,
 		validAtPosition: desc.validAtPosition,
 		maskEnabled: desc.filterMaskEnable,
 		maskLinked: desc.filterMaskLinked,
 		maskExtendWithWhite: desc.filterMaskExtendWithWhite,
-		list: desc.filterFXList.map(x => parseFilterFXItem(x, options)).filter((x): x is Filter => !!x),
+		list: desc.filterFXList.map(x => parseFilterFXItem(x, reader)).filter((x): x is Filter => !!x),
 	};
 }
 
@@ -3275,14 +3674,14 @@ function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
 			Fltr: {
 				_name: 'Rigid Transform',
 				_classID: 'rigidTransform',
-				'null': ['Ordn.Trgt'], // TODO: ???
+				'null': ['Ordn.Trgt'], // target layer reference
 				rigidType: f.filter.rigidType,
 				puppetShapeList: (f.filter.puppetShapeList || []).map(p => ({
 					_name: '',
 					_classID: 'puppetShape',
 					rigidType: p.rigidType,
-					VrsM: 1, // TODO: ???
-					VrsN: 0, // TODO: ???
+					VrsM: 1, // version major
+					VrsN: 0, // version minor
 					originalVertexArray: toUint8(new Float32Array(pointsToArray(p.originalVertexArray))),
 					deformedVertexArray: toUint8(new Float32Array(pointsToArray(p.deformedVertexArray))),
 					indexArray: toUint8(new Uint32Array(p.indexArray)),
@@ -3397,7 +3796,7 @@ function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
 			Fltr: {
 				_name: 'Curves',
 				_classID: 'Crvs',
-				presetKind: presetKindType.encode(f.filter.presetKind),
+				...(f.filter.presetKind !== undefined ? { presetKind: presetKindType.encode(f.filter.presetKind) } : {}),
 				...(f.filter.adjustments ? {
 					Adjs: f.filter.adjustments.map(a => 'curve' in a ? {
 						_name: '',
@@ -3420,6 +3819,33 @@ function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
 			},
 			filterID: 1131574899,
 		};
+		case 'levels': return {
+			...base,
+			Fltr: {
+				_name: 'Levels',
+				_classID: 'Lvls',
+				...(f.filter.presetKind !== undefined ? { presetKind: presetKindType.encode(f.filter.presetKind) } : {}),
+				...(f.filter.adjustments ? {
+					Adjs: f.filter.adjustments.map(a => {
+						const adjustment: FilterLevelsAdjustment = { _name: '', _classID: 'LvlA', Chnl: a.channels.map(Chnl.encode) };
+						if (a.shadowInput !== undefined || a.highlightInput !== undefined) {
+							adjustment.Inpt = [Math.round(a.shadowInput ?? 0), Math.round(a.highlightInput ?? 255)];
+						}
+						if (a.shadowOutput !== undefined || a.highlightOutput !== undefined) {
+							adjustment.Otpt = [Math.round(a.shadowOutput ?? 0), Math.round(a.highlightOutput ?? 255)];
+						}
+						if (a.midtoneInput !== undefined) adjustment['Gmm '] = a.midtoneInput;
+						return adjustment;
+					}),
+				} : {}),
+			},
+			filterID: 1282829427,
+		};
+		case 'camera raw': return {
+			...base,
+			Fltr: serializeCameraRawSettings(f.filter),
+			filterID: cameraRawFilterID,
+		} as any;
 		case 'brightness/contrast': return {
 			...base,
 			Fltr: {
@@ -3463,8 +3889,8 @@ interface SoLdDescriptor {
 	'Sz  ': { _name: '', _classID: 'Pnt ', Wdth: number; Hght: number; };
 	Rslt: DescriptorUnitsValue;
 	filterFX?: SoLdDescriptorFilter;
-	comp?: number; // TODO: support this ?
-	compInfo?: { compID: number; originalCompID: number; }; // TODO: support this ?
+	comp?: number;
+	compInfo?: { compID: number; originalCompID: number; };
 	Impr?: {}; // ???
 	ClMg?: { // TODO: support this ?
 		_name: '';
@@ -3512,7 +3938,7 @@ function getWarpFromPlacedLayer(placed: PlacedLayer): Warp {
 
 addHandler(
 	'SoLd',
-	hasKey('placedLayer'),
+	target => !!target.placedLayer && !target.placedLayer.external, // linked smart objects are stored in SoLE
 	(reader, target, left) => {
 		if (readSignature(reader) !== 'soLD') throw new Error(`Invalid SoLd type`);
 		const version = readInt32(reader);
@@ -3573,6 +3999,12 @@ addHandler(
 		const placedType = placedLayerTypes.indexOf(placed.type);
 		if (placedType === -1) throw new Error('Invalid placedLayer type');
 
+		const warp = getWarpFromPlacedLayer(placed);
+		// size of linked image matches warp bounds if it's not provided
+		const bounds = warp.bounds;
+		const width = placed.width || (bounds ? bounds.right.value - bounds.left.value : 0);
+		const height = placed.height || (bounds ? bounds.bottom.value - bounds.top.value : 0);
+
 		const desc: SoLdDescriptor = {
 			Idnt: placed.id,
 			placed: placed.placed ?? placed.id,
@@ -3587,12 +4019,12 @@ addHandler(
 			Trnf: placed.transform,
 			nonAffineTransform: placed.nonAffineTransform ?? placed.transform,
 			// quiltWarp: {} as any,
-			warp: encodeWarp(getWarpFromPlacedLayer(placed)),
+			warp: encodeWarp(warp),
 			'Sz  ': {
 				_name: '',
 				_classID: 'Pnt ',
-				Wdth: placed.width || 0, // TODO: find size ?
-				Hght: placed.height || 0, // TODO: find size ?
+				Wdth: width,
+				Hght: height,
 			},
 			Rslt: placed.resolution ? unitsValue(placed.resolution, 'resolution') : { units: 'Density', value: 72 },
 		};
@@ -3610,15 +4042,6 @@ addHandler(
 			};
 		}
 
-		// TODO:
-		// desc.comp = -1;
-		// desc.compInfo = { _name: '', _classID: 'null', compID: -1, originalCompID: -1 } as any;
-		// desc.ClMg = {
-		// 	_name: '',
-		// 	_classID: 'ClMg',
-		// 	placedLayerOCIOConversion: 'placedLayerOCIOConversion.placedLayerOCIOConvertEmbedded'
-		// } as any;
-
 		// if (JSON.stringify(t) !== JSON.stringify(desc)) {
 		// 	console.log('read', require('util').inspect(t, false, 99, true));
 		// 	console.log('write', require('util').inspect(desc, false, 99, true));
@@ -3650,7 +4073,17 @@ addHandler(
 	},
 );
 
-addHandlerAlias('SoLE', 'SoLd');
+const soLdHandler = infoHandlersMap['SoLd'];
+
+addHandler(
+	'SoLE', // linked smart object (Photoshop doesn't write PlLd for these)
+	target => !!target.placedLayer?.external,
+	(reader, target, left, psd, imageResources) => {
+		soLdHandler.read(reader, target, left, psd, imageResources);
+		target.placedLayer!.external = true;
+	},
+	soLdHandler.write,
+);
 
 addHandler(
 	'fxrp',
@@ -3667,25 +4100,50 @@ addHandler(
 	},
 );
 
-addHandler(
-	'Lr16',
-	() => false,
-	(reader, _target, _left, psd, imageResources) => {
-		readLayerInfo(reader, psd, imageResources);
-	},
-	(_writer, _target) => {
-	},
-);
+function createGlobalLayerInfoHandler(key: string, bitsPerChannel: number | undefined) {
+	addHandler(
+		key,
+		() => false,
+		(reader, _target, left, psd, imageResources) => {
+			// Photoshop writes empty (or 8bit compatibility) layer info section alongside Lr16/Lr32 in 16/32bit documents,
+			// layers from global info with matching bit depth replace layers from that section, other ones are only used
+			// if the section is empty
+			if (!reader.layersInGlobalInfo && (psd.bitsPerChannel === bitsPerChannel || !psd.children?.length)) {
+				const sectionLayers = psd.children;
+				psd.children = [];
+
+				try {
+					readLayerInfo(reader, psd, imageResources);
+				} catch (e) {
+					psd.children = sectionLayers; // keep layers from layer info section if global info is broken
+					throw e;
+				}
 
-addHandler(
-	'Lr32',
-	() => false,
-	(reader, _target, _left, psd, imageResources) => {
-		readLayerInfo(reader, psd, imageResources);
-	},
-	(_writer, _target) => {
-	},
-);
+				reader.layersInGlobalInfo = true;
+			}
+
+			skipBytes(reader, left());
+		},
+		() => { },
+	);
+}
+
+createGlobalLayerInfoHandler('Lr16', 16);
+createGlobalLayerInfoHandler('Lr32', 32);
+createGlobalLayerInfoHandler('Layr', undefined);
+
+// merged transparency markers, first extra channel of composite image is transparency
+for (const key of ['Mtrn', 'Mt16', 'Mt32']) {
+	addHandler(
+		key,
+		() => false,
+		(reader, _target, left) => {
+			reader.globalAlpha = true;
+			skipBytes(reader, left());
+		},
+		() => { },
+	);
+}
 
 addHandler(
 	'LMsk',
@@ -3708,35 +4166,24 @@ addHandler(
 	},
 );
 
-if (MOCK_HANDLERS) {
-	addHandler(
-		'Patt',
-		target => (target as any)._Patt !== undefined,
-		(reader, target, left) => {
-			// console.log('additional info: Patt');
-			(target as any)._Patt = readBytes(reader, left());
-		},
-		(writer, target) => false && writeBytes(writer, (target as any)._Patt),
-	);
-} else {
-	addHandler(
-		'Patt', // TODO: handle also Pat2 & Pat3
-		target => !!(target.patterns && target.patterns.length > 0),
-		(reader, target, left) => {
-			while (left() > 0) {
-				const pattern = readPattern(reader);
-				if (target.patterns === undefined) target.patterns = [];
-				target.patterns.push(pattern);
-			}
-		},
-		(writer, target, _, _options) => {
-			const patterns = target.patterns || [];
-			for (const pattern of patterns) {
-				writePattern(writer, pattern);
-			}
-		},
-	);
-}
+addHandler(
+	'Patt', // 'Pat2' and 'Pat3' (16 and 32 bit documents) are aliases, patterns are always written as 8 bit
+	target => !!(target.patterns && target.patterns.length > 0),
+	(reader, target, left) => {
+		while (left() > 0) {
+			const pattern = readPatternSafe(reader);
+			if (!pattern) continue;
+			if (target.patterns === undefined) target.patterns = [];
+			target.patterns.push(pattern);
+		}
+	},
+	(writer, target, _, _options) => {
+		const patterns = target.patterns || [];
+		for (const pattern of patterns) {
+			writePattern(writer, pattern);
+		}
+	},
+);
 
 addHandlerAlias('Pat2', 'Patt');
 addHandlerAlias('Pat3', 'Patt');
@@ -3954,6 +4401,11 @@ interface LinkedFileDescriptor {
 	relPath: string;
 }
 
+function readFileTypeSignature(reader: PsdReader) {
+	const value = readSignature(reader);
+	return /^[\0 ]*$/.test(value) ? '' : value.trim(); // empty value is stored as spaces or zeros
+}
+
 function createLnkHandler(tag: string) {
 	addHandler(
 		tag,
@@ -3978,8 +4430,8 @@ function createLnkHandler(tag: string) {
 				const id = readPascalString(reader, 1);
 				const name = readUnicodeString(reader);
 
-				const fileType = readSignature(reader).trim(); // '    ' if empty
-				const fileCreator = readSignature(reader).trim(); // '    ' or '\0\0\0\0' if empty
+				const fileType = readFileTypeSignature(reader); // '    ' if empty
+				const fileCreator = readFileTypeSignature(reader); // '    ' or '\0\0\0\0' if empty
 				const dataSize = readLength64(reader);
 				const hasFileOpenDescriptor = readUint8(reader);
 				const fileOpenDescriptor = hasFileOpenDescriptor ? readVersionAndDescriptor(reader) as FileOpenDescriptor : undefined;
@@ -4137,28 +4589,55 @@ addHandlerAlias('lnk3', 'lnk2');
 
 interface PthsDescriptor {
 	pathList: {
+		_name: '';
 		_classID: 'pathInfoClass';
 		pathUnicodeName: string;
-		pathSymmetryClass: {
+		pathSymmetryClass?: {
+			_name: '';
 			_classID: 'pathSymmetryClass';
 			pathSymmetryMode: string; // 'pathSymmetryModeEnum.pathSymmetryModeBasicPath'
 		};
 	}[];
 }
 
+// unicode names of saved paths (path data is stored in image resources 2000-2998)
 addHandler(
 	'pths',
-	hasKey('pathList'),
-	(reader, target) => {
+	target => (target as Psd).imageResources?.savedPaths !== undefined,
+	(reader, _target, left, psd) => {
 		const desc = readVersionAndDescriptor(reader, true) as PthsDescriptor;
-		// console.log(require('util').inspect(desc, false, 99, true));
-		// if (options.throwForMissingFeatures && desc?.pathList?.length) throw new Error('non-empty pathList in `pths`');
-		desc;
-		target.pathList = []; // TODO: read paths
+		const imageResources = psd.imageResources ??= {};
+		const savedPaths = imageResources.savedPaths ??= [];
+
+		for (let i = 0; i < desc.pathList.length && i < savedPaths.length; i++) {
+			const { pathUnicodeName, pathSymmetryClass } = desc.pathList[i];
+			const path = savedPaths[i];
+
+			// clipping path is referenced by (non-unicode) name
+			if (imageResources.clippingPath && imageResources.clippingPath.name === path.name) {
+				imageResources.clippingPath.name = pathUnicodeName;
+			}
+
+			path.name = pathUnicodeName;
+			if (pathSymmetryClass) path.symmetryMode = pathSymmetryClass.pathSymmetryMode.split('.')[1];
+		}
+
+		skipBytes(reader, left());
 	},
-	(writer, _target) => {
+	(writer, _target, psd) => {
 		const desc: PthsDescriptor = {
-			pathList: [], // TODO: write paths
+			pathList: psd.imageResources!.savedPaths!.map(path => ({
+				_name: '',
+				_classID: 'pathInfoClass',
+				pathUnicodeName: path.name,
+				...(path.symmetryMode ? {
+					pathSymmetryClass: {
+						_name: '',
+						_classID: 'pathSymmetryClass',
+						pathSymmetryMode: `pathSymmetryModeEnum.${path.symmetryMode}`,
+					},
+				} : {}),
+			})),
 		};
 
 		writeVersionAndDescriptor(writer, '', 'pathsDataClass', desc);
@@ -4173,26 +4652,19 @@ addHandler(
 );
 
 addHandler(
-	'lfxs',
-	() => false, // TODO: not sure when we actually need to write this section
-	// NOTE: this might be insufficient
-	// target => target.effects !== undefined && (
-	// 	!!target.effects.dropShadow?.some(e => e.choke) ||
-	// 	!!target.effects.innerShadow?.some(e => e.choke) ||
-	// 	!!target.effects.outerGlow?.choke ||
-	// 	!!target.effects.innerGlow?.choke
-	// ),
+	'lfxs', // effects of group layers (instead of 'lfx2' / 'lmfx')
+	target => target.effects !== undefined && isGroupLayer(target),
 	(reader, target, left) => {
 		const version = readUint32(reader);
 		if (version !== 0) throw new Error(`Invalid lfxs version`);
 
 		const desc: Lfx2Descriptor & LmfxDescriptor = readVersionAndDescriptor(reader);
-		target.effects = parseEffects(desc, !!reader.logMissingFeatures);
+		target.effects = parseEffects(desc, reader);
 
 		skipBytes(reader, left());
 	},
-	(writer, target, _, options) => {
-		const desc = serializeEffects(target.effects!, !!options.logMissingFeatures, true);
+	(writer, target) => {
+		const desc = serializeEffects(target.effects!, writer, true);
 		writeUint32(writer, 0); // version
 		writeVersionAndDescriptor(writer, '', 'null', desc);
 	},
@@ -4238,6 +4710,12 @@ function readLevelsChannel(reader: PsdReader): LevelsAdjustmentChannel {
 	return { shadowInput, highlightInput, shadowOutput, highlightOutput, midtoneInput };
 }
 
+const defaultLevelsChannel: LevelsAdjustmentChannel = { shadowInput: 0, highlightInput: 255, shadowOutput: 0, highlightOutput: 255, midtoneInput: 1 };
+
+function isDefaultLevelsChannel(c: LevelsAdjustmentChannel) {
+	return c.shadowInput === 0 && c.highlightInput === 255 && c.shadowOutput === 0 && c.highlightOutput === 255 && c.midtoneInput === 1;
+}
+
 function writeLevelsChannel(writer: PsdWriter, channel: LevelsAdjustmentChannel) {
 	writeInt16(writer, channel.shadowInput);
 	writeInt16(writer, channel.highlightInput);
@@ -4252,62 +4730,56 @@ addHandler(
 	(reader, target, left) => {
 		if (readUint16(reader) !== 2) throw new Error('Invalid levl version');
 
-		const levels: LevelsAdjustmentChannel[] = [];
+		const channels: LevelsAdjustmentChannel[] = [];
+
+		for (let i = 0; i < 29 && left() >= 10; i++) {
+			channels.push(readLevelsChannel(reader));
+		}
+
+		if (left() >= 8) {
+			const signature = readSignature(reader);
+			let totalChannelRecords: number;
 
-		for (let i = 0; i < 29 && left(); i++) {
-			levels.push(readLevelsChannel(reader));
+			if (signature === 'ls\x00\x03') {
+				// Clip Studio Paint writes 'ls' instead of 'Lvls' signature (version is part of the read signature)
+				totalChannelRecords = readUint16(reader);
+			} else {
+				if (signature !== 'Lvls') throw new Error(`Invalid levl signature`);
+				if (readUint16(reader) !== 3) throw new Error(`Invalid levl version`);
+				totalChannelRecords = readUint16(reader);
+			}
+
+			while (channels.length < totalChannelRecords && left() >= 10) {
+				channels.push(readLevelsChannel(reader));
+			}
 		}
 
-		const [rgb, red, green, blue] = levels;
+		// records for all possible channels are stored, skip unused ones
+		while (channels.length && isDefaultLevelsChannel(channels[channels.length - 1])) channels.pop();
 
 		target.adjustment = {
 			...target.adjustment as PresetInfo,
 			type: 'levels',
-			rgb,
-			red,
-			green,
-			blue,
+			channels,
 		};
 
-		if (left()) {
-			if (readSignature(reader) !== 'Lvls') throw new Error(`Invalid levl signature`);
-			if (readUint16(reader) !== 3) throw new Error(`Invalid levl version`);
-
-			const totalChannelRecords = readUint16(reader);
-
-			for (let i = 0; i < (totalChannelRecords - levels.length) && left(); i++) {
-				levels.push(readLevelsChannel(reader));
-			}
-		}
-
 		skipBytes(reader, left());
 	},
 	(writer, target) => {
-		const info = target.adjustment as LevelsAdjustment;
-		const defaultChannel = {
-			shadowInput: 0,
-			highlightInput: 255,
-			shadowOutput: 0,
-			highlightOutput: 255,
-			midtoneInput: 1,
-		};
+		const channels = (target.adjustment as LevelsAdjustment).channels || [];
 
 		writeUint16(writer, 2); // version
-		writeLevelsChannel(writer, info.rgb || defaultChannel);
-		writeLevelsChannel(writer, info.red || defaultChannel);
-		writeLevelsChannel(writer, info.green || defaultChannel);
-		writeLevelsChannel(writer, info.blue || defaultChannel);
 
-		for (let i = 0; i < (29 - 4); i++) {
-			writeLevelsChannel(writer, defaultChannel);
+		for (let i = 0; i < 29; i++) {
+			writeLevelsChannel(writer, channels[i] || defaultLevelsChannel);
 		}
 
 		writeSignature(writer, 'Lvls');
 		writeUint16(writer, 3); // version
 		writeUint16(writer, 62); // total count
 
-		for (let i = 0; i < (62 - 29); i++) {
-			writeLevelsChannel(writer, defaultChannel);
+		for (let i = 29; i < 62; i++) {
+			writeLevelsChannel(writer, channels[i] || defaultLevelsChannel);
 		}
 	},
 );
@@ -4338,71 +4810,82 @@ addHandler(
 	'curv',
 	adjustmentType('curves'),
 	(reader, target, left) => {
-		readUint8(reader);
-		if (readUint16(reader) !== 1) throw new Error('Invalid curv version');
-		readUint16(reader);
-		const channels = readUint16(reader);
-		const info: CurvesAdjustment = { type: 'curves' };
+		const isMap = !!readUint8(reader); // curves drawn with pencil tool (lookup tables instead of points)
+		const version = readUint16(reader);
+		if (version !== 1 && version !== 4) throw new Error('Invalid curv version');
+		const countOrMask = readUint32(reader);
+		const channels: (CurvesAdjustmentChannel | number[])[] = [];
+		const readChannel = () => isMap ? Array.from(readBytes(reader, 256)) : readCurveChannel(reader);
+
+		if (version === 1) {
+			for (let i = 0; i < 32; i++) {
+				if (countOrMask & (1 << i)) {
+					while (channels.length < i) channels.push([]);
+					channels.push(readChannel());
+				}
+			}
+		} else {
+			if (countOrMask > 64) throw new Error('Invalid curv channel count');
+			for (let i = 0; i < countOrMask; i++) channels.push(readChannel());
+		}
 
-		if (channels & 1) info.rgb = readCurveChannel(reader);
-		if (channels & 2) info.red = readCurveChannel(reader);
-		if (channels & 4) info.green = readCurveChannel(reader);
-		if (channels & 8) info.blue = readCurveChannel(reader);
+		// extra section stores curves for all channels (including ones that don't fit in the mask)
+		if (version === 1 && left() >= 10 && readSignature(reader) === 'Crv ') {
+			readUint16(reader); // version
+			const count = readUint32(reader);
+
+			for (let i = 0; i < count && left() >= 2; i++) {
+				const index = readUint16(reader);
+				const channel = readChannel();
+				while (channels.length < index) channels.push([]);
+				channels[index] = channel;
+			}
+		}
 
 		target.adjustment = {
 			...target.adjustment as PresetInfo,
-			...info,
+			type: 'curves',
+			...(isMap ? { values: channels as number[][] } : { channels: channels as CurvesAdjustmentChannel[] }),
 		};
 
-		// ignoring, duplicate information
-		// checkSignature(reader, 'Crv ');
-
-		// const cVersion = readUint16(reader);
-		// readUint16(reader);
-		// const channelCount = readUint16(reader);
-
-		// for (let i = 0; i < channelCount; i++) {
-		// 	const index = readUint16(reader);
-		// 	const nodes = readUint16(reader);
-
-		// 	for (let j = 0; j < nodes; j++) {
-		// 		const output = readInt16(reader);
-		// 		const input = readInt16(reader);
-		// 	}
-		// }
-
 		skipBytes(reader, left());
 	},
 	(writer, target) => {
-		const info = target.adjustment as CurvesAdjustment;
-		const { rgb, red, green, blue } = info;
-		let channels = 0;
-		let channelCount = 0;
+		const adjustment = target.adjustment as CurvesAdjustment;
+		const isMap = !!adjustment.values;
+		const channels: (CurvesAdjustmentChannel | number[])[] = (isMap ? adjustment.values : adjustment.channels) || [];
+		const used: number[] = [];
+		let channelsMask = 0;
+
+		for (let i = 0; i < channels.length; i++) {
+			if (channels[i]?.length) {
+				if (i < 32) channelsMask |= 1 << i;
+				used.push(i);
+			}
+		}
 
-		if (rgb && rgb.length) { channels |= 1; channelCount++; }
-		if (red && red.length) { channels |= 2; channelCount++; }
-		if (green && green.length) { channels |= 4; channelCount++; }
-		if (blue && blue.length) { channels |= 8; channelCount++; }
+		const writeChannel = (channel: CurvesAdjustmentChannel | number[]) => {
+			if (isMap) {
+				for (let i = 0; i < 256; i++) writeUint8(writer, clamp(Math.round((channel as number[])[i] ?? i), 0, 255));
+			} else {
+				writeCurveChannel(writer, channel as CurvesAdjustmentChannel);
+			}
+		};
 
-		writeUint8(writer, 0);
+		writeUint8(writer, isMap ? 1 : 0);
 		writeUint16(writer, 1); // version
-		writeUint16(writer, 0);
-		writeUint16(writer, channels);
+		writeUint32(writer, channelsMask >>> 0);
 
-		if (rgb && rgb.length) writeCurveChannel(writer, rgb);
-		if (red && red.length) writeCurveChannel(writer, red);
-		if (green && green.length) writeCurveChannel(writer, green);
-		if (blue && blue.length) writeCurveChannel(writer, blue);
+		for (const i of used) if (i < 32) writeChannel(channels[i]);
 
 		writeSignature(writer, 'Crv ');
 		writeUint16(writer, 4); // version
-		writeUint16(writer, 0);
-		writeUint16(writer, channelCount);
+		writeUint32(writer, used.length);
 
-		if (rgb && rgb.length) { writeUint16(writer, 0); writeCurveChannel(writer, rgb); }
-		if (red && red.length) { writeUint16(writer, 1); writeCurveChannel(writer, red); }
-		if (green && green.length) { writeUint16(writer, 2); writeCurveChannel(writer, green); }
-		if (blue && blue.length) { writeUint16(writer, 3); writeCurveChannel(writer, blue); }
+		for (const i of used) {
+			writeUint16(writer, i);
+			writeChannel(channels[i]);
+		}
 	},
 );
 
@@ -4487,10 +4970,26 @@ addHandler(
 	(reader, target, left) => {
 		if (readUint16(reader) !== 2) throw new Error('Invalid hue2 version');
 
+		const colorize = !!readUint8(reader);
+		skipBytes(reader, 1);
+		const colorizeHue = readInt16(reader); // stored as -180..180
+		const colorizeSaturation = readInt16(reader);
+		const colorizeLightness = readInt16(reader);
+
 		target.adjustment = {
 			...target.adjustment as PresetInfo,
 			type: 'hue/saturation',
-			master: readHueChannel(reader),
+			colorize,
+			colorization: {
+				hue: colorizeHue < 0 ? colorizeHue + 360 : colorizeHue,
+				saturation: colorizeSaturation,
+				lightness: colorizeLightness,
+			},
+			master: {
+				hue: readInt16(reader),
+				saturation: readInt16(reader),
+				lightness: readInt16(reader),
+			},
 			reds: readHueChannel(reader),
 			yellows: readHueChannel(reader),
 			greens: readHueChannel(reader),
@@ -4505,7 +5004,15 @@ addHandler(
 		const info = target.adjustment as HueSaturationAdjustment;
 
 		writeUint16(writer, 2); // version
-		writeHueChannel(writer, info.master);
+		writeUint8(writer, info.colorize ? 1 : 0);
+		writeUint8(writer, 0);
+		const colorizeHue = Math.round(info.colorization?.hue ?? 0);
+		writeInt16(writer, colorizeHue > 180 ? colorizeHue - 360 : colorizeHue);
+		writeInt16(writer, Math.round(info.colorization?.saturation ?? 0));
+		writeInt16(writer, Math.round(info.colorization?.lightness ?? 0));
+		writeInt16(writer, Math.round(info.master?.hue ?? 0));
+		writeInt16(writer, Math.round(info.master?.saturation ?? 0));
+		writeInt16(writer, Math.round(info.master?.lightness ?? 0));
 		writeHueChannel(writer, info.reds);
 		writeHueChannel(writer, info.yellows);
 		writeHueChannel(writer, info.greens);
@@ -4619,16 +5126,17 @@ addHandler(
 		if (version === 2) {
 			color = readColor(reader);
 		} else { // version 3
-			// TODO: test this, this is probably wrong
-			// values are stored as L (0..100), a, b (-128..127) multiplied by 100,
-			// normalize them to the same scale as readColor() so they can be written back as version 2
-			const l = readInt32(reader) / 100;
-			const a = readInt32(reader) / 100;
-			const b = readInt32(reader) / 100;
+			// XYZ color relative to D50 white point, 32768 = 1.0 (not documented, matches colors of Photoshop presets),
+			// converted to Lab (same scale as readColor()) so it can be written back as version 2
+			const x = readInt32(reader) / 32768;
+			const y = readInt32(reader) / 32768;
+			const z = readInt32(reader) / 32768;
+			if (!(x >= 0 && y >= 0 && z >= 0 && x <= 2 && y <= 2 && z <= 2)) throw new Error('Invalid phfl XYZ color');
+			const f = (t: number) => t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
 			color = {
-				l: l / 100,
-				a: normalizeLabAB(a),
-				b: normalizeLabAB(b),
+				l: Math.max(0, 116 * f(y) - 16) / 100,
+				a: normalizeLabAB(500 * (f(x) - f(y))),
+				b: normalizeLabAB(200 * (f(y) - f(z))),
 			};
 		}
 
@@ -4844,7 +5352,7 @@ addHandler(
 		const hasMethod = !!readUint8(reader); reader.offset--;
 		if (hasMethod) {
 			const method = readSignature(reader);
-			info.method = gradientInterpolationMethodType.decode(method);
+			info.method = gradientInterpolationMethodType.decode(`gradientInterpolationMethodType.${method}`);
 		}
 
 		info.name = readUnicodeString(reader);
@@ -4917,7 +5425,7 @@ addHandler(
 		writeUint8(writer, info.dither ? 1 : 0);
 
 		if (info.method !== undefined) {
-			writeSignature(writer, gradientInterpolationMethodType.encode(info.method));
+			writeSignature(writer, gradientInterpolationMethodType.encode(info.method).split('.')[1]);
 		}
 
 		writeUnicodeStringWithPadding(writer, info.name || '');
@@ -5316,6 +5824,10 @@ addHandler(
 );
 
 addHandlerAlias('FXid', 'FEid');
+addHandlerAlias('FELS', 'FEid'); // filter effects 3
+addHandlerAlias('hue ', 'hue2'); // old hue/saturation (Photoshop 4.0), same structure as 'hue2'
+addHandlerAlias('plLd', 'PlLd'); // old placed layer key
+addHandlerAlias('abdd', 'artb'); // artboard data 3
 
 addHandler(
 	'FMsk',
@@ -5334,14 +5846,14 @@ addHandler(
 
 interface ArtdDescriptor {
 	'Cnt ': number;
-	autoExpandOffset: { Hrzn: number; Vrtc: number; };
-	origin: { Hrzn: number; Vrtc: number; };
-	autoExpandEnabled: boolean;
-	autoNestEnabled: boolean;
-	autoPositionEnabled: boolean;
+	autoExpandOffset?: { Hrzn: number; Vrtc: number; };
+	origin?: { Hrzn: number; Vrtc: number; };
+	autoExpandEnabled?: boolean;
+	autoNestEnabled?: boolean;
+	autoPositionEnabled?: boolean;
 	shrinkwrapOnSaveEnabled?: boolean;
-	docDefaultNewArtboardBackgroundColor: DescriptorColor;
-	docDefaultNewArtboardBackgroundType: number;
+	docDefaultNewArtboardBackgroundColor?: DescriptorColor;
+	docDefaultNewArtboardBackgroundType?: number;
 }
 
 addHandler(
@@ -5349,17 +5861,15 @@ addHandler(
 	target => (target as Psd).artboards !== undefined,
 	(reader, target, left) => {
 		const desc = readVersionAndDescriptor(reader) as ArtdDescriptor;
-		(target as Psd).artboards = {
-			count: desc['Cnt '],
-			autoExpandOffset: { horizontal: desc.autoExpandOffset.Hrzn, vertical: desc.autoExpandOffset.Vrtc },
-			origin: { horizontal: desc.origin.Hrzn, vertical: desc.origin.Vrtc },
-			autoExpandEnabled: desc.autoExpandEnabled,
-			autoNestEnabled: desc.autoNestEnabled,
-			autoPositionEnabled: desc.autoPositionEnabled,
-			shrinkwrapOnSaveEnabled: !!desc.shrinkwrapOnSaveEnabled,
-			docDefaultNewArtboardBackgroundColor: parseColor(desc.docDefaultNewArtboardBackgroundColor),
-			docDefaultNewArtboardBackgroundType: desc.docDefaultNewArtboardBackgroundType,
-		};
+		const artboards: Psd['artboards'] = (target as Psd).artboards = { count: desc['Cnt '] };
+		if (desc.autoExpandOffset) artboards.autoExpandOffset = { horizontal: desc.autoExpandOffset.Hrzn, vertical: desc.autoExpandOffset.Vrtc };
+		if (desc.origin) artboards.origin = { horizontal: desc.origin.Hrzn, vertical: desc.origin.Vrtc };
+		if (desc.autoExpandEnabled !== undefined) artboards.autoExpandEnabled = desc.autoExpandEnabled;
+		if (desc.autoNestEnabled !== undefined) artboards.autoNestEnabled = desc.autoNestEnabled;
+		if (desc.autoPositionEnabled !== undefined) artboards.autoPositionEnabled = desc.autoPositionEnabled;
+		artboards.shrinkwrapOnSaveEnabled = !!desc.shrinkwrapOnSaveEnabled;
+		if (desc.docDefaultNewArtboardBackgroundColor) artboards.docDefaultNewArtboardBackgroundColor = parseColor(desc.docDefaultNewArtboardBackgroundColor);
+		if (desc.docDefaultNewArtboardBackgroundType !== undefined) artboards.docDefaultNewArtboardBackgroundType = desc.docDefaultNewArtboardBackgroundType;
 
 		skipBytes(reader, left());
 	},
@@ -5380,13 +5890,17 @@ addHandler(
 	},
 );
 
+function isGroupLayer(target: LayerAdditionalInfo) {
+	return !!(target as Layer).children;
+}
+
 export function hasMultiEffects(effects: LayerEffectsInfo) {
 	return Object.keys(effects).map(key => (effects as any)[key]).some(v => Array.isArray(v) && v.length > 1);
 }
 
 addHandler(
 	'lfx2',
-	target => target.effects !== undefined && !hasMultiEffects(target.effects),
+	target => target.effects !== undefined && !isGroupLayer(target) && !hasMultiEffects(target.effects),
 	(reader, target, left) => {
 		const version = readUint32(reader);
 		if (version !== 0) throw new Error(`Invalid lfx2 version`);
@@ -5394,14 +5908,13 @@ addHandler(
 		const desc: Lfx2Descriptor & LmfxDescriptor = readVersionAndDescriptor(reader);
 		// console.log('READ', require('util').inspect(desc, false, 99, true));
 
-		// TODO: don't discard if we got it from lmfx
-		// discard if read in 'lrFX' section
-		target.effects = parseEffects(desc, !!reader.logMissingFeatures);
+		// discard if read in 'lrFX' section ('lmfx' and 'lfx2' are never stored together)
+		target.effects = parseEffects(desc, reader);
 
 		skipBytes(reader, left());
 	},
-	(writer, target, _, options) => {
-		const desc = serializeEffects(target.effects!, !!options.logMissingFeatures, true);
+	(writer, target) => {
+		const desc = serializeEffects(target.effects!, writer, true);
 		// console.log('WRITE', require('util').inspect(desc, false, 99, true));
 
 		writeUint32(writer, 0); // version
@@ -5469,26 +5982,102 @@ addHandler(
 	},
 );
 
-interface ExtensionDesc {
-	generatorSettings: {
-		generator_45_assets: { json: string; };
-		layerTime: number;
-	};
+// generator settings of the document (layers store them in 'shmd' section)
+addHandler(
+	'extn',
+	target => target.generatorSettings !== undefined && isDocument(target),
+	(reader, target, left) => {
+		const desc = readVersionAndDescriptor(reader) as GeneratorSettingsDescriptor;
+		if (desc.generatorSettings) target.generatorSettings = parseGeneratorSettings(desc.generatorSettings);
+		skipBytes(reader, left());
+	},
+	(writer, target) => {
+		writeVersionAndDescriptor(writer, '', 'null', serializeGeneratorSettings(target.generatorSettings!));
+	},
+);
+
+// generator settings stored by older versions of Photoshop (written back in 'shmd' or 'extn' section)
+addHandler(
+	'extd',
+	() => false,
+	(reader, target, left) => {
+		const desc = readVersionAndDescriptor(reader) as GeneratorSettingsDescriptor;
+		if (desc.generatorSettings && target.generatorSettings === undefined) {
+			target.generatorSettings = parseGeneratorSettings(desc.generatorSettings);
+		}
+		skipBytes(reader, left());
+	},
+	() => { },
+);
+
+interface FrgbDescriptor {
+	framedGroupRect: { _name: ''; _classID: 'classFloatRect'; 'Top ': number; Left: number; Btom: number; Rght: number; };
+	framedGroupType: number;
+	LockPPI?: boolean;
+	PreferredResolution?: number;
+	SavedIteratedName?: string;
 }
 
-// extension settings ?, ignore it
 addHandler(
-	'extn',
-	target => (target as any)._extn !== undefined,
-	(reader, target) => {
-		const desc: ExtensionDesc = readVersionAndDescriptor(reader);
-		// console.log(require('util').inspect(desc, false, 99, true));
+	'frgb', // frame tool group
+	hasKey('framedGroup'),
+	(reader, target, left) => {
+		const desc = readVersionAndDescriptor(reader) as FrgbDescriptor;
+		const rect = desc.framedGroupRect;
+		target.framedGroup = {
+			rect: { top: rect['Top '], left: rect.Left, bottom: rect.Btom, right: rect.Rght },
+			type: desc.framedGroupType,
+		};
+		if (desc.LockPPI !== undefined) target.framedGroup.lockPPI = desc.LockPPI;
+		if (desc.PreferredResolution !== undefined) target.framedGroup.preferredResolution = desc.PreferredResolution;
+		if (desc.SavedIteratedName !== undefined) target.framedGroup.savedIteratedName = desc.SavedIteratedName;
+		skipBytes(reader, left());
+	},
+	(writer, target) => {
+		const group = target.framedGroup!;
+		const rect = group.rect;
+		const desc: FrgbDescriptor = {
+			framedGroupRect: { _name: '', _classID: 'classFloatRect', 'Top ': rect.top, Left: rect.left, Btom: rect.bottom, Rght: rect.right },
+			framedGroupType: group.type,
+		};
+		if (group.lockPPI !== undefined) desc.LockPPI = group.lockPPI;
+		if (group.preferredResolution !== undefined) desc.PreferredResolution = group.preferredResolution;
+		if (group.savedIteratedName !== undefined) desc.SavedIteratedName = group.savedIteratedName;
+		writeVersionAndDescriptor(writer, '', 'framedGroup', desc);
+	},
+);
 
-		if (MOCK_HANDLERS) (target as any)._extn = desc;
+addHandler(
+	'anFX',
+	hasKey('animationEffects'),
+	(reader, target, left) => {
+		target.animationEffects = readBytes(reader, left());
 	},
 	(writer, target) => {
-		// TODO: need to add correct types for desc fields (resources/src.psd)
-		if (MOCK_HANDLERS) writeVersionAndDescriptor(writer, '', 'null', (target as any)._extn);
+		writeBytes(writer, target.animationEffects);
+	},
+);
+
+addHandler(
+	'PxSD', // pixel source data 2 (video layer frames)
+	hasKey('pixelSourceData'),
+	(reader, target, left) => {
+		target.pixelSourceData = [];
+
+		while (left() >= 8) {
+			const length = readLength64(reader);
+			if (length > left()) throw new Error('Invalid PxSD data length');
+			target.pixelSourceData.push(readBytes(reader, length));
+		}
+
+		skipBytes(reader, left());
+	},
+	(writer, target) => {
+		for (const data of target.pixelSourceData!) {
+			writeUint32(writer, 0);
+			writeUint32(writer, data.byteLength);
+			writeBytes(writer, data);
+		}
 	},
 );