ag-psd 31.0.3 → 33.0.0

package/src/additionalInfo.ts

@@ -1,9 +1,9 @@
 import { fromByteArray, toByteArray } from 'base64-js';
 import { readEffects, writeEffects } from './effectsHelpers';
-import { clamp, createEnum, layerColors, MOCK_HANDLERS } 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 { PsdWriter, writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32, writePattern } from './psdWriter';
+import { clamp, createEnum, layerColors, MOCK_HANDLERS, normalizeLabAB } from './helpers';
+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 } 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 { serializeEngineData, parseEngineData } from './engineData';
 import { encodeEngineData, decodeEngineData } from './text';
@@ -13,6 +13,8 @@ import type { InternalImageResources } from './imageResources';
 export interface ExtendedWriteOptions extends WriteOptions {
 	layerIds: Set<number>;
 	layerToId: Map<any, number>;
+	explicitLayerIds?: Set<number>; // ids set on layers in the document (generated ids can't use them)
+	nextGeneratedLayerId?: number; // all ids below this one are already taken
 }
 
 type HasMethod = (target: LayerAdditionalInfo) => boolean;
@@ -49,11 +51,6 @@ function readLength64(reader: PsdReader) {
 	return readUint32(reader);
 }
 
-function writeLength64(writer: PsdWriter, length: number) {
-	writeUint32(writer, 0);
-	writeUint32(writer, length);
-}
-
 addHandler(
 	'TySh',
 	hasKey('text'),
@@ -95,7 +92,7 @@ addHandler(
 		if (text.boundingBox) target.text.boundingBox = descBoundsToBounds(text.boundingBox);
 
 		if (text.EngineData) {
-			const engineData = parseEngineData(text.EngineData);
+			const engineData = parseEngineData(text.EngineData, reader);
 			const textData = decodeEngineData(engineData);
 			// console.log(require('util').inspect(engineData, false, 99, false), 'utf8');
 
@@ -106,7 +103,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));
 		}
 
@@ -140,10 +138,10 @@ addHandler(
 		writeInt16(writer, 1); // warp version
 		writeVersionAndDescriptor(writer, '', 'warp', encodeWarp(warp));
 
-		writeFloat32(writer, text.left!);
-		writeFloat32(writer, text.top!);
-		writeFloat32(writer, text.right!);
-		writeFloat32(writer, text.bottom!);
+		writeFloat32(writer, text.left ?? 0);
+		writeFloat32(writer, text.top ?? 0);
+		writeFloat32(writer, text.right ?? 0);
+		writeFloat32(writer, text.bottom ?? 0);
 
 		// writeZeros(writer, 2);
 	},
@@ -231,7 +229,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;
@@ -286,6 +284,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'),
@@ -315,45 +358,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');
 
@@ -368,7 +377,7 @@ addHandler(
 	},
 );
 
-interface VogkDescriptor {
+export interface KeyDescriptorListDescriptor {
 	keyDescriptorList: {
 		keyShapeInvalidated?: boolean;
 		keyOriginType?: number;
@@ -398,121 +407,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);
 	}
@@ -520,7 +536,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');
@@ -586,15 +602,58 @@ addHandler(
 	(writer, target) => writeSignature(writer, target.nameSource!),
 );
 
+// these sections reference layer id
+function layerNeedsId(target: LayerAdditionalInfo) {
+	return !!(target.animationFrames || target.timeline || target.comps);
+}
+
+function getExplicitLayerIds(psd: Psd, options: ExtendedWriteOptions) {
+	if (!options.explicitLayerIds) {
+		const ids = new Set<number>();
+		const addIds = (layers: Layer[] | undefined) => {
+			for (const layer of layers ?? []) {
+				if (layer.id !== undefined) ids.add(layer.id);
+				addIds(layer.children);
+			}
+		};
+		addIds(psd.children);
+		options.explicitLayerIds = ids;
+	}
+
+	return options.explicitLayerIds;
+}
+
+function getLayerId(target: LayerAdditionalInfo, options: ExtendedWriteOptions) {
+	const id = options.layerToId.get(target) ?? target.id;
+	if (id === undefined) throw new Error('Missing layer id');
+	return id;
+}
+
 addHandler(
 	'lyid',
-	hasKey('id'),
+	target => target.id !== undefined || layerNeedsId(target),
 	(reader, target) => {
 		target.id = readUint32(reader);
 	},
-	(writer, target, _psd, options) => {
-		let id = target.id!;
-		while (options.layerIds.has(id)) id += 100; // make sure we don't have duplicate layer ids
+	(writer, target, psd, options) => {
+		let id: number;
+
+		if (target.id !== undefined) {
+			id = target.id;
+
+			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);
+			id = options.nextGeneratedLayerId ?? 1;
+			while (options.layerIds.has(id) || explicitIds.has(id)) id++;
+			options.nextGeneratedLayerId = id + 1;
+		}
+
 		writeUint32(writer, id);
 		options.layerIds.add(id);
 		options.layerToId.set(target, id);
@@ -698,15 +757,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);
 	},
 );
 
@@ -729,6 +790,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;
@@ -742,112 +859,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.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,
+						};
 
-					if (desc.trackList) {
-						timeline.tracks = parseTrackList(desc.trackList, !!reader.logMissingFeatures);
-					}
+						if (desc.trackList) {
+							timeline.tracks = parseTrackList(desc.trackList, !!reader.logMissingFeatures);
+						}
 
-					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++;
@@ -855,6 +973,7 @@ addHandler(
 		if (timeline) count++;
 		if (timestamp !== undefined) count++;
 		if (comps) count++;
+		if (generatorSettings) count++;
 		writeUint32(writer, count);
 
 		if (animationFrames) {
@@ -864,7 +983,7 @@ addHandler(
 			writeZeros(writer, 3);
 			writeSection(writer, 2, () => {
 				const desc: FrameListDescriptor = {
-					LaID: target.id ?? 0,
+					LaID: getLayerId(target, options),
 					LaSt: [],
 				};
 
@@ -875,8 +994,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, false, hasMultiEffects(f.effects));
+					if (f.opacity !== undefined) frame.blendOptions = { Opct: unitsPercentF(f.opacity) };
 					desc.LaSt.push(frame);
 				}
 
@@ -922,9 +1041,7 @@ addHandler(
 					desc.trackList = serializeTrackList(timeline.tracks);
 				}
 
-				const id = options.layerToId.get(target) || target.id;
-				if (!id) throw new Error('You need to provide layer.id value whan writing document with animations');
-				desc.LyrI = id;
+				desc.LyrI = getLayerId(target, options);
 
 				// console.log('WRITE:tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
 				writeVersionAndDescriptor(writer, '', 'null', desc, 'anim');
@@ -950,16 +1067,13 @@ addHandler(
 			writeUint8(writer, 0); // copy (always false)
 			writeZeros(writer, 3);
 			writeSection(writer, 2, () => {
-				const id = options.layerToId.get(target) || target.id;
-				if (!id) throw new Error('You need to provide layer.id value whan writing document with layer comps');
-
 				const desc: CmlsDescriptor = {} as any;
 
 				if (comps.originalEffectsReferencePoint) {
 					desc.origFXRefPoint = { Hrzn: comps.originalEffectsReferencePoint.x, Vrtc: comps.originalEffectsReferencePoint.y };
 				}
 
-				desc.LyrI = id;
+				desc.LyrI = getLayerId(target, options);
 				desc.layerSettings = [];
 
 				for (const item of comps.settings) {
@@ -975,12 +1089,22 @@ 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);
+		}
 	},
 );
 
 addHandler(
 	'PxSc',
-	() => false,
+	hasKey('pixelSource'),
 	(reader, target) => {
 		const desc = readVersionAndDescriptor(reader, true) as PxScDescriptor;
 		// console.log('PxSc', require('util').inspect(desc, false, 99, true));
@@ -1017,7 +1141,7 @@ addHandler(
 			_classID: 'PixelSource',
 			pixelSourceType: 1986285651, // vdP
 			descVersion: 1,
-			origin: { Hrzn: source.origin.x, Vrtc: source.origin.y },
+			origin: { Hrzn: source.origin.x, Vrtc: source.origin.y }, // written as 'null' class with 'long' values (see writeDescriptorStructure)
 			interpretation: {
 				_name: '',
 				_classID: 'footageInterpretation',
@@ -1066,7 +1190,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),
@@ -1105,8 +1229,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(
@@ -1119,10 +1243,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) => {
@@ -1269,13 +1394,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');
@@ -1827,7 +1952,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';
@@ -1997,7 +2122,7 @@ type SoLdDescriptorFilterItem = {
 	Fltr: {
 		_name: 'Perspective Warp';
 		_classID: 'perspectiveWarpTransform';
-		quads: { indices: number[]; }[];
+		quads: { _name?: ''; _classID?: string; indices: number[]; }[];
 		vertices: HrznVrtcDescriptor[];
 		warpedVertices: HrznVrtcDescriptor[];
 	};
@@ -2006,7 +2131,7 @@ type SoLdDescriptorFilterItem = {
 	Fltr: {
 		_name: 'Curves';
 		_classID: 'Crvs';
-		presetKind: string; // 'presetKindType.presetKindCustom';
+		presetKind?: string; // 'presetKindType.presetKindCustom';
 		Adjs?: {
 			_name: '';
 			_classID: 'CrvA';
@@ -2015,6 +2140,14 @@ type SoLdDescriptorFilterItem = {
 			Mpng?: number[];
 		}[];
 	};
+} | {
+	filterID: 1282829427;
+	Fltr: {
+		_name: 'Levels';
+		_classID: 'Lvls';
+		presetKind?: string; // 'presetKindType.presetKindCustom';
+		Adjs?: FilterLevelsAdjustment[];
+	};
 } | {
 	filterID: 1231976050;
 } | {
@@ -2036,6 +2169,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',
@@ -2048,11 +2193,13 @@ interface SoLdDescriptorFilter {
 }
 
 function uint8ToFloat32(array: Uint8Array) {
-	return new Float32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+	const length = Math.floor(array.byteLength / 4);
+	return new Float32Array(array.buffer.slice(array.byteOffset, array.byteOffset + length * 4), 0, length);
 }
 
 function uint8ToUint32(array: Uint8Array) {
-	return new Uint32Array(array.buffer.slice(array.byteOffset), 0, array.byteLength / 4);
+	const length = Math.floor(array.byteLength / 4);
+	return new Uint32Array(array.buffer.slice(array.byteOffset, array.byteOffset + length * 4), 0, length);
 }
 
 function toUint8(array: Uint32Array | Float32Array) {
@@ -2097,7 +2244,7 @@ function pointToHrznVrtc(point: { x: UnitsValue; y: UnitsValue; }): HrznVrtcDesc
 	};
 }
 
-function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): Filter | undefined {
+function parseFilterFXItem(f: SoLdDescriptorFilterItem, reader: PsdReader): Filter | undefined {
 	const base: Omit<Filter, 'type' | 'filter'> = {
 		name: f['Nm  '],
 		opacity: parsePercent(f.blendOptions.Opct),
@@ -2177,7 +2324,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,
 					},
 				},
 			};
@@ -2510,10 +2657,9 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 						{ x: f.Fltr.PuX2, y: f.Fltr.PuY2, },
 						{ x: f.Fltr.PuX3, y: f.Fltr.PuY3, },
 					],
-					puppetShapeList: f.Fltr.puppetShapeList!.map(p => ({
+					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)),
@@ -2632,7 +2778,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);
@@ -2655,6 +2802,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,
@@ -2667,10 +2848,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 {
@@ -2689,22 +2871,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),
 	};
 }
 
@@ -3243,14 +3427,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 => ({
+				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)),
@@ -3356,7 +3540,7 @@ function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
 				_classID: 'perspectiveWarpTransform',
 				vertices: f.filter.vertices.map(pointToHrznVrtc),
 				warpedVertices: f.filter.warpedVertices.map(pointToHrznVrtc),
-				quads: f.filter.quads.map(indices => ({ indices })),
+				quads: f.filter.quads.map(indices => ({ _name: '', _classID: 'quadIndices', indices })),
 			},
 			filterID: 442,
 		};
@@ -3365,7 +3549,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: '',
@@ -3388,6 +3572,28 @@ 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 'brightness/contrast': return {
 			...base,
 			Fltr: {
@@ -3399,10 +3605,17 @@ function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
 			},
 			filterID: 1114793795,
 		};
-		// case 'hsb/hsl': return {
-		// TODO: ...
-		// };
-		default: throw new Error(`Unknow filter type: ${(f as any).type}`);
+		case 'hsb/hsl': return {
+			...base,
+			Fltr: {
+				_name: 'HSB/HSL',
+				_classID: 'HsbP',
+				Inpt: ClrS.encode(f.filter.inputMode),
+				Otpt: ClrS.encode(f.filter.rowOrder),
+			},
+			filterID: 1215521360,
+		};
+		default: throw new Error(`Unknown filter type: ${(f as any).type}`);
 	}
 }
 
@@ -3424,8 +3637,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: '';
@@ -3473,7 +3686,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);
@@ -3531,6 +3744,15 @@ addHandler(
 			throw new Error('Placed layer ID must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)');
 		}
 
+		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,
@@ -3541,16 +3763,16 @@ addHandler(
 			duration: placed.duration || { numerator: 0, denominator: 600 },
 			frameCount: placed.frameCount || 0,
 			Annt: 16,
-			Type: placedLayerTypes.indexOf(placed.type),
+			Type: placedType,
 			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 },
 		};
@@ -3568,15 +3790,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));
@@ -3608,7 +3821,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',
@@ -3625,25 +3848,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',
@@ -3651,7 +3899,7 @@ addHandler(
 	(reader, target) => {
 		target.userMask = {
 			colorSpace: readColor(reader),
-			opacity: readUint16(reader) / 0xff,
+			opacity: readUint16(reader) / 100,
 		};
 		const flag = readUint8(reader);
 		if (flag !== 128) throw new Error('Invalid flag value');
@@ -3660,7 +3908,7 @@ addHandler(
 	(writer, target) => {
 		const userMask = target.userMask!;
 		writeColor(writer, userMask.colorSpace);
-		writeUint16(writer, clamp(userMask.opacity, 0, 1) * 0xff);
+		writeUint16(writer, Math.round(clamp(userMask.opacity, 0, 1) * 100));
 		writeUint8(writer, 128);
 		writeZeros(writer, 1);
 	},
@@ -3678,11 +3926,12 @@ if (MOCK_HANDLERS) {
 	);
 } else {
 	addHandler(
-		'Patt', // TODO: handle also Pat2 & Pat3
+		'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 = readPattern(reader);
+				const pattern = readPatternSafe(reader);
+				if (!pattern) continue;
 				if (target.patterns === undefined) target.patterns = [];
 				target.patterns.push(pattern);
 			}
@@ -3810,7 +4059,8 @@ addHandler(
 		const annotations: Annotation[] = [];
 
 		for (let i = 0; i < count; i++) {
-			/*const length =*/ readUint32(reader);
+			const recordStart = reader.offset;
+			const length = readUint32(reader); // includes the length field itself
 			const type = readSignature(reader);
 			const open = !!readUint8(reader);
 			/*const flags =*/ readUint8(reader); // always 28
@@ -3827,10 +4077,12 @@ addHandler(
 			let data: string | Uint8Array;
 
 			if (type === 'txtA') {
+				const dataStart = reader.offset;
+
 				if (dataLength >= 2 && readUint16(reader) === 0xfeff) {
-					data = readUnicodeStringWithLength(reader, (dataLength - 2) / 2);
+					data = readUnicodeStringWithLength(reader, Math.floor((dataLength - 2) / 2));
 				} else {
-					reader.offset -= 2;
+					reader.offset = dataStart;
 					data = readAsciiString(reader, dataLength);
 				}
 
@@ -3844,6 +4096,8 @@ addHandler(
 			annotations.push({
 				type: type === 'txtA' ? 'text' : 'sound', open, iconLocation, popupLocation, color, author, name, date, data,
 			});
+
+			if (length >= (reader.offset - recordStart)) reader.offset = recordStart + length;
 		}
 
 		(target as Psd).annotations = annotations;
@@ -3907,6 +4161,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,
@@ -3931,8 +4190,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;
@@ -3998,16 +4257,19 @@ function createLnkHandler(tag: string) {
 			for (const file of psd.linkedFiles!) {
 				if ((tag === 'lnkE') !== !!file.linkedFile) continue;
 
+				const external = tag === 'lnkE';
 				let version = 2;
 				if (file.assetLockedState != null) version = 7;
 				else if (file.assetModTime != null) version = 6;
 				else if (file.childDocumentID != null) version = 5;
-				else if (tag === 'lnkE') version = 3;
+				// liFE version 2 is the only one with embedded data, it has no date and its file size is the size of the data,
+				// versions 5+ can't store the data, so it's not written in that case
+				else if (external && !file.data) version = 4;
 
-				writeLength64(writer, 0);
+				writeUint64(writer, 0);
 
 				const sizeOffset = writer.offset;
-				writeSignature(writer, (tag === 'lnkE') ? 'liFE' : (file.data ? 'liFD' : 'liFA'));
+				writeSignature(writer, external ? 'liFE' : (file.data ? 'liFD' : 'liFA'));
 				writeInt32(writer, version);
 				if (!file.id || typeof file.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(file.id)) {
 					throw new Error('Linked file ID must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)');
@@ -4016,7 +4278,7 @@ function createLnkHandler(tag: string) {
 				writeUnicodeStringWithPadding(writer, file.name || '');
 				writeSignature(writer, file.type ? `${file.type}    `.substring(0, 4) : '    ');
 				writeSignature(writer, file.creator ? `${file.creator}    `.substring(0, 4) : '\0\0\0\0');
-				writeLength64(writer, file.data ? file.data.byteLength : 0);
+				writeUint64(writer, (!external && file.data) ? file.data.byteLength : 0);
 
 				if (file.descriptor && file.descriptor.compInfo) {
 					const desc: FileOpenDescriptor = {
@@ -4032,7 +4294,7 @@ function createLnkHandler(tag: string) {
 					writeUint8(writer, 0);
 				}
 
-				if (tag === 'lnkE') {
+				if (external) {
 					const desc: LinkedFileDescriptor = {
 						descVersion: 2,
 						'Nm  ': file.linkedFile?.name ?? '',
@@ -4042,7 +4304,9 @@ function createLnkHandler(tag: string) {
 					};
 
 					writeVersionAndDescriptor(writer, '', 'ExternalFileLink', desc);
+				}
 
+				if (external && version > 3) {
 					const time = file.time ? new Date(file.time) : new Date();
 					writeInt32(writer, time.getUTCFullYear());
 					writeUint8(writer, time.getUTCMonth());
@@ -4052,15 +4316,18 @@ function createLnkHandler(tag: string) {
 					writeFloat64(writer, time.getUTCSeconds() + time.getUTCMilliseconds() / 1000);
 				}
 
-				if (file.data) {
-					writeBytes(writer, file.data);
+				if (external) {
+					writeUint64(writer, (version === 2 ? file.data?.byteLength : file.linkedFile?.fileSize) || 0); // file size
+				} else if (file.data) {
+					writeBytes(writer, file.data); // liFD
 				} else {
-					writeLength64(writer, file.linkedFile?.fileSize || 0);
+					writeZeros(writer, 8); // liFA
 				}
 
 				if (version >= 5) writeUnicodeStringWithPadding(writer, file.childDocumentID || '');
 				if (version >= 6) writeFloat64(writer, file.assetModTime || 0);
 				if (version >= 7) writeUint8(writer, file.assetLockedState || 0);
+				if (external && version === 2 && file.data) writeBytes(writer, file.data);
 
 				let size = writer.offset - sizeOffset;
 				writer.view.setUint32(sizeOffset - 4, size, false); // write size
@@ -4082,28 +4349,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);
@@ -4118,15 +4412,8 @@ 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`);
@@ -4183,6 +4470,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);
@@ -4197,62 +4490,49 @@ 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(); i++) {
-			levels.push(readLevelsChannel(reader));
+		for (let i = 0; i < 29 && left() >= 10; i++) {
+			channels.push(readLevelsChannel(reader));
 		}
 
-		const [rgb, red, green, blue] = levels;
-
-		target.adjustment = {
-			...target.adjustment as PresetInfo,
-			type: 'levels',
-			rgb,
-			red,
-			green,
-			blue,
-		};
-
-		if (left()) {
+		if (left() >= 8) {
 			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));
+			while (channels.length < totalChannelRecords && left() >= 10) {
+				channels.push(readLevelsChannel(reader));
 			}
 		}
 
+		// 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',
+			channels,
+		};
+
 		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);
 		}
 	},
 );
@@ -4286,17 +4566,20 @@ addHandler(
 		readUint8(reader);
 		if (readUint16(reader) !== 1) throw new Error('Invalid curv version');
 		readUint16(reader);
-		const channels = readUint16(reader);
-		const info: CurvesAdjustment = { type: 'curves' };
+		const channelsMask = readUint16(reader);
+		const channels: CurvesAdjustmentChannel[] = [];
 
-		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);
+		for (let i = 0; i < 16; i++) {
+			if (channelsMask & (1 << i)) {
+				while (channels.length < i) channels.push([]);
+				channels.push(readCurveChannel(reader));
+			}
+		}
 
 		target.adjustment = {
 			...target.adjustment as PresetInfo,
-			...info,
+			type: 'curves',
+			channels,
 		};
 
 		// ignoring, duplicate information
@@ -4319,35 +4602,33 @@ addHandler(
 		skipBytes(reader, left());
 	},
 	(writer, target) => {
-		const info = target.adjustment as CurvesAdjustment;
-		const { rgb, red, green, blue } = info;
-		let channels = 0;
-		let channelCount = 0;
-
-		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 channels = ((target.adjustment as CurvesAdjustment).channels || []).slice(0, 16);
+		const used: number[] = [];
+		let channelsMask = 0;
+
+		for (let i = 0; i < channels.length; i++) {
+			if (channels[i]?.length) {
+				channelsMask |= 1 << i;
+				used.push(i);
+			}
+		}
 
 		writeUint8(writer, 0);
 		writeUint16(writer, 1); // version
 		writeUint16(writer, 0);
-		writeUint16(writer, channels);
+		writeUint16(writer, channelsMask);
 
-		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) writeCurveChannel(writer, channels[i]);
 
 		writeSignature(writer, 'Crv ');
 		writeUint16(writer, 4); // version
 		writeUint16(writer, 0);
-		writeUint16(writer, channelCount);
+		writeUint16(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);
+			writeCurveChannel(writer, channels[i]);
+		}
 	},
 );
 
@@ -4432,10 +4713,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),
@@ -4450,7 +4747,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);
@@ -4564,11 +4869,17 @@ addHandler(
 		if (version === 2) {
 			color = readColor(reader);
 		} else { // version 3
-			// TODO: test this, this is probably wrong
+			// 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: readInt32(reader) / 100,
-				a: readInt32(reader) / 100,
-				b: readInt32(reader) / 100,
+				l: Math.max(0, 116 * f(y) - 16) / 100,
+				a: normalizeLabAB(500 * (f(x) - f(y))),
+				b: normalizeLabAB(200 * (f(y) - f(z))),
 			};
 		}
 
@@ -4585,7 +4896,7 @@ addHandler(
 		const info = target.adjustment as PhotoFilterAdjustment;
 		writeUint16(writer, 2); // version
 		writeColor(writer, info.color || { l: 0, a: 0, b: 0 });
-		writeUint32(writer, (info.density || 0) * 100);
+		writeUint32(writer, Math.round(Math.max(0, info.density || 0) * 100));
 		writeUint8(writer, info.preserveLuminosity ? 1 : 0);
 		writeZeros(writer, 3);
 	},
@@ -4784,7 +5095,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);
@@ -4844,8 +5155,9 @@ addHandler(
 
 		skipBytes(reader, left());
 
-		for (const s of info.colorStops) s.location /= interpolation;
-		for (const s of info.opacityStops) s.location /= interpolation;
+		// stop locations are always in 0..4096 range, independent of smoothness
+		for (const s of info.colorStops) s.location /= 4096;
+		for (const s of info.opacityStops) s.location /= 4096;
 
 		target.adjustment = info;
 	},
@@ -4856,16 +5168,16 @@ 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 || '');
 		writeUint16(writer, info.colorStops && info.colorStops.length || 0);
 
-		const interpolation = Math.round((info.smoothness ?? 1) * 4096);
+		const interpolation = Math.round(clamp(info.smoothness ?? 1, 0, 1) * 4096);
 
 		for (const s of info.colorStops || []) {
-			writeUint32(writer, Math.round(s.location * interpolation));
+			writeUint32(writer, Math.round(clamp(s.location, 0, 1) * 4096));
 			writeUint32(writer, Math.round(s.midpoint * 100));
 			writeColor(writer, s.color);
 			writeZeros(writer, 2);
@@ -4874,9 +5186,9 @@ addHandler(
 		writeUint16(writer, info.opacityStops && info.opacityStops.length || 0);
 
 		for (const s of info.opacityStops || []) {
-			writeUint32(writer, Math.round(s.location * interpolation));
+			writeUint32(writer, Math.round(clamp(s.location, 0, 1) * 4096));
 			writeUint32(writer, Math.round(s.midpoint * 100));
-			writeUint16(writer, Math.round(s.opacity * 0xff));
+			writeUint16(writer, Math.round(clamp(s.opacity, 0, 1) * 0xff));
 		}
 
 		writeUint16(writer, 2); // expansion count
@@ -5102,7 +5414,7 @@ addHandler(
 		target.engineData = fromByteArray(data);
 
 		const layersByIndex = getTextLayersSortedByIndex(psd);
-		const engineData = parseEngineData(data);
+		const engineData = parseEngineData(data, reader);
 		const engineData2 = decodeEngineData2(engineData);
 		const TextFrameSet = engineData2.ResourceDict.TextFrameSet;
 
@@ -5230,7 +5542,7 @@ addHandler(
 
 			writer.view.setUint32(length2Offset - 4, writer.offset - length2Offset, false);
 
-			const extra = target.filterEffectsMasks![target.filterEffectsMasks!.length - 1]?.extra;
+			const extra = mask.extra;
 			if (extra) {
 				writeUint8(writer, 1);
 				writeInt32(writer, extra.top);
@@ -5262,25 +5574,25 @@ addHandler(
 	(reader, target) => {
 		target.filterMask = {
 			colorSpace: readColor(reader),
-			opacity: readUint16(reader) / 0xff,
+			opacity: readUint16(reader) / 100,
 		};
 	},
 	(writer, target) => {
 		writeColor(writer, target.filterMask!.colorSpace);
-		writeUint16(writer, clamp(target.filterMask!.opacity ?? 1, 0, 1) * 0xff);
+		writeUint16(writer, Math.round(clamp(target.filterMask!.opacity ?? 1, 0, 1) * 100));
 	},
 );
 
 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(
@@ -5288,17 +5600,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());
 	},
@@ -5319,13 +5629,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`);
@@ -5333,8 +5647,7 @@ 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
+		// discard if read in 'lrFX' section ('lmfx' and 'lfx2' are never stored together)
 		target.effects = parseEffects(desc, !!reader.logMissingFeatures);
 
 		skipBytes(reader, left());
@@ -5408,26 +5721,17 @@ addHandler(
 	},
 );
 
-interface ExtensionDesc {
-	generatorSettings: {
-		generator_45_assets: { json: string; };
-		layerTime: number;
-	};
-}
-
-// extension settings ?, ignore it
+// generator settings of the document (layers store them in 'shmd' section)
 addHandler(
 	'extn',
-	target => (target as any)._extn !== undefined,
-	(reader, target) => {
-		const desc: ExtensionDesc = readVersionAndDescriptor(reader);
-		// console.log(require('util').inspect(desc, false, 99, true));
-
-		if (MOCK_HANDLERS) (target as any)._extn = desc;
+	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) => {
-		// TODO: need to add correct types for desc fields (resources/src.psd)
-		if (MOCK_HANDLERS) writeVersionAndDescriptor(writer, '', 'null', (target as any)._extn);
+		writeVersionAndDescriptor(writer, '', 'null', serializeGeneratorSettings(target.generatorSettings!));
 	},
 );
 
@@ -5439,7 +5743,7 @@ addHandler(
 		skipBytes(reader, 3);
 	},
 	(writer, target) => {
-		writeUint8(writer, target.fillOpacity! * 0xff);
+		writeUint8(writer, Math.round(clamp(target.fillOpacity!, 0, 1) * 0xff));
 		writeZeros(writer, 3);
 	},
 );
@@ -5450,7 +5754,7 @@ addHandler(
 	(reader, target, left) => {
 		target.channelBlendingRestrictions = [];
 
-		while (left() > 4) {
+		while (left() >= 4) {
 			target.channelBlendingRestrictions.push(readInt32(reader));
 		}
 	},