ag-psd 31.0.3 → 32.0.0

package/dist-es/descriptor.js

@@ -15,8 +15,12 @@ exports.IntC = exports.IntE = exports.Drct = exports.WndM = exports.CntE = expor
 exports.presetKindType = exports.prjM = exports.FlMd = void 0;
 exports.setLogErrors = setLogErrors;
 exports.readAsciiStringOrClassId = readAsciiStringOrClassId;
+exports.writeAsciiStringOrClassId = writeAsciiStringOrClassId;
 exports.readDescriptorStructure = readDescriptorStructure;
 exports.writeDescriptorStructure = writeDescriptorStructure;
+exports.createDescriptorReference = createDescriptorReference;
+exports.pathSelectionStateToReference = pathSelectionStateToReference;
+exports.writeClassStructure = writeClassStructure;
 exports.readVersionAndDescriptor = readVersionAndDescriptor;
 exports.writeVersionAndDescriptor = writeVersionAndDescriptor;
 exports.horzVrtcToXY = horzVrtcToXY;
@@ -155,6 +159,8 @@ const fieldToExtType = {
     origFXRefPoint: nullType,
     FXRefPoint: nullType,
     ClMg: makeType('', 'ClMg'),
+    interpretation: makeType('', 'footageInterpretation'),
+    bgColor: makeType('', 'NativeQuad'),
 };
 const fieldToArrayExtType = {
     'Crv ': makeType('', 'CrPt'),
@@ -188,6 +194,9 @@ const fieldToArrayExtType = {
     layerSettings: nullType,
     list: nullType,
     Adjs: makeType('', 'CrvA'),
+    vertices: makeType('', 'Pnt '),
+    warpedVertices: makeType('', 'Pnt '),
+    quads: makeType('', 'quadIndices'),
 };
 const typeToField = {
     'TEXT': [
@@ -213,6 +222,7 @@ const typeToField = {
         'meshExpansion', 'meshRigidity', 'VrsM', 'VrsN', 'NmbG', 'WLMn', 'WLMx', 'AmMn', 'AmMx', 'SclH', 'SclV',
         'Lvl ', 'TlNm', 'TlOf', 'FlRs', 'Thsh', 'ShrS', 'ShrE', 'FlRs', 'Vrnc', 'Strg', 'ExtS', 'ExtD',
         'HrzS', 'VrtS', 'NmbR', 'EdgF', 'Ang1', 'Ang2', 'Ang3', 'Ang4', 'lastAppliedComp', 'capturedInfo',
+        'pixelSourceType',
     ],
     'enum': [
         'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
@@ -223,6 +233,7 @@ const typeToField = {
         'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
         'vertAlign', 'bgColorType', 'shapeOperation', 'UndA', 'Wvtp', 'Drct', 'WndM', 'Edg ', 'FlCl', 'IntE',
         'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod',
+        'interpretAlpha',
     ],
     'bool': [
         'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -235,14 +246,15 @@ const typeToField = {
         'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
         'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
         'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
-        'moreAccurate', 'GpuY', 'LIWy', 'Cnty',
+        'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn',
     ],
     'doub': [
         'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
         'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
         'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
         'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
-        'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
+        'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3',
+        'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity',
     ],
     'UntF': [
         'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -258,14 +270,57 @@ const typeToField = {
         'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
         'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
         'channelDenoise', 'Mtrx', 'layerSettings', 'list', 'compList', 'Adjs',
+        'vertices', 'warpedVertices', 'quads', 'indices', 'Mpng',
     ],
     'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
     'obj ': ['null', 'Chnl'],
     'Pth ': ['DspF'],
+    'alis': ['alis'],
 };
 const channels = [
     'Rd  ', 'Grn ', 'Bl  ', 'Yllw', 'Ylw ', 'Cyn ', 'Mgnt', 'Blck', 'Gry ', 'Lmnc', 'A   ', 'B   ',
 ];
+// color classes whose channel values are written as doubles ('GRYC' and 'LABC' are kept for backwards compatibility)
+const doubleColorClasses = ['Grsc', 'LbCl', 'GRYC', 'LABC'];
+// Hidden (non-enumerable) markers used to remember how values were stored in the file, so they can be
+// written back the same way. They don't change the shape of the objects returned by the reader.
+const osTypeKey = typeof Symbol !== 'undefined' ? Symbol('agPsdOSType') : '__agPsdOSType';
+const obArInfoKey = typeof Symbol !== 'undefined' ? Symbol('agPsdObAr') : '__agPsdObAr';
+const referenceInfoKey = typeof Symbol !== 'undefined' ? Symbol('agPsdReference') : '__agPsdReference';
+function setHidden(target, key, value) {
+    Object.defineProperty(target, key, { value, enumerable: false, configurable: true, writable: true });
+    return target;
+}
+function getHidden(target, key) {
+    return (target && typeof target === 'object') ? target[key] : undefined;
+}
+const osTypeFamilies = {
+    UntF: 'UntF', UnFl: 'UntF',
+    Objc: 'Objc', GlbO: 'Objc',
+    type: 'type', GlbC: 'type',
+    comp: 'comp',
+};
+// returns the OS type the value was originally read with, if it's compatible with the type we'd write it as
+// fallback for unknown keys, based on the type of the value
+function guessOSType(value) {
+    if (typeof value === 'boolean')
+        return 'bool';
+    if (typeof value === 'number' && !Number.isInteger(value))
+        return 'doub';
+    if (Array.isArray(value))
+        return 'VlLs';
+    if (value && typeof value === 'object' && typeof value._classID === 'string')
+        return 'Objc';
+    return undefined;
+}
+function getRecordedOSType(value, type) {
+    const recorded = getHidden(value, osTypeKey);
+    if (!recorded)
+        return type;
+    if (!type || recorded === 'comp' || recorded === 'type' || recorded === 'GlbC')
+        return recorded;
+    return osTypeFamilies[recorded] === osTypeFamilies[type] ? recorded : type;
+}
 const fieldToArrayType = {
     'Mnm ': 'long',
     'Mxm ': 'long',
@@ -305,6 +360,8 @@ const fieldToArrayType = {
     Mtrx: 'long',
     compList: 'long',
     Chnl: 'enum',
+    indices: 'long',
+    Mpng: 'long',
 };
 const fieldToType = {};
 for (const type of Object.keys(typeToField)) {
@@ -319,6 +376,7 @@ for (const field of Object.keys(fieldToExtType)) {
 for (const field of Object.keys(fieldToArrayExtType)) {
     fieldToArrayType[field] = 'Objc';
 }
+const pixelSourceOriginRoot = 'PixelSource.origin';
 function getTypeByKey(key, value, root, parent) {
     if (key === 'presetKind') {
         return typeof value === 'string' ? 'enum' : 'long';
@@ -338,7 +396,7 @@ function getTypeByKey(key, value, root, parent) {
     else if (key === 'AntA') {
         return typeof value === 'string' ? 'enum' : 'bool';
     }
-    else if ((key === 'Hrzn' || key === 'Vrtc') && (parent.Type === 'keyType.Pstn' || parent._classID === 'Ofst')) {
+    else if ((key === 'Hrzn' || key === 'Vrtc') && (parent.Type === 'keyType.Pstn' || parent._classID === 'Ofst' || root === pixelSourceOriginRoot)) {
         return 'long';
     }
     else if (key === 'Hrzn' || key === 'Vrtc' || key === 'Top ' || key === 'Left' || key === 'Btom' || key === 'Rght') {
@@ -355,6 +413,15 @@ function getTypeByKey(key, value, root, parent) {
     else if (key === 'Trnf') {
         return Array.isArray(value) ? 'VlLs' : 'Objc';
     }
+    else if (key === 'alpha' && root === 'slices') {
+        return 'long';
+    }
+    else if ((key === 'Inpt' || key === 'Otpt') && parent._classID === 'HsbP') {
+        return 'enum';
+    }
+    else if (key === 'LghD' && parent._classID === 'oilPaint') {
+        return 'long';
+    }
     else {
         return fieldToType[key];
     }
@@ -398,23 +465,22 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
     // write class structure
     (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
     writeAsciiStringOrClassId(writer, classId);
-    const keys = Object.keys(value);
-    let keyCount = keys.length;
-    if ('_name' in value)
-        keyCount--;
-    if ('_classID' in value)
-        keyCount--;
-    (0, psdWriter_1.writeUint32)(writer, keyCount);
+    const allKeys = Object.keys(value);
+    const keys = allKeys.filter(key => key !== '_name' && key !== '_classID' && value[key] !== undefined);
+    (0, psdWriter_1.writeUint32)(writer, keys.length);
     for (const key of keys) {
-        if (key === '_name' || key === '_classID')
-            continue;
         let type = getTypeByKey(key, value[key], root, value);
+        let childRoot = root;
         let extType = fieldToExtType[key];
         if (key === 'bounds' && root === 'text') {
             extType = makeType('', 'bounds');
         }
         else if (key === 'origin') {
             type = root === 'slices' ? 'enum' : 'Objc';
+            if (classId === 'PixelSource') {
+                extType = nullType; // stored as 'null' class with integer Hrzn/Vrtc
+                childRoot = pixelSourceOriginRoot;
+            }
         }
         else if ((key === 'Cyn ' || key === 'Mgnt' || key === 'Ylw ' || key === 'Blck') && value._classID === 'CMYC') {
             type = 'doub';
@@ -482,10 +548,14 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
             extType = nullType;
         }
         else if (channels.indexOf(key) !== -1) {
-            type = (classId === 'RGBC' && root !== 'artd') ? 'doub' : 'long';
+            type = ((classId === 'RGBC' && root !== 'artd') || doubleColorClasses.indexOf(classId) !== -1) ? 'doub' : 'long';
         }
         else if (key === 'profile') {
-            type = classId === 'printOutput' ? 'TEXT' : 'tdta';
+            type = (classId === 'printOutput' || classId === 'proofSetup') ? 'TEXT' : 'tdta';
+        }
+        else if (key === 'alis' && typeof value[key] === 'string') {
+            // 'alis' is read as a binary string (one char per byte), strings with wider chars can only be stored as TEXT
+            type = /[^\x00-\xff]/.test(value[key]) ? 'TEXT' : 'alis';
         }
         else if (key === 'strokeStyleContent') {
             if (value[key]['Clr ']) {
@@ -509,9 +579,12 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
                 extType = { classID: 'HSBC', name: '' };
             // TODO: other color spaces
         }
+        type = getRecordedOSType(value[key], type);
+        if (!type)
+            type = guessOSType(value[key]);
         writeAsciiStringOrClassId(writer, key);
         (0, psdWriter_1.writeSignature)(writer, type || 'long');
-        writeOSType(writer, type || 'long', value[key], key, extType, root);
+        writeOSType(writer, type || 'long', value[key], key, extType, childRoot);
         if (logErrors && !type)
             console.log(`Missing descriptor field type for: '${key}' in`, value);
     }
@@ -521,8 +594,9 @@ function readOSType(reader, type, includeClass) {
         case 'obj ': // Reference
             return readReferenceStructure(reader);
         case 'Objc': // Descriptor
-        case 'GlbO': // GlobalObject same as Descriptor
             return readDescriptorStructure(reader, includeClass);
+        case 'GlbO': // GlobalObject same as Descriptor
+            return setHidden(readDescriptorStructure(reader, includeClass), osTypeKey, type);
         case 'VlLs': { // List
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
@@ -547,7 +621,7 @@ function readOSType(reader, type, includeClass) {
             const value = (0, psdReader_1.readFloat32)(reader);
             if (!unitsMap[units])
                 throw new Error(`Invalid units: ${units}`);
-            return { units: unitsMap[units], value };
+            return setHidden({ units: unitsMap[units], value }, osTypeKey, type);
         }
         case 'TEXT': // String
             return (0, psdReader_1.readUnicodeString)(reader);
@@ -561,13 +635,13 @@ function readOSType(reader, type, includeClass) {
         case 'comp': { // Large Integer
             const low = (0, psdReader_1.readUint32)(reader);
             const high = (0, psdReader_1.readUint32)(reader);
-            return { low, high };
+            return setHidden({ low, high }, osTypeKey, type);
         }
         case 'bool': // Boolean
             return !!(0, psdReader_1.readUint8)(reader);
         case 'type': // Class
         case 'GlbC': // Class
-            return readClassStructure(reader);
+            return setHidden(readClassStructure(reader), osTypeKey, type);
         case 'alis': { // Alias
             const length = (0, psdReader_1.readInt32)(reader);
             return (0, psdReader_1.readAsciiString)(reader, length);
@@ -579,21 +653,21 @@ function readOSType(reader, type, includeClass) {
         case 'ObAr': { // Object array
             (0, psdReader_1.readInt32)(reader); // version: 16
             (0, psdReader_1.readUnicodeString)(reader); // name: ''
-            readAsciiStringOrClassId(reader); // 'rationalPoint'
+            const classID = readAsciiStringOrClassId(reader); // 'rationalPoint'
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
             for (let i = 0; i < length; i++) {
                 const type1 = readAsciiStringOrClassId(reader); // type Hrzn | Vrtc
-                (0, psdReader_1.readSignature)(reader); // UnFl
-                (0, psdReader_1.readSignature)(reader); // units ? '#Pxl'
+                const valueType = (0, psdReader_1.readSignature)(reader); // UnFl
+                const units = (0, psdReader_1.readSignature)(reader); // units ? '#Pxl'
                 const valuesCount = (0, psdReader_1.readInt32)(reader);
                 const values = [];
                 for (let j = 0; j < valuesCount; j++) {
                     values.push((0, psdReader_1.readFloat64)(reader));
                 }
-                items.push({ type: type1, values });
+                items.push(setHidden({ type: type1, values }, obArInfoKey, { valueType, units }));
             }
-            return items;
+            return setHidden(items, obArInfoKey, { classID });
         }
         case 'Pth ': { // File path
             /*const length =*/ (0, psdReader_1.readInt32)(reader); // total size of all fields below
@@ -613,6 +687,7 @@ const ObArTypes = {
     quiltSliceY: 'UntF',
 };
 function writeOSType(writer, type, value, key, extType, root) {
+    var _a, _b, _c, _d, _e;
     switch (type) {
         case 'obj ': // Reference
             writeReferenceStructure(writer, key, value);
@@ -621,9 +696,9 @@ function writeOSType(writer, type, value, key, extType, root) {
         case 'GlbO': { // GlobalObject same as Descriptor
             if (typeof value !== 'object')
                 throw new Error(`Invalid struct value: ${JSON.stringify(value)}, key: ${key}`);
-            if (!extType)
+            if (!extType && !value._classID)
                 throw new Error(`Missing ext type for: '${key}' (${JSON.stringify(value)})`);
-            const name = value._name || extType.name;
+            const name = value._name || (extType === null || extType === void 0 ? void 0 : extType.name) || '';
             const classID = value._classID || extType.classID;
             writeDescriptorStructure(writer, name, classID, value, root);
             break;
@@ -633,7 +708,7 @@ function writeOSType(writer, type, value, key, extType, root) {
                 throw new Error(`Invalid list value: ${JSON.stringify(value)}, key: ${key}`);
             (0, psdWriter_1.writeInt32)(writer, value.length);
             for (let i = 0; i < value.length; i++) {
-                const type = fieldToArrayType[key];
+                const type = (_a = getRecordedOSType(value[i], fieldToArrayType[key])) !== null && _a !== void 0 ? _a : guessOSType(value[i]);
                 (0, psdWriter_1.writeSignature)(writer, type || 'long');
                 writeOSType(writer, type || 'long', value[i], `${key}[]`, fieldToArrayExtType[key], root);
                 if (logErrors && !type)
@@ -671,20 +746,35 @@ function writeOSType(writer, type, value, key, extType, root) {
         case 'long': // Integer
             if (typeof value !== 'number')
                 throw new Error(`Invalid integer value: ${JSON.stringify(value)}, key: ${key}`);
-            (0, psdWriter_1.writeInt32)(writer, value);
+            (0, psdWriter_1.writeInt32)(writer, Math.round(value)); // round instead of truncating fractional values
+            break;
+        case 'comp': // Large Integer
+            if (!value || typeof value !== 'object')
+                throw new Error(`Invalid large integer value: ${JSON.stringify(value)}, key: ${key}`);
+            (0, psdWriter_1.writeUint32)(writer, value.low >>> 0);
+            (0, psdWriter_1.writeUint32)(writer, value.high >>> 0);
             break;
-        // case 'comp': // Large Integer
-        // 	writeLargeInteger(reader);
         case 'bool': // Boolean
             if (typeof value !== 'boolean')
                 throw new Error(`Invalid boolean value: ${JSON.stringify(value)}, key: ${key}`);
             (0, psdWriter_1.writeUint8)(writer, value ? 1 : 0);
             break;
-        // case 'type': // Class
-        // case 'GlbC': // Class
-        // 	writeClassStructure(reader);
-        // case 'alis': // Alias
-        // 	writeAliasStructure(reader);
+        case 'type': // Class
+        case 'GlbC': // Class
+            if (!value || typeof value !== 'object')
+                throw new Error(`Invalid class value: ${JSON.stringify(value)}, key: ${key}`);
+            (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, value.name || '');
+            writeAsciiStringOrClassId(writer, value.classID);
+            break;
+        case 'alis': { // Alias (read as a binary string, one char per byte)
+            if (typeof value !== 'string')
+                throw new Error(`Invalid alias value: ${JSON.stringify(value)}, key: ${key}`);
+            (0, psdWriter_1.writeInt32)(writer, value.length);
+            for (let i = 0; i < value.length; i++) {
+                (0, psdWriter_1.writeUint8)(writer, value.charCodeAt(i) & 0xff);
+            }
+            break;
+        }
         case 'tdta': // Raw Data
             (0, psdWriter_1.writeInt32)(writer, value.byteLength);
             (0, psdWriter_1.writeBytes)(writer, value);
@@ -692,15 +782,16 @@ function writeOSType(writer, type, value, key, extType, root) {
         case 'ObAr': { // Object array
             (0, psdWriter_1.writeInt32)(writer, 16); // version
             (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, ''); // name
-            const type = ObArTypes[key];
+            const type = (_c = (_b = getHidden(value, obArInfoKey)) === null || _b === void 0 ? void 0 : _b.classID) !== null && _c !== void 0 ? _c : ObArTypes[key];
             if (!type)
                 throw new Error(`Not implemented ObArType for: ${key}`);
             writeAsciiStringOrClassId(writer, type);
             (0, psdWriter_1.writeInt32)(writer, value.length);
             for (let i = 0; i < value.length; i++) {
+                const info = getHidden(value[i], obArInfoKey);
                 writeAsciiStringOrClassId(writer, value[i].type); // Hrzn | Vrtc
-                (0, psdWriter_1.writeSignature)(writer, 'UnFl');
-                (0, psdWriter_1.writeSignature)(writer, '#Pxl');
+                (0, psdWriter_1.writeSignature)(writer, (_d = info === null || info === void 0 ? void 0 : info.valueType) !== null && _d !== void 0 ? _d : 'UnFl');
+                (0, psdWriter_1.writeSignature)(writer, (_e = info === null || info === void 0 ? void 0 : info.units) !== null && _e !== void 0 ? _e : '#Pxl');
                 (0, psdWriter_1.writeInt32)(writer, value[i].values.length);
                 for (let j = 0; j < value[i].values.length; j++) {
                     (0, psdWriter_1.writeFloat64)(writer, value[i].values[j]);
@@ -721,85 +812,144 @@ function writeOSType(writer, type, value, key, extType, root) {
             throw new Error(`Not implemented descriptor OSType: ${type}`);
     }
 }
+function referenceItemToValue(item) {
+    switch (item.type) {
+        case 'prop': return item.keyID;
+        case 'Clss': return { name: item.name || '', classID: item.classID };
+        case 'Enmr': return `${item.typeID}.${item.enumValue}`;
+        default: return item.value;
+    }
+}
+function referenceItemMatches(item, value) {
+    if (!item)
+        return false;
+    const expected = referenceItemToValue(item);
+    if (expected && typeof expected === 'object') {
+        return !!value && typeof value === 'object' && value.name === expected.name && value.classID === expected.classID;
+    }
+    return expected === value;
+}
+// Attaches information about how each item of reference should be written (class IDs, reference types),
+// the public value of the array stays the same (array of strings/numbers/class objects)
+function createDescriptorReference(items) {
+    return setHidden(items.map(referenceItemToValue), referenceInfoKey, items);
+}
 function readReferenceStructure(reader) {
     const itemsCount = (0, psdReader_1.readInt32)(reader);
-    const items = [];
+    const infos = [];
     for (let i = 0; i < itemsCount; i++) {
         const type = (0, psdReader_1.readSignature)(reader);
         switch (type) {
             case 'prop': { // Property
-                readClassStructure(reader);
+                const { name, classID } = readClassStructure(reader);
                 const keyID = readAsciiStringOrClassId(reader);
-                items.push(keyID);
+                infos.push({ type, name, classID, keyID });
                 break;
             }
-            case 'Clss': // Class
-                items.push(readClassStructure(reader));
+            case 'Clss': { // Class
+                const { name, classID } = readClassStructure(reader);
+                infos.push({ type, name, classID });
                 break;
+            }
             case 'Enmr': { // Enumerated Reference
-                readClassStructure(reader);
+                const { name, classID } = readClassStructure(reader);
                 const typeID = readAsciiStringOrClassId(reader);
-                const value = readAsciiStringOrClassId(reader);
-                items.push(`${typeID}.${value}`);
+                const enumValue = readAsciiStringOrClassId(reader);
+                infos.push({ type, name, classID, typeID, enumValue });
                 break;
             }
             case 'rele': { // Offset
-                // const { name, classID } =
-                readClassStructure(reader);
-                items.push((0, psdReader_1.readUint32)(reader));
+                const { name, classID } = readClassStructure(reader);
+                infos.push({ type, name, classID, value: (0, psdReader_1.readUint32)(reader) });
                 break;
             }
             case 'Idnt': // Identifier
-                items.push((0, psdReader_1.readInt32)(reader));
-                break;
             case 'indx': // Index
-                items.push((0, psdReader_1.readInt32)(reader));
+                infos.push({ type, value: (0, psdReader_1.readInt32)(reader) });
                 break;
             case 'name': { // Name
-                readClassStructure(reader);
-                items.push((0, psdReader_1.readUnicodeString)(reader));
+                const { name, classID } = readClassStructure(reader);
+                infos.push({ type, name, classID, value: (0, psdReader_1.readUnicodeString)(reader) });
                 break;
             }
             default:
                 throw new Error(`Invalid descriptor reference type: ${type}`);
         }
     }
-    return items;
+    return createDescriptorReference(infos);
+}
+function guessReferenceItem(value) {
+    if (typeof value === 'string') {
+        // enumerated references are read as `${typeID}.${enumValue}` where typeID is a 4 character ID or a string ID
+        // (values like 'My.Path' or 'Logo.v2' can't be typeID/enum value, so they are written as name references)
+        const match = /^([a-z ]{4}|[a-z]{5,})\.([a-z ]+)$/i.exec(value);
+        if (match) {
+            return { type: 'Enmr', name: '', classID: match[1], typeID: match[1], enumValue: match[2] };
+        }
+        else {
+            return { type: 'name', name: '', classID: 'Lyr ', value };
+        }
+    }
+    else if (typeof value === 'number') {
+        return { type: 'Idnt', value };
+    }
+    else if (value && typeof value === 'object' && typeof value.classID === 'string') {
+        return { type: 'Clss', name: value.name || '', classID: value.classID };
+    }
+    else {
+        throw new Error(`Invalid descriptor reference value: ${JSON.stringify(value)}`);
+    }
+}
+// path selection state (image resource 1088) is a reference to paths, enumerated references there use 'Path' class
+// (name references use 'Lyr ' class, they reference layer of the vector mask)
+function pathSelectionStateToReference(items) {
+    const infos = getHidden(items, referenceInfoKey);
+    return createDescriptorReference(items.map((value, i) => {
+        if (referenceItemMatches(infos === null || infos === void 0 ? void 0 : infos[i], value))
+            return infos[i]; // keep information read from the file
+        const item = guessReferenceItem(value);
+        if (item.type === 'Enmr')
+            item.classID = 'Path';
+        return item;
+    }));
 }
 function writeReferenceStructure(writer, _key, items) {
+    if (!Array.isArray(items))
+        throw new Error(`Invalid reference value: ${JSON.stringify(items)}, key: ${_key}`);
+    const infos = getHidden(items, referenceInfoKey);
     (0, psdWriter_1.writeInt32)(writer, items.length);
     for (let i = 0; i < items.length; i++) {
         const value = items[i];
-        let type = 'unknown';
-        if (typeof value === 'string') {
-            if (/^[a-z ]+\.[a-z ]+$/i.test(value)) {
-                type = 'Enmr';
-            }
-            else {
-                type = 'name';
-            }
-        }
-        (0, psdWriter_1.writeSignature)(writer, type);
-        switch (type) {
-            // case 'prop': // Property
-            // case 'Clss': // Class
-            case 'Enmr': { // Enumerated Reference
-                const [typeID, enumValue] = value.split('.');
-                writeClassStructure(writer, '\0', typeID);
-                writeAsciiStringOrClassId(writer, typeID);
-                writeAsciiStringOrClassId(writer, enumValue);
+        const recorded = infos === null || infos === void 0 ? void 0 : infos[i];
+        const item = referenceItemMatches(recorded, value) ? recorded : guessReferenceItem(value);
+        (0, psdWriter_1.writeSignature)(writer, item.type);
+        switch (item.type) {
+            case 'prop': // Property
+                writeClassStructure(writer, item.name || '', item.classID);
+                writeAsciiStringOrClassId(writer, item.keyID);
                 break;
-            }
-            // case 'rele': // Offset
-            // case 'Idnt': // Identifier
-            // case 'indx': // Index
-            case 'name': { // Name
-                writeClassStructure(writer, '\0', 'Lyr ');
-                (0, psdWriter_1.writeUnicodeString)(writer, value + '\0');
+            case 'Clss': // Class
+                writeClassStructure(writer, item.name || '', item.classID);
+                break;
+            case 'Enmr': // Enumerated Reference
+                writeClassStructure(writer, item.name || '', item.classID);
+                writeAsciiStringOrClassId(writer, item.typeID);
+                writeAsciiStringOrClassId(writer, item.enumValue);
+                break;
+            case 'rele': // Offset
+                writeClassStructure(writer, item.name || '', item.classID);
+                (0, psdWriter_1.writeUint32)(writer, item.value);
+                break;
+            case 'Idnt': // Identifier
+            case 'indx': // Index
+                (0, psdWriter_1.writeInt32)(writer, item.value);
+                break;
+            case 'name': // Name
+                writeClassStructure(writer, item.name || '', item.classID);
+                (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, `${item.value}`);
                 break;
-            }
             default:
-                throw new Error(`Invalid descriptor reference type: ${type}`);
+                throw new Error(`Invalid descriptor reference type: ${item.type}`);
         }
     }
     return items;
@@ -810,7 +960,7 @@ function readClassStructure(reader) {
     return { name, classID };
 }
 function writeClassStructure(writer, name, classID) {
-    (0, psdWriter_1.writeUnicodeString)(writer, name);
+    (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
     writeAsciiStringOrClassId(writer, classID);
 }
 function readVersionAndDescriptor(reader, includeClass = false) {
@@ -942,9 +1092,11 @@ function serializeEffects(e, log, multi) {
         info.numModifyingFX = 0;
         for (const key of Object.keys(e)) {
             const value = e[key];
+            if (value == null || typeof value !== 'object')
+                continue;
             if (Array.isArray(value)) {
                 for (const effect of value) {
-                    if (effect.enabled)
+                    if (effect === null || effect === void 0 ? void 0 : effect.enabled)
                         info.numModifyingFX++;
                 }
             }
@@ -1093,7 +1245,7 @@ function serializeTrackList(tracks) {
         const t = tracks[i];
         trackList.push(Object.assign(Object.assign({ trackID: exports.stdTrackID.encode(t.type), Vrsn: 1, enab: !!t.enabled, Effc: !!t.effectParams }, (t.effectParams ? {
             effectParams: {
-                keyList: serializeKeyList(t.keys),
+                keyList: serializeKeyList(t.effectParams.keys),
                 fillCanvas: t.effectParams.fillCanvas,
                 zoomOrigin: t.effectParams.zoomOrigin,
             }
@@ -1336,7 +1488,7 @@ function serializeEffectObject(obj, objName, reportErrors) {
                 result.sdwO = unitsPercent(val);
                 break;
             case 'angle':
-                if (objName === 'gradientOverlay' || objName === 'patternFill') {
+                if (objName === 'gradientOverlay' || objName === 'patternOverlay') {
                     result.Angl = unitsAngle(val);
                 }
                 else {
@@ -1408,7 +1560,8 @@ function serializeEffectObject(obj, objName, reportErrors) {
 }
 function parseGradient(grad) {
     if (grad.GrdF === 'GrdF.CstS') {
-        const samples = grad.Intr || 4096;
+        // stop locations are always in 0..4096 range, independent of smoothness (Intr)
+        const samples = 4096;
         return {
             type: 'solid',
             name: grad['Nm  '],
@@ -1442,11 +1595,12 @@ function parseGradient(grad) {
 function serializeGradient(grad) {
     var _a, _b;
     if (grad.type === 'solid') {
-        const samples = Math.round(((_a = grad.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096);
+        // stop locations are always in 0..4096 range, independent of smoothness (Intr)
+        const samples = 4096;
         return {
             'Nm  ': grad.name || '',
             GrdF: 'GrdF.CstS',
-            Intr: samples,
+            Intr: Math.round(((_a = grad.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096),
             Clrs: grad.colorStops.map(s => {
                 var _a;
                 return ({
@@ -1475,8 +1629,8 @@ function serializeGradient(grad) {
             ClrS: exports.ClrS.encode(grad.colorModel),
             RndS: grad.randomSeed || 0,
             Smth: Math.round(((_b = grad.roughness) !== null && _b !== void 0 ? _b : 1) * 4096),
-            'Mnm ': (grad.min || [0, 0, 0, 0]).map(x => x * 100),
-            'Mxm ': (grad.max || [1, 1, 1, 1]).map(x => x * 100),
+            'Mnm ': (grad.min || [0, 0, 0, 0]).map(x => Math.round(x * 100)),
+            'Mxm ': (grad.max || [1, 1, 1, 1]).map(x => Math.round(x * 100)),
         };
     }
 }
@@ -1576,21 +1730,65 @@ function serializeVectorContent(content) {
         return { key: 'GdFl', descriptor: serializeGradientContent(content) };
     }
 }
+// Descriptor color values: HSB saturation/brightness 0..100, CMYK 0..100, Gray 0..100, Lab L 0..100, a/b -128..127
+// Color values (see psd.ts): HSB 0..1, CMYK 0..255, Gray 0..255, Lab L 0..1, a/b -1..1 (same as readColor/writeColor)
+const colorSourceKey = typeof Symbol !== 'undefined' ? Symbol('agPsdColorSource') : '__agPsdColorSource';
+const colorConversions = {
+    // key: [descriptor -> color, color -> descriptor]
+    Strt: [x => x / 100, x => x * 100],
+    Brgh: [x => x / 100, x => x * 100],
+    'Cyn ': [x => x * 255 / 100, x => x * 100 / 255],
+    Mgnt: [x => x * 255 / 100, x => x * 100 / 255],
+    'Ylw ': [x => x * 255 / 100, x => x * 100 / 255],
+    Blck: [x => x * 255 / 100, x => x * 100 / 255],
+    'Gry ': [x => x * 255 / 100, x => x * 100 / 255],
+    Lmnc: [x => x / 100, x => x * 100],
+    'A   ': [helpers_1.normalizeLabAB, helpers_1.denormalizeLabAB],
+    'B   ': [helpers_1.normalizeLabAB, helpers_1.denormalizeLabAB],
+};
+function colorToDescriptorValue(key, value) {
+    const conversion = colorConversions[key];
+    if (!conversion)
+        return value;
+    const [from, to] = conversion;
+    const result = to(value);
+    if (!isFinite(result))
+        return result;
+    // prefer shortest number that converts back to the same value (avoids values like 30.200000000000003)
+    for (let precision = 1; precision < 17; precision++) {
+        const candidate = +result.toPrecision(precision);
+        if (from(candidate) === value)
+            return candidate;
+    }
+    return result;
+}
+function shallowEqual(a, b) {
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length)
+        return false;
+    return keys.every(key => a[key] === b[key]);
+}
 function parseColor(color) {
+    let result;
     if ('H   ' in color) {
-        return { h: parsePercentOrAngle(color['H   ']), s: color.Strt, b: color.Brgh };
+        result = { h: parsePercentOrAngle(color['H   ']), s: color.Strt / 100, b: color.Brgh / 100 };
     }
     else if ('Rd  ' in color) {
         return { r: color['Rd  '], g: color['Grn '], b: color['Bl  '] };
     }
     else if ('Cyn ' in color) {
-        return { c: color['Cyn '], m: color.Mgnt, y: color['Ylw '], k: color.Blck };
+        result = {
+            c: color['Cyn '] * 255 / 100,
+            m: color.Mgnt * 255 / 100,
+            y: color['Ylw '] * 255 / 100,
+            k: color.Blck * 255 / 100,
+        };
     }
     else if ('Gry ' in color) {
-        return { k: color['Gry '] };
+        result = { k: color['Gry '] * 255 / 100 };
     }
     else if ('Lmnc' in color) {
-        return { l: color.Lmnc, a: color['A   '], b: color['B   '] };
+        result = { l: color.Lmnc / 100, a: (0, helpers_1.normalizeLabAB)(color['A   ']), b: (0, helpers_1.normalizeLabAB)(color['B   ']) };
     }
     else if ('redFloat' in color) {
         return { fr: color.redFloat, fg: color.greenFloat, fb: color.blueFloat };
@@ -1598,8 +1796,10 @@ function parseColor(color) {
     else {
         throw new Error('Unsupported color descriptor');
     }
+    // remember original descriptor values, so unmodified colors can be written back without conversion errors
+    return setHidden(result, colorSourceKey, { color: Object.assign({}, result), descriptor: color });
 }
-function serializeColor(color) {
+function serializeColorValues(color) {
     if (!color) {
         return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
     }
@@ -1610,21 +1810,50 @@ function serializeColor(color) {
         return { _name: '', _classID: 'RGBC', redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
     }
     else if ('h' in color) {
-        return { _name: '', _classID: 'HSBC', 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
+        return {
+            _name: '', _classID: 'HSBC',
+            'H   ': unitsAngle((color.h || 0) * 360),
+            Strt: colorToDescriptorValue('Strt', color.s || 0),
+            Brgh: colorToDescriptorValue('Brgh', color.b || 0),
+        };
     }
     else if ('c' in color) {
-        return { _name: '', _classID: 'CMYC', 'Cyn ': color.c || 0, Mgnt: color.m || 0, 'Ylw ': color.y || 0, Blck: color.k || 0 };
+        return {
+            _name: '', _classID: 'CMYC',
+            'Cyn ': colorToDescriptorValue('Cyn ', color.c || 0),
+            Mgnt: colorToDescriptorValue('Mgnt', color.m || 0),
+            'Ylw ': colorToDescriptorValue('Ylw ', color.y || 0),
+            Blck: colorToDescriptorValue('Blck', color.k || 0),
+        };
     }
     else if ('l' in color) {
-        return { _name: '', _classID: 'LABC', Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
+        return {
+            _name: '', _classID: 'LbCl',
+            Lmnc: colorToDescriptorValue('Lmnc', color.l || 0),
+            'A   ': colorToDescriptorValue('A   ', color.a || 0),
+            'B   ': colorToDescriptorValue('B   ', color.b || 0),
+        };
     }
     else if ('k' in color) {
-        return { _name: '', _classID: 'GRYC', 'Gry ': color.k };
+        return { _name: '', _classID: 'Grsc', 'Gry ': colorToDescriptorValue('Gry ', color.k || 0) };
     }
     else {
         throw new Error('Invalid color value');
     }
 }
+function serializeColor(color) {
+    const result = serializeColorValues(color);
+    const source = getHidden(color, colorSourceKey);
+    if (source && shallowEqual(source.color, color)) {
+        // color was not modified since it was read, use exact original values
+        for (const key of Object.keys(result)) {
+            if (colorConversions[key] && typeof source.descriptor[key] === 'number') {
+                result[key] = source.descriptor[key];
+            }
+        }
+    }
+    return result;
+}
 function parseAngle(x) {
     if (x === undefined)
         return 0;