@lcap/nasl 0.3.15-beta → 1.0.0-alpha

package/src/concepts/ProcessElement__.ts

@@ -0,0 +1,1370 @@
+import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property } from '../decorators';
+
+import * as utils from '../utils';
+import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
+import Rect from './Rect__';
+import Point from './Point__';
+import Logic from './Logic__';
+import Variable from './Variable__';
+import Return from './Return__';
+import Constant from './Constant__';
+import BindAttribute from './BindAttribute__';
+import Process from './Process__';
+import Module from './Module__';
+import App from './App__';
+
+/**
+ * 流程元素
+ */
+@concept
+export class ProcessElement extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'ProcessElement' = 'ProcessElement';
+
+    /**
+     * 流程元素名称
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 流程元素标题
+     */
+    @property()
+    title: string = undefined;
+
+    /**
+     * 流程元素描述
+     */
+    @property()
+    description: string = undefined;
+
+    /**
+     * type
+     */
+    @property()
+    type: string = undefined;
+
+    /**
+     * sourceRef
+     */
+    @property()
+    sourceRef: string = undefined;
+
+    /**
+     * targetRef
+     */
+    @property()
+    targetRef: string = undefined;
+
+    /**
+     * 矩形信息
+     */
+    @property('Rect')
+    bounds: Rect = undefined;
+
+    /**
+     * 点信息列表
+     */
+    @property('Point')
+    waypoints: Array<Point> = [];
+
+    /**
+     * flowValue
+     */
+    @property()
+    flowValue: string = undefined;
+
+    /**
+     * 逻辑
+     */
+    @property('Logic')
+    logic: Logic = undefined;
+
+    /**
+     * 局部变量列表
+     */
+    @property('Variable')
+    variables: Array<Variable> = [];
+
+    /**
+     * 输出参数列表
+     */
+    @property('Return')
+    returns: Array<Return> = [];
+
+    /**
+     * 常量列表
+     */
+    @property('Constant')
+    constants: Array<Constant> = [];
+
+    /**
+     * 元素绑定属性列表
+     */
+    @property('BindAttribute')
+    bindAttrs: Array<BindAttribute> = [];
+
+    /**
+     * 祖先 Process
+     */
+    get process() {
+        return this.getAncestor('Process') as Process;
+    }
+    /**
+     * 祖先 Module
+     */
+    get module() {
+        return this.getAncestor('Module') as Module;
+    }
+    /**
+     * 祖先 App
+     */
+    get app() {
+        return this.getAncestor('App') as App;
+    }
+
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<ProcessElement>) {
+        source = Object.assign({}, ProcessElement.getDefaultOptions(), source);
+        super(source);
+        super.subConstructor(source);
+    }
+
+    static from(source: any, parentNode?: any, parentKey?: string): ProcessElement {
+        return super.from(source, parentNode, parentKey) as ProcessElement;
+    }
+
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    _delete() {
+        let params: Params = null;
+        if (this.parentNode) {
+            params = (this.parentNode as any)?.__removeProcessElement?.(this);
+        }
+        return params;
+    }
+    /**
+     * 设置流程元素名称
+     */
+    setName(name: string) {
+        const object = {
+            name,
+        };
+        this.update({
+            ...object,
+            field: 'name',
+        });
+    }
+
+    /**
+     * 设置流程元素标题
+     */
+    setTitle(title: string) {
+        const object = {
+            title,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置流程元素描述
+     */
+    setDescription(description: string) {
+        const object = {
+            description,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置sourceRef
+     */
+    setSourceRef(sourceRef: string) {
+        const object = {
+            sourceRef,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置targetRef
+     */
+    setTargetRef(targetRef: string) {
+        const object = {
+            targetRef,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置矩形信息
+     */
+    setBounds(bounds: Rect) {
+        bounds._delete();
+        const relationOptions = { parentNode: this, parentKey: 'bounds' };
+        Object.assign(bounds, relationOptions);
+        const object = {
+            bounds,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置flowValue
+     */
+    setFlowValue(flowValue: string) {
+        const object = {
+            flowValue,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+        getPointExistingNames(excludedList: Array<Point> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.waypoints.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getPointUniqueName(name = 'point1') {
+        return utils.unique(name, this.getPointExistingNames());
+    }
+
+    /**
+    * 插入点信息
+    * @internal
+    * @param name 点信息名称，如果不填会自动生成一个唯一名称
+    */
+    _insertPointAt(name: string, index: number): Point;
+
+    /**
+    * 插入点信息
+    * @internal
+    * @param pointOptions 点信息参数
+    */
+    _insertPointAt(pointOptions: Partial<Point>, index: number): Point;
+
+    /**
+    * 插入点信息
+    * @internal
+    * @param point 已有的点信息实例
+    */
+    _insertPointAt(point: Point, index: number): Point;
+
+    _insertPointAt(options: string | Partial<Point> | Point, index: number) {
+        const pointOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'waypoints' };
+        let point: Point;
+        if (!options) {
+            point = Point.from({
+                ...pointOptions,
+                name: this.getPointUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            point = Point.from({
+                ...pointOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Point) {
+            options.delete(); // 同一实例不支持多处存在
+            point = options;
+        } else {
+            point = Point.from({
+                ...pointOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(point, relationOptions);
+        this.waypoints.splice(index, 0, point);
+        return point;
+    }
+
+    /**
+     * 插入点信息
+     * @param name 点信息名称，如果不填会自动生成一个唯一名称
+     */
+    insertPointAt(name: string, index: number): Point;
+
+    /**
+     * 插入点信息
+     * @param pointOptions 点信息参数
+     */
+    insertPointAt(pointOptions: Partial<Point>, index: number): Point;
+
+    /**
+     * 插入点信息
+     * @param point 已有的点信息实例
+     */
+    insertPointAt(point: Point, index: number): Point;
+
+    insertPointAt(options: string | Partial<Point> | Point, index: number) {
+        const node = this._insertPointAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'waypoints',
+        });
+        return node;
+    }
+
+    /**
+     * 添加点信息
+     * @internal
+     * @param name 点信息名称，如果不填会自动生成一个唯一名称
+     */
+    _addPoint(name?: string): Point;
+
+    /**
+     * 添加点信息
+     * @internal
+     * @param pointOptions 点信息参数
+     */
+    _addPoint(pointOptions: Partial<Point>): Point;
+
+    /**
+     * 添加点信息
+     * @internal
+     * @param point 已有的点信息实例
+     */
+    _addPoint(point: Point): Point;
+
+    _addPoint(options?: string | Partial<Point> | Point) {
+        const index = this.waypoints.length;
+        return this._insertPointAt(options as any, index);
+    }
+
+    /**
+     * 添加点信息
+     * @internal
+     * @param name 点信息名称，如果不填会自动生成一个唯一名称
+     */
+    addPoint(name?: string): Point;
+
+    /**
+     * 添加点信息
+     * @param pointOptions 点信息参数
+     */
+    addPoint(pointOptions: Partial<Point>): Point;
+
+    /**
+     * 添加点信息
+     * @param point 已有的点信息实例
+     */
+    addPoint(point: Point): Point;
+
+    addPoint(options?: string | Partial<Point> | Point) {
+        const node = this._addPoint(options as any);
+        const index = this.waypoints.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'waypoints',
+        });
+        return node;
+    }
+
+
+    getVariableExistingNames(excludedList: Array<Variable> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.variables.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getVariableUniqueName(name = 'variable1') {
+        return utils.unique(name, this.getVariableExistingNames());
+    }
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+    */
+    _insertVariableAt(name: string, index: number): Variable;
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param variableOptions 局部变量参数
+    */
+    _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param variable 已有的局部变量实例
+    */
+    _insertVariableAt(variable: Variable, index: number): Variable;
+
+    _insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
+        const variableOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'variables' };
+        let variable: Variable;
+        if (!options) {
+            variable = Variable.from({
+                ...variableOptions,
+                name: this.getVariableUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            variable = Variable.from({
+                ...variableOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Variable) {
+            options.delete(); // 同一实例不支持多处存在
+            variable = options;
+        } else {
+            variable = Variable.from({
+                ...variableOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(variable, relationOptions);
+        this.variables.splice(index, 0, variable);
+        return variable;
+    }
+
+    /**
+     * 插入局部变量
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    insertVariableAt(name: string, index: number): Variable;
+
+    /**
+     * 插入局部变量
+     * @param variableOptions 局部变量参数
+     */
+    insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+    /**
+     * 插入局部变量
+     * @param variable 已有的局部变量实例
+     */
+    insertVariableAt(variable: Variable, index: number): Variable;
+
+    insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
+        const node = this._insertVariableAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'variables',
+        });
+        return node;
+    }
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    _addVariable(name?: string): Variable;
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param variableOptions 局部变量参数
+     */
+    _addVariable(variableOptions: Partial<Variable>): Variable;
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param variable 已有的局部变量实例
+     */
+    _addVariable(variable: Variable): Variable;
+
+    _addVariable(options?: string | Partial<Variable> | Variable) {
+        const index = this.variables.length;
+        return this._insertVariableAt(options as any, index);
+    }
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    addVariable(name?: string): Variable;
+
+    /**
+     * 添加局部变量
+     * @param variableOptions 局部变量参数
+     */
+    addVariable(variableOptions: Partial<Variable>): Variable;
+
+    /**
+     * 添加局部变量
+     * @param variable 已有的局部变量实例
+     */
+    addVariable(variable: Variable): Variable;
+
+    addVariable(options?: string | Partial<Variable> | Variable) {
+        const node = this._addVariable(options as any);
+        const index = this.variables.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'variables',
+        });
+        return node;
+    }
+
+
+    getReturnExistingNames(excludedList: Array<Return> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.returns.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getReturnUniqueName(name = 'ret1') {
+        return utils.unique(name, this.getReturnExistingNames());
+    }
+
+    /**
+    * 插入输出参数
+    * @internal
+    * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+    */
+    _insertReturnAt(name: string, index: number): Return;
+
+    /**
+    * 插入输出参数
+    * @internal
+    * @param retOptions 输出参数参数
+    */
+    _insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+
+    /**
+    * 插入输出参数
+    * @internal
+    * @param ret 已有的输出参数实例
+    */
+    _insertReturnAt(ret: Return, index: number): Return;
+
+    _insertReturnAt(options: string | Partial<Return> | Return, index: number) {
+        const retOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'returns' };
+        let ret: Return;
+        if (!options) {
+            ret = Return.from({
+                ...retOptions,
+                name: this.getReturnUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            ret = Return.from({
+                ...retOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Return) {
+            options.delete(); // 同一实例不支持多处存在
+            ret = options;
+        } else {
+            ret = Return.from({
+                ...retOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(ret, relationOptions);
+        this.returns.splice(index, 0, ret);
+        return ret;
+    }
+
+    /**
+     * 插入输出参数
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertReturnAt(name: string, index: number): Return;
+
+    /**
+     * 插入输出参数
+     * @param retOptions 输出参数参数
+     */
+    insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+
+    /**
+     * 插入输出参数
+     * @param ret 已有的输出参数实例
+     */
+    insertReturnAt(ret: Return, index: number): Return;
+
+    insertReturnAt(options: string | Partial<Return> | Return, index: number) {
+        const node = this._insertReturnAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'returns',
+        });
+        return node;
+    }
+
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addReturn(name?: string): Return;
+
+    /**
+     * 添加输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
+    _addReturn(retOptions: Partial<Return>): Return;
+
+    /**
+     * 添加输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
+    _addReturn(ret: Return): Return;
+
+    _addReturn(options?: string | Partial<Return> | Return) {
+        const index = this.returns.length;
+        return this._insertReturnAt(options as any, index);
+    }
+
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    addReturn(name?: string): Return;
+
+    /**
+     * 添加输出参数
+     * @param retOptions 输出参数参数
+     */
+    addReturn(retOptions: Partial<Return>): Return;
+
+    /**
+     * 添加输出参数
+     * @param ret 已有的输出参数实例
+     */
+    addReturn(ret: Return): Return;
+
+    addReturn(options?: string | Partial<Return> | Return) {
+        const node = this._addReturn(options as any);
+        const index = this.returns.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'returns',
+        });
+        return node;
+    }
+
+
+    getConstantExistingNames(excludedList: Array<Constant> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.constants.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getConstantUniqueName(name = 'constant1') {
+        return utils.unique(name, this.getConstantExistingNames());
+    }
+
+    /**
+    * 插入常量
+    * @internal
+    * @param name 常量名称，如果不填会自动生成一个唯一名称
+    */
+    _insertConstantAt(name: string, index: number): Constant;
+
+    /**
+    * 插入常量
+    * @internal
+    * @param constantOptions 常量参数
+    */
+    _insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
+
+    /**
+    * 插入常量
+    * @internal
+    * @param constant 已有的常量实例
+    */
+    _insertConstantAt(constant: Constant, index: number): Constant;
+
+    _insertConstantAt(options: string | Partial<Constant> | Constant, index: number) {
+        const constantOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'constants' };
+        let constant: Constant;
+        if (!options) {
+            constant = Constant.from({
+                ...constantOptions,
+                name: this.getConstantUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            constant = Constant.from({
+                ...constantOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Constant) {
+            options.delete(); // 同一实例不支持多处存在
+            constant = options;
+        } else {
+            constant = Constant.from({
+                ...constantOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(constant, relationOptions);
+        this.constants.splice(index, 0, constant);
+        return constant;
+    }
+
+    /**
+     * 插入常量
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    insertConstantAt(name: string, index: number): Constant;
+
+    /**
+     * 插入常量
+     * @param constantOptions 常量参数
+     */
+    insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
+
+    /**
+     * 插入常量
+     * @param constant 已有的常量实例
+     */
+    insertConstantAt(constant: Constant, index: number): Constant;
+
+    insertConstantAt(options: string | Partial<Constant> | Constant, index: number) {
+        const node = this._insertConstantAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'constants',
+        });
+        return node;
+    }
+
+    /**
+     * 添加常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    _addConstant(name?: string): Constant;
+
+    /**
+     * 添加常量
+     * @internal
+     * @param constantOptions 常量参数
+     */
+    _addConstant(constantOptions: Partial<Constant>): Constant;
+
+    /**
+     * 添加常量
+     * @internal
+     * @param constant 已有的常量实例
+     */
+    _addConstant(constant: Constant): Constant;
+
+    _addConstant(options?: string | Partial<Constant> | Constant) {
+        const index = this.constants.length;
+        return this._insertConstantAt(options as any, index);
+    }
+
+    /**
+     * 添加常量
+     * @internal
+     * @param name 常量名称，如果不填会自动生成一个唯一名称
+     */
+    addConstant(name?: string): Constant;
+
+    /**
+     * 添加常量
+     * @param constantOptions 常量参数
+     */
+    addConstant(constantOptions: Partial<Constant>): Constant;
+
+    /**
+     * 添加常量
+     * @param constant 已有的常量实例
+     */
+    addConstant(constant: Constant): Constant;
+
+    addConstant(options?: string | Partial<Constant> | Constant) {
+        const node = this._addConstant(options as any);
+        const index = this.constants.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'constants',
+        });
+        return node;
+    }
+
+
+    getBindAttributeExistingNames(excludedList: Array<BindAttribute> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.bindAttrs.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getBindAttributeUniqueName(name = 'bindAttribute1') {
+        return utils.unique(name, this.getBindAttributeExistingNames());
+    }
+
+    /**
+    * 插入元素绑定属性
+    * @internal
+    * @param name 元素绑定属性名称，如果不填会自动生成一个唯一名称
+    */
+    _insertBindAttributeAt(name: string, index: number): BindAttribute;
+
+    /**
+    * 插入元素绑定属性
+    * @internal
+    * @param bindAttributeOptions 元素绑定属性参数
+    */
+    _insertBindAttributeAt(bindAttributeOptions: Partial<BindAttribute>, index: number): BindAttribute;
+
+    /**
+    * 插入元素绑定属性
+    * @internal
+    * @param bindAttribute 已有的元素绑定属性实例
+    */
+    _insertBindAttributeAt(bindAttribute: BindAttribute, index: number): BindAttribute;
+
+    _insertBindAttributeAt(options: string | Partial<BindAttribute> | BindAttribute, index: number) {
+        const bindAttributeOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'bindAttrs' };
+        let bindAttribute: BindAttribute;
+        if (!options) {
+            bindAttribute = BindAttribute.from({
+                ...bindAttributeOptions,
+                name: this.getBindAttributeUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            bindAttribute = BindAttribute.from({
+                ...bindAttributeOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof BindAttribute) {
+            options.delete(); // 同一实例不支持多处存在
+            bindAttribute = options;
+        } else {
+            bindAttribute = BindAttribute.from({
+                ...bindAttributeOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(bindAttribute, relationOptions);
+        this.bindAttrs.splice(index, 0, bindAttribute);
+        return bindAttribute;
+    }
+
+    /**
+     * 插入元素绑定属性
+     * @param name 元素绑定属性名称，如果不填会自动生成一个唯一名称
+     */
+    insertBindAttributeAt(name: string, index: number): BindAttribute;
+
+    /**
+     * 插入元素绑定属性
+     * @param bindAttributeOptions 元素绑定属性参数
+     */
+    insertBindAttributeAt(bindAttributeOptions: Partial<BindAttribute>, index: number): BindAttribute;
+
+    /**
+     * 插入元素绑定属性
+     * @param bindAttribute 已有的元素绑定属性实例
+     */
+    insertBindAttributeAt(bindAttribute: BindAttribute, index: number): BindAttribute;
+
+    insertBindAttributeAt(options: string | Partial<BindAttribute> | BindAttribute, index: number) {
+        const node = this._insertBindAttributeAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'bindAttrs',
+        });
+        return node;
+    }
+
+    /**
+     * 添加元素绑定属性
+     * @internal
+     * @param name 元素绑定属性名称，如果不填会自动生成一个唯一名称
+     */
+    _addBindAttribute(name?: string): BindAttribute;
+
+    /**
+     * 添加元素绑定属性
+     * @internal
+     * @param bindAttributeOptions 元素绑定属性参数
+     */
+    _addBindAttribute(bindAttributeOptions: Partial<BindAttribute>): BindAttribute;
+
+    /**
+     * 添加元素绑定属性
+     * @internal
+     * @param bindAttribute 已有的元素绑定属性实例
+     */
+    _addBindAttribute(bindAttribute: BindAttribute): BindAttribute;
+
+    _addBindAttribute(options?: string | Partial<BindAttribute> | BindAttribute) {
+        const index = this.bindAttrs.length;
+        return this._insertBindAttributeAt(options as any, index);
+    }
+
+    /**
+     * 添加元素绑定属性
+     * @internal
+     * @param name 元素绑定属性名称，如果不填会自动生成一个唯一名称
+     */
+    addBindAttribute(name?: string): BindAttribute;
+
+    /**
+     * 添加元素绑定属性
+     * @param bindAttributeOptions 元素绑定属性参数
+     */
+    addBindAttribute(bindAttributeOptions: Partial<BindAttribute>): BindAttribute;
+
+    /**
+     * 添加元素绑定属性
+     * @param bindAttribute 已有的元素绑定属性实例
+     */
+    addBindAttribute(bindAttribute: BindAttribute): BindAttribute;
+
+    addBindAttribute(options?: string | Partial<BindAttribute> | BindAttribute) {
+        const node = this._addBindAttribute(options as any);
+        const index = this.bindAttrs.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'bindAttrs',
+        });
+        return node;
+    }
+
+
+    
+
+    /**
+    * 删除矩形信息
+    * @param name 矩形信息名称
+    */
+    removeBounds(name: string): void;
+
+    /**
+     * 删除矩形信息
+     * @param bounds 已有的矩形信息实例
+     */
+    removeBounds(bounds: Rect): void;
+
+    removeBounds(options: string | Rect) {
+        let bounds: Rect;
+        if (typeof options === 'string') {
+            bounds = this.bounds;
+            if (!bounds) {
+                throw new Error('找不到矩形信息 ' + options);
+            }
+        } else {
+            bounds = options;
+        }
+        return bounds.delete();
+    }
+
+    __removeRect(rect: Rect) {
+        const parentKey = rect.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: rect,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(rect);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === rect) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除点信息
+    * @param name 点信息名称
+    */
+    removePoint(name: string): void;
+
+    /**
+     * 删除点信息
+     * @param point 已有的点信息实例
+     */
+    removePoint(point: Point): void;
+
+    removePoint(options: string | Point) {
+        let point: Point;
+        if (typeof options === 'string') {
+            point = this.waypoints.find((item) => item.name === options);
+            if (!point) {
+                throw new Error('找不到点信息 ' + options);
+            }
+        } else {
+            point = options;
+        }
+        return point.delete();
+    }
+
+    __removePoint(point: Point) {
+        const parentKey = point.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: point,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(point);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === point) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除逻辑
+    * @param name 逻辑名称
+    */
+    removeLogic(name: string): void;
+
+    /**
+     * 删除逻辑
+     * @param logic 已有的逻辑实例
+     */
+    removeLogic(logic: Logic): void;
+
+    removeLogic(options: string | Logic) {
+        let logic: Logic;
+        if (typeof options === 'string') {
+            logic = this.logic;
+            if (!logic) {
+                throw new Error('找不到逻辑 ' + options);
+            }
+        } else {
+            logic = options;
+        }
+        return logic.delete();
+    }
+
+    __removeLogic(logic: Logic) {
+        const parentKey = logic.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: logic,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(logic);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === logic) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除局部变量
+    * @param name 局部变量名称
+    */
+    removeVariable(name: string): void;
+
+    /**
+     * 删除局部变量
+     * @param variable 已有的局部变量实例
+     */
+    removeVariable(variable: Variable): void;
+
+    removeVariable(options: string | Variable) {
+        let variable: Variable;
+        if (typeof options === 'string') {
+            variable = this.variables.find((item) => item.name === options);
+            if (!variable) {
+                throw new Error('找不到局部变量 ' + options);
+            }
+        } else {
+            variable = options;
+        }
+        return variable.delete();
+    }
+
+    __removeVariable(variable: Variable) {
+        const parentKey = variable.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: variable,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(variable);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === variable) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除输出参数
+    * @param name 输出参数名称
+    */
+    removeReturn(name: string): void;
+
+    /**
+     * 删除输出参数
+     * @param ret 已有的输出参数实例
+     */
+    removeReturn(ret: Return): void;
+
+    removeReturn(options: string | Return) {
+        let ret: Return;
+        if (typeof options === 'string') {
+            ret = this.returns.find((item) => item.name === options);
+            if (!ret) {
+                throw new Error('找不到输出参数 ' + options);
+            }
+        } else {
+            ret = options;
+        }
+        return ret.delete();
+    }
+
+    __removeReturn(ret: Return) {
+        const parentKey = ret.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: ret,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(ret);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === ret) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除常量
+    * @param name 常量名称
+    */
+    removeConstant(name: string): void;
+
+    /**
+     * 删除常量
+     * @param constant 已有的常量实例
+     */
+    removeConstant(constant: Constant): void;
+
+    removeConstant(options: string | Constant) {
+        let constant: Constant;
+        if (typeof options === 'string') {
+            constant = this.constants.find((item) => item.name === options);
+            if (!constant) {
+                throw new Error('找不到常量 ' + options);
+            }
+        } else {
+            constant = options;
+        }
+        return constant.delete();
+    }
+
+    __removeConstant(constant: Constant) {
+        const parentKey = constant.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: constant,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(constant);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === constant) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+
+
+    /**
+    * 删除元素绑定属性
+    * @param name 元素绑定属性名称
+    */
+    removeBindAttribute(name: string): void;
+
+    /**
+     * 删除元素绑定属性
+     * @param bindAttribute 已有的元素绑定属性实例
+     */
+    removeBindAttribute(bindAttribute: BindAttribute): void;
+
+    removeBindAttribute(options: string | BindAttribute) {
+        let bindAttribute: BindAttribute;
+        if (typeof options === 'string') {
+            bindAttribute = this.bindAttrs.find((item) => item.name === options);
+            if (!bindAttribute) {
+                throw new Error('找不到元素绑定属性 ' + options);
+            }
+        } else {
+            bindAttribute = options;
+        }
+        return bindAttribute.delete();
+    }
+
+    __removeBindAttribute(bindAttribute: BindAttribute) {
+        const parentKey = bindAttribute.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: bindAttribute,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(bindAttribute);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === bindAttribute) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    getVarExistingNames(excludedList: Array<Variable | Return | Constant> = []) {
+        const excludedSet = new Set(excludedList);
+        return [...this.variables, ...this.returns, ...this.constants].filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        const tab0 = indent(state.tabSize);
+        let code = '';
+        this.variables.forEach((property) => {
+            code += `${tab0}let `;
+            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+
+        this.returns.forEach((property) => {
+            code += `${tab0}let `;
+            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+        this.constants.forEach((property) => {
+            code += `${tab0}let `;
+            code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            code += ';\n';
+        });
+        return code;
+    }
+
+    /**
+     * 设置流程元素名称
+     */
+    setNameWithFlowChange(name: string) {
+        this.app.emit('collect:start');
+        const oldName = this.name;
+        this.setName(name);
+        const process = this.process;
+        process.elements.forEach((el) => {
+            if (el.sourceRef === oldName) {
+                el.setSourceRef(name);
+            }
+            if (el.targetRef === oldName) {
+                el.setTargetRef(name);
+            }
+        });
+        this.app.emit('collect:end');
+    }
+    //================================================================================
+    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap['ProcessElement'] = ProcessElement;
+export default ProcessElement;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================