ag-psd 32.0.0 → 34.0.0

package/dist/descriptor.js

@@ -11,14 +11,12 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntC = exports.IntE = exports.Drct = exports.WndM = exports.CntE = exports.FlCl = exports.ExtR = exports.ExtT = exports.DfsM = exports.blurType = exports.Lns = exports.MztT = exports.Chnl = exports.Dstr = exports.ZZTy = exports.Wvtp = exports.SphM = exports.RplS = exports.Cnvr = exports.UndA = exports.DspM = exports.SmBQ = exports.SmBM = exports.BlrQ = exports.BlrM = exports.strokeStyleLineAlignment = exports.strokeStyleLineJoinType = exports.strokeStyleLineCapType = exports.ESliceBGColorType = exports.ESliceOrigin = exports.ESliceVertAlign = exports.ESliceHorzAlign = exports.ESliceType = exports.FrFl = exports.FStl = exports.ClrS = exports.gradientInterpolationMethodType = exports.stdTrackID = exports.animInterpStyleEnum = exports.GrdT = exports.IGSr = exports.BETE = exports.BESs = exports.bvlT = exports.BESl = exports.BlnM = exports.warpStyle = exports.Annt = exports.Ornt = exports.textGridding = void 0;
-exports.presetKindType = exports.prjM = exports.FlMd = void 0;
-exports.setLogErrors = setLogErrors;
+exports.CntE = exports.FlCl = exports.ExtR = exports.ExtT = exports.DfsM = exports.blurType = exports.Lns = exports.MztT = exports.Chnl = exports.Dstr = exports.ZZTy = exports.Wvtp = exports.SphM = exports.RplS = exports.Cnvr = exports.UndA = exports.DspM = exports.SmBQ = exports.SmBM = exports.BlrQ = exports.BlrM = exports.strokeStyleLineAlignment = exports.strokeStyleLineJoinType = exports.strokeStyleLineCapType = exports.ESliceBGColorType = exports.ESliceOrigin = exports.ESliceVertAlign = exports.ESliceHorzAlign = exports.ESliceType = exports.FrFl = exports.FStl = exports.ClrS = exports.Clry = exports.gradientInterpolationMethodType = exports.stdTrackID = exports.animInterpStyleEnum = exports.GrdT = exports.IGSr = exports.BETE = exports.BESs = exports.bvlT = exports.BESl = exports.BlnM = exports.warpStyle = exports.Annt = exports.Ornt = exports.textGridding = exports.outputSettingsRoot = exports.cameraRawFilterKeyTypes = exports.cameraRawFilterClassID = void 0;
+exports.patternColorHandling = exports.presetKindType = exports.prjM = exports.FlMd = exports.IntC = exports.IntE = exports.Drct = exports.WndM = void 0;
 exports.readAsciiStringOrClassId = readAsciiStringOrClassId;
 exports.writeAsciiStringOrClassId = writeAsciiStringOrClassId;
 exports.readDescriptorStructure = readDescriptorStructure;
 exports.writeDescriptorStructure = writeDescriptorStructure;
-exports.createDescriptorReference = createDescriptorReference;
 exports.pathSelectionStateToReference = pathSelectionStateToReference;
 exports.writeClassStructure = writeClassStructure;
 exports.readVersionAndDescriptor = readVersionAndDescriptor;
@@ -68,10 +66,6 @@ const unitsMap = {
     'RrCm': 'Centimeters',
 };
 const unitsMapRev = revMap(unitsMap);
-let logErrors = false;
-function setLogErrors(value) {
-    logErrors = value;
-}
 function makeType(name, classID) {
     return { name, classID };
 }
@@ -117,6 +111,7 @@ const fieldToExtType = {
     psVersion: nullType,
     docDefaultNewArtboardBackgroundColor: makeType('', 'RGBC'),
     artboardRect: makeType('', 'classFloatRect'),
+    framedGroupRect: makeType('', 'classFloatRect'),
     keyOriginRRectRadii: makeType('', 'radii'),
     keyOriginBoxCorners: nullType,
     rectangleCornerA: makeType('', 'Pnt '),
@@ -167,6 +162,7 @@ const fieldToArrayExtType = {
     Clrs: makeType('', 'Clrt'),
     Trns: makeType('', 'TrnS'),
     keyDescriptorList: nullType,
+    keyRootDescriptorList: nullType,
     solidFillMulti: makeType('', 'SoFi'),
     gradientFillMulti: makeType('', 'GrFl'),
     dropShadowMulti: makeType('', 'DrSh'),
@@ -200,17 +196,23 @@ const fieldToArrayExtType = {
 };
 const typeToField = {
     'TEXT': [
-        'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
+        'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName', 'exportOption', 'scaleSettings',
+        'BackgroundImagePath', 'ImageSubfolderName', 'SavedIteratedName',
         'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
         'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
-        'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath',
+        'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath', 'Bk  ', 'pathUnicodeName',
     ],
     'tdta': [
         'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
-        'LqMe',
+        'LqMe', 'bookKey',
     ],
     'long': [
-        'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
+        'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ', 'bookID',
+        'cropRectBottom', 'cropRectLeft', 'cropRectRight', 'cropRectTop',
+        // save for web output settings
+        'Version', 'BackgroundColorBlue', 'BackgroundColorGreen', 'BackgroundColorRed', 'BackgroundColorState', 'AttributeCase', 'Encoding',
+        'DuplicateFileNameBehavior', 'ImageMapLocation', 'ImageMapType', 'Indent', 'LineEndings', 'SpacersEmptyCells',
+        'SpacersHorizontal', 'SpacersVertical', 'StylesFormat', 'TDWidthHeight', 'TagCase', 'ColorPolicy', 'MetadataPolicy',
         'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'comp', 'compID', 'originalCompID',
         'curvesPresetKind', 'mixerPresetKind', 'uOrder', 'vOrder', 'PgNm', 'totalPages', 'Crop',
         'numerator', 'denominator', 'frameCount', 'Annt', 'keyOriginType', 'unitValueQuadVersion',
@@ -222,7 +224,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',
+        'pixelSourceType', 'framedGroupType',
     ],
     'enum': [
         'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
@@ -232,7 +234,7 @@ const typeToField = {
         'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
         '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',
+        'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion', 'gradientsInterpolationMethod', 'pathSymmetryMode',
         'interpretAlpha',
     ],
     'bool': [
@@ -246,15 +248,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', 'Lnkd', 'showAlteredVideo', 'lightingOn',
+        'moreAccurate', 'GpuY', 'LIWy', 'Cnty', 'Lnkd', 'showAlteredVideo', 'lightingOn', 'LockPPI',
     ],
     'doub': [
-        'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
+        'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght', 'Gmm ',
         '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',
-        'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity',
+        'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity', 'PreferredResolution',
     ],
     'UntF': [
         'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -263,7 +265,7 @@ const typeToField = {
         'topRight', 'topLeft', 'bottomLeft', 'bottomRight', 'ClNs', 'Shrp',
     ],
     'VlLs': [
-        'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
+        'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'keyRootDescriptorList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
         'LaSt', 'Trnf', 'nonAffineTransform', 'keyDescriptorList', 'guideIndeces', 'gradientFillMulti',
         'solidFillMulti', 'frameFXMulti', 'innerShadowMulti', 'dropShadowMulti', 'FrIn', 'FSts', 'FsFr',
         'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
@@ -282,26 +284,13 @@ const channels = [
 ];
 // 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
+exports.cameraRawFilterClassID = 'Adobe Camera Raw Filter';
+// types of Camera Raw Filter settings (keys clash with other descriptors so they're typed by class)
+exports.cameraRawFilterKeyTypes = {
+    CrVe: 'TEXT', PrVN: 'long', PrVe: 'long', WBal: 'enum', Ex12: 'doub', ShpR: 'doub',
+    'Crv ': 'VlLs', CrvR: 'VlLs', CrvG: 'VlLs', CrvB: 'VlLs',
+};
 function guessOSType(value) {
     if (typeof value === 'boolean')
         return 'bool';
@@ -309,26 +298,33 @@ function guessOSType(value) {
         return 'doub';
     if (Array.isArray(value))
         return 'VlLs';
-    if (value && typeof value === 'object' && typeof value._classID === 'string')
-        return 'Objc';
+    if (value && typeof value === 'object') {
+        if (typeof value._classID === 'string')
+            return 'Objc';
+        if (typeof value.classID === 'string')
+            return 'type'; // class read from 'type' or 'GlbC'
+        if (typeof value.low === 'number' && typeof value.high === 'number')
+            return 'comp';
+        if (typeof value.units === 'string' && typeof value.value === 'number')
+            return 'UntF';
+    }
     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',
+    HtmlFileNameComponents: 'long', // save for web output settings
+    SavingFileNameComponents: 'long',
+    SliceFileNameComponents: 'long',
+    Inpt: 'long', // levels filter
+    Otpt: 'long', // levels filter
     FrLs: 'long',
     strokeStyleLineDashSet: 'UntF',
     Trnf: 'doub',
     nonAffineTransform: 'doub',
     keyDescriptorList: 'Objc',
+    keyRootDescriptorList: 'Objc',
+    pathList: 'Objc',
     gradientFillMulti: 'Objc',
     solidFillMulti: 'Objc',
     frameFXMulti: 'Objc',
@@ -419,6 +415,15 @@ function getTypeByKey(key, value, root, parent) {
     else if ((key === 'Inpt' || key === 'Otpt') && parent._classID === 'HsbP') {
         return 'enum';
     }
+    else if ((key === 'Inpt' || key === 'Otpt') && parent._classID === 'LvlA') {
+        return 'VlLs';
+    }
+    else if (key === 'Intr' && typeof value === 'boolean') {
+        return 'bool'; // interpolation in print style
+    }
+    else if (key === 'PgPs') {
+        return 'enum';
+    }
     else if (key === 'LghD' && parent._classID === 'oilPaint') {
         return 'long';
     }
@@ -431,7 +436,7 @@ function readAsciiStringOrClassId(reader) {
     return (0, psdReader_1.readAsciiString)(reader, length || 4);
 }
 function writeAsciiStringOrClassId(writer, value) {
-    if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list') {
+    if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list' && value !== 'json') {
         // write classId
         (0, psdWriter_1.writeInt32)(writer, 0);
         (0, psdWriter_1.writeSignature)(writer, value);
@@ -459,12 +464,21 @@ function readDescriptorStructure(reader, includeClass) {
     }
     return object;
 }
+exports.outputSettingsRoot = 'outputSettings';
 function writeDescriptorStructure(writer, name, classId, value, root) {
-    if (logErrors && !classId)
-        console.log('Missing classId for: ', name, classId, value);
+    var _a;
+    if (writer.logMissingFeatures && !classId)
+        writer.log('Missing classId for: ', name, classId, value);
     // write class structure
     (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, name);
-    writeAsciiStringOrClassId(writer, classId);
+    if (root === exports.outputSettingsRoot && classId === 'null') {
+        // Photoshop writes 'null' class id as 4 character string in save for web output settings
+        (0, psdWriter_1.writeInt32)(writer, 4);
+        (0, psdWriter_1.writeSignature)(writer, classId);
+    }
+    else {
+        writeAsciiStringOrClassId(writer, classId);
+    }
     const allKeys = Object.keys(value);
     const keys = allKeys.filter(key => key !== '_name' && key !== '_classID' && value[key] !== undefined);
     (0, psdWriter_1.writeUint32)(writer, keys.length);
@@ -472,6 +486,10 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
         let type = getTypeByKey(key, value[key], root, value);
         let childRoot = root;
         let extType = fieldToExtType[key];
+        if (classId === exports.cameraRawFilterClassID) {
+            type = (_a = exports.cameraRawFilterKeyTypes[key]) !== null && _a !== void 0 ? _a : 'long'; // other settings are integer levels
+            childRoot = exports.cameraRawFilterClassID; // lists (curves) contain integer levels
+        }
         if (key === 'bounds' && root === 'text') {
             extType = makeType('', 'bounds');
         }
@@ -568,25 +586,30 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
                 extType = makeType('', 'patternLayer');
             }
             else {
-                logErrors && console.log('Invalid strokeStyleContent value', value[key]);
+                writer.logMissingFeatures && writer.log('Invalid strokeStyleContent value', value[key]);
             }
         }
         else if (key === 'bounds' && root === 'quiltWarp') {
             extType = makeType('', 'classFloatRect');
         }
+        // guess color class from its fields (colors created by serializeColor always have _classID set)
         if (extType && extType.classID === 'RGBC') {
             if ('H   ' in value[key])
                 extType = { classID: 'HSBC', name: '' };
-            // TODO: other color spaces
+            else if ('Cyn ' in value[key])
+                extType = { classID: 'CMYC', name: '' };
+            else if ('Lmnc' in value[key])
+                extType = { classID: 'LbCl', name: '' };
+            else if ('Gry ' in value[key])
+                extType = { classID: 'Grsc', name: '' };
         }
-        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, childRoot);
-        if (logErrors && !type)
-            console.log(`Missing descriptor field type for: '${key}' in`, value);
+        if (writer.logMissingFeatures && !type)
+            writer.log(`Missing descriptor field type for: '${key}' in`, value);
     }
 }
 function readOSType(reader, type, includeClass) {
@@ -594,9 +617,8 @@ function readOSType(reader, type, includeClass) {
         case 'obj ': // Reference
             return readReferenceStructure(reader);
         case 'Objc': // Descriptor
-            return readDescriptorStructure(reader, includeClass);
         case 'GlbO': // GlobalObject same as Descriptor
-            return setHidden(readDescriptorStructure(reader, includeClass), osTypeKey, type);
+            return readDescriptorStructure(reader, includeClass);
         case 'VlLs': { // List
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
@@ -621,7 +643,7 @@ function readOSType(reader, type, includeClass) {
             const value = (0, psdReader_1.readFloat32)(reader);
             if (!unitsMap[units])
                 throw new Error(`Invalid units: ${units}`);
-            return setHidden({ units: unitsMap[units], value }, osTypeKey, type);
+            return { units: unitsMap[units], value };
         }
         case 'TEXT': // String
             return (0, psdReader_1.readUnicodeString)(reader);
@@ -635,13 +657,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 setHidden({ low, high }, osTypeKey, type);
+            return { low, high };
         }
         case 'bool': // Boolean
             return !!(0, psdReader_1.readUint8)(reader);
         case 'type': // Class
         case 'GlbC': // Class
-            return setHidden(readClassStructure(reader), osTypeKey, type);
+            return readClassStructure(reader);
         case 'alis': { // Alias
             const length = (0, psdReader_1.readInt32)(reader);
             return (0, psdReader_1.readAsciiString)(reader, length);
@@ -653,21 +675,21 @@ function readOSType(reader, type, includeClass) {
         case 'ObAr': { // Object array
             (0, psdReader_1.readInt32)(reader); // version: 16
             (0, psdReader_1.readUnicodeString)(reader); // name: ''
-            const classID = readAsciiStringOrClassId(reader); // 'rationalPoint'
+            readAsciiStringOrClassId(reader); // classID: 'rationalPoint'
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
             for (let i = 0; i < length; i++) {
                 const type1 = readAsciiStringOrClassId(reader); // type Hrzn | Vrtc
-                const valueType = (0, psdReader_1.readSignature)(reader); // UnFl
-                const units = (0, psdReader_1.readSignature)(reader); // units ? '#Pxl'
+                (0, psdReader_1.readSignature)(reader); // UnFl
+                (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(setHidden({ type: type1, values }, obArInfoKey, { valueType, units }));
+                items.push({ type: type1, values });
             }
-            return setHidden(items, obArInfoKey, { classID });
+            return items;
         }
         case 'Pth ': { // File path
             /*const length =*/ (0, psdReader_1.readInt32)(reader); // total size of all fields below
@@ -687,7 +709,7 @@ const ObArTypes = {
     quiltSliceY: 'UntF',
 };
 function writeOSType(writer, type, value, key, extType, root) {
-    var _a, _b, _c, _d, _e;
+    var _a;
     switch (type) {
         case 'obj ': // Reference
             writeReferenceStructure(writer, key, value);
@@ -708,11 +730,11 @@ 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 = (_a = getRecordedOSType(value[i], fieldToArrayType[key])) !== null && _a !== void 0 ? _a : guessOSType(value[i]);
+                const type = root === exports.cameraRawFilterClassID ? 'long' : ((_a = 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)
-                    console.log(`Missing descriptor array type for: '${key}' in`, value);
+                if (writer.logMissingFeatures && !type)
+                    writer.log(`Missing descriptor array type for: '${key}' in`, value);
             }
             break;
         case 'doub': // Double
@@ -782,16 +804,15 @@ 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 = (_c = (_b = getHidden(value, obArInfoKey)) === null || _b === void 0 ? void 0 : _b.classID) !== null && _c !== void 0 ? _c : ObArTypes[key];
+            const type = 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, (_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.writeSignature)(writer, 'UnFl');
+                (0, psdWriter_1.writeSignature)(writer, '#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]);
@@ -800,83 +821,60 @@ function writeOSType(writer, type, value, key, extType, root) {
             break;
         }
         case 'Pth ': { // File path
-            const length = 4 + 4 + 4 + value.path.length * 2;
+            const path = value.path + '\0'; // Photoshop stores trailing null character (stripped when reading)
+            const length = 4 + 4 + 4 + path.length * 2;
             (0, psdWriter_1.writeInt32)(writer, length);
             (0, psdWriter_1.writeSignature)(writer, value.sig);
             (0, psdWriter_1.writeInt32LE)(writer, length);
-            (0, psdWriter_1.writeInt32LE)(writer, value.path.length);
-            (0, psdWriter_1.writeUnicodeStringWithoutLengthLE)(writer, value.path);
+            (0, psdWriter_1.writeInt32LE)(writer, path.length);
+            (0, psdWriter_1.writeUnicodeStringWithoutLengthLE)(writer, path);
             break;
         }
         default:
             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);
+const referenceTypes = ['prop', 'Clss', 'Enmr', 'rele', 'Idnt', 'indx', 'name'];
+function isReferenceItem(value) {
+    return !!value && typeof value === 'object' && referenceTypes.indexOf(value.type) !== -1;
 }
 function readReferenceStructure(reader) {
     const itemsCount = (0, psdReader_1.readInt32)(reader);
-    const infos = [];
+    const items = [];
     for (let i = 0; i < itemsCount; i++) {
         const type = (0, psdReader_1.readSignature)(reader);
         switch (type) {
-            case 'prop': { // Property
-                const { name, classID } = readClassStructure(reader);
-                const keyID = readAsciiStringOrClassId(reader);
-                infos.push({ type, name, classID, keyID });
+            case 'prop': // Property
+                readClassStructure(reader);
+                items.push(readAsciiStringOrClassId(reader));
                 break;
-            }
-            case 'Clss': { // Class
-                const { name, classID } = readClassStructure(reader);
-                infos.push({ type, name, classID });
+            case 'Clss': // Class
+                items.push(readClassStructure(reader));
                 break;
-            }
             case 'Enmr': { // Enumerated Reference
-                const { name, classID } = readClassStructure(reader);
+                readClassStructure(reader);
                 const typeID = readAsciiStringOrClassId(reader);
                 const enumValue = readAsciiStringOrClassId(reader);
-                infos.push({ type, name, classID, typeID, enumValue });
+                items.push(`${typeID}.${enumValue}`);
                 break;
             }
-            case 'rele': { // Offset
-                const { name, classID } = readClassStructure(reader);
-                infos.push({ type, name, classID, value: (0, psdReader_1.readUint32)(reader) });
+            case 'rele': // Offset
+                readClassStructure(reader);
+                items.push((0, psdReader_1.readUint32)(reader));
                 break;
-            }
             case 'Idnt': // Identifier
             case 'indx': // Index
-                infos.push({ type, value: (0, psdReader_1.readInt32)(reader) });
+                items.push((0, psdReader_1.readInt32)(reader));
                 break;
-            case 'name': { // Name
-                const { name, classID } = readClassStructure(reader);
-                infos.push({ type, name, classID, value: (0, psdReader_1.readUnicodeString)(reader) });
+            case 'name': // Name
+                readClassStructure(reader);
+                items.push((0, psdReader_1.readUnicodeString)(reader));
                 break;
-            }
             default:
                 throw new Error(`Invalid descriptor reference type: ${type}`);
         }
     }
-    return createDescriptorReference(infos);
+    return items;
 }
 function guessReferenceItem(value) {
     if (typeof value === 'string') {
@@ -884,17 +882,17 @@ function guessReferenceItem(value) {
         // (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] };
+            return { type: 'Enmr', _name: '', _classID: match[1], typeID: match[1], enumValue: match[2] };
         }
         else {
-            return { type: 'name', name: '', classID: 'Lyr ', value };
+            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 };
+        return { type: 'Clss', _name: value.name || '', _classID: value.classID };
     }
     else {
         throw new Error(`Invalid descriptor reference value: ${JSON.stringify(value)}`);
@@ -903,41 +901,35 @@ function guessReferenceItem(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
+    return items.map(value => {
         const item = guessReferenceItem(value);
         if (item.type === 'Enmr')
-            item.classID = 'Path';
+            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];
-        const recorded = infos === null || infos === void 0 ? void 0 : infos[i];
-        const item = referenceItemMatches(recorded, value) ? recorded : guessReferenceItem(value);
+    for (const value of items) {
+        const item = isReferenceItem(value) ? value : guessReferenceItem(value);
         (0, psdWriter_1.writeSignature)(writer, item.type);
         switch (item.type) {
             case 'prop': // Property
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 writeAsciiStringOrClassId(writer, item.keyID);
                 break;
             case 'Clss': // Class
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 break;
             case 'Enmr': // Enumerated Reference
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 writeAsciiStringOrClassId(writer, item.typeID);
                 writeAsciiStringOrClassId(writer, item.enumValue);
                 break;
             case 'rele': // Offset
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 (0, psdWriter_1.writeUint32)(writer, item.value);
                 break;
             case 'Idnt': // Identifier
@@ -945,7 +937,7 @@ function writeReferenceStructure(writer, _key, items) {
                 (0, psdWriter_1.writeInt32)(writer, item.value);
                 break;
             case 'name': // Name
-                writeClassStructure(writer, item.name || '', item.classID);
+                writeClassStructure(writer, item._name || '', item._classID);
                 (0, psdWriter_1.writeUnicodeStringWithPadding)(writer, `${item.value}`);
                 break;
             default:
@@ -1004,7 +996,7 @@ function parseFxObject(fx) {
         fillType: exports.FrFl.decode(fx.PntT),
         blendMode: exports.BlnM.decode(fx['Md  ']),
         opacity: parsePercent(fx.Opct),
-        size: parseUnits(fx['Sz  ']),
+        size: parseUnitsOrNumber(fx['Sz  ']), // stored as number (pixels) in old versions
     };
     if (fx.present !== undefined)
         stroke.present = fx.present;
@@ -1042,7 +1034,7 @@ function serializeFxObject(stroke) {
         FrFX.overprint = !!stroke.overprint;
     return FrFX;
 }
-function serializeEffects(e, log, multi) {
+function serializeEffects(e, writer, multi) {
     var _a, _b, _c;
     const info = multi ? {
         'Scl ': unitsPercentF((_a = e.scale) !== null && _a !== void 0 ? _a : 1),
@@ -1059,33 +1051,33 @@ function serializeEffects(e, log, multi) {
     const useMulti = (arr) => !!arr && arr.length > 1 && multi;
     const useSingle = (arr) => !!arr && arr.length >= 1 && (!multi || arr.length === 1);
     if (useSingle(e.dropShadow))
-        info.DrSh = serializeEffectObject(e.dropShadow[0], 'dropShadow', log);
+        info.DrSh = serializeEffectObject(e.dropShadow[0], 'dropShadow', writer);
     if (useMulti(e.dropShadow))
-        info.dropShadowMulti = e.dropShadow.map(i => serializeEffectObject(i, 'dropShadow', log));
+        info.dropShadowMulti = e.dropShadow.map(i => serializeEffectObject(i, 'dropShadow', writer));
     if (useSingle(e.innerShadow))
-        info.IrSh = serializeEffectObject(e.innerShadow[0], 'innerShadow', log);
+        info.IrSh = serializeEffectObject(e.innerShadow[0], 'innerShadow', writer);
     if (useMulti(e.innerShadow))
-        info.innerShadowMulti = e.innerShadow.map(i => serializeEffectObject(i, 'innerShadow', log));
+        info.innerShadowMulti = e.innerShadow.map(i => serializeEffectObject(i, 'innerShadow', writer));
     if (e.outerGlow)
-        info.OrGl = serializeEffectObject(e.outerGlow, 'outerGlow', log);
+        info.OrGl = serializeEffectObject(e.outerGlow, 'outerGlow', writer);
     if (useMulti(e.solidFill))
-        info.solidFillMulti = e.solidFill.map(i => serializeEffectObject(i, 'solidFill', log));
+        info.solidFillMulti = e.solidFill.map(i => serializeEffectObject(i, 'solidFill', writer));
     if (useMulti(e.gradientOverlay))
-        info.gradientFillMulti = e.gradientOverlay.map(i => serializeEffectObject(i, 'gradientOverlay', log));
+        info.gradientFillMulti = e.gradientOverlay.map(i => serializeEffectObject(i, 'gradientOverlay', writer));
     if (useMulti(e.stroke))
         info.frameFXMulti = e.stroke.map(i => serializeFxObject(i));
     if (e.innerGlow)
-        info.IrGl = serializeEffectObject(e.innerGlow, 'innerGlow', log);
+        info.IrGl = serializeEffectObject(e.innerGlow, 'innerGlow', writer);
     if (e.bevel)
-        info.ebbl = serializeEffectObject(e.bevel, 'bevel', log);
+        info.ebbl = serializeEffectObject(e.bevel, 'bevel', writer);
     if (useSingle(e.solidFill))
-        info.SoFi = serializeEffectObject(e.solidFill[0], 'solidFill', log);
+        info.SoFi = serializeEffectObject(e.solidFill[0], 'solidFill', writer);
     if (e.patternOverlay)
-        info.patternFill = serializeEffectObject(e.patternOverlay, 'patternOverlay', log);
+        info.patternFill = serializeEffectObject(e.patternOverlay, 'patternOverlay', writer);
     if (useSingle(e.gradientOverlay))
-        info.GrFl = serializeEffectObject(e.gradientOverlay[0], 'gradientOverlay', log);
+        info.GrFl = serializeEffectObject(e.gradientOverlay[0], 'gradientOverlay', writer);
     if (e.satin)
-        info.ChFX = serializeEffectObject(e.satin, 'satin', log);
+        info.ChFX = serializeEffectObject(e.satin, 'satin', writer);
     if (useSingle(e.stroke))
         info.FrFX = serializeFxObject((_c = e.stroke) === null || _c === void 0 ? void 0 : _c[0]);
     if (multi) {
@@ -1107,48 +1099,48 @@ function serializeEffects(e, log, multi) {
     }
     return info;
 }
-function parseEffects(info, log) {
+function parseEffects(info, reader) {
     const effects = {};
-    const { masterFXSwitch, DrSh, dropShadowMulti, IrSh, innerShadowMulti, OrGl, IrGl, ebbl, SoFi, solidFillMulti, patternFill, GrFl, gradientFillMulti, ChFX, FrFX, frameFXMulti, numModifyingFX } = info, rest = __rest(info, ["masterFXSwitch", "DrSh", "dropShadowMulti", "IrSh", "innerShadowMulti", "OrGl", "IrGl", "ebbl", "SoFi", "solidFillMulti", "patternFill", "GrFl", "gradientFillMulti", "ChFX", "FrFX", "frameFXMulti", "numModifyingFX"]);
+    const _a = info, { _name, _classID, 'Scl ': scale, masterFXSwitch, DrSh, dropShadowMulti, IrSh, innerShadowMulti, OrGl, IrGl, ebbl, SoFi, solidFillMulti, patternFill, GrFl, gradientFillMulti, ChFX, FrFX, frameFXMulti, numModifyingFX } = _a, rest = __rest(_a, ["_name", "_classID", 'Scl ', "masterFXSwitch", "DrSh", "dropShadowMulti", "IrSh", "innerShadowMulti", "OrGl", "IrGl", "ebbl", "SoFi", "solidFillMulti", "patternFill", "GrFl", "gradientFillMulti", "ChFX", "FrFX", "frameFXMulti", "numModifyingFX"]);
     if (!masterFXSwitch)
         effects.disabled = true;
-    if (info['Scl '])
-        effects.scale = parsePercent(info['Scl ']);
+    if (scale)
+        effects.scale = parsePercent(scale);
     if (DrSh)
-        effects.dropShadow = [parseEffectObject(DrSh, log)];
+        effects.dropShadow = [parseEffectObject(DrSh, reader)];
     if (dropShadowMulti)
-        effects.dropShadow = dropShadowMulti.map(i => parseEffectObject(i, log));
+        effects.dropShadow = dropShadowMulti.map(i => parseEffectObject(i, reader));
     if (IrSh)
-        effects.innerShadow = [parseEffectObject(IrSh, log)];
+        effects.innerShadow = [parseEffectObject(IrSh, reader)];
     if (innerShadowMulti)
-        effects.innerShadow = innerShadowMulti.map(i => parseEffectObject(i, log));
+        effects.innerShadow = innerShadowMulti.map(i => parseEffectObject(i, reader));
     if (OrGl)
-        effects.outerGlow = parseEffectObject(OrGl, log);
+        effects.outerGlow = parseEffectObject(OrGl, reader);
     if (IrGl)
-        effects.innerGlow = parseEffectObject(IrGl, log);
+        effects.innerGlow = parseEffectObject(IrGl, reader);
     if (ebbl)
-        effects.bevel = parseEffectObject(ebbl, log);
+        effects.bevel = parseEffectObject(ebbl, reader, 'bevel');
     if (SoFi)
-        effects.solidFill = [parseEffectObject(SoFi, log)];
+        effects.solidFill = [parseEffectObject(SoFi, reader)];
     if (solidFillMulti)
-        effects.solidFill = solidFillMulti.map(i => parseEffectObject(i, log));
+        effects.solidFill = solidFillMulti.map(i => parseEffectObject(i, reader));
     if (patternFill)
-        effects.patternOverlay = parseEffectObject(patternFill, log);
+        effects.patternOverlay = parseEffectObject(patternFill, reader);
     if (GrFl)
-        effects.gradientOverlay = [parseEffectObject(GrFl, log)];
+        effects.gradientOverlay = [parseEffectObject(GrFl, reader)];
     if (gradientFillMulti)
-        effects.gradientOverlay = gradientFillMulti.map(i => parseEffectObject(i, log));
+        effects.gradientOverlay = gradientFillMulti.map(i => parseEffectObject(i, reader));
     if (ChFX)
-        effects.satin = parseEffectObject(ChFX, log);
+        effects.satin = parseEffectObject(ChFX, reader);
     if (FrFX)
         effects.stroke = [parseFxObject(FrFX)];
     if (frameFXMulti)
         effects.stroke = frameFXMulti.map(i => parseFxObject(i));
-    if (log && Object.keys(rest).length > 1)
-        console.log('Unhandled effect keys:', rest);
+    if (reader.logMissingFeatures && Object.keys(rest).length)
+        reader.log('Unhandled effect keys:', rest);
     return effects;
 }
-function parseKeyList(keyList, logMissingFeatures) {
+function parseKeyList(keyList, reader) {
     const keys = [];
     for (let j = 0; j < keyList.length; j++) {
         const key = keyList[j];
@@ -1171,7 +1163,7 @@ function parseKeyList(keyList, logMissingFeatures) {
             case 'keyType.sheetStyle': {
                 const key = { interpolation, time, selected, type: 'style' };
                 if (animKey.sheetStyle.Lefx)
-                    key.style = parseEffects(animKey.sheetStyle.Lefx, logMissingFeatures);
+                    key.style = parseEffects(animKey.sheetStyle.Lefx, reader);
                 keys.push(key);
                 break;
             }
@@ -1187,7 +1179,7 @@ function parseKeyList(keyList, logMissingFeatures) {
     }
     return keys;
 }
-function serializeKeyList(keys) {
+function serializeKeyList(keys, writer) {
     const keyList = [];
     for (let j = 0; j < keys.length; j++) {
         const key = keys[j];
@@ -1207,7 +1199,7 @@ function serializeKeyList(keys) {
             case 'style':
                 animKey = { Type: 'keyType.sheetStyle', sheetStyle: { Vrsn: 1, blendOptions: {} } };
                 if (key.style)
-                    animKey.sheetStyle = { Vrsn: 1, Lefx: serializeEffects(key.style, false, false), blendOptions: {} };
+                    animKey.sheetStyle = { Vrsn: 1, Lefx: serializeEffects(key.style, writer, false), blendOptions: {} };
                 break;
             case 'globalLighting': {
                 animKey = { Type: 'keyType.globalLighting', gblA: key.globalAngle, globalAltitude: key.globalAltitude };
@@ -1219,41 +1211,41 @@ function serializeKeyList(keys) {
     }
     return keyList;
 }
-function parseTrackList(trackList, logMissingFeatures) {
+function parseTrackList(trackList, reader) {
     const tracks = [];
     for (let i = 0; i < trackList.length; i++) {
         const tr = trackList[i];
         const track = {
             type: exports.stdTrackID.decode(tr.trackID),
             enabled: tr.enab,
-            keys: parseKeyList(tr.keyList, logMissingFeatures),
+            keys: parseKeyList(tr.keyList, reader),
         };
         if (tr.effectParams) {
             track.effectParams = {
                 fillCanvas: tr.effectParams.fillCanvas,
                 zoomOrigin: tr.effectParams.zoomOrigin,
-                keys: parseKeyList(tr.effectParams.keyList, logMissingFeatures),
+                keys: parseKeyList(tr.effectParams.keyList, reader),
             };
         }
         tracks.push(track);
     }
     return tracks;
 }
-function serializeTrackList(tracks) {
+function serializeTrackList(tracks, writer) {
     const trackList = [];
     for (let i = 0; i < tracks.length; i++) {
         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.effectParams.keys),
+                keyList: serializeKeyList(t.effectParams.keys, writer),
                 fillCanvas: t.effectParams.fillCanvas,
                 zoomOrigin: t.effectParams.zoomOrigin,
             }
-        } : {})), { keyList: serializeKeyList(t.keys) }));
+        } : {})), { keyList: serializeKeyList(t.keys, writer) }));
     }
     return trackList;
 }
-function parseEffectObject(obj, reportErrors) {
+function parseEffectObject(obj, reader, objName) {
     const result = {};
     for (const key of Object.keys(obj)) {
         const val = obj[key];
@@ -1318,7 +1310,8 @@ function parseEffectObject(obj, reportErrors) {
             case 'Type':
                 result.type = exports.GrdT.decode(val);
                 break;
-            case 'gs99':
+            case 'gs99': // gradient overlay
+            case 'gradientsInterpolationMethod': // glows
                 result.interpolationMethod = exports.gradientInterpolationMethodType.decode(val);
                 break;
             case 'Opct':
@@ -1370,18 +1363,26 @@ function parseEffectObject(obj, reportErrors) {
                 result.pattern = { name: val['Nm  '], id: val.Idnt };
                 break;
             case 'phase':
-                result.phase = { x: val.Hrzn, y: val.Vrtc };
+                result.phase = parsePhase(val);
                 break;
             case 'Ofst':
                 result.offset = { x: parsePercent(val.Hrzn), y: parsePercent(val.Vrtc) };
                 break;
             case 'MpgS':
-            case 'TrnS':
-                result.contour = {
+            case 'TrnS': {
+                const contour = {
                     name: val['Nm  '],
                     curve: val['Crv '].map(p => ({ x: p.Hrzn, y: p.Vrtc })),
                 };
+                // bevel can have both: gloss contour (TrnS) and contour of the shape (MpgS)
+                if (objName === 'bevel' && key === 'MpgS') {
+                    result.shapeContour = contour;
+                }
+                else {
+                    result.contour = contour;
+                }
                 break;
+            }
             case 'Grad':
                 result.gradient = parseGradient(val);
                 break;
@@ -1397,12 +1398,12 @@ function parseEffectObject(obj, reportErrors) {
             case '_classID':
                 break;
             default:
-                reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+                reader.logMissingFeatures && reader.log(`Invalid effect key: '${key}', value:`, val);
         }
     }
     return result;
 }
-function serializeEffectObject(obj, objName, reportErrors) {
+function serializeEffectObject(obj, objName, writer) {
     const result = {
         enab: false,
     };
@@ -1476,7 +1477,7 @@ function serializeEffectObject(obj, objName, reportErrors) {
                 result.Type = exports.GrdT.encode(val);
                 break;
             case 'interpolationMethod':
-                result.gs99 = exports.gradientInterpolationMethodType.encode(val);
+                result[(objName === 'outerGlow' || objName === 'innerGlow') ? 'gradientsInterpolationMethod' : 'gs99'] = exports.gradientInterpolationMethodType.encode(val);
                 break;
             case 'opacity':
                 result.Opct = unitsPercent(val);
@@ -1532,15 +1533,14 @@ function serializeEffectObject(obj, objName, reportErrors) {
                 result.phase = { Hrzn: val.x, Vrtc: val.y };
                 break;
             case 'offset':
-                result.Ofst = { Hrzn: unitsPercent(val.x), Vrtc: unitsPercent(val.y) };
+                result.Ofst = { Hrzn: unitsPercentF(val.x), Vrtc: unitsPercentF(val.y) };
                 break;
-            case 'contour': {
-                result[objName === 'satin' ? 'MpgS' : 'TrnS'] = {
-                    'Nm  ': val.name,
-                    'Crv ': val.curve.map(p => ({ Hrzn: p.x, Vrtc: p.y })),
-                };
+            case 'contour':
+                result[objName === 'satin' ? 'MpgS' : 'TrnS'] = serializeContour(val);
+                break;
+            case 'shapeContour':
+                result.MpgS = serializeContour(val);
                 break;
-            }
             case 'gradient':
                 result.Grad = serializeGradient(val);
                 break;
@@ -1553,11 +1553,17 @@ function serializeEffectObject(obj, objName, reportErrors) {
                 result[key] = val;
                 break;
             default:
-                reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+                writer.logMissingFeatures && writer.log(`Invalid effect key: '${key}', value:`, val);
         }
     }
     return result;
 }
+function serializeContour(contour) {
+    return {
+        'Nm  ': contour.name,
+        'Crv ': contour.curve.map(p => ({ Hrzn: p.x, Vrtc: p.y })),
+    };
+}
 function parseGradient(grad) {
     if (grad.GrdF === 'GrdF.CstS') {
         // stop locations are always in 0..4096 range, independent of smoothness (Intr)
@@ -1566,11 +1572,22 @@ function parseGradient(grad) {
             type: 'solid',
             name: grad['Nm  '],
             smoothness: grad.Intr / 4096,
-            colorStops: grad.Clrs.map(s => ({
-                color: parseColor(s['Clr ']),
-                location: s.Lctn / samples,
-                midpoint: s.Mdpn / 100,
-            })),
+            colorStops: grad.Clrs.map(s => {
+                const stop = {
+                    color: s['Clr '] ? parseColor(s['Clr ']) : { r: 0, g: 0, b: 0 },
+                    location: s.Lctn / samples,
+                    midpoint: s.Mdpn / 100,
+                };
+                if (s.Type) {
+                    try {
+                        const type = exports.Clry.decode(s.Type);
+                        if (type !== 'user')
+                            stop.type = type;
+                    }
+                    catch (_a) { } // unknown stop type, read as user color
+                }
+                return stop;
+            }),
             opacityStops: grad.Trns.map(s => ({
                 opacity: parsePercent(s.Opct),
                 location: s.Lctn / samples,
@@ -1602,18 +1619,18 @@ function serializeGradient(grad) {
             GrdF: 'GrdF.CstS',
             Intr: Math.round(((_a = grad.smoothness) !== null && _a !== void 0 ? _a : 1) * 4096),
             Clrs: grad.colorStops.map(s => {
-                var _a;
+                var _a, _b;
                 return ({
                     'Clr ': serializeColor(s.color),
-                    Type: 'Clry.UsrS',
+                    Type: exports.Clry.encode((_a = s.type) !== null && _a !== void 0 ? _a : 'user'),
                     Lctn: Math.round(s.location * samples),
-                    Mdpn: Math.round(((_a = s.midpoint) !== null && _a !== void 0 ? _a : 0.5) * 100),
+                    Mdpn: Math.round(((_b = s.midpoint) !== null && _b !== void 0 ? _b : 0.5) * 100),
                 });
             }),
             Trns: grad.opacityStops.map(s => {
                 var _a;
                 return ({
-                    Opct: unitsPercent(s.opacity),
+                    Opct: unitsPercentF(s.opacity),
                     Lctn: Math.round(s.location * samples),
                     Mdpn: Math.round(((_a = s.midpoint) !== null && _a !== void 0 ? _a : 0.5) * 100),
                 });
@@ -1657,6 +1674,13 @@ function parseGradientContent(descriptor) {
     }
     return result;
 }
+// phase is usually stored as plain numbers, but some files store it as unit values
+function parsePhase({ Hrzn, Vrtc }) {
+    return {
+        x: typeof Hrzn === 'number' ? Hrzn : Hrzn.value,
+        y: typeof Vrtc === 'number' ? Vrtc : Vrtc.value,
+    };
+}
 function parsePatternContent(descriptor) {
     const result = {
         name: descriptor.Ptrn['Nm  '],
@@ -1665,7 +1689,11 @@ function parsePatternContent(descriptor) {
     if (descriptor.Lnkd !== undefined)
         result.linked = descriptor.Lnkd;
     if (descriptor.phase !== undefined)
-        result.phase = { x: descriptor.phase.Hrzn, y: descriptor.phase.Vrtc };
+        result.phase = parsePhase(descriptor.phase);
+    if (descriptor['Scl '] !== undefined)
+        result.scale = parsePercent(descriptor['Scl ']);
+    if (descriptor.Angl !== undefined)
+        result.angle = parseAngle(descriptor.Angl);
     return result;
 }
 function parseVectorContent(descriptor) {
@@ -1696,11 +1724,11 @@ function serializeGradientContent(content) {
     if (content.align !== undefined)
         result.Algn = content.align;
     if (content.scale !== undefined)
-        result['Scl '] = unitsPercent(content.scale);
+        result['Scl '] = unitsPercentF(content.scale);
     if (content.offset) {
         result.Ofst = {
-            Hrzn: unitsPercent(content.offset.x),
-            Vrtc: unitsPercent(content.offset.y),
+            Hrzn: unitsPercentF(content.offset.x),
+            Vrtc: unitsPercentF(content.offset.y),
         };
     }
     result.Grad = serializeGradient(content);
@@ -1717,6 +1745,10 @@ function serializePatternContent(content) {
         result.Lnkd = !!content.linked;
     if (content.phase !== undefined)
         result.phase = { Hrzn: content.phase.x, Vrtc: content.phase.y };
+    if (content.scale !== undefined)
+        result['Scl '] = unitsPercentF(content.scale);
+    if (content.angle !== undefined)
+        result.Angl = unitsAngle(content.angle);
     return result;
 }
 function serializeVectorContent(content) {
@@ -1732,9 +1764,9 @@ function serializeVectorContent(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]
+    'H   ': [x => x / 360, x => x * 360], // angle
     Strt: [x => x / 100, x => x * 100],
     Brgh: [x => x / 100, x => x * 100],
     'Cyn ': [x => x * 255 / 100, x => x * 100 / 255],
@@ -1762,22 +1794,33 @@ function colorToDescriptorValue(key, value) {
     }
     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 isBookColor(color) {
+    return color._classID === 'BkCl' || 'Bk  ' in color || 'bookID' in color;
 }
 function parseColor(color) {
-    let result;
+    var _a, _b, _c;
+    const result = parseColorValues(color);
+    if (isBookColor(color)) {
+        const book = color;
+        const key = book.bookKey;
+        result.book = {
+            book: (_a = book['Bk  ']) !== null && _a !== void 0 ? _a : '',
+            name: (_b = book['Nm  ']) !== null && _b !== void 0 ? _b : '',
+            bookID: (_c = book.bookID) !== null && _c !== void 0 ? _c : 0,
+            bookKey: typeof key === 'string' ? key : (key ? String.fromCharCode(...Array.from(key)) : ''),
+        };
+    }
+    return result;
+}
+function parseColorValues(color) {
     if ('H   ' in color) {
-        result = { h: parsePercentOrAngle(color['H   ']), s: color.Strt / 100, b: color.Brgh / 100 };
+        return { 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) {
-        result = {
+        return {
             c: color['Cyn '] * 255 / 100,
             m: color.Mgnt * 255 / 100,
             y: color['Ylw '] * 255 / 100,
@@ -1785,19 +1828,31 @@ function parseColor(color) {
         };
     }
     else if ('Gry ' in color) {
-        result = { k: color['Gry '] * 255 / 100 };
+        return { k: color['Gry '] * 255 / 100 };
     }
     else if ('Lmnc' in color) {
-        result = { l: color.Lmnc / 100, a: (0, helpers_1.normalizeLabAB)(color['A   ']), b: (0, helpers_1.normalizeLabAB)(color['B   ']) };
+        return { 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 };
     }
+    else if (isBookColor(color)) {
+        return { r: 0, g: 0, b: 0 }; // book (Pantone) color without color values
+    }
     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) {
+    const result = serializeColorValues(color);
+    if (color === null || color === void 0 ? void 0 : color.book) {
+        const { book, name, bookID, bookKey } = color.book;
+        const key = new Uint8Array(bookKey.length);
+        for (let i = 0; i < key.length; i++)
+            key[i] = bookKey.charCodeAt(i) & 0xff;
+        Object.assign(result, { 'Bk  ': book, 'Nm  ': name, bookID, bookKey: key });
+    }
+    return result;
 }
 function serializeColorValues(color) {
     if (!color) {
@@ -1812,7 +1867,7 @@ function serializeColorValues(color) {
     else if ('h' in color) {
         return {
             _name: '', _classID: 'HSBC',
-            'H   ': unitsAngle((color.h || 0) * 360),
+            'H   ': unitsAngle(colorToDescriptorValue('H   ', color.h || 0)),
             Strt: colorToDescriptorValue('Strt', color.s || 0),
             Brgh: colorToDescriptorValue('Brgh', color.b || 0),
         };
@@ -1841,19 +1896,6 @@ function serializeColorValues(color) {
         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;
@@ -1879,7 +1921,8 @@ function parsePercentOrAngle(x) {
 }
 function parseUnits({ units, value }) {
     if (units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
-        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density') {
+        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density' &&
+        units !== 'Distance') {
         throw new Error(`Invalid units: ${JSON.stringify({ units, value })}`);
     }
     return { value, units };
@@ -1912,7 +1955,8 @@ function unitsValue(x, key) {
     if (typeof value !== 'number')
         throw new Error(`Invalid value in ${JSON.stringify(x)} (key: ${key})`);
     if (units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
-        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density') {
+        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density' &&
+        units !== 'Distance') {
         throw new Error(`Invalid units in ${JSON.stringify(x)} (key: ${key})`);
     }
     return { units, value };
@@ -2040,6 +2084,11 @@ exports.gradientInterpolationMethodType = (0, helpers_1.createEnum)('gradientInt
     smooth: 'Smoo',
     // TODO: stripes
 });
+exports.Clry = (0, helpers_1.createEnum)('Clry', 'user', {
+    user: 'UsrS',
+    foreground: 'FrgC',
+    background: 'BckC',
+});
 exports.ClrS = (0, helpers_1.createEnum)('ClrS', 'rgb', {
     rgb: 'RGBC',
     hsb: 'HSBl',
@@ -2231,4 +2280,9 @@ exports.presetKindType = (0, helpers_1.createEnum)('presetKindType', 'custom', {
     custom: 'presetKindCustom',
     default: 'presetKindDefault',
 });
+exports.patternColorHandling = (0, helpers_1.createEnum)('', 'convert', {
+    'convert': 'conv',
+    'avoid conversion': 'avod',
+    'luminance only': 'lumi',
+});
 //# sourceMappingURL=descriptor.js.map