ag-psd 16.0.0 → 17.0.1

package/dist-es/descriptor.js

@@ -10,8 +10,8 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { createEnum } from './helpers';
-import { readSignature, readUnicodeString, readUint32, readUint8, readFloat64, readBytes, readAsciiString, readInt32, readFloat32, readInt32LE, readUnicodeStringWithLength } from './psdReader';
-import { writeSignature, writeBytes, writeUint32, writeFloat64, writeUint8, writeUnicodeStringWithPadding, writeInt32, writeFloat32, writeUnicodeString } from './psdWriter';
+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) {
     var result = {};
     Object.keys(map).forEach(function (key) { return result[map[key]] = key; });
@@ -102,6 +102,7 @@ var fieldToExtType = {
     sheetStyle: nullType,
     translation: nullType,
     Skew: nullType,
+    boundingBox: makeType('', 'boundingBox'),
     'Lnk ': makeType('', 'ExternalFileLink'),
     frameReader: makeType('', 'FrameReader'),
     effectParams: makeType('', 'motionTrackEffectParams'),
@@ -109,11 +110,15 @@ var fieldToExtType = {
     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'),
 };
 var fieldToArrayExtType = {
     'Crv ': makeType('', 'CrPt'),
@@ -142,15 +147,20 @@ var fieldToArrayExtType = {
     pathComponents: makeType('', 'PaCm'),
     filterFXList: makeType('', 'filterFX'),
     puppetShapeList: makeType('', 'puppetShape'),
+    channelDenoise: makeType('', 'channelDenoiseParams'),
+    ShrP: makeType('', 'Pnt '),
 };
 var typeToField = {
     'TEXT': [
         'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
         'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
         'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
-        'altTag', 'url', 'cellText',
+        'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth',
+    ],
+    'tdta': [
+        'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
+        'LqMe',
     ],
-    'tdta': ['EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray'],
     'long': [
         'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
         'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
@@ -161,16 +171,19 @@ var typeToField = {
         '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',
+        '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',
     ],
     'enum': [
-        'textGridding', 'Ornt', 'warpStyle', 'warpRotate', 'Inte', 'Bltn', 'ClrS',
-        'sdwM', 'hglM', 'bvlT', 'bvlS', 'bvlD', 'Md  ', 'glwS', 'GrdF', 'GlwT',
+        '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',
+        'vertAlign', 'bgColorType', 'shapeOperation', 'UndA', 'Wvtp', 'Drct', 'WndM', 'Edg ', 'FlCl', 'IntE',
+        'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ',
     ],
     'bool': [
         'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -182,7 +195,8 @@ var typeToField = {
         'present', 'showInDialog', 'overprint', 'sheetDisclosed', 'lightsDisclosed', 'meshesDisclosed',
         'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
         'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
-        'filterMaskLinked', 'filterMaskExtendWithWhite',
+        'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
+        'moreAccurate', 'GpuY', 'LIWy',
     ],
     'doub': [
         'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
@@ -192,10 +206,10 @@ var typeToField = {
         'PuX0', 'PuX1', 'PuX2', 'PuX3', 'PuY0', 'PuY1', 'PuY2', 'PuY3'
     ],
     'UntF': [
-        'Scl ', 'sdwO', 'hglO', 'lagl', 'Lald', 'srgR', 'blur', 'Sftn', 'Opct', 'Dstn', 'Angl',
+        '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',
+        'topRight', 'topLeft', 'bottomLeft', 'bottomRight', 'ClNs', 'Shrp',
     ],
     'VlLs': [
         'Crv ', 'Clrs', 'Mnm ', 'Mxm ', 'Trns', 'pathList', 'strokeStyleLineDashSet', 'FrLs', 'slices',
@@ -203,10 +217,12 @@ var typeToField = {
         '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',
+        'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
+        'channelDenoise', 'Mtrx',
     ],
     'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
-    'obj ': ['null'],
+    'obj ': ['null', 'Chnl'],
+    'Pth ': ['DspF'],
 };
 var channels = [
     'Rd  ', 'Grn ', 'Bl  ', 'Yllw', 'Ylw ', 'Cyn ', 'Mgnt', 'Blck', 'Gry ', 'Lmnc', 'A   ', 'B   ',
@@ -245,6 +261,9 @@ var fieldToArrayType = {
     PnDp: 'doub',
     filterFXList: 'Objc',
     puppetShapeList: 'Objc',
+    ShrP: 'Objc',
+    channelDenoise: 'Objc',
+    Mtrx: 'long',
 };
 var fieldToType = {};
 for (var _i = 0, _a = Object.keys(typeToField); _i < _a.length; _i++) {
@@ -319,11 +338,12 @@ function writeAsciiStringOrClassId(writer, value) {
     }
 }
 export function readDescriptorStructure(reader) {
-    var object = {};
-    // object.__struct =
+    // const struct =
     readClassStructure(reader);
+    // const object: any = { _name: struct.name, _classID: struct.classID };
+    var object = {};
+    // console.log('>> ', struct);
     var itemsCount = readUint32(reader);
-    // console.log('//', object.__struct);
     for (var i = 0; i < itemsCount; i++) {
         var key = readAsciiStringOrClassId(reader);
         var type = readSignature(reader);
@@ -341,21 +361,63 @@ export function writeDescriptorStructure(writer, name, classId, value, root) {
     writeUnicodeStringWithPadding(writer, name);
     writeAsciiStringOrClassId(writer, classId);
     var keys = Object.keys(value);
-    writeUint32(writer, keys.length);
+    var keyCount = keys.length;
+    if ('_name' in value)
+        keyCount--;
+    if ('_classID' in value)
+        keyCount--;
+    writeUint32(writer, keyCount);
     for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
         var key = keys_1[_i];
+        if (key === '_name' || key === '_classID')
+            continue;
         var type = getTypeByKey(key, value[key], root, value);
         var extType = fieldToExtType[key];
-        if (key === 'origin') {
+        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 === '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 === 'Angl' && typeof value[key] === 'number') {
+            type = 'doub'; // ???
+        }
         else if (key === 'bounds' && root === 'slices') {
             type = 'Objc';
             extType = makeType('', 'Rct1');
         }
-        else if (key === 'Scl ' && 'Hrzn' in value[key]) {
-            type = 'Objc';
-            extType = nullType;
+        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';
@@ -363,7 +425,13 @@ export function writeDescriptorStructure(writer, name, classId, value, root) {
         else if ((key === 'Strt' || key === 'Brgh') && 'H   ' in value) {
             type = 'doub';
         }
-        else if (key === 'Strt') {
+        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;
         }
@@ -482,11 +550,11 @@ function readOSType(reader, type) {
             return items;
         }
         case 'Pth ': { // File path
-            /*const length =*/ readInt32(reader);
+            /*const length =*/ readInt32(reader); // total size of all fields below
             var sig = readSignature(reader);
-            /*const pathSize =*/ readInt32LE(reader);
+            /*const pathSize =*/ readInt32LE(reader); // the same as length
             var charsCount = readInt32LE(reader);
-            var path = readUnicodeStringWithLength(reader, charsCount);
+            var path = readUnicodeStringWithLengthLE(reader, charsCount);
             return { sig: sig, path: path };
         }
         default:
@@ -504,12 +572,19 @@ function writeOSType(writer, type, value, key, extType, root) {
             writeReferenceStructure(writer, key, value);
             break;
         case 'Objc': // Descriptor
-        case 'GlbO': // GlobalObject same as Descriptor
+        case 'GlbO': { // GlobalObject same as Descriptor
+            if (typeof value !== 'object')
+                throw new Error("Invalid struct value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             if (!extType)
                 throw new Error("Missing ext type for: '".concat(key, "' (").concat(JSON.stringify(value), ")"));
-            writeDescriptorStructure(writer, extType.name, extType.classID, value, root);
+            var name_1 = value._name || extType.name;
+            var classID = value._classID || extType.classID;
+            writeDescriptorStructure(writer, name_1, classID, value, root);
             break;
+        }
         case 'VlLs': // List
+            if (!Array.isArray(value))
+                throw new Error("Invalid list value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             writeInt32(writer, value.length);
             for (var i = 0; i < value.length; i++) {
                 var type_3 = fieldToArrayType[key];
@@ -520,6 +595,8 @@ function writeOSType(writer, type, value, key, extType, root) {
             }
             break;
         case 'doub': // Double
+            if (typeof value !== 'number')
+                throw new Error("Invalid number value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             writeFloat64(writer, value);
             break;
         case 'UntF': // Unit double
@@ -538,17 +615,23 @@ function writeOSType(writer, type, value, key, extType, root) {
             writeUnicodeStringWithPadding(writer, value);
             break;
         case 'enum': { // Enumerated
+            if (typeof value !== 'string')
+                throw new Error("Invalid enum value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             var _a = value.split('.'), _type = _a[0], val = _a[1];
             writeAsciiStringOrClassId(writer, _type);
             writeAsciiStringOrClassId(writer, val);
             break;
         }
         case 'long': // Integer
+            if (typeof value !== 'number')
+                throw new Error("Invalid integer value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             writeInt32(writer, value);
             break;
         // case 'comp': // Large Integer
         // 	writeLargeInteger(reader);
         case 'bool': // Boolean
+            if (typeof value !== 'boolean')
+                throw new Error("Invalid boolean value: ".concat(JSON.stringify(value), ", key: ").concat(key));
             writeUint8(writer, value ? 1 : 0);
             break;
         // case 'type': // Class
@@ -579,8 +662,15 @@ function writeOSType(writer, type, value, key, extType, root) {
             }
             break;
         }
-        // case 'Pth ': // File path
-        // 	writeFilePath(reader);
+        case 'Pth ': { // File path
+            var length_5 = 4 + 4 + 4 + value.path.length * 2;
+            writeInt32(writer, length_5);
+            writeSignature(writer, value.sig);
+            writeInt32LE(writer, length_5);
+            writeInt32LE(writer, value.path.length);
+            writeUnicodeStringWithoutLengthLE(writer, value.path);
+            break;
+        }
         default:
             throw new Error("Not implemented descriptor OSType: ".concat(type));
     }
@@ -671,7 +761,6 @@ function writeReferenceStructure(writer, _key, items) {
 function readClassStructure(reader) {
     var name = readUnicodeString(reader);
     var classID = readAsciiStringOrClassId(reader);
-    // console.log({ name, classID });
     return { name: name, classID: classID };
 }
 function writeClassStructure(writer, name, classID) {
@@ -697,6 +786,24 @@ export function horzVrtcToXY(hv) {
 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) {
+    var _a;
+    return _a = {
+            Left: unitsValue(bounds.left, 'bounds.left')
+        },
+        _a['Top '] = unitsValue(bounds.top, 'bounds.top'),
+        _a.Rght = unitsValue(bounds.right, 'bounds.right'),
+        _a.Btom = unitsValue(bounds.bottom, 'bounds.bottom'),
+        _a;
+}
 function parseFxObject(fx) {
     var stroke = {
         enabled: !!fx.enab,
@@ -845,7 +952,8 @@ function parseKeyList(keyList, logMissingFeatures) {
     var keys = [];
     for (var j = 0; j < keyList.length; j++) {
         var key = keyList[j];
-        var time = key.time, selected = key.selected, animKey = key.animKey;
+        var _a = key.time, denominator = _a.denominator, numerator = _a.numerator, selected = key.selected, animKey = key.animKey;
+        var time = { numerator: numerator, denominator: denominator };
         var interpolation = animInterpStyleEnum.decode(key.animInterpStyle);
         switch (animKey.Type) {
             case 'keyType.Opct':
@@ -1092,6 +1200,9 @@ function parseEffectObject(obj, reportErrors) {
             case 'antialiasGloss':
                 result[key] = val;
                 break;
+            case '_name':
+            case '_classID':
+                break;
             default:
                 reportErrors && console.log("Invalid effect key: '".concat(key, "', value:"), val);
         }
@@ -1441,25 +1552,25 @@ export function parseColor(color) {
 }
 export function serializeColor(color) {
     if (!color) {
-        return { 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
+        return { _name: '', _classID: 'RGBC', 'Rd  ': 0, 'Grn ': 0, 'Bl  ': 0 };
     }
     else if ('r' in color) {
-        return { 'Rd  ': color.r || 0, 'Grn ': color.g || 0, 'Bl  ': color.b || 0 };
+        return { _name: '', _classID: 'RGBC', 'Rd  ': color.r || 0, 'Grn ': color.g || 0, 'Bl  ': color.b || 0 };
     }
     else if ('fr' in color) {
-        return { redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
+        return { _name: '', _classID: 'XXXX', redFloat: color.fr, greenFloat: color.fg, blueFloat: color.fb };
     }
     else if ('h' in color) {
-        return { 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
+        return { _name: '', _classID: 'HSBC', 'H   ': unitsAngle(color.h * 360), Strt: color.s || 0, Brgh: color.b || 0 };
     }
     else if ('c' in color) {
-        return { 'Cyn ': color.c || 0, Mgnt: color.m || 0, 'Ylw ': color.y || 0, Blck: color.k || 0 };
+        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 { Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
+        return { _name: '', _classID: 'LABC', Lmnc: color.l || 0, 'A   ': color.a || 0, 'B   ': color.b || 0 };
     }
     else if ('k' in color) {
-        return { 'Gry ': color.k };
+        return { _name: '', _classID: 'GRYC', 'Gry ': color.k };
     }
     else {
         throw new Error('Invalid color value');
@@ -1514,6 +1625,9 @@ export function unitsAngle(value) {
 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 };
@@ -1528,6 +1642,10 @@ export function unitsValue(x, key) {
     }
     return { units: units, value: value };
 }
+export function frac(_a) {
+    var numerator = _a.numerator, denominator = _a.denominator;
+    return { numerator: numerator, denominator: denominator };
+}
 export var textGridding = createEnum('textGridding', 'none', {
     none: 'None',
     round: 'Rnd ',
@@ -1649,6 +1767,7 @@ export var ClrS = createEnum('ClrS', 'rgb', {
     rgb: 'RGBC',
     hsb: 'HSBl',
     lab: 'LbCl',
+    hsl: 'HSLC',
 });
 export var FStl = createEnum('FStl', 'outside', {
     outside: 'OutF',
@@ -1695,4 +1814,140 @@ export var strokeStyleLineAlignment = createEnum('strokeStyleLineAlignment', 'in
     center: 'strokeStyleAlignCenter',
     outside: 'strokeStyleAlignOutside',
 });
+export var BlrM = createEnum('BlrM', 'ispinmage', {
+    spin: 'Spn ',
+    zoom: 'Zm  ',
+});
+export var BlrQ = createEnum('BlrQ', 'good', {
+    draft: 'Drft',
+    good: 'Gd  ',
+    best: 'Bst ',
+});
+export var SmBM = createEnum('SmBM', 'normal', {
+    normal: 'SBMN',
+    'edge only': 'SBME',
+    'overlay edge': 'SBMO',
+});
+export var SmBQ = createEnum('SmBQ', 'medium', {
+    low: 'SBQL',
+    medium: 'SBQM',
+    high: 'SBQH',
+});
+export var DspM = createEnum('DspM', 'stretch to fit', {
+    'stretch to fit': 'StrF',
+    'tile': 'Tile',
+});
+export var UndA = createEnum('UndA', 'repeat edge pixels', {
+    'wrap around': 'WrpA',
+    'repeat edge pixels': 'RptE',
+});
+export var Cnvr = createEnum('Cnvr', 'rectangular to polar', {
+    'rectangular to polar': 'RctP',
+    'polar to rectangular': 'PlrR',
+});
+export var RplS = createEnum('RplS', 'medium', {
+    small: 'Sml ',
+    medium: 'Mdm ',
+    large: 'Lrg ',
+});
+export var SphM = createEnum('SphM', 'normal', {
+    'normal': 'Nrml',
+    'horizontal only': 'HrzO',
+    'vertical only': 'VrtO',
+});
+export var Wvtp = createEnum('Wvtp', 'sine', {
+    sine: 'WvSn',
+    triangle: 'WvTr',
+    square: 'WvSq',
+});
+export var ZZTy = createEnum('ZZTy', 'pond ripples', {
+    'around center': 'ArnC',
+    'out from center': 'OtFr',
+    'pond ripples': 'PndR',
+});
+export var Dstr = createEnum('Dstr', 'uniform', {
+    uniform: 'Unfr',
+    gaussian: 'Gsn ',
+});
+export var Chnl = createEnum('Chnl', 'composite', {
+    red: 'Rd  ',
+    green: 'Grn ',
+    blue: 'Bl  ',
+    composite: 'Cmps',
+});
+export var 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 var Lns = createEnum('Lns ', '50-300mm zoom', {
+    '50-300mm zoom': 'Zm  ',
+    '32mm prime': 'Nkn ',
+    '105mm prime': 'Nkn1',
+    'movie prime': 'PnVs',
+});
+export var blurType = createEnum('blurType', 'gaussian blur', {
+    'gaussian blur': 'GsnB',
+    'lens blur': 'lensBlur',
+    'motion blur': 'MtnB',
+});
+export var DfsM = createEnum('DfsM', 'normal', {
+    'normal': 'Nrml',
+    'darken only': 'DrkO',
+    'lighten only': 'LghO',
+    'anisotropic': 'anisotropic',
+});
+export var ExtT = createEnum('ExtT', 'blocks', {
+    blocks: 'Blks',
+    pyramids: 'Pyrm',
+});
+export var ExtR = createEnum('ExtR', 'random', {
+    random: 'Rndm',
+    'level-based': 'LvlB',
+});
+export var FlCl = createEnum('FlCl', 'background color', {
+    'background color': 'FlBc',
+    'foreground color': 'FlFr',
+    'inverse image': 'FlIn',
+    'unaltered image': 'FlSm',
+});
+export var CntE = createEnum('CntE', 'upper', {
+    lower: 'Lwr ',
+    upper: 'Upr ',
+});
+export var WndM = createEnum('WndM', 'wind', {
+    wind: 'Wnd ',
+    blast: 'Blst',
+    stagger: 'Stgr',
+});
+export var Drct = createEnum('Drct', 'from the right', {
+    left: 'Left',
+    right: 'Rght',
+});
+export var IntE = createEnum('IntE', 'odd lines', {
+    'odd lines': 'ElmO',
+    'even lines': 'ElmE',
+});
+export var IntC = createEnum('IntC', 'interpolation', {
+    duplication: 'CrtD',
+    interpolation: 'CrtI',
+});
+export var FlMd = createEnum('FlMd', 'wrap around', {
+    'set to transparent': 'Bckg',
+    'repeat edge pixels': 'Rpt ',
+    'wrap around': 'Wrp ',
+});
+export var prjM = createEnum('prjM', 'fisheye', {
+    'fisheye': 'fisP',
+    'perspective': 'perP',
+    'auto': 'auto',
+    'full spherical': 'fusP',
+});
 //# sourceMappingURL=descriptor.js.map