其他分享
首页 > 其他分享> > Photoshop插件--删除亮调通道蒙板--脚本开发--PS插件

Photoshop插件--删除亮调通道蒙板--脚本开发--PS插件

作者:互联网

文章目录


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

1.插件界面

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

2.关键代码-删除亮度通道蒙板

  大家可通过源代码阅读,来掌握相关技巧,源代码如下:

// jamEngine.jsxinc v4.4 (minified)
if (typeof jamEngine !== 'object') {
    var jamEngine = {};
    (function () {
        var that;
        jamEngine.meaningfulIds = false;
        jamEngine.parseFriendly = false;
        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 === (1 + 4 + 1)) && (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++) {
                    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++) {
                    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", "<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",
                    "gradientClassEvent": "interpolation",
                    "photoshopEPSFormat": "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 uniIdStr;
            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 desiredCompact;
                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++) {
                var itemCompact;
                var typeID;
                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.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.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:
                        var isRawType;
                        var isLargeIntegerType;
                        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 = {};
                var keyCount;
                try {
                    keyCount = desc.count;
                } catch (e) {
                    return null;
                }
                for (var keyIndex = 0; keyIndex < keyCount; keyIndex++) {
                    var keyID = desc.getKey(keyIndex);
                    var keyString = getFromId(["<key>", keyID], parentContext);
                    var keyCompact;
                    var typeID;
                    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.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.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:
                            var isRawType;
                            var isLargeIntegerType;
                            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;
            var actionDescriptor;
            if (descriptorObj) {
                actionDescriptor = new ActionDescriptor();
                putInDescriptor(actionDescriptor, descriptorObj);
            }
            return actionDescriptor;
        };
        jamEngine.jsonToActionReference = function (referenceArr) {
            that = this;
            var actionReference;
            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);
            var parentContext;
            if (eventId === getEventId) {
                var ref = desc.getReference(targetKeyId);
                parentContext = ["<class>", getReferenceClassId(ref)];
            } else {
                parentContext = ["<event>", eventId];
            }
            return getFromDescriptor(app.executeAction(eventId, desc, 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];
                var normalizedValue;
                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++) {
                            normalizedValue.push(normalizeItem(value[i]));
                        }
                        break;
                    case"<object>":
                        var object = that.parseCompact(value);
                        var objectClassContext = ["<class>", that.uniIdStrToId(object[0])];
                        var objectDescriptor = object[1];
                        var normalizedDescriptor;
                        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++) {
                            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++) {
                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 simplifiedItem;
            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++) {
                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) {
            var compact;
            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) {
            var compact;
            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 = true;
jamEngine.parseFriendly = true;

// Action “Delete Bright LMs”
try {
    // Select
    if (true) {
        jamEngine.jsonPlay
        (
            "select",
            {
                "target":
                    [
                        "<reference>",
                        [
                            [
                                "channel",
                                [
                                    "<name>",
                                    "Brights 1"
                                ]
                            ]
                        ]
                    ]
            },
            DialogModes.NO
        );
    }
    // Select
    if (true) {
        jamEngine.jsonPlay
        (
            "select",
            {
                "target":
                    [
                        "<reference>",
                        [
                            [
                                "channel",
                                [
                                    "<name>",
                                    "Brights 2"
                                ]
                            ]
                        ]
                    ],
                "extend":
                    [
                        "<boolean>",
                        true
                    ]
            },
            DialogModes.NO
        );
    }
    // Select
    if (true) {
        jamEngine.jsonPlay
        (
            "select",
            {
                "target":
                    [
                        "<reference>",
                        [
                            [
                                "channel",
                                [
                                    "<name>",
                                    "Brights 3"
                                ]
                            ]
                        ]
                    ],
                "extend":
                    [
                        "<boolean>",
                        true
                    ]
            },
            DialogModes.NO
        );
    }
    // Select
    if (true) {
        jamEngine.jsonPlay
        (
            "select",
            {
                "target":
                    [
                        "<reference>",
                        [
                            [
                                "channel",
                                [
                                    "<name>",
                                    "Brights 4"
                                ]
                            ]
                        ]
                    ],
                "extend":
                    [
                        "<boolean>",
                        true
                    ]
            },
            DialogModes.NO
        );
    }
    // Select
    if (true) {
        jamEngine.jsonPlay
        (
            "select",
            {
                "target":
                    [
                        "<reference>",
                        [
                            [
                                "channel",
                                [
                                    "<name>",
                                    "Brights 5"
                                ]
                            ]
                        ]
                    ],
                "extend":
                    [
                        "<boolean>",
                        true
                    ]
            },
            DialogModes.NO
        );
    }
    // Select
    if (true) {
        jamEngine.jsonPlay
        (
            "select",
            {
                "target":
                    [
                        "<reference>",
                        [
                            [
                                "channel",
                                [
                                    "<name>",
                                    "Brights 6"
                                ]
                            ]
                        ]
                    ],
                "extend":
                    [
                        "<boolean>",
                        true
                    ]
            },
            DialogModes.NO
        );
    }
    // Delete
    if (true) {
        jamEngine.jsonPlay
        (
            "delete",
            {
                "target":
                    [
                        "<list>",
                        [
                            [
                                "<reference>",
                                [
                                    [
                                        "channel",
                                        [
                                            "<name>",
                                            "Brights 6"
                                        ]
                                    ]
                                ]
                            ],
                            [
                                "<reference>",
                                [
                                    [
                                        "channel",
                                        [
                                            "<name>",
                                            "Brights 5"
                                        ]
                                    ]
                                ]
                            ],
                            [
                                "<reference>",
                                [
                                    [
                                        "channel",
                                        [
                                            "<name>",
                                            "Brights 4"
                                        ]
                                    ]
                                ]
                            ],
                            [
                                "<reference>",
                                [
                                    [
                                        "channel",
                                        [
                                            "<name>",
                                            "Brights 3"
                                        ]
                                    ]
                                ]
                            ],
                            [
                                "<reference>",
                                [
                                    [
                                        "channel",
                                        [
                                            "<name>",
                                            "Brights 2"
                                        ]
                                    ]
                                ]
                            ],
                            [
                                "<reference>",
                                [
                                    [
                                        "channel",
                                        [
                                            "<name>",
                                            "Brights 1"
                                        ]
                                    ]
                                ]
                            ]
                        ]
                    ]
            },
            DialogModes.NO
        );
    }
}
catch (e) {
    if (e.number !== 8007)  // Not a user cancel error
    {
        try {
            jamEngine.jsonPlay
            (
                "stop",
                {
                    "message":
                        [
                            "<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,Photoshop,插件,--,value,break,var,buildCompact,jamEngine
来源: https://blog.csdn.net/weixin_42247427/article/details/122488113