ag-psd 31.0.3 → 33.0.0

package/dist-es/descriptor.js

@@ -11,12 +11,15 @@ 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.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.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 = void 0;
+exports.presetKindType = exports.prjM = exports.FlMd = exports.IntC = exports.IntE = void 0;
 exports.setLogErrors = setLogErrors;
 exports.readAsciiStringOrClassId = readAsciiStringOrClassId;
+exports.writeAsciiStringOrClassId = writeAsciiStringOrClassId;
 exports.readDescriptorStructure = readDescriptorStructure;
 exports.writeDescriptorStructure = writeDescriptorStructure;
+exports.pathSelectionStateToReference = pathSelectionStateToReference;
+exports.writeClassStructure = writeClassStructure;
 exports.readVersionAndDescriptor = readVersionAndDescriptor;
 exports.writeVersionAndDescriptor = writeVersionAndDescriptor;
 exports.horzVrtcToXY = horzVrtcToXY;
@@ -155,12 +158,15 @@ const fieldToExtType = {
     origFXRefPoint: nullType,
     FXRefPoint: nullType,
     ClMg: makeType('', 'ClMg'),
+    interpretation: makeType('', 'footageInterpretation'),
+    bgColor: makeType('', 'NativeQuad'),
 };
 const fieldToArrayExtType = {
     'Crv ': makeType('', 'CrPt'),
     Clrs: makeType('', 'Clrt'),
     Trns: makeType('', 'TrnS'),
     keyDescriptorList: nullType,
+    keyRootDescriptorList: nullType,
     solidFillMulti: makeType('', 'SoFi'),
     gradientFillMulti: makeType('', 'GrFl'),
     dropShadowMulti: makeType('', 'DrSh'),
@@ -188,20 +194,29 @@ const fieldToArrayExtType = {
     layerSettings: nullType,
     list: nullType,
     Adjs: makeType('', 'CrvA'),
+    vertices: makeType('', 'Pnt '),
+    warpedVertices: makeType('', 'Pnt '),
+    quads: makeType('', 'quadIndices'),
 };
 const typeToField = {
     'TEXT': [
-        'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
+        'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName', 'exportOption', 'scaleSettings',
+        'BackgroundImagePath', 'ImageSubfolderName',
         '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',
@@ -213,6 +228,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',
@@ -222,7 +238,8 @@ 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': [
         'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -235,14 +252,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',
+        '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'
+        'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3',
+        'stylization', 'cleanliness', 'brushScale', 'microBrush', 'specularity',
     ],
     'UntF': [
         'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
@@ -251,29 +269,60 @@ 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',
         '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'];
+// 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') {
+        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;
+}
 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',
@@ -305,6 +354,8 @@ const fieldToArrayType = {
     Mtrx: 'long',
     compList: 'long',
     Chnl: 'enum',
+    indices: 'long',
+    Mpng: 'long',
 };
 const fieldToType = {};
 for (const type of Object.keys(typeToField)) {
@@ -319,6 +370,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 +390,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 +407,24 @@ 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 === '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';
+    }
     else {
         return fieldToType[key];
     }
@@ -364,7 +434,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);
@@ -392,29 +462,36 @@ 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);
     // 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);
+    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);
     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 +559,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 ']) {
@@ -504,14 +585,22 @@ function writeDescriptorStructure(writer, name, classId, value, root) {
         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: '' };
         }
+        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);
     }
@@ -579,7 +668,7 @@ 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'
+            readAsciiStringOrClassId(reader); // classID: 'rationalPoint'
             const length = (0, psdReader_1.readInt32)(reader);
             const items = [];
             for (let i = 0; i < length; i++) {
@@ -613,6 +702,7 @@ const ObArTypes = {
     quiltSliceY: 'UntF',
 };
 function writeOSType(writer, type, value, key, extType, root) {
+    var _a;
     switch (type) {
         case 'obj ': // Reference
             writeReferenceStructure(writer, key, value);
@@ -621,9 +711,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 +723,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 = 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 +761,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);
@@ -709,97 +814,127 @@ 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}`);
     }
 }
+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 items = [];
     for (let i = 0; i < itemsCount; i++) {
         const type = (0, psdReader_1.readSignature)(reader);
         switch (type) {
-            case 'prop': { // Property
+            case 'prop': // Property
                 readClassStructure(reader);
-                const keyID = readAsciiStringOrClassId(reader);
-                items.push(keyID);
+                items.push(readAsciiStringOrClassId(reader));
                 break;
-            }
             case 'Clss': // Class
                 items.push(readClassStructure(reader));
                 break;
             case 'Enmr': { // Enumerated Reference
                 readClassStructure(reader);
                 const typeID = readAsciiStringOrClassId(reader);
-                const value = readAsciiStringOrClassId(reader);
-                items.push(`${typeID}.${value}`);
+                const enumValue = readAsciiStringOrClassId(reader);
+                items.push(`${typeID}.${enumValue}`);
                 break;
             }
-            case 'rele': { // Offset
-                // const { name, classID } =
+            case 'rele': // Offset
                 readClassStructure(reader);
                 items.push((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));
                 break;
-            case 'name': { // Name
+            case 'name': // Name
                 readClassStructure(reader);
                 items.push((0, psdReader_1.readUnicodeString)(reader));
                 break;
-            }
             default:
                 throw new Error(`Invalid descriptor reference type: ${type}`);
         }
     }
     return items;
 }
+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) {
+    return items.map(value => {
+        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}`);
     (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);
+    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);
+                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 +945,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) {
@@ -854,7 +989,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;
@@ -942,9 +1077,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++;
                 }
             }
@@ -957,11 +1094,11 @@ function serializeEffects(e, log, multi) {
 }
 function parseEffects(info, log) {
     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)];
     if (dropShadowMulti)
@@ -975,7 +1112,7 @@ function parseEffects(info, log) {
     if (IrGl)
         effects.innerGlow = parseEffectObject(IrGl, log);
     if (ebbl)
-        effects.bevel = parseEffectObject(ebbl, log);
+        effects.bevel = parseEffectObject(ebbl, log, 'bevel');
     if (SoFi)
         effects.solidFill = [parseEffectObject(SoFi, log)];
     if (solidFillMulti)
@@ -992,7 +1129,7 @@ function parseEffects(info, log) {
         effects.stroke = [parseFxObject(FrFX)];
     if (frameFXMulti)
         effects.stroke = frameFXMulti.map(i => parseFxObject(i));
-    if (log && Object.keys(rest).length > 1)
+    if (log && Object.keys(rest).length)
         console.log('Unhandled effect keys:', rest);
     return effects;
 }
@@ -1093,7 +1230,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,
             }
@@ -1101,7 +1238,7 @@ function serializeTrackList(tracks) {
     }
     return trackList;
 }
-function parseEffectObject(obj, reportErrors) {
+function parseEffectObject(obj, reportErrors, objName) {
     const result = {};
     for (const key of Object.keys(obj)) {
         const val = obj[key];
@@ -1166,7 +1303,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':
@@ -1218,18 +1356,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;
@@ -1324,7 +1470,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);
@@ -1336,7 +1482,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 {
@@ -1380,15 +1526,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;
@@ -1406,18 +1551,36 @@ function serializeEffectObject(obj, objName, reportErrors) {
     }
     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') {
-        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  '],
             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,
@@ -1442,24 +1605,25 @@ 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;
+                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),
                 });
@@ -1475,8 +1639,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)),
         };
     }
 }
@@ -1503,6 +1667,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  '],
@@ -1511,7 +1682,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) {
@@ -1542,11 +1717,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);
@@ -1563,6 +1738,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) {
@@ -1576,25 +1755,68 @@ 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 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],
+    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 isBookColor(color) {
+    return color._classID === 'BkCl' || 'Bk  ' in color || 'bookID' in color;
+}
 function parseColor(color) {
     if ('H   ' in color) {
-        return { h: parsePercentOrAngle(color['H   ']), s: color.Strt, b: color.Brgh };
+        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) {
-        return { c: color['Cyn '], m: color.Mgnt, y: color['Ylw '], k: color.Blck };
+        return {
+            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 '] };
+        return { k: color['Gry '] * 255 / 100 };
     }
     else if ('Lmnc' in color) {
-        return { l: color.Lmnc, a: color['A   '], b: 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) colors are not supported
+    }
     else {
         throw new Error('Unsupported color descriptor');
     }
@@ -1610,16 +1832,32 @@ 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(colorToDescriptorValue('H   ', color.h || 0)),
+            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');
@@ -1650,7 +1888,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 };
@@ -1683,7 +1922,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 };
@@ -1811,6 +2051,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',