@yft-design/psd-lib 1.0.1

package/dist/descriptor.js

@@ -0,0 +1,1958 @@
+import { createEnum } from './helpers';
+import { readSignature, readUnicodeString, readUint32, readUint8, readFloat64, readBytes, readAsciiString, readInt32, readFloat32, readInt32LE, readUnicodeStringWithLengthLE } from './psdReader';
+import { writeSignature, writeBytes, writeUint32, writeFloat64, writeUint8, writeUnicodeStringWithPadding, writeInt32, writeFloat32, writeUnicodeString, writeInt32LE, writeUnicodeStringWithoutLengthLE } from './psdWriter';
+function revMap(map) {
+    const result = {};
+    Object.keys(map).forEach(key => result[map[key]] = key);
+    return result;
+}
+const unitsMap = {
+    '#Ang': 'Angle',
+    '#Rsl': 'Density',
+    '#Rlt': 'Distance',
+    '#Nne': 'None',
+    '#Prc': 'Percent',
+    '#Pxl': 'Pixels',
+    '#Mlm': 'Millimeters',
+    '#Pnt': 'Points',
+    'RrPi': 'Picas',
+    'RrIn': 'Inches',
+    'RrCm': 'Centimeters',
+};
+const unitsMapRev = revMap(unitsMap);
+let logErrors = false;
+export function setLogErrors(value) {
+    logErrors = value;
+}
+function makeType(name, classID) {
+    return { name, classID };
+}
+const nullType = makeType('', 'null');
+const USE_CHINESE = false; // Testing
+const fieldToExtType = {
+    strokeStyleContent: makeType('', 'solidColorLayer'),
+    printProofSetup: makeType(USE_CHINESE ? '校样设置' : 'Proof Setup', 'proofSetup'),
+    Grad: makeType(USE_CHINESE ? '渐变' : 'Gradient', 'Grdn'),
+    Trnf: makeType(USE_CHINESE ? '变换' : 'Transform', 'Trnf'),
+    patternFill: makeType('', 'patternFill'),
+    ebbl: makeType('', 'ebbl'),
+    SoFi: makeType('', 'SoFi'),
+    GrFl: makeType('', 'GrFl'),
+    sdwC: makeType('', 'RGBC'),
+    hglC: makeType('', 'RGBC'),
+    'Clr ': makeType('', 'RGBC'),
+    'tintColor': makeType('', 'RGBC'),
+    Ofst: makeType('', 'Pnt '),
+    ChFX: makeType('', 'ChFX'),
+    MpgS: makeType('', 'ShpC'),
+    DrSh: makeType('', 'DrSh'),
+    IrSh: makeType('', 'IrSh'),
+    OrGl: makeType('', 'OrGl'),
+    IrGl: makeType('', 'IrGl'),
+    TrnS: makeType('', 'ShpC'),
+    Ptrn: makeType('', 'Ptrn'),
+    FrFX: makeType('', 'FrFX'),
+    phase: makeType('', 'Pnt '),
+    frameStep: nullType,
+    duration: nullType,
+    workInTime: nullType,
+    workOutTime: nullType,
+    audioClipGroupList: nullType,
+    bounds: makeType('', 'Rctn'),
+    customEnvelopeWarp: makeType('', 'customEnvelopeWarp'),
+    warp: makeType('', 'warp'),
+    'Sz  ': makeType('', 'Pnt '),
+    origin: makeType('', 'Pnt '),
+    autoExpandOffset: makeType('', 'Pnt '),
+    keyOriginShapeBBox: makeType('', 'unitRect'),
+    Vrsn: nullType,
+    psVersion: nullType,
+    docDefaultNewArtboardBackgroundColor: makeType('', 'RGBC'),
+    artboardRect: makeType('', 'classFloatRect'),
+    keyOriginRRectRadii: makeType('', 'radii'),
+    keyOriginBoxCorners: nullType,
+    rectangleCornerA: makeType('', 'Pnt '),
+    rectangleCornerB: makeType('', 'Pnt '),
+    rectangleCornerC: makeType('', 'Pnt '),
+    rectangleCornerD: makeType('', 'Pnt '),
+    compInfo: nullType,
+    quiltWarp: makeType('', 'quiltWarp'),
+    generatorSettings: nullType,
+    crema: nullType,
+    FrIn: nullType,
+    blendOptions: nullType,
+    FXRf: nullType,
+    Lefx: nullType,
+    time: nullType,
+    animKey: nullType,
+    timeScope: nullType,
+    inTime: nullType,
+    outTime: nullType,
+    sheetStyle: nullType,
+    translation: nullType,
+    Skew: nullType,
+    boundingBox: makeType('', 'boundingBox'),
+    'Lnk ': makeType('', 'ExternalFileLink'),
+    frameReader: makeType('', 'FrameReader'),
+    effectParams: makeType('', 'motionTrackEffectParams'),
+    Impr: makeType('None', 'none'),
+    Anch: makeType('', 'Pnt '),
+    'Fwd ': makeType('', 'Pnt '),
+    'Bwd ': makeType('', 'Pnt '),
+    FlrC: makeType('', 'Pnt '),
+    meshBoundaryPath: makeType('', 'pathClass'),
+    filterFX: makeType('', 'filterFXStyle'),
+    Fltr: makeType('', 'rigidTransform'),
+    FrgC: makeType('', 'RGBC'),
+    BckC: makeType('', 'RGBC'),
+    sdwM: makeType('Parameters', 'adaptCorrectTones'),
+    hglM: makeType('Parameters', 'adaptCorrectTones'),
+    customShape: makeType('', 'customShape'),
+    origFXRefPoint: nullType,
+    FXRefPoint: nullType,
+    ClMg: makeType('', 'ClMg'),
+};
+const fieldToArrayExtType = {
+    'Crv ': makeType('', 'CrPt'),
+    Clrs: makeType('', 'Clrt'),
+    Trns: makeType('', 'TrnS'),
+    keyDescriptorList: nullType,
+    solidFillMulti: makeType('', 'SoFi'),
+    gradientFillMulti: makeType('', 'GrFl'),
+    dropShadowMulti: makeType('', 'DrSh'),
+    innerShadowMulti: makeType('', 'IrSh'),
+    frameFXMulti: makeType('', 'FrFX'),
+    FrIn: nullType,
+    FSts: nullType,
+    LaSt: nullType,
+    sheetTimelineOptions: nullType,
+    trackList: makeType('', 'animationTrack'),
+    globalTrackList: makeType('', 'animationTrack'),
+    keyList: nullType,
+    audioClipGroupList: nullType,
+    audioClipList: nullType,
+    countObjectList: makeType('', 'countObject'),
+    countGroupList: makeType('', 'countGroup'),
+    slices: makeType('', 'slice'),
+    'Pts ': makeType('', 'Pthp'),
+    SbpL: makeType('', 'SbpL'),
+    pathComponents: makeType('', 'PaCm'),
+    filterFXList: makeType('', 'filterFX'),
+    puppetShapeList: makeType('', 'puppetShape'),
+    channelDenoise: makeType('', 'channelDenoiseParams'),
+    ShrP: makeType('', 'Pnt '),
+    layerSettings: nullType,
+    list: nullType,
+    Adjs: makeType('', 'CrvA'),
+};
+const typeToField = {
+    'TEXT': [
+        'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
+        'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
+        'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
+        'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath',
+    ],
+    'tdta': [
+        'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
+        'LqMe',
+    ],
+    'long': [
+        'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
+        'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'comp', 'compID', 'originalCompID',
+        'curvesPresetKind', 'mixerPresetKind', 'uOrder', 'vOrder', 'PgNm', 'totalPages', 'Crop',
+        'numerator', 'denominator', 'frameCount', 'Annt', 'keyOriginType', 'unitValueQuadVersion',
+        'keyOriginIndex', 'major', 'minor', 'fix', 'docDefaultNewArtboardBackgroundType', 'artboardBackgroundType',
+        'numModifyingFX', 'deformNumRows', 'deformNumCols', 'FrID', 'FrDl', 'FsID', 'LCnt', 'AFrm', 'AFSt',
+        'numBefore', 'numAfter', 'Spcn', 'minOpacity', 'maxOpacity', 'BlnM', 'sheetID', 'gblA', 'globalAltitude',
+        'descVersion', 'frameReaderType', 'LyrI', 'zoomOrigin', 'fontSize', 'Rds ', 'sliceID',
+        'topOutset', 'leftOutset', 'bottomOutset', 'rightOutset', 'filterID', 'meshQuality',
+        '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',
+    ],
+    'enum': [
+        'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS', 'BlrQ',
+        'bvlT', 'bvlS', 'bvlD', 'Md  ', 'glwS', 'GrdF', 'GlwT', 'RplS', 'BlrM', 'SmBM',
+        'strokeStyleLineCapType', 'strokeStyleLineJoinType', 'strokeStyleLineAlignment',
+        'strokeStyleBlendMode', 'PntT', 'Styl', 'lookupType', 'LUTFormat', 'dataOrder',
+        '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',
+    ],
+    'bool': [
+        'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
+        'useShape', 'useTexture', 'uglg', 'antialiasGloss', 'useShape', 'Vsbl',
+        'useTexture', 'Algn', 'Rvrs', 'Dthr', 'Invr', 'VctC', 'ShTr', 'layerConceals',
+        'strokeEnabled', 'fillEnabled', 'strokeStyleScaleLock', 'strokeStyleStrokeAdjust',
+        'hardProof', 'MpBl', 'paperWhite', 'useLegacy', 'Auto', 'Lab ', 'useTint', 'keyShapeInvalidated',
+        'autoExpandEnabled', 'autoNestEnabled', 'autoPositionEnabled', 'shrinkwrapOnSaveEnabled',
+        'present', 'showInDialog', 'overprint', 'sheetDisclosed', 'lightsDisclosed', 'meshesDisclosed',
+        'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
+        'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
+        'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
+        'moreAccurate', 'GpuY', 'LIWy', 'Cnty',
+    ],
+    'doub': [
+        'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
+        'strokeStyleMiterLimit', 'strokeStyleResolution', 'layerTime', 'keyOriginResolution',
+        'xx', 'xy', 'yx', 'yy', 'tx', 'ty', 'FrGA', 'frameRate', 'audioLevel', 'rotation',
+        'X   ', 'Y   ', 'redFloat', 'greenFloat', 'blueFloat', 'imageResolution',
+        'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
+    ],
+    'UntF': [
+        'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
+        'Ckmt', 'Nose', 'Inpr', 'ShdN', 'strokeStyleLineWidth', 'strokeStyleLineDashOffset',
+        'strokeStyleOpacity', 'H   ', 'Top ', 'Left', 'Btom', 'Rght', 'Rslt',
+        'topRight', 'topLeft', 'bottomLeft', 'bottomRight', 'ClNs', 'Shrp',
+    ],
+    'VlLs': [
+        'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', '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',
+    ],
+    'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
+    'obj ': ['null', 'Chnl'],
+    'Pth ': ['DspF'],
+};
+const channels = [
+    'Rd  ', 'Grn ', 'Bl  ', 'Yllw', 'Ylw ', 'Cyn ', 'Mgnt', 'Blck', 'Gry ', 'Lmnc', 'A   ', 'B   ',
+];
+const fieldToArrayType = {
+    'Mnm ': 'long',
+    'Mxm ': 'long',
+    FrLs: 'long',
+    strokeStyleLineDashSet: 'UntF',
+    Trnf: 'doub',
+    nonAffineTransform: 'doub',
+    keyDescriptorList: 'Objc',
+    gradientFillMulti: 'Objc',
+    solidFillMulti: 'Objc',
+    frameFXMulti: 'Objc',
+    innerShadowMulti: 'Objc',
+    dropShadowMulti: 'Objc',
+    LaSt: 'Objc',
+    FrIn: 'Objc',
+    FSts: 'Objc',
+    FsFr: 'long',
+    blendOptions: 'Objc',
+    sheetTimelineOptions: 'Objc',
+    keyList: 'Objc',
+    warpValues: 'doub',
+    selectedPin: 'long',
+    'Pts ': 'Objc',
+    SbpL: 'Objc',
+    pathComponents: 'Objc',
+    pinOffsets: 'doub',
+    posFinalPins: 'doub',
+    pinVertexIndices: 'long',
+    PinP: 'doub',
+    PnRt: 'long',
+    PnOv: 'bool',
+    PnDp: 'doub',
+    filterFXList: 'Objc',
+    puppetShapeList: 'Objc',
+    ShrP: 'Objc',
+    channelDenoise: 'Objc',
+    Mtrx: 'long',
+    compList: 'long',
+    Chnl: 'enum',
+};
+const fieldToType = {};
+for (const type of Object.keys(typeToField)) {
+    for (const field of typeToField[type]) {
+        fieldToType[field] = type;
+    }
+}
+for (const field of Object.keys(fieldToExtType)) {
+    if (!fieldToType[field])
+        fieldToType[field] = 'Objc';
+}
+for (const field of Object.keys(fieldToArrayExtType)) {
+    fieldToArrayType[field] = 'Objc';
+}
+function getTypeByKey(key, value, root, parent) {
+    if (key === 'presetKind') {
+        return typeof value === 'string' ? 'enum' : 'long';
+    }
+    if (key === 'null' && root === 'slices') {
+        return 'TEXT';
+    }
+    else if (key === 'groupID') {
+        return root === 'slices' ? 'long' : 'TEXT';
+    }
+    else if (key === 'Sz  ') {
+        return ('Wdth' in value) ? 'Objc' : (('units' in value) ? 'UntF' : 'doub');
+    }
+    else if (key === 'Type') {
+        return typeof value === 'string' ? 'enum' : 'long';
+    }
+    else if (key === 'AntA') {
+        return typeof value === 'string' ? 'enum' : 'bool';
+    }
+    else if ((key === 'Hrzn' || key === 'Vrtc') && (parent.Type === 'keyType.Pstn' || parent._classID === 'Ofst')) {
+        return 'long';
+    }
+    else if (key === 'Hrzn' || key === 'Vrtc' || key === 'Top ' || key === 'Left' || key === 'Btom' || key === 'Rght') {
+        if (root === 'slices')
+            return 'long';
+        return typeof value === 'number' ? 'doub' : 'UntF';
+    }
+    else if (key === 'Vrsn') {
+        return typeof value === 'number' ? 'long' : 'Objc';
+    }
+    else if (key === 'Rd  ' || key === 'Grn ' || key === 'Bl  ') {
+        return root === 'artd' ? 'long' : 'doub';
+    }
+    else if (key === 'Trnf') {
+        return Array.isArray(value) ? 'VlLs' : 'Objc';
+    }
+    else {
+        return fieldToType[key];
+    }
+}
+export function readAsciiStringOrClassId(reader) {
+    const length = readInt32(reader);
+    return readAsciiString(reader, length || 4);
+}
+function writeAsciiStringOrClassId(writer, value) {
+    if (value.length === 4 && value !== 'warp' && value !== 'time' && value !== 'hold' && value !== 'list') {
+        // write classId
+        writeInt32(writer, 0);
+        writeSignature(writer, value);
+    }
+    else {
+        // write ascii string
+        writeInt32(writer, value.length);
+        for (let i = 0; i < value.length; i++) {
+            writeUint8(writer, value.charCodeAt(i));
+        }
+    }
+}
+export function readDescriptorStructure(reader, includeClass) {
+    const struct = readClassStructure(reader);
+    const object = includeClass ? { _name: struct.name, _classID: struct.classID } : {};
+    // console.log('>> ', struct);
+    const itemsCount = readUint32(reader);
+    for (let i = 0; i < itemsCount; i++) {
+        const key = readAsciiStringOrClassId(reader);
+        const type = readSignature(reader);
+        // console.log(`> '${key}' '${type}'`);
+        const data = readOSType(reader, type, includeClass);
+        // if (!getTypeByKey(key, data)) console.log(`> '${key}' '${type}'`, data);
+        object[key] = data;
+    }
+    return object;
+}
+export function writeDescriptorStructure(writer, name, classId, value, root) {
+    if (logErrors && !classId)
+        console.log('Missing classId for: ', name, classId, value);
+    // write class structure
+    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--;
+    writeUint32(writer, keyCount);
+    for (const key of keys) {
+        if (key === '_name' || key === '_classID')
+            continue;
+        let type = getTypeByKey(key, value[key], root, value);
+        let extType = fieldToExtType[key];
+        if (key === 'bounds' && root === 'text') {
+            extType = makeType('', 'bounds');
+        }
+        else if (key === 'origin') {
+            type = root === 'slices' ? 'enum' : 'Objc';
+        }
+        else if ((key === 'Cyn ' || key === 'Mgnt' || key === 'Ylw ' || key === 'Blck') && value._classID === 'CMYC') {
+            type = 'doub';
+        }
+        else if (/^PN[a-z][a-z]$/.test(key)) {
+            type = 'TEXT';
+        }
+        else if (/^PT[a-z][a-z]$/.test(key)) {
+            type = 'long';
+        }
+        else if (/^PF[a-z][a-z]$/.test(key)) {
+            type = 'doub';
+        }
+        else if ((key === 'Rds ' || key === 'Thsh') && typeof value[key] === 'number' && value._classID === 'SmrB') {
+            type = 'doub';
+        }
+        else if (key === 'ClSz' || key === 'Rds ' || key === 'Amnt') {
+            type = typeof value[key] === 'number' ? 'long' : 'UntF';
+        }
+        else if ((key === 'sdwM' || key === 'hglM') && typeof value[key] === 'string') {
+            type = 'enum';
+        }
+        else if (key === 'blur' && typeof value[key] === 'string') {
+            type = 'enum';
+        }
+        else if (key === 'Hght' && typeof value[key] === 'number' && value._classID === 'Embs') {
+            type = 'long';
+        }
+        else if (key === 'Angl' && typeof value[key] === 'number' && (value._classID === 'Embs' || value._classID === 'smartSharpen' || value._classID === 'Twrl' || value._classID === 'MtnB')) {
+            type = 'long';
+        }
+        else if (key === 'Angl' && typeof value[key] === 'number') {
+            type = 'doub'; // ???
+        }
+        else if (key === 'bounds' && root === 'slices') {
+            type = 'Objc';
+            extType = makeType('', 'Rct1');
+        }
+        else if (key === 'Scl ') {
+            if (typeof value[key] === 'object' && 'Hrzn' in value[key]) {
+                type = 'Objc';
+                extType = nullType;
+            }
+            else if (typeof value[key] === 'number') {
+                type = 'long';
+            }
+            else {
+                type = 'UntF';
+            }
+        }
+        else if (key === 'audioClipGroupList' && keys.length === 1) {
+            type = 'VlLs';
+        }
+        else if ((key === 'Strt' || key === 'Brgh') && 'H   ' in value) {
+            type = 'doub';
+        }
+        else if (key === 'Wdth' && typeof value[key] === 'object') {
+            type = 'UntF';
+        }
+        else if (key === 'Ofst' && typeof value[key] === 'number') {
+            type = 'long';
+        }
+        else if (key === 'Strt' && typeof value[key] === 'object') {
+            type = 'Objc';
+            extType = nullType;
+        }
+        else if (channels.indexOf(key) !== -1) {
+            type = (classId === 'RGBC' && root !== 'artd') ? 'doub' : 'long';
+        }
+        else if (key === 'profile') {
+            type = classId === 'printOutput' ? 'TEXT' : 'tdta';
+        }
+        else if (key === 'strokeStyleContent') {
+            if (value[key]['Clr ']) {
+                extType = makeType('', 'solidColorLayer');
+            }
+            else if (value[key].Grad) {
+                extType = makeType('', 'gradientLayer');
+            }
+            else if (value[key].Ptrn) {
+                extType = makeType('', 'patternLayer');
+            }
+            else {
+                logErrors && console.log('Invalid strokeStyleContent value', value[key]);
+            }
+        }
+        else if (key === 'bounds' && root === 'quiltWarp') {
+            extType = makeType('', 'classFloatRect');
+        }
+        if (extType && extType.classID === 'RGBC') {
+            if ('H   ' in value[key])
+                extType = { classID: 'HSBC', name: '' };
+            // TODO: other color spaces
+        }
+        writeAsciiStringOrClassId(writer, key);
+        writeSignature(writer, type || 'long');
+        writeOSType(writer, type || 'long', value[key], key, extType, root);
+        if (logErrors && !type)
+            console.log(`Missing descriptor field type for: '${key}' in`, value);
+    }
+}
+function readOSType(reader, type, includeClass) {
+    switch (type) {
+        case 'obj ': // Reference
+            return readReferenceStructure(reader);
+        case 'Objc': // Descriptor
+        case 'GlbO': // GlobalObject same as Descriptor
+            return readDescriptorStructure(reader, includeClass);
+        case 'VlLs': { // List
+            const length = readInt32(reader);
+            const items = [];
+            for (let i = 0; i < length; i++) {
+                const itemType = readSignature(reader);
+                // console.log('  >', itemType);
+                items.push(readOSType(reader, itemType, includeClass));
+            }
+            return items;
+        }
+        case 'doub': // Double
+            return readFloat64(reader);
+        case 'UntF': { // Unit double
+            const units = readSignature(reader);
+            const value = readFloat64(reader);
+            if (!unitsMap[units])
+                throw new Error(`Invalid units: ${units}`);
+            return { units: unitsMap[units], value };
+        }
+        case 'UnFl': { // Unit float
+            const units = readSignature(reader);
+            const value = readFloat32(reader);
+            if (!unitsMap[units])
+                throw new Error(`Invalid units: ${units}`);
+            return { units: unitsMap[units], value };
+        }
+        case 'TEXT': // String
+            return readUnicodeString(reader);
+        case 'enum': { // Enumerated
+            const enumType = readAsciiStringOrClassId(reader);
+            const value = readAsciiStringOrClassId(reader);
+            return `${enumType}.${value}`;
+        }
+        case 'long': // Integer
+            return readInt32(reader);
+        case 'comp': { // Large Integer
+            const low = readUint32(reader);
+            const high = readUint32(reader);
+            return { low, high };
+        }
+        case 'bool': // Boolean
+            return !!readUint8(reader);
+        case 'type': // Class
+        case 'GlbC': // Class
+            return readClassStructure(reader);
+        case 'alis': { // Alias
+            const length = readInt32(reader);
+            return readAsciiString(reader, length);
+        }
+        case 'tdta': { // Raw Data
+            const length = readInt32(reader);
+            return readBytes(reader, length);
+        }
+        case 'ObAr': { // Object array
+            readInt32(reader); // version: 16
+            readUnicodeString(reader); // name: ''
+            readAsciiStringOrClassId(reader); // 'rationalPoint'
+            const length = readInt32(reader);
+            const items = [];
+            for (let i = 0; i < length; i++) {
+                const type1 = readAsciiStringOrClassId(reader); // type Hrzn | Vrtc
+                readSignature(reader); // UnFl
+                readSignature(reader); // units ? '#Pxl'
+                const valuesCount = readInt32(reader);
+                const values = [];
+                for (let j = 0; j < valuesCount; j++) {
+                    values.push(readFloat64(reader));
+                }
+                items.push({ type: type1, values });
+            }
+            return items;
+        }
+        case 'Pth ': { // File path
+            /*const length =*/ readInt32(reader); // total size of all fields below
+            const sig = readSignature(reader);
+            /*const pathSize =*/ readInt32LE(reader); // the same as length
+            const charsCount = readInt32LE(reader);
+            const path = readUnicodeStringWithLengthLE(reader, charsCount);
+            return { sig, path };
+        }
+        default:
+            throw new Error(`Invalid TySh descriptor OSType: ${type} at ${reader.offset.toString(16)}`);
+    }
+}
+const ObArTypes = {
+    meshPoints: 'rationalPoint',
+    quiltSliceX: 'UntF',
+    quiltSliceY: 'UntF',
+};
+function writeOSType(writer, type, value, key, extType, root) {
+    switch (type) {
+        case 'obj ': // Reference
+            writeReferenceStructure(writer, key, value);
+            break;
+        case 'Objc': // Descriptor
+        case 'GlbO': { // GlobalObject same as Descriptor
+            if (typeof value !== 'object')
+                throw new Error(`Invalid struct value: ${JSON.stringify(value)}, key: ${key}`);
+            if (!extType)
+                throw new Error(`Missing ext type for: '${key}' (${JSON.stringify(value)})`);
+            const name = value._name || extType.name;
+            const classID = value._classID || extType.classID;
+            writeDescriptorStructure(writer, name, classID, value, root);
+            break;
+        }
+        case 'VlLs': // List
+            if (!Array.isArray(value))
+                throw new Error(`Invalid list value: ${JSON.stringify(value)}, key: ${key}`);
+            writeInt32(writer, value.length);
+            for (let i = 0; i < value.length; i++) {
+                const type = fieldToArrayType[key];
+                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);
+            }
+            break;
+        case 'doub': // Double
+            if (typeof value !== 'number')
+                throw new Error(`Invalid number value: ${JSON.stringify(value)}, key: ${key}`);
+            writeFloat64(writer, value);
+            break;
+        case 'UntF': // Unit double
+            if (!unitsMapRev[value.units])
+                throw new Error(`Invalid units: ${value.units} in ${key}`);
+            writeSignature(writer, unitsMapRev[value.units]);
+            writeFloat64(writer, value.value);
+            break;
+        case 'UnFl': // Unit float
+            if (!unitsMapRev[value.units])
+                throw new Error(`Invalid units: ${value.units} in ${key}`);
+            writeSignature(writer, unitsMapRev[value.units]);
+            writeFloat32(writer, value.value);
+            break;
+        case 'TEXT': // String
+            writeUnicodeStringWithPadding(writer, value);
+            break;
+        case 'enum': { // Enumerated
+            if (typeof value !== 'string')
+                throw new Error(`Invalid enum value: ${JSON.stringify(value)}, key: ${key}`);
+            const [_type, val] = value.split('.');
+            writeAsciiStringOrClassId(writer, _type);
+            writeAsciiStringOrClassId(writer, val);
+            break;
+        }
+        case 'long': // Integer
+            if (typeof value !== 'number')
+                throw new Error(`Invalid integer value: ${JSON.stringify(value)}, key: ${key}`);
+            writeInt32(writer, value);
+            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}`);
+            writeUint8(writer, value ? 1 : 0);
+            break;
+        // case 'type': // Class
+        // case 'GlbC': // Class
+        // 	writeClassStructure(reader);
+        // case 'alis': // Alias
+        // 	writeAliasStructure(reader);
+        case 'tdta': // Raw Data
+            writeInt32(writer, value.byteLength);
+            writeBytes(writer, value);
+            break;
+        case 'ObAr': { // Object array
+            writeInt32(writer, 16); // version
+            writeUnicodeStringWithPadding(writer, ''); // name
+            const type = ObArTypes[key];
+            if (!type)
+                throw new Error(`Not implemented ObArType for: ${key}`);
+            writeAsciiStringOrClassId(writer, type);
+            writeInt32(writer, value.length);
+            for (let i = 0; i < value.length; i++) {
+                writeAsciiStringOrClassId(writer, value[i].type); // Hrzn | Vrtc
+                writeSignature(writer, 'UnFl');
+                writeSignature(writer, '#Pxl');
+                writeInt32(writer, value[i].values.length);
+                for (let j = 0; j < value[i].values.length; j++) {
+                    writeFloat64(writer, value[i].values[j]);
+                }
+            }
+            break;
+        }
+        case 'Pth ': { // File path
+            const length = 4 + 4 + 4 + value.path.length * 2;
+            writeInt32(writer, length);
+            writeSignature(writer, value.sig);
+            writeInt32LE(writer, length);
+            writeInt32LE(writer, value.path.length);
+            writeUnicodeStringWithoutLengthLE(writer, value.path);
+            break;
+        }
+        default:
+            throw new Error(`Not implemented descriptor OSType: ${type}`);
+    }
+}
+function readReferenceStructure(reader) {
+    const itemsCount = readInt32(reader);
+    const items = [];
+    for (let i = 0; i < itemsCount; i++) {
+        const type = readSignature(reader);
+        switch (type) {
+            case 'prop': { // Property
+                readClassStructure(reader);
+                const keyID = readAsciiStringOrClassId(reader);
+                items.push(keyID);
+                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}`);
+                break;
+            }
+            case 'rele': { // Offset
+                // const { name, classID } =
+                readClassStructure(reader);
+                items.push(readUint32(reader));
+                break;
+            }
+            case 'Idnt': // Identifier
+                items.push(readInt32(reader));
+                break;
+            case 'indx': // Index
+                items.push(readInt32(reader));
+                break;
+            case 'name': { // Name
+                readClassStructure(reader);
+                items.push(readUnicodeString(reader));
+                break;
+            }
+            default:
+                throw new Error(`Invalid descriptor reference type: ${type}`);
+        }
+    }
+    return items;
+}
+function writeReferenceStructure(writer, _key, items) {
+    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';
+            }
+        }
+        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);
+                break;
+            }
+            // case 'rele': // Offset
+            // case 'Idnt': // Identifier
+            // case 'indx': // Index
+            case 'name': { // Name
+                writeClassStructure(writer, '\0', 'Lyr ');
+                writeUnicodeString(writer, value + '\0');
+                break;
+            }
+            default:
+                throw new Error(`Invalid descriptor reference type: ${type}`);
+        }
+    }
+    return items;
+}
+function readClassStructure(reader) {
+    const name = readUnicodeString(reader);
+    const classID = readAsciiStringOrClassId(reader);
+    return { name, classID };
+}
+function writeClassStructure(writer, name, classID) {
+    writeUnicodeString(writer, name);
+    writeAsciiStringOrClassId(writer, classID);
+}
+export function readVersionAndDescriptor(reader, includeClass = false) {
+    const version = readUint32(reader);
+    if (version !== 16)
+        throw new Error(`Invalid descriptor version: ${version}`);
+    const desc = readDescriptorStructure(reader, includeClass);
+    // console.log(require('util').inspect(desc, false, 99, true));
+    return desc;
+}
+export function writeVersionAndDescriptor(writer, name, classID, descriptor, root = '') {
+    writeUint32(writer, 16); // version
+    writeDescriptorStructure(writer, name, classID, descriptor, root);
+}
+export function horzVrtcToXY(hv) {
+    return { x: hv.Hrzn, y: hv.Vrtc };
+}
+export function xyToHorzVrtc(xy) {
+    return { Hrzn: xy.x, Vrtc: xy.y };
+}
+export function descBoundsToBounds(desc) {
+    return {
+        top: parseUnits(desc['Top ']),
+        left: parseUnits(desc.Left),
+        right: parseUnits(desc.Rght),
+        bottom: parseUnits(desc.Btom),
+    };
+}
+export function boundsToDescBounds(bounds) {
+    return {
+        Left: unitsValue(bounds.left, 'bounds.left'),
+        ['Top ']: unitsValue(bounds.top, 'bounds.top'),
+        Rght: unitsValue(bounds.right, 'bounds.right'),
+        Btom: unitsValue(bounds.bottom, 'bounds.bottom'),
+    };
+}
+function parseFxObject(fx) {
+    const stroke = {
+        enabled: !!fx.enab,
+        position: FStl.decode(fx.Styl),
+        fillType: FrFl.decode(fx.PntT),
+        blendMode: BlnM.decode(fx['Md  ']),
+        opacity: parsePercent(fx.Opct),
+        size: parseUnits(fx['Sz  ']),
+    };
+    if (fx.present !== undefined)
+        stroke.present = fx.present;
+    if (fx.showInDialog !== undefined)
+        stroke.showInDialog = fx.showInDialog;
+    if (fx.overprint !== undefined)
+        stroke.overprint = fx.overprint;
+    if (fx['Clr '])
+        stroke.color = parseColor(fx['Clr ']);
+    if (fx.Grad)
+        stroke.gradient = parseGradientContent(fx);
+    if (fx.Ptrn)
+        stroke.pattern = parsePatternContent(fx);
+    return stroke;
+}
+function serializeFxObject(stroke) {
+    let FrFX = {};
+    FrFX.enab = !!stroke.enabled;
+    if (stroke.present !== undefined)
+        FrFX.present = !!stroke.present;
+    if (stroke.showInDialog !== undefined)
+        FrFX.showInDialog = !!stroke.showInDialog;
+    FrFX.Styl = FStl.encode(stroke.position);
+    FrFX.PntT = FrFl.encode(stroke.fillType);
+    FrFX['Md  '] = BlnM.encode(stroke.blendMode);
+    FrFX.Opct = unitsPercent(stroke.opacity);
+    FrFX['Sz  '] = unitsValue(stroke.size, 'size');
+    if (stroke.color)
+        FrFX['Clr '] = serializeColor(stroke.color);
+    if (stroke.gradient)
+        FrFX = { ...FrFX, ...serializeGradientContent(stroke.gradient) };
+    if (stroke.pattern)
+        FrFX = { ...FrFX, ...serializePatternContent(stroke.pattern) };
+    if (stroke.overprint !== undefined)
+        FrFX.overprint = !!stroke.overprint;
+    return FrFX;
+}
+export function serializeEffects(e, log, multi) {
+    const info = multi ? {
+        'Scl ': unitsPercentF(e.scale ?? 1),
+        masterFXSwitch: !e.disabled,
+    } : {
+        masterFXSwitch: !e.disabled,
+        'Scl ': unitsPercentF(e.scale ?? 1),
+    };
+    const arrayKeys = ['dropShadow', 'innerShadow', 'solidFill', 'gradientOverlay', 'stroke'];
+    for (const key of arrayKeys) {
+        if (e[key] && !Array.isArray(e[key]))
+            throw new Error(`${key} should be an array`);
+    }
+    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);
+    if (useMulti(e.dropShadow))
+        info.dropShadowMulti = e.dropShadow.map(i => serializeEffectObject(i, 'dropShadow', log));
+    if (useSingle(e.innerShadow))
+        info.IrSh = serializeEffectObject(e.innerShadow[0], 'innerShadow', log);
+    if (useMulti(e.innerShadow))
+        info.innerShadowMulti = e.innerShadow.map(i => serializeEffectObject(i, 'innerShadow', log));
+    if (e.outerGlow)
+        info.OrGl = serializeEffectObject(e.outerGlow, 'outerGlow', log);
+    if (useMulti(e.solidFill))
+        info.solidFillMulti = e.solidFill.map(i => serializeEffectObject(i, 'solidFill', log));
+    if (useMulti(e.gradientOverlay))
+        info.gradientFillMulti = e.gradientOverlay.map(i => serializeEffectObject(i, 'gradientOverlay', log));
+    if (useMulti(e.stroke))
+        info.frameFXMulti = e.stroke.map(i => serializeFxObject(i));
+    if (e.innerGlow)
+        info.IrGl = serializeEffectObject(e.innerGlow, 'innerGlow', log);
+    if (e.bevel)
+        info.ebbl = serializeEffectObject(e.bevel, 'bevel', log);
+    if (useSingle(e.solidFill))
+        info.SoFi = serializeEffectObject(e.solidFill[0], 'solidFill', log);
+    if (e.patternOverlay)
+        info.patternFill = serializeEffectObject(e.patternOverlay, 'patternOverlay', log);
+    if (useSingle(e.gradientOverlay))
+        info.GrFl = serializeEffectObject(e.gradientOverlay[0], 'gradientOverlay', log);
+    if (e.satin)
+        info.ChFX = serializeEffectObject(e.satin, 'satin', log);
+    if (useSingle(e.stroke))
+        info.FrFX = serializeFxObject(e.stroke?.[0]);
+    if (multi) {
+        info.numModifyingFX = 0;
+        for (const key of Object.keys(e)) {
+            const value = e[key];
+            if (Array.isArray(value)) {
+                for (const effect of value) {
+                    if (effect.enabled)
+                        info.numModifyingFX++;
+                }
+            }
+            else if (value.enabled) {
+                info.numModifyingFX++;
+            }
+        }
+    }
+    return info;
+}
+export function parseEffects(info, log) {
+    const effects = {};
+    const { masterFXSwitch, DrSh, dropShadowMulti, IrSh, innerShadowMulti, OrGl, IrGl, ebbl, SoFi, solidFillMulti, patternFill, GrFl, gradientFillMulti, ChFX, FrFX, frameFXMulti, numModifyingFX, ...rest } = info;
+    if (!masterFXSwitch)
+        effects.disabled = true;
+    if (info['Scl '])
+        effects.scale = parsePercent(info['Scl ']);
+    if (DrSh)
+        effects.dropShadow = [parseEffectObject(DrSh, log)];
+    if (dropShadowMulti)
+        effects.dropShadow = dropShadowMulti.map(i => parseEffectObject(i, log));
+    if (IrSh)
+        effects.innerShadow = [parseEffectObject(IrSh, log)];
+    if (innerShadowMulti)
+        effects.innerShadow = innerShadowMulti.map(i => parseEffectObject(i, log));
+    if (OrGl)
+        effects.outerGlow = parseEffectObject(OrGl, log);
+    if (IrGl)
+        effects.innerGlow = parseEffectObject(IrGl, log);
+    if (ebbl)
+        effects.bevel = parseEffectObject(ebbl, log);
+    if (SoFi)
+        effects.solidFill = [parseEffectObject(SoFi, log)];
+    if (solidFillMulti)
+        effects.solidFill = solidFillMulti.map(i => parseEffectObject(i, log));
+    if (patternFill)
+        effects.patternOverlay = parseEffectObject(patternFill, log);
+    if (GrFl)
+        effects.gradientOverlay = [parseEffectObject(GrFl, log)];
+    if (gradientFillMulti)
+        effects.gradientOverlay = gradientFillMulti.map(i => parseEffectObject(i, log));
+    if (ChFX)
+        effects.satin = parseEffectObject(ChFX, log);
+    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);
+    return effects;
+}
+function parseKeyList(keyList, logMissingFeatures) {
+    const keys = [];
+    for (let j = 0; j < keyList.length; j++) {
+        const key = keyList[j];
+        const { time: { denominator, numerator }, selected, animKey } = key;
+        const time = { numerator, denominator };
+        const interpolation = animInterpStyleEnum.decode(key.animInterpStyle);
+        switch (animKey.Type) {
+            case 'keyType.Opct':
+                keys.push({ interpolation, time, selected, type: 'opacity', value: parsePercent(animKey.Opct) });
+                break;
+            case 'keyType.Pstn':
+                keys.push({ interpolation, time, selected, type: 'position', x: animKey.Hrzn, y: animKey.Vrtc });
+                break;
+            case 'keyType.Trnf':
+                keys.push({
+                    interpolation, time, selected, type: 'transform',
+                    scale: horzVrtcToXY(animKey['Scl ']), skew: horzVrtcToXY(animKey.Skew), rotation: animKey.rotation, translation: horzVrtcToXY(animKey.translation)
+                });
+                break;
+            case 'keyType.sheetStyle': {
+                const key = { interpolation, time, selected, type: 'style' };
+                if (animKey.sheetStyle.Lefx)
+                    key.style = parseEffects(animKey.sheetStyle.Lefx, logMissingFeatures);
+                keys.push(key);
+                break;
+            }
+            case 'keyType.globalLighting': {
+                keys.push({
+                    interpolation, time, selected, type: 'globalLighting',
+                    globalAngle: animKey.gblA, globalAltitude: animKey.globalAltitude
+                });
+                break;
+            }
+            default: throw new Error(`Unsupported keyType value`);
+        }
+    }
+    return keys;
+}
+function serializeKeyList(keys) {
+    const keyList = [];
+    for (let j = 0; j < keys.length; j++) {
+        const key = keys[j];
+        const { time, selected = false, interpolation } = key;
+        const animInterpStyle = animInterpStyleEnum.encode(interpolation);
+        let animKey;
+        switch (key.type) {
+            case 'opacity':
+                animKey = { Type: 'keyType.Opct', Opct: unitsPercent(key.value) };
+                break;
+            case 'position':
+                animKey = { Type: 'keyType.Pstn', Hrzn: key.x, Vrtc: key.y };
+                break;
+            case 'transform':
+                animKey = { Type: 'keyType.Trnf', 'Scl ': xyToHorzVrtc(key.scale), Skew: xyToHorzVrtc(key.skew), rotation: key.rotation, translation: xyToHorzVrtc(key.translation) };
+                break;
+            case 'style':
+                animKey = { Type: 'keyType.sheetStyle', sheetStyle: { Vrsn: 1, blendOptions: {} } };
+                if (key.style)
+                    animKey.sheetStyle = { Vrsn: 1, Lefx: serializeEffects(key.style, false, false), blendOptions: {} };
+                break;
+            case 'globalLighting': {
+                animKey = { Type: 'keyType.globalLighting', gblA: key.globalAngle, globalAltitude: key.globalAltitude };
+                break;
+            }
+            default: throw new Error(`Unsupported keyType value`);
+        }
+        keyList.push({ Vrsn: 1, animInterpStyle, time, animKey, selected });
+    }
+    return keyList;
+}
+export function parseTrackList(trackList, logMissingFeatures) {
+    const tracks = [];
+    for (let i = 0; i < trackList.length; i++) {
+        const tr = trackList[i];
+        const track = {
+            type: stdTrackID.decode(tr.trackID),
+            enabled: tr.enab,
+            keys: parseKeyList(tr.keyList, logMissingFeatures),
+        };
+        if (tr.effectParams) {
+            track.effectParams = {
+                fillCanvas: tr.effectParams.fillCanvas,
+                zoomOrigin: tr.effectParams.zoomOrigin,
+                keys: parseKeyList(tr.effectParams.keyList, logMissingFeatures),
+            };
+        }
+        tracks.push(track);
+    }
+    return tracks;
+}
+export function serializeTrackList(tracks) {
+    const trackList = [];
+    for (let i = 0; i < tracks.length; i++) {
+        const t = tracks[i];
+        trackList.push({
+            trackID: stdTrackID.encode(t.type),
+            Vrsn: 1,
+            enab: !!t.enabled,
+            Effc: !!t.effectParams,
+            ...(t.effectParams ? {
+                effectParams: {
+                    keyList: serializeKeyList(t.keys),
+                    fillCanvas: t.effectParams.fillCanvas,
+                    zoomOrigin: t.effectParams.zoomOrigin,
+                }
+            } : {}),
+            keyList: serializeKeyList(t.keys),
+        });
+    }
+    return trackList;
+}
+function parseEffectObject(obj, reportErrors) {
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        const val = obj[key];
+        switch (key) {
+            case 'enab':
+                result.enabled = !!val;
+                break;
+            case 'uglg':
+                result.useGlobalLight = !!val;
+                break;
+            case 'AntA':
+                result.antialiased = !!val;
+                break;
+            case 'Algn':
+                result.align = !!val;
+                break;
+            case 'Dthr':
+                result.dither = !!val;
+                break;
+            case 'Invr':
+                result.invert = !!val;
+                break;
+            case 'Rvrs':
+                result.reverse = !!val;
+                break;
+            case 'Clr ':
+                result.color = parseColor(val);
+                break;
+            case 'hglC':
+                result.highlightColor = parseColor(val);
+                break;
+            case 'sdwC':
+                result.shadowColor = parseColor(val);
+                break;
+            case 'Styl':
+                result.position = FStl.decode(val);
+                break;
+            case 'Md  ':
+                result.blendMode = BlnM.decode(val);
+                break;
+            case 'hglM':
+                result.highlightBlendMode = BlnM.decode(val);
+                break;
+            case 'sdwM':
+                result.shadowBlendMode = BlnM.decode(val);
+                break;
+            case 'bvlS':
+                result.style = BESl.decode(val);
+                break;
+            case 'bvlD':
+                result.direction = BESs.decode(val);
+                break;
+            case 'bvlT':
+                result.technique = bvlT.decode(val);
+                break;
+            case 'GlwT':
+                result.technique = BETE.decode(val);
+                break;
+            case 'glwS':
+                result.source = IGSr.decode(val);
+                break;
+            case 'Type':
+                result.type = GrdT.decode(val);
+                break;
+            case 'gs99':
+                result.interpolationMethod = gradientInterpolationMethodType.decode(val);
+                break;
+            case 'Opct':
+                result.opacity = parsePercent(val);
+                break;
+            case 'hglO':
+                result.highlightOpacity = parsePercent(val);
+                break;
+            case 'sdwO':
+                result.shadowOpacity = parsePercent(val);
+                break;
+            case 'lagl':
+                result.angle = parseAngle(val);
+                break;
+            case 'Angl':
+                result.angle = parseAngle(val);
+                break;
+            case 'Lald':
+                result.altitude = parseAngle(val);
+                break;
+            case 'Sftn':
+                result.soften = parseUnits(val);
+                break;
+            case 'srgR':
+                result.strength = parsePercent(val);
+                break;
+            case 'blur':
+                result.size = parseUnits(val);
+                break;
+            case 'Nose':
+                result.noise = parsePercent(val);
+                break;
+            case 'Inpr':
+                result.range = parsePercent(val);
+                break;
+            case 'Ckmt':
+                result.choke = parseUnits(val);
+                break;
+            case 'ShdN':
+                result.jitter = parsePercent(val);
+                break;
+            case 'Dstn':
+                result.distance = parseUnits(val);
+                break;
+            case 'Scl ':
+                result.scale = parsePercent(val);
+                break;
+            case 'Ptrn':
+                result.pattern = { name: val['Nm  '], id: val.Idnt };
+                break;
+            case 'phase':
+                result.phase = { x: val.Hrzn, y: val.Vrtc };
+                break;
+            case 'Ofst':
+                result.offset = { x: parsePercent(val.Hrzn), y: parsePercent(val.Vrtc) };
+                break;
+            case 'MpgS':
+            case 'TrnS':
+                result.contour = {
+                    name: val['Nm  '],
+                    curve: val['Crv '].map(p => ({ x: p.Hrzn, y: p.Vrtc })),
+                };
+                break;
+            case 'Grad':
+                result.gradient = parseGradient(val);
+                break;
+            case 'useTexture':
+            case 'useShape':
+            case 'layerConceals':
+            case 'present':
+            case 'showInDialog':
+            case 'antialiasGloss':
+                result[key] = val;
+                break;
+            case '_name':
+            case '_classID':
+                break;
+            default:
+                reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+        }
+    }
+    return result;
+}
+function serializeEffectObject(obj, objName, reportErrors) {
+    const result = {
+        enab: false,
+    };
+    if (objName === 'dropShadow') {
+        result.TrnS = { 'Nm  ': '', 'Crv ': [] };
+    }
+    for (const objKey of Object.keys(obj)) {
+        const key = objKey;
+        const val = obj[key];
+        switch (key) {
+            case 'enabled':
+                result.enab = !!val;
+                break;
+            case 'useGlobalLight':
+                result.uglg = !!val;
+                break;
+            case 'antialiased':
+                result.AntA = !!val;
+                break;
+            case 'align':
+                result.Algn = !!val;
+                break;
+            case 'dither':
+                result.Dthr = !!val;
+                break;
+            case 'invert':
+                result.Invr = !!val;
+                break;
+            case 'reverse':
+                result.Rvrs = !!val;
+                break;
+            case 'color':
+                result['Clr '] = serializeColor(val);
+                break;
+            case 'highlightColor':
+                result.hglC = serializeColor(val);
+                break;
+            case 'shadowColor':
+                result.sdwC = serializeColor(val);
+                break;
+            case 'position':
+                result.Styl = FStl.encode(val);
+                break;
+            case 'blendMode':
+                result['Md  '] = BlnM.encode(val);
+                break;
+            case 'highlightBlendMode':
+                result.hglM = BlnM.encode(val);
+                break;
+            case 'shadowBlendMode':
+                result.sdwM = BlnM.encode(val);
+                break;
+            case 'style':
+                result.bvlS = BESl.encode(val);
+                break;
+            case 'direction':
+                result.bvlD = BESs.encode(val);
+                break;
+            case 'technique':
+                if (objName === 'bevel') {
+                    result.bvlT = bvlT.encode(val);
+                }
+                else {
+                    result.GlwT = BETE.encode(val);
+                }
+                break;
+            case 'source':
+                result.glwS = IGSr.encode(val);
+                break;
+            case 'type':
+                result.Type = GrdT.encode(val);
+                break;
+            case 'interpolationMethod':
+                result.gs99 = gradientInterpolationMethodType.encode(val);
+                break;
+            case 'opacity':
+                result.Opct = unitsPercent(val);
+                break;
+            case 'highlightOpacity':
+                result.hglO = unitsPercent(val);
+                break;
+            case 'shadowOpacity':
+                result.sdwO = unitsPercent(val);
+                break;
+            case 'angle':
+                if (objName === 'gradientOverlay' || objName === 'patternFill') {
+                    result.Angl = unitsAngle(val);
+                }
+                else {
+                    result.lagl = unitsAngle(val);
+                }
+                break;
+            case 'altitude':
+                result.Lald = unitsAngle(val);
+                break;
+            case 'soften':
+                result.Sftn = unitsValue(val, key);
+                break;
+            case 'strength':
+                result.srgR = unitsPercent(val);
+                break;
+            case 'size':
+                result.blur = unitsValue(val, key);
+                break;
+            case 'noise':
+                result.Nose = unitsPercent(val);
+                break;
+            case 'range':
+                result.Inpr = unitsPercent(val);
+                break;
+            case 'choke':
+                result.Ckmt = unitsValue(val, key);
+                break;
+            case 'jitter':
+                result.ShdN = unitsPercent(val);
+                break;
+            case 'distance':
+                result.Dstn = unitsValue(val, key);
+                break;
+            case 'scale':
+                result['Scl '] = unitsPercent(val);
+                break;
+            case 'pattern':
+                result.Ptrn = { 'Nm  ': val.name, Idnt: val.id };
+                break;
+            case 'phase':
+                result.phase = { Hrzn: val.x, Vrtc: val.y };
+                break;
+            case 'offset':
+                result.Ofst = { Hrzn: unitsPercent(val.x), Vrtc: unitsPercent(val.y) };
+                break;
+            case 'contour': {
+                result[objName === 'satin' ? 'MpgS' : 'TrnS'] = {
+                    'Nm  ': val.name,
+                    'Crv ': val.curve.map(p => ({ Hrzn: p.x, Vrtc: p.y })),
+                };
+                break;
+            }
+            case 'gradient':
+                result.Grad = serializeGradient(val);
+                break;
+            case 'useTexture':
+            case 'useShape':
+            case 'layerConceals':
+            case 'present':
+            case 'showInDialog':
+            case 'antialiasGloss':
+                result[key] = val;
+                break;
+            default:
+                reportErrors && console.log(`Invalid effect key: '${key}', value:`, val);
+        }
+    }
+    return result;
+}
+function parseGradient(grad) {
+    if (grad.GrdF === 'GrdF.CstS') {
+        const samples = grad.Intr || 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,
+            })),
+            opacityStops: grad.Trns.map(s => ({
+                opacity: parsePercent(s.Opct),
+                location: s.Lctn / samples,
+                midpoint: s.Mdpn / 100,
+            })),
+        };
+    }
+    else {
+        return {
+            type: 'noise',
+            name: grad['Nm  '],
+            roughness: grad.Smth / 4096,
+            colorModel: ClrS.decode(grad.ClrS),
+            randomSeed: grad.RndS,
+            restrictColors: !!grad.VctC,
+            addTransparency: !!grad.ShTr,
+            min: grad['Mnm '].map(x => x / 100),
+            max: grad['Mxm '].map(x => x / 100),
+        };
+    }
+}
+function serializeGradient(grad) {
+    if (grad.type === 'solid') {
+        const samples = Math.round((grad.smoothness ?? 1) * 4096);
+        return {
+            'Nm  ': grad.name || '',
+            GrdF: 'GrdF.CstS',
+            Intr: samples,
+            Clrs: grad.colorStops.map(s => ({
+                'Clr ': serializeColor(s.color),
+                Type: 'Clry.UsrS',
+                Lctn: Math.round(s.location * samples),
+                Mdpn: Math.round((s.midpoint ?? 0.5) * 100),
+            })),
+            Trns: grad.opacityStops.map(s => ({
+                Opct: unitsPercent(s.opacity),
+                Lctn: Math.round(s.location * samples),
+                Mdpn: Math.round((s.midpoint ?? 0.5) * 100),
+            })),
+        };
+    }
+    else {
+        return {
+            GrdF: 'GrdF.ClNs',
+            'Nm  ': grad.name || '',
+            ShTr: !!grad.addTransparency,
+            VctC: !!grad.restrictColors,
+            ClrS: ClrS.encode(grad.colorModel),
+            RndS: grad.randomSeed || 0,
+            Smth: Math.round((grad.roughness ?? 1) * 4096),
+            'Mnm ': (grad.min || [0, 0, 0, 0]).map(x => x * 100),
+            'Mxm ': (grad.max || [1, 1, 1, 1]).map(x => x * 100),
+        };
+    }
+}
+function parseGradientContent(descriptor) {
+    const result = parseGradient(descriptor.Grad);
+    result.style = GrdT.decode(descriptor.Type);
+    if (descriptor.Dthr !== undefined)
+        result.dither = descriptor.Dthr;
+    if (descriptor.gradientsInterpolationMethod !== undefined)
+        result.interpolationMethod = gradientInterpolationMethodType.decode(descriptor.gradientsInterpolationMethod);
+    if (descriptor.Rvrs !== undefined)
+        result.reverse = descriptor.Rvrs;
+    if (descriptor.Angl !== undefined)
+        result.angle = parseAngle(descriptor.Angl);
+    if (descriptor['Scl '] !== undefined)
+        result.scale = parsePercent(descriptor['Scl ']);
+    if (descriptor.Algn !== undefined)
+        result.align = descriptor.Algn;
+    if (descriptor.Ofst !== undefined) {
+        result.offset = {
+            x: parsePercent(descriptor.Ofst.Hrzn),
+            y: parsePercent(descriptor.Ofst.Vrtc)
+        };
+    }
+    return result;
+}
+function parsePatternContent(descriptor) {
+    const result = {
+        name: descriptor.Ptrn['Nm  '],
+        id: descriptor.Ptrn.Idnt,
+    };
+    if (descriptor.Lnkd !== undefined)
+        result.linked = descriptor.Lnkd;
+    if (descriptor.phase !== undefined)
+        result.phase = { x: descriptor.phase.Hrzn, y: descriptor.phase.Vrtc };
+    return result;
+}
+export function parseVectorContent(descriptor) {
+    if ('Grad' in descriptor) {
+        return parseGradientContent(descriptor);
+    }
+    else if ('Ptrn' in descriptor) {
+        return { type: 'pattern', ...parsePatternContent(descriptor) };
+    }
+    else if ('Clr ' in descriptor) {
+        return { type: 'color', color: parseColor(descriptor['Clr ']) };
+    }
+    else {
+        throw new Error('Invalid vector content');
+    }
+}
+function serializeGradientContent(content) {
+    const result = {};
+    if (content.dither !== undefined)
+        result.Dthr = content.dither;
+    if (content.interpolationMethod !== undefined)
+        result.gradientsInterpolationMethod = gradientInterpolationMethodType.encode(content.interpolationMethod);
+    if (content.reverse !== undefined)
+        result.Rvrs = content.reverse;
+    if (content.angle !== undefined)
+        result.Angl = unitsAngle(content.angle);
+    result.Type = GrdT.encode(content.style);
+    if (content.align !== undefined)
+        result.Algn = content.align;
+    if (content.scale !== undefined)
+        result['Scl '] = unitsPercent(content.scale);
+    if (content.offset) {
+        result.Ofst = {
+            Hrzn: unitsPercent(content.offset.x),
+            Vrtc: unitsPercent(content.offset.y),
+        };
+    }
+    result.Grad = serializeGradient(content);
+    return result;
+}
+function serializePatternContent(content) {
+    const result = {
+        Ptrn: {
+            'Nm  ': content.name || '',
+            Idnt: content.id || '',
+        }
+    };
+    if (content.linked !== undefined)
+        result.Lnkd = !!content.linked;
+    if (content.phase !== undefined)
+        result.phase = { Hrzn: content.phase.x, Vrtc: content.phase.y };
+    return result;
+}
+export function serializeVectorContent(content) {
+    if (content.type === 'color') {
+        return { key: 'SoCo', descriptor: { 'Clr ': serializeColor(content.color) } };
+    }
+    else if (content.type === 'pattern') {
+        return { key: 'PtFl', descriptor: serializePatternContent(content) };
+    }
+    else {
+        return { key: 'GdFl', descriptor: serializeGradientContent(content) };
+    }
+}
+export function parseColor(color) {
+    if ('H   ' in color) {
+        return { h: parsePercentOrAngle(color['H   ']), s: color.Strt, b: color.Brgh };
+    }
+    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 };
+    }
+    else if ('Gry ' in color) {
+        return { k: color['Gry '] };
+    }
+    else if ('Lmnc' in color) {
+        return { l: color.Lmnc, a: color['A   '], b: color['B   '] };
+    }
+    else if ('redFloat' in color) {
+        return { fr: color.redFloat, fg: color.greenFloat, fb: color.blueFloat };
+    }
+    else {
+        throw new Error('Unsupported color descriptor');
+    }
+}
+export function serializeColor(color) {
+    if (!color) {
+        return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
+    }
+    else if ('r' in color) {
+        return { _name: '', _classID: 'RGBC', 'Rd  ': color.r || 0, 'Grn ': color.g || 0, 'Bl  ': color.b || 0 };
+    }
+    else if ('fr' in 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 };
+    }
+    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 };
+    }
+    else if ('l' in color) {
+        return { _name: '', _classID: 'LABC', Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
+    }
+    else if ('k' in color) {
+        return { _name: '', _classID: 'GRYC', 'Gry ': color.k };
+    }
+    else {
+        throw new Error('Invalid color value');
+    }
+}
+export function parseAngle(x) {
+    if (x === undefined)
+        return 0;
+    if (x.units !== 'Angle')
+        throw new Error(`Invalid units: ${x.units}`);
+    return x.value;
+}
+export function parsePercent(x) {
+    if (x === undefined)
+        return 1;
+    if (x.units !== 'Percent')
+        throw new Error(`Invalid units: ${x.units}`);
+    return x.value / 100;
+}
+export function parsePercentOrAngle(x) {
+    if (x === undefined)
+        return 1;
+    if (x.units === 'Percent')
+        return x.value / 100;
+    if (x.units === 'Angle')
+        return x.value / 360;
+    throw new Error(`Invalid units: ${x.units}`);
+}
+export function parseUnits({ units, value }) {
+    if (units !== 'Pixels' && units !== 'Millimeters' && units !== 'Points' && units !== 'None' &&
+        units !== 'Picas' && units !== 'Inches' && units !== 'Centimeters' && units !== 'Density') {
+        throw new Error(`Invalid units: ${JSON.stringify({ units, value })}`);
+    }
+    return { value, units };
+}
+export function parseUnitsOrNumber(value, units = 'Pixels') {
+    if (typeof value === 'number')
+        return { value, units };
+    return parseUnits(value);
+}
+export function parseUnitsToNumber({ units, value }, expectedUnits) {
+    if (units !== expectedUnits)
+        throw new Error(`Invalid units: ${JSON.stringify({ units, value })}`);
+    return value;
+}
+export function unitsAngle(value) {
+    return { units: 'Angle', value: value || 0 };
+}
+export function unitsPercent(value) {
+    return { units: 'Percent', value: Math.round((value || 0) * 100) };
+}
+export function unitsPercentF(value) {
+    return { units: 'Percent', value: (value || 0) * 100 };
+}
+export function unitsValue(x, key) {
+    if (x == null)
+        return { units: 'Pixels', value: 0 };
+    if (typeof x !== 'object')
+        throw new Error(`Invalid value: ${JSON.stringify(x)} (key: ${key}) (should have value and units)`);
+    const { units, value } = x;
+    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') {
+        throw new Error(`Invalid units in ${JSON.stringify(x)} (key: ${key})`);
+    }
+    return { units, value };
+}
+export function frac({ numerator, denominator }) {
+    return { numerator, denominator };
+}
+export const textGridding = createEnum('textGridding', 'none', {
+    none: 'None',
+    round: 'Rnd ',
+});
+export const Ornt = createEnum('Ornt', 'horizontal', {
+    horizontal: 'Hrzn',
+    vertical: 'Vrtc',
+});
+export const Annt = createEnum('Annt', 'sharp', {
+    none: 'Anno',
+    sharp: 'antiAliasSharp',
+    crisp: 'AnCr',
+    strong: 'AnSt',
+    smooth: 'AnSm',
+    platform: 'antiAliasPlatformGray',
+    platformLCD: 'antiAliasPlatformLCD',
+});
+export const warpStyle = createEnum('warpStyle', 'none', {
+    none: 'warpNone',
+    arc: 'warpArc',
+    arcLower: 'warpArcLower',
+    arcUpper: 'warpArcUpper',
+    arch: 'warpArch',
+    bulge: 'warpBulge',
+    shellLower: 'warpShellLower',
+    shellUpper: 'warpShellUpper',
+    flag: 'warpFlag',
+    wave: 'warpWave',
+    fish: 'warpFish',
+    rise: 'warpRise',
+    fisheye: 'warpFisheye',
+    inflate: 'warpInflate',
+    squeeze: 'warpSqueeze',
+    twist: 'warpTwist',
+    cylinder: 'warpCylinder',
+    custom: 'warpCustom',
+});
+export const BlnM = createEnum('BlnM', 'normal', {
+    'normal': 'Nrml',
+    'dissolve': 'Dslv',
+    'darken': 'Drkn',
+    'multiply': 'Mltp',
+    'color burn': 'CBrn',
+    'linear burn': 'linearBurn',
+    'darker color': 'darkerColor',
+    'lighten': 'Lghn',
+    'screen': 'Scrn',
+    'color dodge': 'CDdg',
+    'linear dodge': 'linearDodge',
+    'lighter color': 'lighterColor',
+    'overlay': 'Ovrl',
+    'soft light': 'SftL',
+    'hard light': 'HrdL',
+    'vivid light': 'vividLight',
+    'linear light': 'linearLight',
+    'pin light': 'pinLight',
+    'hard mix': 'hardMix',
+    'difference': 'Dfrn',
+    'exclusion': 'Xclu',
+    'subtract': 'blendSubtraction',
+    'divide': 'blendDivide',
+    'hue': 'H   ',
+    'saturation': 'Strt',
+    'color': 'Clr ',
+    'luminosity': 'Lmns',
+    // used in ABR
+    'linear height': 'linearHeight',
+    'height': 'Hght',
+    'subtraction': 'Sbtr', // 2nd version of subtract ?
+});
+export const BESl = createEnum('BESl', 'inner bevel', {
+    'inner bevel': 'InrB',
+    'outer bevel': 'OtrB',
+    'emboss': 'Embs',
+    'pillow emboss': 'PlEb',
+    'stroke emboss': 'strokeEmboss',
+});
+export const bvlT = createEnum('bvlT', 'smooth', {
+    'smooth': 'SfBL',
+    'chisel hard': 'PrBL',
+    'chisel soft': 'Slmt',
+});
+export const BESs = createEnum('BESs', 'up', {
+    up: 'In  ',
+    down: 'Out ',
+});
+export const BETE = createEnum('BETE', 'softer', {
+    softer: 'SfBL',
+    precise: 'PrBL',
+});
+export const IGSr = createEnum('IGSr', 'edge', {
+    edge: 'SrcE',
+    center: 'SrcC',
+});
+export const GrdT = createEnum('GrdT', 'linear', {
+    linear: 'Lnr ',
+    radial: 'Rdl ',
+    angle: 'Angl',
+    reflected: 'Rflc',
+    diamond: 'Dmnd',
+});
+export const animInterpStyleEnum = createEnum('animInterpStyle', 'linear', {
+    linear: 'Lnr ',
+    hold: 'hold',
+});
+export const stdTrackID = createEnum('stdTrackID', 'opacity', {
+    opacity: 'opacityTrack',
+    style: 'styleTrack',
+    sheetTransform: 'sheetTransformTrack',
+    sheetPosition: 'sheetPositionTrack',
+    globalLighting: 'globalLightingTrack',
+});
+export const gradientInterpolationMethodType = createEnum('gradientInterpolationMethodType', 'perceptual', {
+    perceptual: 'Perc',
+    linear: 'Lnr ',
+    classic: 'Gcls',
+    smooth: 'Smoo',
+    // TODO: stripes
+});
+export const ClrS = createEnum('ClrS', 'rgb', {
+    rgb: 'RGBC',
+    hsb: 'HSBl',
+    lab: 'LbCl',
+    hsl: 'HSLC',
+});
+export const FStl = createEnum('FStl', 'outside', {
+    outside: 'OutF',
+    center: 'CtrF',
+    inside: 'InsF'
+});
+export const FrFl = createEnum('FrFl', 'color', {
+    color: 'SClr',
+    gradient: 'GrFl',
+    pattern: 'Ptrn',
+});
+export const ESliceType = createEnum('ESliceType', 'image', {
+    image: 'Img ',
+    noImage: 'noImage',
+});
+export const ESliceHorzAlign = createEnum('ESliceHorzAlign', 'default', {
+    default: 'default',
+});
+export const ESliceVertAlign = createEnum('ESliceVertAlign', 'default', {
+    default: 'default',
+});
+export const ESliceOrigin = createEnum('ESliceOrigin', 'userGenerated', {
+    userGenerated: 'userGenerated',
+    autoGenerated: 'autoGenerated',
+    layer: 'layer',
+});
+export const ESliceBGColorType = createEnum('ESliceBGColorType', 'none', {
+    none: 'None',
+    matte: 'matte',
+    color: 'Clr ',
+});
+export const strokeStyleLineCapType = createEnum('strokeStyleLineCapType', 'butt', {
+    butt: 'strokeStyleButtCap',
+    round: 'strokeStyleRoundCap',
+    square: 'strokeStyleSquareCap',
+});
+export const strokeStyleLineJoinType = createEnum('strokeStyleLineJoinType', 'miter', {
+    miter: 'strokeStyleMiterJoin',
+    round: 'strokeStyleRoundJoin',
+    bevel: 'strokeStyleBevelJoin',
+});
+export const strokeStyleLineAlignment = createEnum('strokeStyleLineAlignment', 'inside', {
+    inside: 'strokeStyleAlignInside',
+    center: 'strokeStyleAlignCenter',
+    outside: 'strokeStyleAlignOutside',
+});
+export const BlrM = createEnum('BlrM', 'ispinmage', {
+    spin: 'Spn ',
+    zoom: 'Zm  ',
+});
+export const BlrQ = createEnum('BlrQ', 'good', {
+    draft: 'Drft',
+    good: 'Gd  ',
+    best: 'Bst ',
+});
+export const SmBM = createEnum('SmBM', 'normal', {
+    normal: 'SBMN',
+    'edge only': 'SBME',
+    'overlay edge': 'SBMO',
+});
+export const SmBQ = createEnum('SmBQ', 'medium', {
+    low: 'SBQL',
+    medium: 'SBQM',
+    high: 'SBQH',
+});
+export const DspM = createEnum('DspM', 'stretch to fit', {
+    'stretch to fit': 'StrF',
+    'tile': 'Tile',
+});
+export const UndA = createEnum('UndA', 'repeat edge pixels', {
+    'wrap around': 'WrpA',
+    'repeat edge pixels': 'RptE',
+});
+export const Cnvr = createEnum('Cnvr', 'rectangular to polar', {
+    'rectangular to polar': 'RctP',
+    'polar to rectangular': 'PlrR',
+});
+export const RplS = createEnum('RplS', 'medium', {
+    small: 'Sml ',
+    medium: 'Mdm ',
+    large: 'Lrg ',
+});
+export const SphM = createEnum('SphM', 'normal', {
+    'normal': 'Nrml',
+    'horizontal only': 'HrzO',
+    'vertical only': 'VrtO',
+});
+export const Wvtp = createEnum('Wvtp', 'sine', {
+    sine: 'WvSn',
+    triangle: 'WvTr',
+    square: 'WvSq',
+});
+export const ZZTy = createEnum('ZZTy', 'pond ripples', {
+    'around center': 'ArnC',
+    'out from center': 'OtFr',
+    'pond ripples': 'PndR',
+});
+export const Dstr = createEnum('Dstr', 'uniform', {
+    uniform: 'Unfr',
+    gaussian: 'Gsn ',
+});
+export const Chnl = createEnum('Chnl', 'composite', {
+    red: 'Rd  ',
+    green: 'Grn ',
+    blue: 'Bl  ',
+    composite: 'Cmps',
+});
+export const MztT = createEnum('MztT', 'fine dots', {
+    'fine dots': 'FnDt',
+    'medium dots': 'MdmD',
+    'grainy dots': 'GrnD',
+    'coarse dots': 'CrsD',
+    'short lines': 'ShrL',
+    'medium lines': 'MdmL',
+    'long lines': 'LngL',
+    'short strokes': 'ShSt',
+    'medium strokes': 'MdmS',
+    'long strokes': 'LngS',
+});
+export const Lns = createEnum('Lns ', '50-300mm zoom', {
+    '50-300mm zoom': 'Zm  ',
+    '32mm prime': 'Nkn ',
+    '105mm prime': 'Nkn1',
+    'movie prime': 'PnVs',
+});
+export const blurType = createEnum('blurType', 'gaussian blur', {
+    'gaussian blur': 'GsnB',
+    'lens blur': 'lensBlur',
+    'motion blur': 'MtnB',
+});
+export const DfsM = createEnum('DfsM', 'normal', {
+    'normal': 'Nrml',
+    'darken only': 'DrkO',
+    'lighten only': 'LghO',
+    'anisotropic': 'anisotropic',
+});
+export const ExtT = createEnum('ExtT', 'blocks', {
+    blocks: 'Blks',
+    pyramids: 'Pyrm',
+});
+export const ExtR = createEnum('ExtR', 'random', {
+    random: 'Rndm',
+    'level-based': 'LvlB',
+});
+export const FlCl = createEnum('FlCl', 'background color', {
+    'background color': 'FlBc',
+    'foreground color': 'FlFr',
+    'inverse image': 'FlIn',
+    'unaltered image': 'FlSm',
+});
+export const CntE = createEnum('CntE', 'upper', {
+    lower: 'Lwr ',
+    upper: 'Upr ',
+});
+export const WndM = createEnum('WndM', 'wind', {
+    wind: 'Wnd ',
+    blast: 'Blst',
+    stagger: 'Stgr',
+});
+export const Drct = createEnum('Drct', 'from the right', {
+    left: 'Left',
+    right: 'Rght',
+});
+export const IntE = createEnum('IntE', 'odd lines', {
+    'odd lines': 'ElmO',
+    'even lines': 'ElmE',
+});
+export const IntC = createEnum('IntC', 'interpolation', {
+    duplication: 'CrtD',
+    interpolation: 'CrtI',
+});
+export const FlMd = createEnum('FlMd', 'wrap around', {
+    'set to transparent': 'Bckg',
+    'repeat edge pixels': 'Rpt ',
+    'wrap around': 'Wrp ',
+});
+export const prjM = createEnum('prjM', 'fisheye', {
+    'fisheye': 'fisP',
+    'perspective': 'perP',
+    'auto': 'auto',
+    'full spherical': 'fusP',
+});
+export const presetKindType = createEnum('presetKindType', 'presetKindCustom', {
+    custom: 'presetKindCustom',
+    default: 'presetKindDefault',
+});