其他分享
首页 > 其他分享> > Photoshop插件--2分频 肖像滤镜 | 自动蒙板--脚本开发--PS插件

Photoshop插件--2分频 肖像滤镜 | 自动蒙板--脚本开发--PS插件

作者:互联网

文章目录


  PS是一款栅格图像编辑软件,具有许多强大的功能,本文演示如何通过脚本实现2分频 肖像滤镜 | 自动蒙板相关功能,展示从互联网收集而来的一个小插件,供大家学习交流,请勿用于商业用途。

1.插件界面

  本文界面是一系列功能的一部分,将逐步展示,但是功能界面是共同的,如下图所示:
在这里插入图片描述

2.关键代码

  大家可通过源代码阅读,来掌握相关技巧,大部分源代码如下(代码太多无法显示,想参考的读者可以私信作者获取):


if (ScriptUI.environment.keyboardState.shiftKey) {
    if (app.documents.length > 0) {
        if (bits() == 8) {
            if (bounds()) {
                try {
                    FS_TWOFS8();
                } catch (e) {

                }
            } else {
                try {
                    FS_SIMPLE8();
                } catch (e) {

                }
            }
        } else {
            if (app.documents.length > 0) {
                if (bits() == 16) {
                    if (bounds()) {
                        try {
                            FS_TWOFS16();
                        } catch (e) {

                        }
                    } else {
                        try {
                            FS_SIMPLE16();
                        } catch (e) {

                        }
                    }
                }
            }
        }
    }

    function FS_SIMPLE8() {
        if (typeof jamEngine !== "object") {
            var jamEngine = {};

            function() {
                jamEngine.meaningfulIds = false;
                jamEngine.parseFriendly = false;
                jamEngine.displayDialogs = DialogModes.ERROR;
                var conflictingStringIdStrs = {
                    "'Algn'": ["align", "alignment"],
                    "'AntA'": ["antiAlias", "antiAliasedPICTAcquire"],
                    "'BckL'": ["backgroundLayer", "backgroundLevel"],
                    "'BlcG'": ["blackGenerationType", "blackGenerationCurve"],
                    "'BlcL'": ["blackLevel", "blackLimit"],
                    "'Blks'": ["blacks", "blocks"],
                    "'BlrM'": ["blurMethod", "blurMore"],
                    "'BrgC'": ["brightnessEvent", "brightnessContrast"],
                    "'BrsD'": ["brushDetail", "brushesDefine"],
                    "'Brsh'": ["brush", "brushes"],
                    "'Clcl'": ["calculation", "calculations"],
                    "'ClrP'": ["colorPalette", "coloredPencil"],
                    "'Cnst'": ["constant", "constrain"],
                    "'CntC'": ["centerCropMarks", "conteCrayon"],
                    "'Cntr'": ["center", "contrast"],
                    "'CrtD'": ["createDroplet", "createDuplicate"],
                    "'CstP'": ["customPalette", "customPhosphors"],
                    "'Cstm'": ["custom", "customPattern"],
                    "'Drkn'": ["darken", "darkness"],
                    "'Dstr'": ["distort", "distortion", "distribute", "distribution"],
                    "'Dstt'": ["desaturate", "destWhiteMax"],
                    "'FlIn'": ["fileInfo", "fillInverse"],
                    "'Gd  '": ["good", "guide"],
                    "'GnrP'": ["generalPreferences", "generalPrefs", "preferencesClass"],
                    "'GrSt'": ["grainStippled", "graySetup"],
                    "'Grdn'": ["gradientClassEvent", "gridMinor"],
                    "'Grn '": ["grain", "green"],
                    "'Grns'": ["graininess", "greens"],
                    "'HstP'": ["historyPreferences", "historyPrefs"],
                    "'HstS'": ["historyState", "historyStateSourceType"],
                    "'ImgP'": ["imageCachePreferences", "imagePoint"],
                    "'In  '": ["in", "stampIn"],
                    "'IntW'": ["interfaceWhite", "intersectWith"],
                    "'Intr'": ["interfaceIconFrameDimmed", "interlace", "interpolation", "intersect"],
                    "'JPEG'": ["JPEG", "JPEGFormat"],
                    "'LghD'": ["lightDirection", "lightDirectional"],
                    "'LghO'": ["lightOmni", "lightenOnly"],
                    "'LghS'": ["lightSource", "lightSpot"],
                    "'Lns '": ["lens", "lines"],
                    "'Mgnt'": ["magenta", "magentas"],
                    "'MrgL'": ["mergeLayers", "mergedLayers"],
                    "'Mxm '": ["maximum", "maximumQuality"],
                    "'NTSC'": ["NTSC", "NTSCColors"],
                    "'NmbL'": ["numberOfLayers", "numberOfLevels"],
                    "'PlgP'": ["pluginPicker", "pluginPrefs"],
                    "'Pncl'": ["pencilEraser", "pencilWidth"],
                    "'Pnt '": ["paint", "point"],
                    "'Prsp'": ["perspective", "perspectiveIndex"],
                    "'PrvM'": ["previewMacThumbnail", "previewMagenta"],
                    "'Pstr'": ["posterization", "posterize"],
                    "'RGBS'": ["RGBSetup", "RGBSetupSource"],
                    "'Rds '": ["radius", "reds"],
                    "'ScrD'": ["scratchDisks", "screenDot"],
                    "'ShdI'": ["shadingIntensity", "shadowIntensity"],
                    "'ShpC'": ["shapeCurveType", "shapingCurve"],
                    "'ShrE'": ["sharpenEdges", "shearEd"],
                    "'Shrp'": ["sharpen", "sharpness"],
                    "'SplC'": ["splitChannels", "supplementalCategories"],
                    "'Spot'": ["spot", "spotColor"],
                    "'SprS'": ["separationSetup", "sprayedStrokes"],
                    "'StrL'": ["strokeLength", "strokeLocation"],
                    "'Strt'": ["saturation", "start"],
                    "'TEXT'": ["char", "textType"],
                    "'TIFF'": ["TIFF", "TIFFFormat"],
                    "'TglO'": ["toggleOptionsPalette", "toggleOthers"],
                    "'TrnG'": ["transparencyGamutPreferences", "transparencyGrid", "transparencyGridSize"],
                    "'TrnS'": ["transferSpec", "transparencyShape", "transparencyStop"],
                    "'Trns'": ["transparency", "transparent"],
                    "'TxtC'": ["textClickPoint", "textureCoverage"],
                    "'TxtF'": ["textureFile", "textureFill"],
                    "'UsrM'": ["userMaskEnabled", "userMaskOptions"],
                    "'c@#^'": ["inherits", "pInherits"],
                    "'comp'": ["comp", "sInt64"],
                    "'doub'": ["floatType", "IEEE64BitFloatingPoint", "longFloat"],
                    "'long'": ["integer", "longInteger", "sInt32"],
                    "'magn'": ["magnitude", "uInt32"],
                    "'null'": ["null", "target"],
                    "'shor'": ["sInt16", "sMInt", "shortInteger"],
                    "'sing'": ["IEEE32BitFloatingPoint", "sMFloat", "shortFloat"]
                };
                jamEngine.getConflictingStringIdStrs = function(charIdStr) {
                    return conflictingStringIdStrs[charIdStr] || null;
                };
                jamEngine.uniIdStrToId = function(uniIdStr) {
                    var id = 0;
                    if (typeof uniIdStr === "string") {
                        if (uniIdStr.length === 6 && uniIdStr.charAt(0) === "'" && uniIdStr.charAt(5) === "'") {
                            id = app.charIDToTypeID(uniIdStr.substring(1, 5));
                        } else {
                            id = app.stringIDToTypeID(uniIdStr);
                        }
                    }
                    return id;
                };
                var smallestHashValue = app.charIDToTypeID("    ");
                jamEngine.idToUniIdStrs = function(id) {
                    var charIdStr = "";
                    var stringIdStr = app.typeIDToStringID(id);
                    if (id >= smallestHashValue) {
                        charIdStr = "'" + app.typeIDToCharID(id) + "'";
                        if (stringIdStr !== "") {
                            if (charIdStr in conflictingStringIdStrs) {
                                stringIdStr = conflictingStringIdStrs[charIdStr];
                            }
                        }
                    }
                    return [charIdStr, stringIdStr];
                };
                jamEngine.equivalentUniIdStrs = function(uniIdStr1, uniIdStr2) {
                    return this.uniIdStrToId(uniIdStr1) === this.uniIdStrToId(uniIdStr2);
                };

                function putInReference(ref, containers) {
                    if (containers.constructor === Array) {
                        var count = containers.length;
                        for (var i = 0; i < count; i += 1) {
                            var container = that.parseCompact(containers[i]);
                            var desiredClassId = that.uniIdStrToId(container[0]);
                            var typedValue = that.parseCompact(container[1]);
                            var form = typedValue[0];
                            var value = typedValue[1];
                            switch (form) {
                                case "<class>":
                                    ref.putClass(desiredClassId);
                                    break;
                                case "<enumerated>":
                                    var enumerated = that.parseCompact(value);
                                    ref.putEnumerated(desiredClassId, that.uniIdStrToId(enumerated[0]), that.uniIdStrToId(enumerated[1]));
                                    break;
                                case "<identifier>":
                                    ref.putIdentifier(desiredClassId, value);
                                    break;
                                case "<index>":
                                    ref.putIndex(desiredClassId, value);
                                    break;
                                case "<name>":
                                    ref.putName(desiredClassId, value);
                                    break;
                                case "<offset>":
                                    ref.putOffset(desiredClassId, value);
                                    break;
                                case "<property>":
                                    ref.putProperty(desiredClassId, that.uniIdStrToId(value));
                                    break;
                                default:
                                    throw new Error("[jamEngine putInReference] Unknown reference form: " + form)
                                    break;
                            }
                        }
                    } else {
                        throw new Error("[jamEngine putInReference] JavaScript array expected")
                    }
                }

                function putInList(list, items) {
                    if (items.constructor === Array) {
                        var count = items.length;
                        for (var i = 0; i < count; i += 1) {
                            var item = that.parseCompact(items[i]);
                            var type = item[0];
                            var value = item[1];
                            switch (type) {
                                case "<boolean>":
                                    list.putBoolean(value);
                                    break;
                                case "<class>":
                                    list.putClass(that.uniIdStrToId(value));
                                    break;
                                case "<data>":
                                    list.putData(value);
                                    break;
                                case "<double>":
                                    list.putDouble(value);
                                    break;
                                case "<enumerated>":
                                    var enumerated = that.parseCompact(value);
                                    list.putEnumerated(that.uniIdStrToId(enumerated[0]), that.uniIdStrToId(enumerated[1]));
                                    break;
                                case "<integer>":
                                    list.putInteger(value);
                                    break;
                                case "<largeInteger>":
                                    list.putLargeInteger(value);
                                    break;
                                case "<list>":
                                    var actionList = new ActionList();
                                    putInList(actionList, value);
                                    list.putList(actionList);
                                    break;
                                case "<object>":
                                    var object = that.parseCompact(value);
                                    if (object[1]) {
                                        var actionDescriptor = new ActionDescriptor();
                                        putInDescriptor(actionDescriptor, object[1]);
                                        list.putObject(that.uniIdStrToId(object[0]), actionDescriptor);
                                    } else {
                                        list.putClass(that.uniIdStrToId(object[0]));
                                    }
                                    break;
                                case "<path>":
                                    var fileRef = new File(value);
                                    list.putPath(fileRef);
                                    break;
                                case "<reference>":
                                    var actionReference = new ActionReference();
                                    putInReference(actionReference, value);
                                    list.putReference(actionReference);
                                    break;
                                case "<string>":
                                    list.putString(value);
                                    break;
                                case "<unitDouble>":
                                    var unitDouble = that.parseCompact(value);
                                    list.putUnitDouble(that.uniIdStrToId(unitDouble[0]), unitDouble[1]);
                                    break;
                                default:
                                    throw new Error("[jamEngine putInList] Unknown list type: " + type)
                                    break;
                            }
                        }
                    } else {
                        throw new Error("[jamEngine putInList] JavaScript array expected")
                    }
                }

                function putInDescriptor(desc, members) {
                    if (members.constructor === Object) {
                        for (var key in members) {
                            if (members.hasOwnProperty(key)) {
                                var keyID = that.uniIdStrToId(key);
                                var member = that.parseCompact(members[key]);
                                var type = member[0];
                                var value = member[1];
                                switch (type) {
                                    case "<boolean>":
                                        desc.putBoolean(keyID, value);
                                        break;
                                    case "<class>":
                                        desc.putClass(keyID, that.uniIdStrToId(value));
                                        break;
                                    case "<data>":
                                        desc.putData(keyID, value);
                                        break;
                                    case "<double>":
                                        desc.putDouble(keyID, value);
                                        break;
                                    case "<enumerated>":
                                        var enumerated = that.parseCompact(value);
                                        desc.putEnumerated(keyID, that.uniIdStrToId(enumerated[0]), that.uniIdStrToId(enumerated[1]));
                                        break;
                                    case "<integer>":
                                        desc.putInteger(keyID, value);
                                        break;
                                    case "<largeInteger>":
                                        desc.putLargeInteger(keyID, value);
                                        break;
                                    case "<list>":
                                        var actionList = new ActionList();
                                        putInList(actionList, value);
                                        desc.putList(keyID, actionList);
                                        break;
                                    case "<object>":
                                        var object = that.parseCompact(value);
                                        if (object[1]) {
                                            var actionDescriptor = new ActionDescriptor();
                                            putInDescriptor(actionDescriptor, object[1]);
                                            desc.putObject(keyID, that.uniIdStrToId(object[0]), actionDescriptor);
                                        } else {
                                            desc.putClass(keyID, that.uniIdStrToId(object[0]));
                                        }
                                        break;
                                    case "<path>":
                                        var fileRef = new File(value);
                                        desc.putPath(keyID, fileRef);
                                        break;
                                    case "<reference>":
                                        var actionReference = new ActionReference();
                                        putInReference(actionReference, value);
                                        desc.putReference(keyID, actionReference);
                                        break;
                                    case "<string>":
                                        desc.putString(keyID, value);
                                        break;
                                    case "<unitDouble>":
                                        var unitDouble = that.parseCompact(value);
                                        desc.putUnitDouble(keyID, that.uniIdStrToId(unitDouble[0]), unitDouble[1]);
                                        break;
                                    default:
                                        throw new Error("[jamEngine putInDescriptor] Unknown descriptor type: " + type)
                                        break;
                                }
                            }
                        }
                    } else {
                        throw new Error("[jamEngine putInDescriptor] JavaScript object expected")
                    }
                }
                var contextRules = {
                    "'Algn'": {
                        "<classKey>": {
                            bevelEmboss: "align",
                            frameFX: "align",
                            gradientFill: "align",
                            gradientLayer: "align",
                            patternFill: "align",
                            patternLayer: "align"
                        },
                        "<event>": "align",
                        "<key>": "alignment"
                    },
                    "'AntA'": {
                        "<class>": "antiAliasedPICTAcquire",
                        "<key>": "antiAlias"
                    },
                    "'BckL'": {
                        "<class>": "backgroundLayer",
                        "<key>": "backgroundLevel"
                    },
                    "'BlcG'": {
                        "<enumType>": "blackGenerationType",
                        "<key>": "blackGenerationCurve"
                    },
                    "'BlcL'": {
                        "<classKey>": {
                            "'GEfc'": "blackLevel",
                            CMYKSetup: "blackLimit"
                        },
                        "<eventKey>": {
                            reticulation: "blackLevel"
                        }
                    },
                    "'Blks'": {
                        "<typeValue>": {
                            colors: "blacks",
                            extrudeType: "blocks"
                        }
                    },
                    "'BlrM'": {
                        "<enumType>": "blurMethod",
                        "<event>": "blurMore",
                        "<key>": "blurMethod"
                    },
                    "'BrgC'": {
                        "<class>": "brightnessContrast",
                        "<event>": "brightnessContrast"
                    },
                    "'BrsD'": {
                        "<enumValue>": "brushesDefine",
                        "<key>": "brushDetail"
                    },
                    "'Brsh'": {
                        "<class>": "brush",
                        "<classKey>": {
                            brushPreset: "brush",
                            currentToolOptions: "brush",
                            displayPrefs: "brush"
                        },
                        "<key>": "brushes"
                    },
                    "'Clcl'": {
                        "<class>": "calculation",
                        "<enumValue>": "calculations",
                        "<key>": "calculation"
                    },
                    "'ClrP'": {
                        "<typeValue>": {
                            "'GEft'": "coloredPencil"
                        },
                        "<enumType>": "colorPalette",
                        "<event>": "coloredPencil"
                    },
                    "'Cnst'": {
                        "<classKey>": {
                            channelMatrix: "constant"
                        },
                        "<unknown>": "constrain"
                    },
                    "'CntC'": {
                        "<typeValue>": {
                            "'GEft'": "conteCrayon"
                        },
                        "<event>": "conteCrayon",
                        "<key>": "centerCropMarks"
                    },
                    "'Cntr'": {
                        "<classKey>": {
                            "'GEfc'": "contrast",
                            brightnessContrast: "contrast",
                            document: "center",
                            polygon: "center",
                            quadrilateral: "center"
                        },
                        "<eventKey>": {
                            adaptCorrect: "contrast",
                            brightnessEvent: "contrast",
                            grain: "contrast",
                            halftoneScreen: "contrast",
                            sumie: "contrast",
                            tornEdges: "contrast",
                            waterPaper: "contrast"
                        },
                        "<enumValue>": "center"
                    },
                    "'CrtD'": {
                        "<enumValue>": "createDuplicate",
                        "<event>": "createDroplet"
                    },
                    "'CstP'": {
                        "<class>": "customPhosphors",
                        "<key>": "customPalette"
                    },
                    "'Cstm'": {
                        "<enumValue>": "customPattern",
                        "<event>": "custom",
                        "<key>": "custom"
                    },
                    "'Drkn'": {
                        "<enumValue>": "darken",
                        "<key>": "darkness"
                    },
                    "'Dstr'": {
                        "<classKey>": {
                            "'GEfc'": "distortion"
                        },
                        "<eventKey>": {
                            glass: "distortion",
                            addNoise: "distribution"
                        },
                        "<enumType>": "distribution",
                        "<enumValue>": "distort",
                        "<event>": "distribute"
                    },
                    "'Dstt'": {
                        "<enumValue>": "desaturate",
                        "<event>": "desaturate",
                        "<key>": "destWhiteMax"
                    },
                    "'FlIn'": {
                        "<typeValue>": {
                            fillColor: "fillInverse",
                            menuItemType: "fileInfo"
                        },
                        "<class>": "fileInfo",
                        "<key>": "fileInfo"
                    },
                    "'Gd  '": {
                        "<class>": "guide",
                        "<enumValue>": "good"
                    },
                    "'GnrP'": {
                        "<class>": "preferencesClass",
                        "<enumValue>": "generalPreferences",
                        "<key>": "generalPrefs"
                    },
                    "'GrSt'": {
                        "<class>": "graySetup",
                        "<enumValue>": "grainStippled",
                        "<key>": "graySetup"
                    },
                    "'Grdn'": {
                        "<class>": "gradientClassEvent",
                        "<event>": "gradientClassEvent",
                        "<key>": "gridMinor"
                    },
                    "'Grn '": {
                        "<typeValue>": {
                            "'GEft'": "grain"
                        },
                        "<classKey>": {
                            "'GEfc'": "grain",
                            RGBColor: "green",
                            blackAndWhite: "green",
                            channelMatrix: "green",
                            channelMixer: "green"
                        },
                        "<eventKey>": {
                            blackAndWhite: "green",
                            channelMixer: "green",
                            filmGrain: "grain"
                        },
                        "<enumValue>": "green",
                        "<event>": "grain"
                    },
                    "'Grns'": {
                        "<enumValue>": "greens",
                        "<key>": "graininess"
                    },
                    "'HstP'": {
                        "<enumValue>": "historyPreferences",
                        "<key>": "historyPrefs"
                    },
                    "'HstS'": {
                        "<class>": "historyState",
                        "<enumType>": "historyStateSourceType"
                    },
                    "'ImgP'": {
                        "<class>": "imagePoint",
                        "<enumValue>": "imageCachePreferences"
                    },
                    "'In  '": {
                        "<enumValue>": "stampIn",
                        "<key>": "in"
                    },
                    "'IntW'": {
                        "<event>": "intersectWith",
                        "<key>": "interfaceWhite"
                    },
                    "'Intr'": {
                        "<typeValue>": {
                            shapeOperation: "intersect"
                        },
                        "<classKey>": {
                            GIFFormat: "interlace",
                            SaveForWeb: "interlace",
                            application: "interfaceIconFrameDimmed",
                            computedBrush: "interpolation",
                            dBrush: "interpolation",
                            gradientClassEvent: "interpolation",
                            photoshopEPSFormat: "interpolation",
                            sampledBrush: "interpolation"
                        },
                        "<eventKey>": {
                            convertMode: "interpolation",
                            imageSize: "interpolation",
                            transform: "interpolation"
                        },
                        "<event>": "intersect"
                    },
                    "'JPEG'": {
                        "<class>": "JPEGFormat",
                        "<enumValue>": "JPEG"
                    },
                    "'LghD'": {
                        "<enumType>": "lightDirection",
                        "<enumValue>": "lightDirectional",
                        "<key>": "lightDirection"
                    },
                    "'LghO'": {
                        "<typeValue>": {
                            diffuseMode: "lightenOnly",
                            lightType: "lightOmni"
                        }
                    },
                    "'LghS'": {
                        "<class>": "lightSource",
                        "<enumValue>": "lightSpot",
                        "<key>": "lightSource"
                    },
                    "'Lns '": {
                        "<enumType>": "lens",
                        "<enumValue>": "lines",
                        "<key>": "lens"
                    },
                    "'Mgnt'": {
                        "<typeValue>": {
                            channel: "magenta",
                            colors: "magentas",
                            guideGridColor: "magenta"
                        },
                        "<key>": "magenta"
                    },
                    "'MrgL'": {
                        "<enumValue>": "mergedLayers",
                        "<event>": "mergeLayers"
                    },
                    "'Mxm '": {
                        "<enumValue>": "maximumQuality",
                        "<event>": "maximum",
                        "<key>": "maximum"
                    },
                    "'NTSC'": {
                        "<enumValue>": "NTSC",
                        "<event>": "NTSCColors"
                    },
                    "'NmbL'": {
                        "<classKey>": {
                            "'GEfc'": "numberOfLevels",
                            document: "numberOfLayers"
                        },
                        "<eventKey>": {
                            cutout: "numberOfLevels"
                        }
                    },
                    "'PlgP'": {
                        "<class>": "pluginPrefs",
                        "<enumValue>": "pluginPicker",
                        "<key>": "pluginPrefs"
                    },
                    "'Pncl'": {
                        "<enumValue>": "pencilEraser",
                        "<key>": "pencilWidth"
                    },
                    "'Pnt '": {
                        "<typeValue>": {
                            textType: "point"
                        },
                        "<class>": "point",
                        "<event>": "paint"
                    },
                    "'Prsp'": {
                        "<enumValue>": "perspective",
                        "<key>": "perspectiveIndex"
                    },
                    "'PrvM'": {
                        "<enumValue>": "previewMagenta",
                        "<key>": "previewMacThumbnail"
                    },
                    "'Pstr'": {
                        "<class>": "posterize",
                        "<event>": "posterize",
                        "<key>": "posterization"
                    },
                    "'RGBS'": {
                        "<enumType>": "RGBSetupSource",
                        "<key>": "RGBSetup"
                    },
                    "'Rds '": {
                        "<enumValue>": "reds",
                        "<key>": "radius"
                    },
                    "'ScrD'": {
                        "<enumValue>": "screenDot",
                        "<key>": "scratchDisks"
                    },
                    "'ShdI'": {
                        "<classKey>": {
                            "'GEfc'": "shadowIntensity"
                        },
                        "<eventKey>": {
                            watercolor: "shadowIntensity"
                        },
                        "<unknown>": "shadingIntensity"
                    },
                    "'ShpC'": {
                        "<classKey>": {
                            application: "shapingCurve"
                        },
                        "<class>": "shapingCurve",
                        "<key>": "shapeCurveType"
                    },
                    "'ShrE'": {
                        "<event>": "sharpenEdges",
                        "<key>": "shearEd"
                    },
                    "'Shrp'": {
                        "<event>": "sharpen",
                        "<key>": "sharpness"
                    },
                    "'SplC'": {
                        "<event>": "splitChannels",
                        "<key>": "supplementalCategories"
                    },
                    "'Spot'": {
                        "<enumValue>": "spotColor",
                        "<key>": "spot"
                    },
                    "'SprS'": {
                        "<typeValue>": {
                            "'GEft'": "sprayedStrokes"
                        },
                        "<enumValue>": "separationSetup",
                        "<event>": "sprayedStrokes"
                    },
                    "'StrL'": {
                        "<enumType>": "strokeLocation",
                        "<key>": "strokeLength"
                    },
                    "'Strt'": {
                        "<classKey>": {
                            currentToolOptions: "saturation",
                            fileNamingRules: "start",
                            HSBColorClass: "saturation",
                            hueSatAdjustment: "saturation",
                            hueSatAdjustmentV2: "saturation",
                            lineClass: "start",
                            range: "start",
                            vibrance: "saturation"
                        },
                        "<eventKey>": {
                            replaceColor: "saturation",
                            variations: "saturation",
                            vibrance: "saturation"
                        },
                        "<enumValue>": "saturation"
                    },
                    "'TEXT'": {
                        "<enumType>": "textType",
                        "<key>": "textType"
                    },
                    "'TIFF'": {
                        "<class>": "TIFFFormat",
                        "<enumValue>": "TIFF"
                    },
                    "'TglO'": {
                        "<enumValue>": "toggleOptionsPalette",
                        "<key>": "toggleOthers"
                    },
                    "'TrnG'": {
                        "<classKey>": {
                            application: "transparencyGrid",
                            transparencyPrefs: "transparencyGridSize"
                        },
                        "<enumType>": "transparencyGridSize",
                        "<enumValue>": "transparencyGamutPreferences"
                    },
                    "'TrnS'": {
                        "<classKey>": {
                            bevelEmboss: "transparencyShape",
                            dropShadow: "transparencyShape",
                            innerGlow: "transparencyShape",
                            innerShadow: "transparencyShape",
                            outerGlow: "transparencyShape"
                        },
                        "<class>": "transparencyStop",
                        "<unknown>": "transferSpec"
                    },
                    "'Trns'": {
                        "<enumValue>": "transparent",
                        "<key>": "transparency"
                    },
                    "'TxtC'": {
                        "<classKey>": {
                            "'GEfc'": "textureCoverage",
                            textLayer: "textClickPoint"
                        },
                        "<eventKey>": {
                            underpainting: "textureCoverage"
                        }
                    },
                    "'TxtF'": {
                        "<event>": "textureFill",
                        "<key>": "textureFile"
                    },
                    "'UsrM'": {
                        "<enumType>": "userMaskOptions",
                        "<key>": "userMaskEnabled"
                    },
                    "'null'": {
                        "<class>": "null",
                        "<enumValue>": "null",
                        "<event>": "null",
                        "<key>": "target"
                    }
                };

                function getFromId(context, parentContext) {
                    var kind = context[0];
                    var id = context[1];
                    if (id < smallestHashValue) {
                        uniIdStr = app.typeIDToStringID(id);
                    } else {
                        uniIdStr = "'" + app.typeIDToCharID(id) + "'";
                        if (that.meaningfulIds) {
                            if (uniIdStr in contextRules) {
                                function resolveIdStr(candidates) {
                                    var idStr = "";
                                    for (var parentString in candidates) {
                                        if (candidates.hasOwnProperty(parentString)) {
                                            if (parentContext[1] === that.uniIdStrToId(parentString)) {
                                                idStr = candidates[parentString];
                                                break;
                                            }
                                        }
                                    }
                                    return idStr;
                                }
                                var resolvedIdStr = "";
                                var rule = contextRules[uniIdStr];
                                if (parentContext) {
                                    switch (kind) {
                                        case "<key>":
                                            if (parentContext[0] === "<class>" && "<classKey>" in rule) {
                                                resolvedIdStr = resolveIdStr(rule["<classKey>"]);
                                            } else {
                                                if (parentContext[0] === "<event>" && "<eventKey>" in rule) {
                                                    resolvedIdStr = resolveIdStr(rule["<eventKey>"]);
                                                }
                                            }
                                            break;
                                        case "<enumValue>":
                                            if (parentContext[0] === "<enumType>" && "<typeValue>" in rule) {
                                                resolvedIdStr = resolveIdStr(rule["<typeValue>"]);
                                            }
                                            break;
                                    }
                                }
                                if (resolvedIdStr !== "") {
                                    uniIdStr = resolvedIdStr;
                                } else {
                                    if (kind in rule) {
                                        uniIdStr = rule[kind];
                                    }
                                }
                            } else {
                                var stringIDStr = app.typeIDToStringID(id);
                                if (stringIDStr !== "") {
                                    uniIdStr = stringIDStr;
                                }
                            }
                        }
                    }
                    return uniIdStr;
                }
                var incompatiblePlatformPath = "";
                var getEventId = app.stringIDToTypeID("get");
                var targetKeyId = app.stringIDToTypeID("target");
                var propertyClassId = app.stringIDToTypeID("property");

                function getFromReference(ref) {
                    var propertyId = 0;
                    var arr = [];
                    do {
                        try {
                            var desiredClassId = ref.getDesiredClass();
                        } catch (e) {
                            break;
                        }
                        if (propertyId !== 0) {
                            var propertyCompact = that.buildCompact("<property>", getFromId(["<key>", propertyId], ["<class>", desiredClassId]));
                            arr.push(that.buildCompact(getFromId(["<class>", propertyClassId]), propertyCompact));
                            propertyId = 0;
                        }
                        var aFormID = ref.getForm();
                        switch (aFormID) {
                            case ReferenceFormType.CLASSTYPE:
                                desiredCompact = that.buildCompact("<class>", null);
                                break;
                            case ReferenceFormType.ENUMERATED:
                                var enumTypeContext = ["<enumType>", ref.getEnumeratedType()];
                                var enumValueContext = ["<enumValue>", ref.getEnumeratedValue()];
                                desiredCompact = that.buildCompact("<enumerated>", that.buildCompact(getFromId(enumTypeContext), getFromId(enumValueContext, enumTypeContext)));
                                break;
                            case ReferenceFormType.IDENTIFIER:
                                desiredCompact = that.buildCompact("<identifier>", ref.getIdentifier());
                                break;
                            case ReferenceFormType.INDEX:
                                desiredCompact = that.buildCompact("<index>", ref.getIndex());
                                break;
                            case ReferenceFormType.NAME:
                                desiredCompact = that.buildCompact("<name>", ref.getName());
                                break;
                            case ReferenceFormType.OFFSET:
                                desiredCompact = that.buildCompact("<offset>", ref.getOffset());
                                break;
                            case ReferenceFormType.PROPERTY:
                                if (desiredClassId === propertyClassId) {
                                    propertyId = ref.getProperty();
                                } else {
                                    desiredCompact = that.buildCompact("<property>", getFromId(["<key>", ref.getProperty()], ["<class>", desiredClassId]));
                                }
                                break;
                            default:
                                throw new Error("[jamEngine getFromReference] Unknown reference form type: " + aFormID)
                                break;
                        }
                        if (desiredClassId !== propertyClassId) {
                            arr.push(that.buildCompact(getFromId(["<class>", desiredClassId]), desiredCompact));
                        }
                        ref = ref.getContainer();
                    } while (ref)
                    return arr;
                }

                function getFromList(list) {
                    var arr = [];
                    var itemCount = list.count;
                    for (var itemIndex = 0; itemIndex < itemCount; itemIndex += 1) {
                        try {
                            typeID = list.getType(itemIndex);
                        } catch (e) {
                            continue;
                        }
                        switch (typeID) {
                            case DescValueType.BOOLEANTYPE:
                                itemCompact = that.buildCompact("<boolean>", list.getBoolean(itemIndex));
                                break;
                            case DescValueType.CLASSTYPE:
                                itemCompact = that.buildCompact("<class>", getFromId(["<class>", list.getClass(itemIndex)]));
                                break;
                            case DescValueType.RAWTYPE:
                                itemCompact = that.buildCompact("<data>", list.getData(itemIndex));
                                break;
                            case DescValueType.DOUBLETYPE:
                                itemCompact = that.buildCompact("<double>", list.getDouble(itemIndex));
                                break;
                            case DescValueType.ENUMERATEDTYPE:
                                var enumTypeContext = ["<enumType>", list.getEnumerationType(itemIndex)];
                                var enumValueContext = ["<enumValue>", list.getEnumerationValue(itemIndex)];
                                itemCompact = that.buildCompact("<enumerated>", that.buildCompact(getFromId(enumTypeContext), getFromId(enumValueContext, enumTypeContext)));
                                break;
                            case DescValueType.INTEGERTYPE:
                                itemCompact = that.buildCompact("<integer>", list.getInteger(itemIndex));
                                break;
                            case DescValueType.LARGEINTEGERTYPE:
                                itemCompact = that.buildCompact("<largeInteger>", list.getLargeInteger(itemIndex));
                                break;
                            case DescValueType.LISTTYPE:
                                itemCompact = that.buildCompact("<list>", getFromList(list.getList(itemIndex)));
                                break;
                            case DescValueType.OBJECTTYPE:
                                var objectTypeContext = ["<class>", list.getObjectType(itemIndex)];
                                var objectValue = list.getObjectValue(itemIndex);
                                itemCompact = that.buildCompact("<object>", that.buildCompact(getFromId(objectTypeContext), getFromDescriptor(objectValue, objectTypeContext)));
                                break;
                            case DescValueType.ALIASTYPE:
                                try {
                                    var fileRef = list.getPath(itemIndex);
                                    itemCompact = that.buildCompact("<path>", fileRef.fsName);
                                } catch (e) {
                                    itemCompact = that.buildCompact("<path>", incompatiblePlatformPath);
                                }
                                break;
                            case DescValueType.REFERENCETYPE:
                                itemCompact = that.buildCompact("<reference>", getFromReference(list.getReference(itemIndex)));
                                break;
                            case DescValueType.STRINGTYPE:
                                itemCompact = that.buildCompact("<string>", list.getString(itemIndex));
                                break;
                            case DescValueType.UNITDOUBLE:
                                var unitTypeContext = ["<unit>", list.getUnitDoubleType(itemIndex)];
                                var doubleValue = list.getUnitDoubleValue(itemIndex);
                                itemCompact = that.buildCompact("<unitDouble>", that.buildCompact(getFromId(unitTypeContext), doubleValue));
                                break;
                            default:
                                try {
                                    isRawType = typeID === DescValueType.RAWTYPE;
                                } catch (e) {

                                }
                                try {
                                    isLargeIntegerType = typeID === DescValueType.LARGEINTEGERTYPE;
                                } catch (e) {

                                }
                                if (isRawType) {
                                    itemCompact = that.buildCompact("<data>", list.getData(itemIndex));
                                } else if (isLargeIntegerType) {
                                    itemCompact = that.buildCompact("<largeInteger>", list.getLargeInteger(itemIndex));
                                } else {
                                    throw new Error("[jamEngine getFromList] Unknown descriptor value type: " + typeID)
                                }
                                break;
                        }
                        arr[itemIndex] = itemCompact;
                    }
                    return arr;
                }

                function getFromDescriptor(desc, parentContext) {
                    if (desc) {
                        var obj = {};
                        try {
                            keyCount = desc.count;
                        } catch (e) {
                            return null;
                        }
                        for (var keyIndex = 0; keyIndex < keyCount; keyIndex += 1) {
                            var keyID = desc.getKey(keyIndex);
                            var keyString = getFromId(["<key>", keyID], parentContext);
                            try {
                                typeID = desc.getType(keyID);
                            } catch (e) {
                                continue;
                            }
                            switch (typeID) {
                                case DescValueType.BOOLEANTYPE:
                                    keyCompact = that.buildCompact("<boolean>", desc.getBoolean(keyID));
                                    break;
                                case DescValueType.CLASSTYPE:
                                    keyCompact = that.buildCompact("<class>", getFromId(["<class>", desc.getClass(keyID)]));
                                    break;
                                case DescValueType.RAWTYPE:
                                    keyCompact = that.buildCompact("<data>", desc.getData(keyID));
                                    break;
                                case DescValueType.DOUBLETYPE:
                                    keyCompact = that.buildCompact("<double>", desc.getDouble(keyID));
                                    break;
                                case DescValueType.ENUMERATEDTYPE:
                                    var enumTypeContext = ["<enumType>", desc.getEnumerationType(keyID)];
                                    var enumValueContext = ["<enumValue>", desc.getEnumerationValue(keyID)];
                                    keyCompact = that.buildCompact("<enumerated>", that.buildCompact(getFromId(enumTypeContext), getFromId(enumValueContext, enumTypeContext)));
                                    break;
                                case DescValueType.INTEGERTYPE:
                                    keyCompact = that.buildCompact("<integer>", desc.getInteger(keyID));
                                    break;
                                case DescValueType.LARGEINTEGERTYPE:
                                    keyCompact = that.buildCompact("<largeInteger>", desc.getLargeInteger(keyID));
                                    break;
                                case DescValueType.LISTTYPE:
                                    keyCompact = that.buildCompact("<list>", getFromList(desc.getList(keyID)));
                                    break;
                                case DescValueType.OBJECTTYPE:
                                    var objectTypeContext = ["<class>", desc.getObjectType(keyID)];
                                    var objectValue = desc.getObjectValue(keyID);
                                    keyCompact = that.buildCompact("<object>", that.buildCompact(getFromId(objectTypeContext), getFromDescriptor(objectValue, objectTypeContext)));
                                    break;
                                case DescValueType.ALIASTYPE:
                                    try {
                                        var fileRef = desc.getPath(keyID);
                                        keyCompact = that.buildCompact("<path>", fileRef.fsName);
                                    } catch (e) {
                                        keyCompact = that.buildCompact("<path>", incompatiblePlatformPath);
                                    }
                                    break;
                                case DescValueType.REFERENCETYPE:
                                    keyCompact = that.buildCompact("<reference>", getFromReference(desc.getReference(keyID)));
                                    break;
                                case DescValueType.STRINGTYPE:
                                    keyCompact = that.buildCompact("<string>", desc.getString(keyID));
                                    break;
                                case DescValueType.UNITDOUBLE:
                                    var unitTypeContext = ["<unit>", desc.getUnitDoubleType(keyID)];
                                    var doubleValue = desc.getUnitDoubleValue(keyID);
                                    keyCompact = that.buildCompact("<unitDouble>", that.buildCompact(getFromId(unitTypeContext), doubleValue));
                                    break;
                                default:
                                    try {
                                        isRawType = typeID === DescValueType.RAWTYPE;
                                    } catch (e) {

                                    }
                                    try {
                                        isLargeIntegerType = typeID === DescValueType.LARGEINTEGERTYPE;
                                    } catch (e) {

                                    }
                                    if (isRawType) {
                                        keyCompact = that.buildCompact("<data>", desc.getData(keyID));
                                    } else if (isLargeIntegerType) {
                                        keyCompact = that.buildCompact("<largeInteger>", desc.getLargeInteger(keyID));
                                    } else {
                                        throw new Error("[jamEngine getFromDescriptor] Unknown descriptor value type: " + typeID)
                                    }
                                    break;
                            }
                            obj[keyString] = keyCompact;
                        }
                        return obj;
                    } else {
                        return null;
                    }
                }
                jamEngine.jsonToActionDescriptor = function(descriptorObj) {
                    that = this;
                    if (descriptorObj) {
                        actionDescriptor = new ActionDescriptor();
                        putInDescriptor(actionDescriptor, descriptorObj);
                    }
                    return actionDescriptor;
                };
                jamEngine.jsonToActionReference = function(referenceArr) {
                    that = this;
                    if (referenceArr) {
                        actionReference = new ActionReference();
                        putInReference(actionReference, referenceArr);
                    }
                    return actionReference;
                };
                jamEngine.eventIdAndActionDescriptorToJson = function(eventId, actionDescriptor) {
                    that = this;
                    var eventIdContext = ["<event>", eventId];
                    return {
                        "<event>": getFromId(eventIdContext),
                        "<descriptor>": getFromDescriptor(actionDescriptor, eventIdContext)
                    };
                };
                jamEngine.classIdAndActionDescriptorToJson = function(classId, actionDescriptor) {
                    that = this;
                    var classIdContext = ["<class>", classId];
                    return {
                        "<class>": getFromId(classIdContext),
                        "<descriptor>": getFromDescriptor(actionDescriptor, classIdContext)
                    };
                };
                jamEngine.actionReferenceToJson = function(actionReference) {
                    that = this;
                    return getFromReference(actionReference);
                };

                function getReferenceClassId(ref) {
                    classId = 0;
                    do {
                        try {
                            var desiredClassId = ref.getDesiredClass();
                        } catch (e) {
                            break;
                        }
                        if (desiredClassId !== propertyClassId) {
                            classId = desiredClassId;
                            break;
                        }
                        ref = ref.getContainer();
                    } while (ref)
                    return classId;
                }
                jamEngine.jsonPlay = function(eventUniIdStr, descriptorObj, displayDialogs) {
                    var eventId = this.uniIdStrToId(eventUniIdStr);
                    var desc = this.jsonToActionDescriptor(descriptorObj);
                    if (eventId === getEventId) {
                        var ref = desc.getReference(targetKeyId);
                        parentContext = ["<class>", getReferenceClassId(ref)];
                    } else {
                        parentContext = ["<event>", eventId];
                    }
                    return getFromDescriptor(app.executeAction(eventId, desc, displayDialogs || this.displayDialogs), parentContext);
                };
                jamEngine.jsonGet = function(referenceArr) {
                    var ref = this.jsonToActionReference(referenceArr);
                    return getFromDescriptor(app.executeActionGet(ref), ["<class>", getReferenceClassId(ref)]);
                };
                jamEngine.normalizeJsonItem = function(item, options) {
                    function normalizeItem(item) {
                        var explicit = that.parseCompact(item);
                        var type = explicit[0];
                        var value = explicit[1];
                        switch (type) {
                            case "<boolean>":
                            case "<data>":
                            case "<double>":
                            case "<identifier>":
                            case "<index>":
                            case "<integer>":
                            case "<largeInteger>":
                            case "<name>":
                            case "<offset>":
                            case "<path>":
                            case "<string>":
                                normalizedValue = value;
                                break;
                            case "<class>":
                                normalizedValue = value && getFromId(["<class>", that.uniIdStrToId(value)]);
                                break;
                            case "<enumerated>":
                                var enumerated = that.parseCompact(value);
                                var enumTypeContext = ["<enumType>", that.uniIdStrToId(enumerated[0])];
                                var enumValueContext = ["<enumValue>", that.uniIdStrToId(enumerated[1])];
                                normalizedValue = that.buildCompact(getFromId(enumTypeContext), getFromId(enumValueContext, enumTypeContext));
                                break;
                            case "<list>":
                                normalizedValue = [];
                                for (var i = 0; i < value.length; i += 1) {
                                    normalizedValue.push(normalizeItem(value[i]));
                                }
                                break;
                            case "<object>":
                                var object = that.parseCompact(value);
                                var objectClassContext = ["<class>", that.uniIdStrToId(object[0])];
                                var objectDescriptor = object[1];
                                if (objectDescriptor === null) {
                                    normalizedDescriptor = null;
                                } else {
                                    normalizedDescriptor = {};
                                    for (var key in objectDescriptor) {
                                        if (objectDescriptor.hasOwnProperty(key)) {
                                            var objectKeyContext = ["<key>", that.uniIdStrToId(key)];
                                            normalizedDescriptor[getFromId(objectKeyContext, objectClassContext)] = normalizeItem(objectDescriptor[key]);
                                        }
                                    }
                                }
                                normalizedValue = that.buildCompact(getFromId(objectClassContext), normalizedDescriptor);
                                break;
                            case "<property>":
                                normalizedValue = getFromId(["<key>", that.uniIdStrToId(value)]);
                                break;
                            case "<reference>":
                                normalizedValue = [];
                                for (var i = 0; i < value.length; i += 1) {
                                    var container = that.parseCompact(value[i]);
                                    normalizedValue.push(that.buildCompact(getFromId(["<class>", that.uniIdStrToId(container[0])]), normalizeItem(container[1])));
                                }
                                break;
                            case "<unitDouble>":
                                var unitDouble = that.parseCompact(value);
                                var unitTypeContext = ["<unit>", that.uniIdStrToId(unitDouble[0])];
                                normalizedValue = that.buildCompact(getFromId(unitTypeContext), unitDouble[1]);
                                break;
                            default:
                                throw new Error("[jamEngine.normalizeJsonItem] Unknown item type: " + type)
                                break;
                        }
                        return that.buildCompact(type, normalizedValue);
                    }
                    that = this;
                    var saveMeaningfulIds = this.meaningfulIds;
                    var saveParseFriendly = this.parseFriendly;
                    if (options && options.constructor === Object) {
                        if (typeof options.meaningfulIds !== "undefined") {
                            this.meaningfulIds = options.meaningfulIds;
                        }
                        if (typeof options.parseFriendly !== "undefined") {
                            this.parseFriendly = options.parseFriendly;
                        }
                    }
                    var normalizedItem = normalizeItem(item);
                    this.meaningfulIds = saveMeaningfulIds;
                    this.parseFriendly = saveParseFriendly;
                    return normalizedItem;
                };

                function simplifyRef(ref) {
                    var simplifiedRef = [];
                    for (var i = 0; i < ref.length; i += 1) {
                        var element = ref[i];
                        var simplifiedElement = {};
                        var desiredClass = element[0];
                        var form = element[1][0];
                        var value = element[1][1];
                        switch (form) {
                            case "<class>":
                            case "<identifier>":
                            case "<index>":
                            case "<name>":
                            case "<offset>":
                            case "<property":
                                simplifiedElement[desiredClass] = value;
                                break;
                            case "<enumerated>":
                                simplifiedElement[desiredClass] = value[1];
                                break;
                            default:
                                throw new Error("[jamEngine simplifyRef] Unexpected element form: " + form)
                                break;
                        }
                        simplifiedRef.push(simplifiedElement);
                    }
                    return simplifiedRef;
                }

                function simplifyItem(item, hook) {
                    var type = item[0];
                    var value = item[1];
                    switch (type) {
                        case "<boolean>":
                        case "<class>":
                        case "<data>":
                        case "<double>":
                        case "<integer>":
                        case "<largeInteger>":
                        case "<path>":
                        case "<string>":
                            simplifiedItem = value;
                            break;
                        case "<list>":
                            simplifiedItem = simplifyList(value, hook);
                            break;
                        case "<enumerated>":
                        case "<unitDouble>":
                            simplifiedItem = value[1];
                            break;
                        case "<object>":
                            simplifiedItem = simplifyDesc(value[1], hook);
                            break;
                        case "<reference>":
                            simplifiedItem = simplifyRef(value);
                            break;
                        default:
                            throw new Error("[jamEngine simplifyItem] Unexpected item type: " + type)
                            break;
                    }
                    return simplifiedItem;
                }

                function simplifyList(list, hook) {
                    var simplifiedList = [];
                    for (var i = 0; i < list.length; i += 1) {
                        simplifiedList.push(simplifyItem(list[i], hook));
                    }
                    return simplifiedList;
                }

                function simplifyDesc(desc, hook) {
                    var getDefaultValue = function(desc, key) {
                        return simplifyItem(desc[key], hook);
                    };
                    var simplifiedDesc = {};
                    for (var key in desc) {
                        if (desc.hasOwnProperty(key)) {
                            var value = undefined;
                            if (typeof hook === "function") {
                                value = hook(desc, key, getDefaultValue);
                            }
                            if (typeof value === "undefined") {
                                value = simplifyItem(desc[key], hook);
                            }
                            simplifiedDesc[key] = value;
                        }
                    }
                    return simplifiedDesc;
                }
                jamEngine.simplifyObject = function(object, hookFunction) {
                    return simplifyDesc(this.normalizeJsonItem(object, {
                        meaningfulIds: true,
                        parseFriendly: true
                    })[1][1], hookFunction);
                };
                jamEngine.simplifyList = function(list, hookFunction) {
                    return simplifyList(this.normalizeJsonItem(list, {
                        meaningfulIds: true,
                        parseFriendly: true
                    })[1], hookFunction);
                };
                jamEngine.parseCompact = function(compact) {
                    var result = [];
                    if (compact.constructor === Object) {
                        var keys = [];
                        for (var k in compact) {
                            if (compact.hasOwnProperty(k)) {
                                keys.push(k);
                            }
                        }
                        if (keys.length === 1) {
                            result[0] = keys[0];
                            result[1] = compact[keys[0]];
                        } else {
                            throw new Error("[jamEngine.parseCompact] Syntax error: " + compact.toSource())
                        }
                    } else if (compact.constructor === Array) {
                        if (compact.length === 2) {
                            result[0] = compact[0];
                            result[1] = compact[1];
                        } else {
                            throw new Error("[jamEngine.parseCompact] Syntax error: " + compact.toSource())
                        }
                    } else {
                        throw new Error("[jamEngine.parseCompact] JavaScript object or array expected")
                    }
                    return result;
                };
                jamEngine.compactToExplicit = function(compact, typeKey, valueKey) {
                    var explicit = {};
                    var typeValue = this.parseCompact(compact);
                    explicit[typeKey || "<type>"] = typeValue[0];
                    explicit[valueKey || "<value>"] = typeValue[1];
                    return explicit;
                };
                jamEngine.buildCompact = function(type, value) {
                    if (typeof type === "string") {
                        if (this.parseFriendly) {
                            compact = [type, value];
                        } else {
                            compact = {};
                            compact[type] = value;
                        }
                    } else {
                        throw new Error("[jamEngine.buildCompact] String expected")
                    }
                    return compact;
                };
                jamEngine.explicitToCompact = function(explicit, typeKey, valueKey) {
                    if (explicit.constructor === Object) {
                        compact = this.buildCompact(explicit[typeKey || "<type>"], explicit[valueKey || "<value>"]);
                    } else {
                        throw new Error("[jamEngine.explicitToCompact] JavaScript object expected")
                    }
                    return compact;
                };
                for (var charIdStr in conflictingStringIdStrs) {
                    if (conflictingStringIdStrs.hasOwnProperty(charIdStr)) {
                        var stringIdStrs = conflictingStringIdStrs[charIdStr];
                        for (var index = stringIdStrs.length - 1; index >= 0; index--) {
                            var stringIdStr = stringIdStrs[index];
                            if (!(app.charIDToTypeID(charIdStr.substring(1, 5)) === app.stringIDToTypeID(stringIdStr))) {
                                stringIdStrs.splice(index, 1);
                            }
                        }
                        if (stringIdStrs.length < 2) {
                            delete conflictingStringIdStrs[charIdStr];
                        }
                    }
                }
                for (var charIdStr in contextRules) {
                    if (contextRules.hasOwnProperty(charIdStr)) {
                        if (charIdStr in conflictingStringIdStrs) {
                            var rule = contextRules[charIdStr];
                            for (var kind in rule) {
                                if (rule.hasOwnProperty(kind)) {
                                    switch (kind) {
                                        case "<class>":
                                        case "<event>":
                                        case "<enumType>":
                                        case "<enumValue>":
                                        case "<key>":
                                        case "<unknown>":
                                            if (app.charIDToTypeID(charIdStr.substring(1, 5)) != app.stringIDToTypeID(rule[kind])) {
                                                throw new Error("[jamEngine] \"" + charIdStr + "\" and \"" + rule[kind] + "\" are not equivalent ID strings")
                                            }
                                            break;
                                        case "<classKey>":
                                        case "<eventKey>":
                                        case "<typeValue>":
                                            for (var parent in rule[kind]) {
                                                if (rule[kind].hasOwnProperty(parent)) {
                                                    if (app.charIDToTypeID(charIdStr.substring(1, 5)) != app.stringIDToTypeID(rule[kind][parent])) {
                                                        throw new Error("[jamEngine] \"" + charIdStr + "\" and \"" + rule[kind][parent] + "\" are not equivalent ID strings")
                                                    }
                                                }
                                            }
                                            break;
                                    }
                                }
                            }
                        } else {
                            delete contextRules[charIdStr];
                        }
                    }
                }
            }();
        }
        jamEngine.meaningfulIds = false;
        jamEngine.parseFriendly = false;
        try {
            jamEngine.jsonPlay("'Mk  '", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<class>": null
                        }
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'AppI'", {
                "'With'": {
                    "<object>": {
                        "'Clcl'": {
                            "'T   '": {
                                "<reference>": [{
                                    "'Chnl'": {
                                        "<enumerated>": {
                                            "'Chnl'": "'RGB '"
                                        }
                                    }
                                }, {
                                    "'Lyr '": {
                                        "<enumerated>": {
                                            "'Ordn'": "'Mrgd'"
                                        }
                                    }
                                }]
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Temp_1"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'CpTL'", null, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Temp_2"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'Hd  '", {
                "'null'": {
                    "<list>": [{
                        "<reference>": [{
                            "'Lyr '": {
                                "<enumerated>": {
                                    "'Ordn'": "'Trgt'"
                                }
                            }
                        }]
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'slct'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<name>": "Temp_1"
                        }
                    }]
                },
                "'MkVs'": {
                    "<boolean>": false
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Low"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'GsnB'", {
                "'Rds '": {
                    "<unitDouble>": {
                        "'#Pxl'": 1
                    }
                }
            }, DialogModes.ALL);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Temp_1"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'slct'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<name>": "Temp_2"
                        }
                    }]
                },
                "'MkVs'": {
                    "<boolean>": false
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'Shw '", {
                "'null'": {
                    "<list>": [{
                        "<reference>": [{
                            "'Lyr '": {
                                "<enumerated>": {
                                    "'Ordn'": "'Trgt'"
                                }
                            }
                        }]
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'AppI'", {
                "'With'": {
                    "<object>": {
                        "'Clcl'": {
                            "'T   '": {
                                "<reference>": [{
                                    "'Chnl'": {
                                        "<enumerated>": {
                                            "'Chnl'": "'RGB '"
                                        }
                                    }
                                }, {
                                    "'Lyr '": {
                                        "<name>": "Temp_1"
                                    }
                                }]
                            },
                            "'Clcl'": {
                                "<enumerated>": {
                                    "'Clcn'": "'Sbtr'"
                                }
                            },
                            "'Scl '": {
                                "<double>": 2
                            },
                            "'Ofst'": {
                                "<integer>": 128
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Md  '": {
                                "<enumerated>": {
                                    "'BlnM'": "linearLight"
                                }
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'CpTL'", null, DialogModes.NO);
            jamEngine.jsonPlay("'GrpL'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Texture_Retouch"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Md  '": {
                                "<enumerated>": {
                                    "'BlnM'": "'Nrml'"
                                }
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'Mk  '", {
                "'null'": {
                    "<reference>": [{
                        "'AdjL'": {
                            "<class>": null
                        }
                    }]
                },
                "'Usng'": {
                    "<object>": {
                        "'AdjL'": {
                            "'Type'": {
                                "<object>": {
                                    "'Crvs'": {
                                        presetKind: {
                                            "<enumerated>": {
                                                presetKindType: "presetKindDefault"
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'Dlt '", {
                "'null'": {
                    "<reference>": [{
                        "'Chnl'": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Texture_Boost"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'AdjL'": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Crvs'": {
                            presetKind: {
                                "<enumerated>": {
                                    presetKindType: "presetKindCustom"
                                }
                            },
                            "'Adjs'": {
                                "<list>": [{
                                    "<object>": {
                                        "'CrvA'": {
                                            "'Chnl'": {
                                                "<reference>": [{
                                                    "'Chnl'": {
                                                        "<enumerated>": {
                                                            "'Chnl'": "'Cmps'"
                                                        }
                                                    }
                                                }]
                                            },
                                            "'Crv '": {
                                                "<list>": [{
                                                    "<object>": {
                                                        "'Pnt '": {
                                                            "'Hrzn'": {
                                                                "<double>": 72
                                                            },
                                                            "'Vrtc'": {
                                                                "<double>": 0
                                                            }
                                                        }
                                                    }
                                                }, {
                                                    "<object>": {
                                                        "'Pnt '": {
                                                            "'Hrzn'": {
                                                                "<double>": 128
                                                            },
                                                            "'Vrtc'": {
                                                                "<double>": 128
                                                            }
                                                        }
                                                    }
                                                }, {
                                                    "<object>": {
                                                        "'Pnt '": {
                                                            "'Hrzn'": {
                                                                "<double>": 181
                                                            },
                                                            "'Vrtc'": {
                                                                "<double>": 255
                                                            }
                                                        }
                                                    }
                                                }]
                                            }
                                        }
                                    }
                                }]
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'AdjL'": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Crvs'": {
                            "'Adjs'": {
                                "<list>": [{
                                    "<object>": {
                                        "'CrvA'": {
                                            "'Chnl'": {
                                                "<reference>": [{
                                                    "'Chnl'": {
                                                        "<enumerated>": {
                                                            "'Chnl'": "'Cmps'"
                                                        }
                                                    }
                                                }]
                                            },
                                            "'Crv '": {
                                                "<list>": [{
                                                    "<object>": {
                                                        "'Pnt '": {
                                                            "'Hrzn'": {
                                                                "<double>": 113
                                                            },
                                                            "'Vrtc'": {
                                                                "<double>": 0
                                                            }
                                                        }
                                                    }
                                                }, {
                                                    "<object>": {
                                                        "'Pnt '": {
                                                            "'Hrzn'": {
                                                                "<double>": 128
                                                            },
                                                            "'Vrtc'": {
                                                                "<double>": 128
                                                            }
                                                        }
                                                    }
                                                }, {
                                                    "<object>": {
                                                        "'Pnt '": {
                                                            "'Hrzn'": {
                                                                "<double>": 148
                                                            },
                                                            "'Vrtc'": {
                                                                "<double>": 255
                                                            }
                                                        }
                                                    }
                                                }]
                                            }
                                        }
                                    }
                                }]
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'Hd  '", {
                "'null'": {
                    "<list>": [{
                        "<reference>": [{
                            "'Lyr '": {
                                "<enumerated>": {
                                    "'Ordn'": "'Trgt'"
                                }
                            }
                        }]
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'GrpL'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'slct'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<name>": "Temp_1"
                        }
                    }]
                },
                selectionModifier: {
                    "<enumerated>": {
                        selectionModifierType: "addToSelectionContinuous"
                    }
                },
                "'MkVs'": {
                    "<boolean>": false
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'Mk  '", {
                "'null'": {
                    "<reference>": [{
                        layerSection: {
                            "<class>": null
                        }
                    }]
                },
                "'From'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Clr '": {
                                "<enumerated>": {
                                    "'Clr '": "'Bl  '"
                                }
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "FS_Radius_"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'slct'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<name>": "Temp_1"
                        }
                    }]
                },
                "'MkVs'": {
                    "<boolean>": false
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Volume_R="
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'slct'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<name>": "Temp_2"
                        }
                    }]
                },
                "'MkVs'": {
                    "<boolean>": false
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Texture_R="
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Texture_R=Manual"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'slct'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<name>": "FS_Radius_"
                        }
                    }]
                },
                "'MkVs'": {
                    "<boolean>": false
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "2 F-S Portraiture 8 bits"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'slct'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<name>": "Volume_R="
                        }
                    }]
                },
                "'MkVs'": {
                    "<boolean>": false
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Volume_R=Manual"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'CpTL'", null, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Lyr '": {
                            "<enumerated>": {
                                "'Ordn'": "'Trgt'"
                            }
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'Lyr '": {
                            "'Nm  '": {
                                "<string>": "Volume_Retouch"
                            }
                        }
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("df04cbe7-7dc2-436c-b010-4d0d39758adf", {
                "'pdOu'": {
                    "<integer>": 0
                },
                "'pdRw'": {
                    "<data>": "<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\r\n<rdf:Document rdf:about=\"\" xmlns:nws=\"http://www.imagenomic.com/PT/2.0/filter/\">\r\n<nws:ID>1936028737</nws:ID>\r\n<nws:Name><![CDATA[]]></nws:Name>\r\n<nws:Group><![CDATA[]]></nws:Group>\r\n<nws:Description><![CDATA[]]></nws:Description>\r\n<nws:VM_1937012307>\r\n<rdf:Seq>\r\n<rdf:_1>-1,1936028737</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1937012307>\r\n<nws:VM_2>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_2>\r\n<nws:VM_1937012302>\r\n<rdf:Seq>\r\n<rdf:_1>-1,5</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1937012302>\r\n<nws:VM_1937012303>\r\n<rdf:Seq>\r\n<rdf:_1>-1,11</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1937012303>\r\n<nws:VM_1937012304>\r\n<rdf:Seq>\r\n<rdf:_1>-1,15</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1937012304>\r\n<nws:VM_1937012290>\r\n<rdf:Seq>\r\n<rdf:_1>-1,40</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1937012290>\r\n<nws:VM_1886670963>\r\n<rdf:Seq>\r\n<rdf:_1>-1,3</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886670963>\r\n<nws:VM_3>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_3>\r\n<nws:VM_1886670195>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886670195>\r\n<nws:VM_1886670187>\r\n<rdf:Seq>\r\n<rdf:_1>-1,1</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886670187>\r\n<nws:VM_1886670190>\r\n<rdf:Seq>\r\n<rdf:_1>-1,2</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886670190>\r\n<nws:VM_1886670194>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886670194>\r\n<nws:VM_1886671728>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671728>\r\n<nws:VM_1886671736>\r\n<rdf:Seq>\r\n<rdf:_1>-1,100</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671736>\r\n<nws:VM_1886671727>\r\n<rdf:Seq>\r\n<rdf:_1>-1,100</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671727>\r\n<nws:VM_1886668919>\r\n<rdf:Seq>\r\n<rdf:_1>-1,100</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886668919>\r\n<nws:VM_1886671720>\r\n<rdf:Seq>\r\n<rdf:_1>-1,153</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671720>\r\n<nws:VM_1886671731>\r\n<rdf:Seq>\r\n<rdf:_1>-1,83</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671731>\r\n<nws:VM_1886671732>\r\n<rdf:Seq>\r\n<rdf:_1>-1,100</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671732>\r\n<nws:VM_1886671730>\r\n<rdf:Seq>\r\n<rdf:_1>-1,40</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671730>\r\n<nws:VM_1886671713>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671713>\r\n<nws:VM_1886671982>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886671982>\r\n<nws:VM_4>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_4>\r\n<nws:VM_1886668133>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886668133>\r\n<nws:VM_1886668141>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886668141>\r\n<nws:VM_1937012301>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1937012301>\r\n<nws:VM_1919369836>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1919369836>\r\n<nws:VM_1936995414>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1936995414>\r\n<nws:VM_1886668917>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886668917>\r\n<nws:VM_1936995416>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1936995416>\r\n<nws:VM_1936995415>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1936995415>\r\n<nws:VM_1886668901>\r\n<rdf:Seq>\r\n<rdf:_1>-1,50</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886668901>\r\n<nws:VM_5>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_5>\r\n<nws:VM_1886670196>\r\n<rdf:Seq>\r\n<rdf:_1>-1,1</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1886670196>\r\n<nws:VM_1885622133>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1885622133>\r\n<nws:VM_1885621871>\r\n<rdf:Seq>\r\n<rdf:_1>-1,100</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1885621871>\r\n<nws:VM_1885622132>\r\n<rdf:Seq>\r\n<rdf:_1>-1,0</rdf:_1>\r\n</rdf:Seq>\r\n</nws:VM_1885622132>\r\n</rdf:Document></rdf:RDF>"
                },
                "'pdNo'": {
                    "<integer>": 100
                }
            }, DialogModes.ALL);
            jamEngine.jsonPlay("'Mk  '", {
                "'Nw  '": {
                    "<class>": "'Chnl'"
                },
                "'At  '": {
                    "<reference>": [{
                        "'Chnl'": {
                            "<enumerated>": {
                                "'Chnl'": "'Msk '"
                            }
                        }
                    }]
                },
                "'Usng'": {
                    "<enumerated>": {
                        "'UsrM'": "'HdAl'"
                    }
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'slct'", {
                "'null'": {
                    "<reference>": [{
                        "'PbTl'": {
                            "<class>": null
                        }
                    }]
                }
            }, DialogModes.NO);
            jamEngine.jsonPlay("'setd'", {
                "'null'": {
                    "<reference>": [{
                        "'Clr '": {
                            "<property>": "'FrgC'"
                        }
                    }]
                },
                "'T   '": {
                    "<object>": {
                        "'HSBC'": {
                            "'H   '": {
                                "<unitDouble>": {
                                    "'#Ang'": 0
                                }
                            },
                            "'Strt'": {
                                "<double>": 0
                            },
                            "'Brgh'": {
                                "<double>": 100
                            }
                        }
                    }
                },
                "'Srce'": {
                    "<string>": "photoshopPicker"
                }
            }, DialogModes.NO);
            var idDlt = charIDToTypeID("Dlt ");
            var desc63 = new ActionDescriptor();
            var idnull = charIDToTypeID("null");
            var ref28 = new ActionReference();
            var idChnl = charIDToTypeID("Chnl");
            var idOrdn = charIDToTypeID("Ordn");
            var idTrgt = charIDToTypeID("Trgt");
            ref28.putEnumerated(idChnl, idOrdn, idTrgt);
            desc63.putReference(idnull, ref28);
            executeAction(idDlt, desc63, DialogModes.NO);
            var idClrR = charIDToTypeID("ClrR");
            var desc66 = new ActionDescriptor();
            var idFzns = charIDToTypeID("Fzns");
            desc66.putInteger(idFzns, 55);
            var idClrs = charIDToTypeID("Clrs");
            var idClrs = charIDToTypeID("Clrs");
            var idskinTone = stringIDToTypeID("skinTone");
            desc66.putEnumerated(idClrs, idClrs, idskinTone);
            var idcolorModel = stringIDToTypeID("colorModel");
            desc66.putInteger(idcolorModel, 0);
            executeAction(idClrR, desc66, DialogModes.NO);
            var idMk = charIDToTypeID("Mk  ");
            var desc67 = new ActionDescriptor();
            var idNw = charIDToTypeID("Nw  ");
            var idChnl = charIDToTypeID("Chnl");
            desc67.putClass(idNw, idChnl);
            var idAt = charIDToTypeID("At  ");
            var ref29 = new ActionReference();
            var idChnl = charIDToTypeID("Chnl");
            var idChnl = charIDToTypeID("Chnl");
            var idMsk = charIDToTypeID("Msk ");
            ref29.putEnumerated(idChnl, idChnl, idMsk);
            desc67.putReference(idAt, ref29);
            var idUsng = charIDToTypeID("Usng");
            var idUsrM = charIDToTypeID("UsrM");
            var idRvlS = charIDToTypeID("RvlS");
            desc67.putEnumerated(idUsng, idUsrM, idRvlS);
            executeAction(idMk, desc67, DialogModes.NO);
        } catch (e) {
            alert("使用这种频率分离方法,请安装' 肖像 '插件。您可以在视频教程指南中找到有关信息。");
        }
        if (e.number !== 8007) {
            try {
                jamEngine.jsonPlay("'Stop'", {
                    "'Msge'": {
                        "<string>": e.message.replace(/^.*\n- /, "")
                    }
                }, DialogModes.ALL);
            } catch (e) {

            }
        }
    }

    

3.作者寄语

  合理的脚本代码可以有效的提高工作效率,减少重复劳动。


  欢迎光临知了软件开发网络平台,本公司定制开发各类软件,主要方向为桌面专业软件开发、插件定制开发、微信小程序(各类小程序)、网站定制开发和App开发,桌面软件主要包括文字图形识别类软件,信息管理类软件,3D打印类软件,视频类软件以及其它涉及专业的各类图形图像处理软件。插件包含AE插件,AI插件,PS插件,PDF插件,3DMAX插件以及Word,Excel等Office插件开发。详情请咨询,微信QQ:312117271,手机:18928899728,邮箱: anjingzhi_sea@163.com.
公司网址:http://www.zhiliaos.com

标签:case,分频,插件,--,value,break,var,buildCompact,jamEngine
来源: https://blog.csdn.net/weixin_42247427/article/details/121929281