@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/concepts/BatchAssignment__.ts

@@ -1,17 +1,17 @@
+import { v4 as uuidv4 } from 'uuid';
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import MemberExpression from './MemberExpression__';
 import Assignment from './Assignment__';
 import Logic from './Logic__';
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import SelectMembers from './SelectMembers__';
@@ -23,975 +23,1023 @@ import LogicItem from './LogicItem__';
  */
 @concept('批量赋值语句')
 export class BatchAssignment extends LogicItem {
-    /**
-     * 产品概念
-     */
-    @property()
-    concept: 'BatchAssignment' = 'BatchAssignment';
-
-    /**
-     * 批量赋值语句标题
-     */
-    @property()
-    label: string = '批量赋值';
-
-    /**
-     * 左边项
-     */
-    @property('SelectMembers')
-    left: SelectMembers = undefined;
-
-    /**
-     * 右边项
-     */
-    @property('SelectMembers')
-    rights: Array<SelectMembers> = [];
-
-    /**
-     * 赋值
-     */
-    @property('AssignmentLine')
-    assignmentLines: Array<AssignmentLine> = [];
-
-    /**
-     * 自动连线
-     */
-    @property()
-    autoConnection: boolean = true;
-
-    
-
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source?: Partial<BatchAssignment>) {
-        source = Object.assign({}, BatchAssignment.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
+  /**
+   * 产品概念
+   */
+  @property()
+  concept: 'BatchAssignment' = 'BatchAssignment';
+
+  /**
+   * 批量赋值语句标题
+   */
+  @property()
+  label: string = '批量赋值';
+
+  /**
+   * 左边项
+   */
+  @property('SelectMembers')
+  left: SelectMembers = undefined;
+
+  /**
+   * 右边项
+   */
+  @property('SelectMembers')
+  rights: Array<SelectMembers> = [];
+
+  /**
+   * 赋值
+   */
+  @property('AssignmentLine')
+  assignmentLines: Array<AssignmentLine> = [];
+
+  /**
+   * 自动连线
+   */
+  @property()
+  autoConnection: boolean = true;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<BatchAssignment>) {
+    // @ts-ignore
+    source = { ...BatchAssignment.getDefaultOptions(), ...source };
+    super(source);
+    super.subConstructor(source);
+  }
+
+  getClassName() {
+    return 'BatchAssignment';
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): BatchAssignment {
+    return super.from(source, parentNode, parentKey) as BatchAssignment;
+  }
+
+  /**
+   * 设置左边项
+   */
+  setLeft(left: SelectMembers) {
+    left._delete();
+    const relationOptions = { parentNode: this, parentKey: 'left' };
+    Object.assign(left, relationOptions);
+    const object = {
+      left,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置右边项
+   */
+  setRights(rights: Array<SelectMembers>) {
+    const object = {
+      rights,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置赋值
+   */
+  setAssignmentLines(assignmentLines: Array<AssignmentLine>) {
+    const object = {
+      assignmentLines,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置自动连线
+   */
+  setAutoConnection(autoConnection: boolean) {
+    const object = {
+      autoConnection,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  getSelectMembersExistingNames(excludedList: Array<SelectMembers> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.rights as SelectMembers[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getSelectMembersUniqueName(name = 'selectMembers1') {
+    return utils.unique(name, this.getSelectMembersExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入选择成员
+   * @internal
+   * @param name 选择成员名称，如果不填会自动生成一个唯一名称
+   */
+  _insertSelectMembersAt(name: string, index: number): SelectMembers;
+
+  /**
+   * 插入选择成员
+   * @internal
+   * @param selectMembersOptions 选择成员参数
+   */
+  _insertSelectMembersAt(selectMembersOptions: Partial<SelectMembers>, index: number): SelectMembers;
+
+  /**
+   * 插入选择成员
+   * @internal
+   * @param selectMembers 已有的选择成员实例
+   */
+  _insertSelectMembersAt(selectMembers: SelectMembers, index: number): SelectMembers;
+
+  _insertSelectMembersAt(options: string | Partial<SelectMembers> | SelectMembers, index: number) {
+    const selectMembersOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'rights' };
+    let selectMembers: SelectMembers;
+    if (!options) {
+      selectMembers = SelectMembers.from(
+        {
+          ...selectMembersOptions,
+          name: this.getSelectMembersUniqueName(),
+        },
+        this,
+        'rights'
+      );
+    } else if (typeof options === 'string') {
+      selectMembers = SelectMembers.from(
+        {
+          ...selectMembersOptions,
+          name: options,
+        },
+        this,
+        'rights'
+      );
+    } else if (options instanceof SelectMembers) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      selectMembers = options;
+      Object.assign(selectMembers, relationOptions);
+    } else {
+      selectMembers = SelectMembers.from(
+        {
+          ...selectMembersOptions,
+          ...options,
+        },
+        this,
+        'rights'
+      );
     }
-    getClassName() {
-        return 'BatchAssignment';
+    this.rights.splice(index, 0, selectMembers);
+    return selectMembers;
+  }
+
+  /**
+   * 插入选择成员
+   * @param name 选择成员名称，如果不填会自动生成一个唯一名称
+   */
+  insertSelectMembersAt(name: string, index: number): SelectMembers;
+
+  /**
+   * 插入选择成员
+   * @param selectMembersOptions 选择成员参数
+   */
+  insertSelectMembersAt(selectMembersOptions: Partial<SelectMembers>, index: number): SelectMembers;
+
+  /**
+   * 插入选择成员
+   * @param selectMembers 已有的选择成员实例
+   */
+  insertSelectMembersAt(selectMembers: SelectMembers, index: number): SelectMembers;
+
+  insertSelectMembersAt(options: string | Partial<SelectMembers> | SelectMembers, index: number) {
+    const node = this._insertSelectMembersAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'rights',
+    });
+    return node;
+  }
+
+  /**
+   * 添加选择成员
+   * @internal
+   * @param name 选择成员名称，如果不填会自动生成一个唯一名称
+   */
+  _addSelectMembers(name?: string): SelectMembers;
+
+  /**
+   * 添加选择成员
+   * @internal
+   * @param selectMembersOptions 选择成员参数
+   */
+  _addSelectMembers(selectMembersOptions: Partial<SelectMembers>): SelectMembers;
+
+  /**
+   * 添加选择成员
+   * @internal
+   * @param selectMembers 已有的选择成员实例
+   */
+  _addSelectMembers(selectMembers: SelectMembers): SelectMembers;
+
+  _addSelectMembers(options?: string | Partial<SelectMembers> | SelectMembers) {
+    const index = this.rights.length;
+    return this._insertSelectMembersAt(options as any, index);
+  }
+
+  /**
+   * 添加选择成员
+   * @internal
+   * @param name 选择成员名称，如果不填会自动生成一个唯一名称
+   */
+  addSelectMembers(name?: string): SelectMembers;
+
+  /**
+   * 添加选择成员
+   * @param selectMembersOptions 选择成员参数
+   */
+  addSelectMembers(selectMembersOptions: Partial<SelectMembers>): SelectMembers;
+
+  /**
+   * 添加选择成员
+   * @param selectMembers 已有的选择成员实例
+   */
+  addSelectMembers(selectMembers: SelectMembers): SelectMembers;
+
+  addSelectMembers(options?: string | Partial<SelectMembers> | SelectMembers) {
+    const node = this._addSelectMembers(options as any);
+    const index = this.rights.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'rights',
+    });
+    return node;
+  }
+
+  getAssignmentLineExistingNames(excludedList: Array<AssignmentLine> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.assignmentLines as AssignmentLine[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getAssignmentLineUniqueName(name = 'assignmentLine1') {
+    return utils.unique(name, this.getAssignmentLineExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入赋值连线
+   * @internal
+   * @param name 赋值连线名称，如果不填会自动生成一个唯一名称
+   */
+  _insertAssignmentLineAt(name: string, index: number): AssignmentLine;
+
+  /**
+   * 插入赋值连线
+   * @internal
+   * @param assignmentLineOptions 赋值连线参数
+   */
+  _insertAssignmentLineAt(assignmentLineOptions: Partial<AssignmentLine>, index: number): AssignmentLine;
+
+  /**
+   * 插入赋值连线
+   * @internal
+   * @param assignmentLine 已有的赋值连线实例
+   */
+  _insertAssignmentLineAt(assignmentLine: AssignmentLine, index: number): AssignmentLine;
+
+  _insertAssignmentLineAt(options: string | Partial<AssignmentLine> | AssignmentLine, index: number) {
+    const assignmentLineOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'assignmentLines' };
+    let assignmentLine: AssignmentLine;
+    if (!options) {
+      assignmentLine = AssignmentLine.from(
+        {
+          ...assignmentLineOptions,
+          name: this.getAssignmentLineUniqueName(),
+        },
+        this,
+        'assignmentLines'
+      );
+    } else if (typeof options === 'string') {
+      assignmentLine = AssignmentLine.from(
+        {
+          ...assignmentLineOptions,
+          name: options,
+        },
+        this,
+        'assignmentLines'
+      );
+    } else if (options instanceof AssignmentLine) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      assignmentLine = options;
+      Object.assign(assignmentLine, relationOptions);
+    } else {
+      assignmentLine = AssignmentLine.from(
+        {
+          ...assignmentLineOptions,
+          ...options,
+        },
+        this,
+        'assignmentLines'
+      );
     }
-
-    static from(source: any, parentNode?: any, parentKey?: string): BatchAssignment {
-        return super.from(source, parentNode, parentKey) as BatchAssignment;
-    }
-
-    
-    /**
-     * 设置左边项
-     */
-    setLeft(left: SelectMembers) {
-        left._delete();
-        const relationOptions = { parentNode: this, parentKey: 'left' };
-        Object.assign(left, relationOptions);
-        const object = {
-            left,
-        };
-        this.update({
-            ...object,
-        });
-    }
-
-    /**
-     * 设置右边项
-     */
-    setRights(rights: Array<SelectMembers>) {
-        const object = {
-            rights,
-        };
-        this.update({
-            ...object,
-        });
+    this.assignmentLines.splice(index, 0, assignmentLine);
+    return assignmentLine;
+  }
+
+  /**
+   * 插入赋值连线
+   * @param name 赋值连线名称，如果不填会自动生成一个唯一名称
+   */
+  insertAssignmentLineAt(name: string, index: number): AssignmentLine;
+
+  /**
+   * 插入赋值连线
+   * @param assignmentLineOptions 赋值连线参数
+   */
+  insertAssignmentLineAt(assignmentLineOptions: Partial<AssignmentLine>, index: number): AssignmentLine;
+
+  /**
+   * 插入赋值连线
+   * @param assignmentLine 已有的赋值连线实例
+   */
+  insertAssignmentLineAt(assignmentLine: AssignmentLine, index: number): AssignmentLine;
+
+  insertAssignmentLineAt(options: string | Partial<AssignmentLine> | AssignmentLine, index: number) {
+    const node = this._insertAssignmentLineAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'assignmentLines',
+    });
+    return node;
+  }
+
+  /**
+   * 添加赋值连线
+   * @internal
+   * @param name 赋值连线名称，如果不填会自动生成一个唯一名称
+   */
+  _addAssignmentLine(name?: string): AssignmentLine;
+
+  /**
+   * 添加赋值连线
+   * @internal
+   * @param assignmentLineOptions 赋值连线参数
+   */
+  _addAssignmentLine(assignmentLineOptions: Partial<AssignmentLine>): AssignmentLine;
+
+  /**
+   * 添加赋值连线
+   * @internal
+   * @param assignmentLine 已有的赋值连线实例
+   */
+  _addAssignmentLine(assignmentLine: AssignmentLine): AssignmentLine;
+
+  _addAssignmentLine(options?: string | Partial<AssignmentLine> | AssignmentLine) {
+    const index = this.assignmentLines.length;
+    return this._insertAssignmentLineAt(options as any, index);
+  }
+
+  /**
+   * 添加赋值连线
+   * @internal
+   * @param name 赋值连线名称，如果不填会自动生成一个唯一名称
+   */
+  addAssignmentLine(name?: string): AssignmentLine;
+
+  /**
+   * 添加赋值连线
+   * @param assignmentLineOptions 赋值连线参数
+   */
+  addAssignmentLine(assignmentLineOptions: Partial<AssignmentLine>): AssignmentLine;
+
+  /**
+   * 添加赋值连线
+   * @param assignmentLine 已有的赋值连线实例
+   */
+  addAssignmentLine(assignmentLine: AssignmentLine): AssignmentLine;
+
+  addAssignmentLine(options?: string | Partial<AssignmentLine> | AssignmentLine) {
+    const node = this._addAssignmentLine(options as any);
+    const index = this.assignmentLines.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'assignmentLines',
+    });
+    return node;
+  }
+
+  /**
+   * 删除选择成员
+   * @param name 选择成员名称
+   */
+  removeLeft(name: string): void;
+
+  /**
+   * 删除选择成员
+   * @param left 已有的选择成员实例
+   */
+  removeLeft(left: SelectMembers): void;
+
+  removeLeft(options: string | SelectMembers) {
+    let left: SelectMembers;
+    if (typeof options === 'string') {
+      left = this.left;
+      if (!left) {
+        throw new Error(`找不到选择成员 ${options}`);
+      }
+    } else {
+      left = options;
     }
-
-    /**
-     * 设置赋值
-     */
-    setAssignmentLines(assignmentLines: Array<AssignmentLine>) {
-        const object = {
-            assignmentLines,
-        };
-        this.update({
-            ...object,
-        });
+    return left.delete();
+  }
+
+  /**
+   * 删除选择成员
+   * @param name 选择成员名称
+   */
+  removeSelectMembersInRights(name: string): void;
+
+  /**
+   * 删除选择成员
+   * @param selectMembers 已有的选择成员实例
+   */
+  removeSelectMembersInRights(selectMembers: SelectMembers): void;
+
+  removeSelectMembersInRights(options: string | SelectMembers) {
+    let selectMembers: SelectMembers;
+    if (typeof options === 'string') {
+      selectMembers = (this.rights as SelectMembers[]).find((item) => item.name === options);
+      if (!selectMembers) {
+        throw new Error(`找不到选择成员 ${options}`);
+      }
+    } else {
+      selectMembers = options;
     }
-
-    /**
-     * 设置自动连线
-     */
-    setAutoConnection(autoConnection: boolean) {
-        const object = {
-            autoConnection,
-        };
-        this.update({
-            ...object,
-        });
+    return selectMembers.delete();
+  }
+
+  __removeSelectMembers(selectMembers: SelectMembers) {
+    const { parentKey } = selectMembers;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: selectMembers,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(selectMembers);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === selectMembers) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
     }
-
-        getSelectMembersExistingNames(excludedList: Array<SelectMembers> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.rights as SelectMembers[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return params;
+  }
+
+  /**
+   * 删除赋值连线
+   * @param name 赋值连线名称
+   */
+  removeAssignmentLine(name: string): void;
+
+  /**
+   * 删除赋值连线
+   * @param assignmentLine 已有的赋值连线实例
+   */
+  removeAssignmentLine(assignmentLine: AssignmentLine): void;
+
+  removeAssignmentLine(options: string | AssignmentLine) {
+    let assignmentLine: AssignmentLine;
+    if (typeof options === 'string') {
+      assignmentLine = (this.assignmentLines as AssignmentLine[]).find((item) => item.name === options);
+      if (!assignmentLine) {
+        throw new Error(`找不到赋值连线 ${options}`);
+      }
+    } else {
+      assignmentLine = options;
     }
-    getSelectMembersUniqueName(name = 'selectMembers1') {
-        return utils.unique(name, this.getSelectMembersExistingNames(), undefined, false);
+    return assignmentLine.delete();
+  }
+
+  __removeAssignmentLine(assignmentLine: AssignmentLine) {
+    const { parentKey } = assignmentLine;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: assignmentLine,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(assignmentLine);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === assignmentLine) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
     }
-
-    /**
-    * 插入选择成员
-    * @internal
-    * @param name 选择成员名称，如果不填会自动生成一个唯一名称
-    */
-    _insertSelectMembersAt(name: string, index: number): SelectMembers;
-
-    /**
-    * 插入选择成员
-    * @internal
-    * @param selectMembersOptions 选择成员参数
-    */
-    _insertSelectMembersAt(selectMembersOptions: Partial<SelectMembers>, index: number): SelectMembers;
-
-    /**
-    * 插入选择成员
-    * @internal
-    * @param selectMembers 已有的选择成员实例
-    */
-    _insertSelectMembersAt(selectMembers: SelectMembers, index: number): SelectMembers;
-
-    _insertSelectMembersAt(options: string | Partial<SelectMembers> | SelectMembers, index: number) {
-        const selectMembersOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'rights' };
-        let selectMembers: SelectMembers;
-        if (!options) {
-            selectMembers = SelectMembers.from({
-                ...selectMembersOptions,
-                name: this.getSelectMembersUniqueName(),
-            }, this, 'rights');
-        } else if (typeof options === 'string') {
-            selectMembers = SelectMembers.from({
-                ...selectMembersOptions,
-                name: options,
-            }, this, 'rights');
-        } else if (options instanceof SelectMembers) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            selectMembers = options;
-            Object.assign(selectMembers, relationOptions);
-        } else {
-            selectMembers = SelectMembers.from({
-                ...selectMembersOptions,
-                ...options,
-            }, this, 'rights');
-        }
-        this.rights.splice(index, 0, selectMembers);
-        return selectMembers;
+    return params;
+  }
+
+  //= ===============================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //= ===============================================================================
+
+  public static getDefaultOptions() {
+    return {
+      left: {
+        concept: 'SelectMembers',
+        expression: {
+          concept: 'Identifier',
+          name: '',
+        },
+      },
+    };
+  }
+
+  // 自动连线算法---addRightIndex : 指右边选择变量后对该selectmember进行自动连线。
+  async batchAutoConnection(addRightIndex?: number) {
+    const leftLineSet = new Set();
+    const lineArr: Array<AssignmentLine> = [];
+    // 系统属性不可自动连线
+    ['id', 'createdTime', 'updatedTime', 'createdBy', 'updatedBy'].forEach((name) => leftLineSet.add(name));
+    // 左边已连线的下标
+    this.assignmentLines.forEach((line) => {
+      if (line.leftIndex.length > 1) leftLineSet.add(Number(line.leftIndex[1]));
+    });
+    // 父节点不允许自动连线
+    for (let i = 0; i < this.left.members.length - 1; i++) {
+      const { completeName } = this.left.members[i];
+      const preCompleteName = this.left.members[i + 1].completeName;
+      if (preCompleteName.includes(completeName) && completeName.split('.').length !== preCompleteName.split('.').length) leftLineSet.add(i);
     }
-
-    /**
-     * 插入选择成员
-     * @param name 选择成员名称，如果不填会自动生成一个唯一名称
-     */
-    insertSelectMembersAt(name: string, index: number): SelectMembers;
-
-    /**
-     * 插入选择成员
-     * @param selectMembersOptions 选择成员参数
-     */
-    insertSelectMembersAt(selectMembersOptions: Partial<SelectMembers>, index: number): SelectMembers;
-
-    /**
-     * 插入选择成员
-     * @param selectMembers 已有的选择成员实例
-     */
-    insertSelectMembersAt(selectMembers: SelectMembers, index: number): SelectMembers;
-
-    insertSelectMembersAt(options: string | Partial<SelectMembers> | SelectMembers, index: number) {
-        const node = this._insertSelectMembersAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'rights',
-        });
-        return node;
-    }
-
-    /**
-     * 添加选择成员
-     * @internal
-     * @param name 选择成员名称，如果不填会自动生成一个唯一名称
-     */
-    _addSelectMembers(name?: string): SelectMembers;
-
-    /**
-     * 添加选择成员
-     * @internal
-     * @param selectMembersOptions 选择成员参数
-     */
-    _addSelectMembers(selectMembersOptions: Partial<SelectMembers>): SelectMembers;
-
-    /**
-     * 添加选择成员
-     * @internal
-     * @param selectMembers 已有的选择成员实例
-     */
-    _addSelectMembers(selectMembers: SelectMembers): SelectMembers;
-
-    _addSelectMembers(options?: string | Partial<SelectMembers> | SelectMembers) {
-        const index = this.rights.length;
-        return this._insertSelectMembersAt(options as any, index);
-    }
-
-    /**
-     * 添加选择成员
-     * @internal
-     * @param name 选择成员名称，如果不填会自动生成一个唯一名称
-     */
-    addSelectMembers(name?: string): SelectMembers;
-
-    /**
-     * 添加选择成员
-     * @param selectMembersOptions 选择成员参数
-     */
-    addSelectMembers(selectMembersOptions: Partial<SelectMembers>): SelectMembers;
-
-    /**
-     * 添加选择成员
-     * @param selectMembers 已有的选择成员实例
-     */
-    addSelectMembers(selectMembers: SelectMembers): SelectMembers;
-
-    addSelectMembers(options?: string | Partial<SelectMembers> | SelectMembers) {
-        const node = this._addSelectMembers(options as any);
-        const index = this.rights.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'rights',
-        });
-        return node;
-    }
-
-
-    getAssignmentLineExistingNames(excludedList: Array<AssignmentLine> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.assignmentLines as AssignmentLine[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getAssignmentLineUniqueName(name = 'assignmentLine1') {
-        return utils.unique(name, this.getAssignmentLineExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入赋值连线
-    * @internal
-    * @param name 赋值连线名称，如果不填会自动生成一个唯一名称
-    */
-    _insertAssignmentLineAt(name: string, index: number): AssignmentLine;
-
-    /**
-    * 插入赋值连线
-    * @internal
-    * @param assignmentLineOptions 赋值连线参数
-    */
-    _insertAssignmentLineAt(assignmentLineOptions: Partial<AssignmentLine>, index: number): AssignmentLine;
-
-    /**
-    * 插入赋值连线
-    * @internal
-    * @param assignmentLine 已有的赋值连线实例
-    */
-    _insertAssignmentLineAt(assignmentLine: AssignmentLine, index: number): AssignmentLine;
-
-    _insertAssignmentLineAt(options: string | Partial<AssignmentLine> | AssignmentLine, index: number) {
-        const assignmentLineOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'assignmentLines' };
-        let assignmentLine: AssignmentLine;
-        if (!options) {
-            assignmentLine = AssignmentLine.from({
-                ...assignmentLineOptions,
-                name: this.getAssignmentLineUniqueName(),
-            }, this, 'assignmentLines');
-        } else if (typeof options === 'string') {
-            assignmentLine = AssignmentLine.from({
-                ...assignmentLineOptions,
-                name: options,
-            }, this, 'assignmentLines');
-        } else if (options instanceof AssignmentLine) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            assignmentLine = options;
-            Object.assign(assignmentLine, relationOptions);
-        } else {
-            assignmentLine = AssignmentLine.from({
-                ...assignmentLineOptions,
-                ...options,
-            }, this, 'assignmentLines');
-        }
-        this.assignmentLines.splice(index, 0, assignmentLine);
-        return assignmentLine;
-    }
-
-    /**
-     * 插入赋值连线
-     * @param name 赋值连线名称，如果不填会自动生成一个唯一名称
-     */
-    insertAssignmentLineAt(name: string, index: number): AssignmentLine;
-
-    /**
-     * 插入赋值连线
-     * @param assignmentLineOptions 赋值连线参数
-     */
-    insertAssignmentLineAt(assignmentLineOptions: Partial<AssignmentLine>, index: number): AssignmentLine;
-
-    /**
-     * 插入赋值连线
-     * @param assignmentLine 已有的赋值连线实例
-     */
-    insertAssignmentLineAt(assignmentLine: AssignmentLine, index: number): AssignmentLine;
-
-    insertAssignmentLineAt(options: string | Partial<AssignmentLine> | AssignmentLine, index: number) {
-        const node = this._insertAssignmentLineAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'assignmentLines',
-        });
-        return node;
-    }
-
-    /**
-     * 添加赋值连线
-     * @internal
-     * @param name 赋值连线名称，如果不填会自动生成一个唯一名称
-     */
-    _addAssignmentLine(name?: string): AssignmentLine;
-
-    /**
-     * 添加赋值连线
-     * @internal
-     * @param assignmentLineOptions 赋值连线参数
-     */
-    _addAssignmentLine(assignmentLineOptions: Partial<AssignmentLine>): AssignmentLine;
-
-    /**
-     * 添加赋值连线
-     * @internal
-     * @param assignmentLine 已有的赋值连线实例
-     */
-    _addAssignmentLine(assignmentLine: AssignmentLine): AssignmentLine;
-
-    _addAssignmentLine(options?: string | Partial<AssignmentLine> | AssignmentLine) {
-        const index = this.assignmentLines.length;
-        return this._insertAssignmentLineAt(options as any, index);
-    }
-
-    /**
-     * 添加赋值连线
-     * @internal
-     * @param name 赋值连线名称，如果不填会自动生成一个唯一名称
-     */
-    addAssignmentLine(name?: string): AssignmentLine;
-
-    /**
-     * 添加赋值连线
-     * @param assignmentLineOptions 赋值连线参数
-     */
-    addAssignmentLine(assignmentLineOptions: Partial<AssignmentLine>): AssignmentLine;
-
-    /**
-     * 添加赋值连线
-     * @param assignmentLine 已有的赋值连线实例
-     */
-    addAssignmentLine(assignmentLine: AssignmentLine): AssignmentLine;
-
-    addAssignmentLine(options?: string | Partial<AssignmentLine> | AssignmentLine) {
-        const node = this._addAssignmentLine(options as any);
-        const index = this.assignmentLines.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'assignmentLines',
-        });
-        return node;
-    }
-
-
-    
-
-    /**
-    * 删除选择成员
-    * @param name 选择成员名称
-    */
-    removeLeft(name: string): void;
-
-    /**
-     * 删除选择成员
-     * @param left 已有的选择成员实例
-     */
-    removeLeft(left: SelectMembers): void;
-
-    removeLeft(options: string | SelectMembers) {
-        let left: SelectMembers;
-        if (typeof options === 'string') {
-            left = this.left;
-            if (!left) {
-                throw new Error('找不到选择成员 ' + options);
-            }
-        } else {
-            left = options;
-        }
-        return left.delete();
-    }
-
-    
-
-    /**
-    * 删除选择成员
-    * @param name 选择成员名称
-    */
-    removeSelectMembersInRights(name: string): void;
-
-    /**
-     * 删除选择成员
-     * @param selectMembers 已有的选择成员实例
-     */
-    removeSelectMembersInRights(selectMembers: SelectMembers): void;
-
-    removeSelectMembersInRights(options: string | SelectMembers) {
-        let selectMembers: SelectMembers;
-        if (typeof options === 'string') {
-            selectMembers = (this.rights as SelectMembers[]).find((item) => item.name === options);
-            if (!selectMembers) {
-                throw new Error('找不到选择成员 ' + options);
-            }
-        } else {
-            selectMembers = options;
-        }
-        return selectMembers.delete();
-    }
-
-    __removeSelectMembers(selectMembers: SelectMembers) {
-        const parentKey = selectMembers.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: selectMembers,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(selectMembers);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === selectMembers) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除赋值连线
-    * @param name 赋值连线名称
-    */
-    removeAssignmentLine(name: string): void;
-
-    /**
-     * 删除赋值连线
-     * @param assignmentLine 已有的赋值连线实例
-     */
-    removeAssignmentLine(assignmentLine: AssignmentLine): void;
-
-    removeAssignmentLine(options: string | AssignmentLine) {
-        let assignmentLine: AssignmentLine;
-        if (typeof options === 'string') {
-            assignmentLine = (this.assignmentLines as AssignmentLine[]).find((item) => item.name === options);
-            if (!assignmentLine) {
-                throw new Error('找不到赋值连线 ' + options);
+    // await new Promise((resolve) => setTimeout(resolve, 400));
+    const autoConnection = () => {
+      this.app.emit('collect:start', {
+        actionMsg: '自动连线',
+      });
+      this.left.members.forEach((member: any, leftSecondIndex: number) => {
+        const leftValue = member.getValue();
+        const leftName = member.property?.name;
+        const leftTypeAnnotation = member.__TypeAnnotation;
+        if (leftLineSet.has(leftSecondIndex) || leftLineSet.has(leftName)) return;
+
+        this.rights.forEach((selectMember, rightFirstIndex) => {
+          const { members, expression } = selectMember;
+          if (leftLineSet.has(leftSecondIndex)) return;
+          if (addRightIndex !== -1 && addRightIndex !== rightFirstIndex) return;
+          // 右侧父节点也不允许自动连线
+          const rightLineSet = new Set();
+          for (let i = 0; i < members.length - 1; i++) {
+            const { completeName } = members[i];
+            const preCompleteName = members[i + 1].completeName;
+            if (preCompleteName.includes(completeName) && completeName.split('.').length !== preCompleteName.split('.').length) rightLineSet.add(i);
+          }
+
+          if (leftName === expression.name && expression.__TypeAnnotation?.typeKind === leftTypeAnnotation.typeKind) {
+            const Line: AssignmentLine = new AssignmentLine({
+              leftIndex: [0, leftSecondIndex],
+              rightIndex: [rightFirstIndex],
+            });
+            lineArr.push(Line);
+            leftLineSet.add(leftSecondIndex);
+            return;
+          }
+          members.forEach((rightMember: any, rightSecondIndex: number) => {
+            const rightValue = rightMember.getValue();
+            const rightName = rightMember.property?.name;
+            if (rightLineSet.has(rightSecondIndex)) return;
+
+            if (leftName === rightName && leftValue.split('.').length === rightValue.split('.').length) {
+              const rightTypeAnnotation = rightMember.__TypeAnnotation;
+              if (leftTypeAnnotation.typeKind !== rightTypeAnnotation.typeKind) return;
+              const leftIndex = [0, leftSecondIndex];
+              const rightIndex = [rightFirstIndex, rightSecondIndex];
+              const Line: AssignmentLine = new AssignmentLine({ leftIndex, rightIndex });
+              lineArr.push(Line);
+              leftLineSet.add(leftSecondIndex);
             }
-        } else {
-            assignmentLine = options;
+          });
+        });
+      });
+      lineArr.length && this.setAssignmentLines([...this.assignmentLines, ...lineArr]);
+      this.app.emit('collect:end');
+    };
+
+    let count = 0;
+    const typeAnnotationEnd = () => {
+      const l = this.left.members.every((item) => item.__isCorrectTypeAnnotation);
+      const r = this.rights.every(
+        (right) => right.members.every((item) => item.__isCorrectTypeAnnotation) && right.expression.__isCorrectTypeAnnotation
+      );
+      count++;
+      if (l && r) {
+        autoConnection();
+      } else if (count <= 10) {
+        setTimeout(() => {
+          typeAnnotationEnd();
+        }, 100);
+      }
+    };
+    typeAnnotationEnd();
+  }
+
+  connection(leftItem: LogicItem | SelectMembers, rightItem: LogicItem | SelectMembers, rightToLeft: boolean) {
+    let newLeftIndex = [0];
+    let newRightIndex = [];
+    let newLines: Array<AssignmentLine> = [];
+    let newMembers = this.left.members;
+    if (leftItem.concept !== 'SelectMembers' && leftItem.parentKey !== 'expression') {
+      const { members } = this.left;
+      const secondIndex = members.findIndex((exp: any) => exp === leftItem);
+      const completeNameSplitLength = members[secondIndex].completeName.split('.').length;
+      let filterLines: Array<AssignmentLine> = [];
+      // 连线左边的坐标。
+      newLeftIndex = [0, secondIndex];
+      // 父节点选中后删除此节点下的子节点
+      let sameLevelIndex = members.findIndex((exp: any, index: number) => {
+        if (index > secondIndex) {
+          return exp.completeName.split('.').length <= completeNameSplitLength;
         }
-        return assignmentLine.delete();
-    }
-
-    __removeAssignmentLine(assignmentLine: AssignmentLine) {
-        const parentKey = assignmentLine.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: assignmentLine,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(assignmentLine);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === assignmentLine) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
+        return false;
+      });
+      sameLevelIndex = sameLevelIndex === -1 ? members.length : sameLevelIndex;
+      newMembers = members.filter((member: any, index: number) => index <= secondIndex || index >= sameLevelIndex);
+      filterLines = this.assignmentLines.filter(({ leftIndex }) => leftIndex[1] <= secondIndex || leftIndex[1] >= sameLevelIndex);
+      // members成员减少，需要重新计算后续连线下标
+      filterLines.forEach((line) => {
+        const distance = sameLevelIndex - secondIndex - 1;
+        if (line.leftIndex[1] > secondIndex) {
+          const newLine = { ...line, leftIndex: [line.leftIndex[0], line.leftIndex[1] - distance] };
+          newLines.push(newLine as AssignmentLine);
+          return;
         }
-        return params;
+        newLines.push(line);
+      });
+    } else {
+      newLines = [];
+      newMembers = [];
     }
-
-    //================================================================================
-    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-    // 自动生成的代码已结束。下面可以手动编写。
-    //================================================================================
-
-    public static getDefaultOptions() {
-        return {
-            left: {
-                concept: 'SelectMembers',
-                expression: {
-                    concept: 'Identifier',
-                    name: '',
-                },
-            },
-        };
+    if (rightItem.concept === 'SelectMembers') {
+      newRightIndex = [this.rights.findIndex((right) => right === rightItem)];
+    } else if (rightItem.concept !== 'MemberExpression') {
+      newRightIndex = [this.rights.findIndex((right) => right === rightItem.parentNode)];
+    } else {
+      const selectMember = rightItem.getAncestor('SelectMembers');
+      const firstIndex = this.rights.findIndex((right) => right === selectMember);
+      const secondIndex = this.rights[firstIndex].members.findIndex((exp: any) => exp === rightItem);
+      newRightIndex = [firstIndex, secondIndex];
     }
-
-    // 自动连线算法---addRightIndex : 指右边选择变量后对该selectmember进行自动连线。
-    async batchAutoConnection(addRightIndex?: number) {
-        const leftLineSet = new Set();
-        const lineArr: Array<AssignmentLine> = [];
-        // 系统属性不可自动连线
-        ['id', 'createdTime', 'updatedTime', 'createdBy', 'updatedBy'].forEach((name) => leftLineSet.add(name));
-        // 左边已连线的下标
-        this.assignmentLines.forEach((line) => {
-            if (line.leftIndex.length > 1)
-                leftLineSet.add(Number(line.leftIndex[1]));
-        });
-        // 父节点不允许自动连线
-        for (let i = 0; i < this.left.members.length - 1; i++) {
-            const completeName = this.left.members[i].completeName;
-            const preCompleteName = this.left.members[i + 1].completeName;
-            if (preCompleteName.includes(completeName) && completeName.split('.').length !== preCompleteName.split('.').length)
-                leftLineSet.add(i);
-        }
-        // await new Promise((resolve) => setTimeout(resolve, 400));
-        const autoConnection = () => {
-            this.app.emit('collect:start', {
-                actionMsg: '自动连线',
-            });
-            this.left.members.forEach((member: any, leftSecondIndex: number) => {
-                const leftValue = member.getValue();
-                const leftName = member.property?.name;
-                const leftTypeAnnotation = member.__TypeAnnotation;
-                if (leftLineSet.has(leftSecondIndex) || leftLineSet.has(leftName))
-                    return;
-    
-                this.rights.forEach((selectMember, rightFirstIndex) => {
-                    const { members, expression } = selectMember;
-                    if (leftLineSet.has(leftSecondIndex))
-                        return;
-                    if (addRightIndex !== -1 && addRightIndex !== rightFirstIndex)
-                        return;
-                    // 右侧父节点也不允许自动连线
-                    const rightLineSet = new Set();
-                    for (let i = 0; i < members.length - 1; i++) {
-                        const completeName = members[i].completeName;
-                        const preCompleteName = members[i + 1].completeName;
-                        if (preCompleteName.includes(completeName) && completeName.split('.').length !== preCompleteName.split('.').length)
-                            rightLineSet.add(i);
-                    }
-    
-                    if (leftName === expression.name && expression.__TypeAnnotation?.typeKind === leftTypeAnnotation.typeKind) {
-                        const Line: AssignmentLine = new AssignmentLine({
-                            leftIndex: [0, leftSecondIndex],
-                            rightIndex: [rightFirstIndex],
-                        });
-                        lineArr.push(Line);
-                        leftLineSet.add(leftSecondIndex);
-                        return;
-                    }
-                    members.forEach((rightMember: any, rightSecondIndex: number) => {
-                        const rightValue = rightMember.getValue();
-                        const rightName = rightMember.property?.name;
-                        if (rightLineSet.has(rightSecondIndex))
-                            return;
-    
-                        if (leftName === rightName && leftValue.split('.').length === rightValue.split('.').length) {
-                            const rightTypeAnnotation = rightMember.__TypeAnnotation;
-                            if (leftTypeAnnotation.typeKind !== rightTypeAnnotation.typeKind)
-                                return;
-                            const leftIndex = [0, leftSecondIndex];
-                            const rightIndex = [rightFirstIndex, rightSecondIndex];
-                            const Line: AssignmentLine = new AssignmentLine({ leftIndex, rightIndex });
-                            lineArr.push(Line);
-                            leftLineSet.add(leftSecondIndex);
-                        }
-                    });
-                });
-            });
-            lineArr.length && this.setAssignmentLines([...this.assignmentLines, ...lineArr]);
-            this.app.emit('collect:end');
-        };
-
-        let count = 0;
-        const typeAnnotationEnd = () => {
-            const l = this.left.members.every((item) => item.__isCorrectTypeAnnotation);
-            const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation) && right.expression.__isCorrectTypeAnnotation);
-            count++;
-            if (l && r) {
-                autoConnection();
-            } else if (count <= 10) {
-                setTimeout(() => {
-                    typeAnnotationEnd();
-                }, 100);
-            }
-        };
-        typeAnnotationEnd();
+    // 左边同一个属性只能有一个连线
+    if (rightToLeft) {
+      newLines = newLines.filter(({ leftIndex: index }) => !(newLeftIndex[0] === index[0] && newLeftIndex[1] === index[1]));
     }
 
-    connection(leftItem: LogicItem | SelectMembers, rightItem: LogicItem | SelectMembers, rightToLeft: boolean) {
-        let newLeftIndex = [0];
-        let newRightIndex = [];
-        let newLines: Array<AssignmentLine> = [];
-        let newMembers = this.left.members;
-        if (leftItem.concept !== 'SelectMembers' && leftItem.parentKey !== 'expression') {
-            const members = this.left.members;
-            const secondIndex = members.findIndex((exp: any) => exp === leftItem);
-            const completeNameSplitLength = members[secondIndex].completeName.split('.').length;
-            let filterLines: Array<AssignmentLine> = [];
-            // 连线左边的坐标。
-            newLeftIndex = [0, secondIndex];
-            // 父节点选中后删除此节点下的子节点
-            let sameLevelIndex = members.findIndex((exp: any, index: number) => {
-                if (index > secondIndex) {
-                    return exp.completeName.split('.').length <= completeNameSplitLength;
-                }
-                return false;
-            });
-            sameLevelIndex = sameLevelIndex === -1 ? members.length : sameLevelIndex;
-            newMembers = members.filter((member: any, index: number) => index <= secondIndex || index >= sameLevelIndex);
-            filterLines = this.assignmentLines.filter(({ leftIndex }) => leftIndex[1] <= secondIndex || leftIndex[1] >= sameLevelIndex);
-            // members成员减少，需要重新计算后续连线下标
-            filterLines.forEach((line) => {
-                const distance = sameLevelIndex - secondIndex - 1;
-                if (line.leftIndex[1] > secondIndex) {
-                    const newLine = Object.assign({}, line, { leftIndex: [line.leftIndex[0], line.leftIndex[1] - distance] });
-                    newLines.push(newLine);
-                    return;
-                }
-                newLines.push(line);
-            });
+    this.update({
+      assignmentLines: newLines,
+    });
+    this.left.update({
+      members: newMembers,
+    });
+    const Line: AssignmentLine = new AssignmentLine({
+      leftIndex: newLeftIndex,
+      rightIndex: newRightIndex,
+    });
+    this.addAssignmentLine(Line);
+  }
+
+  swapLocation(location1: number, location2: number) {
+    if (location1 === location2) return;
+    const newRights = this.rights;
+    [newRights[location1], newRights[2]] = [newRights[location2], newRights[1]];
+    const newLines = this.assignmentLines.map((line) => {
+      if (line.rightIndex[0] === location1) {
+        line.rightIndex[0] = location2;
+      } else if (line.rightIndex[0] === location2) {
+        line.rightIndex[0] = location1;
+      }
+      return line;
+    });
+    this.update({
+      rigths: newRights,
+      assignmentLines: newLines,
+    });
+  }
+
+  deleteAssignmentLine(assignmentLine: AssignmentLine) {
+    const newLine = this.assignmentLines.filter((line) => line !== assignmentLine);
+    this.update({
+      assignmentLines: newLine,
+    });
+  }
+
+  changeLinesLocation(selectMember: SelectMembers) {
+    // 区分操作左边或者操作右边
+    if (selectMember === this.left) {
+      this.update({
+        left: null,
+        assignmentLines: [],
+      });
+    } else if (this.rights.findIndex((member) => selectMember === member) !== -1) {
+      const index = this.rights.findIndex((member) => selectMember === member);
+      const newRights = this.rights.filter((member) => selectMember !== member);
+      const filterLine = this.assignmentLines.filter((line) => line.rightIndex[0] !== index);
+      const newLines: Array<AssignmentLine> = [];
+      filterLine.forEach((line) => {
+        if (line.rightIndex[0] > index) {
+          if (line.rightIndex[1] === undefined) {
+            const newLine = { ...line, rightIndex: [line.rightIndex[0] - 1] };
+            newLines.push(newLine as AssignmentLine);
+          } else {
+            const newLine = { ...line, rightIndex: [line.rightIndex[0] - 1, line.rightIndex[1]] };
+            newLines.push(newLine as AssignmentLine);
+          }
         } else {
-            newLines = [];
-            newMembers = [];
-        }
-        if (rightItem.concept === 'SelectMembers') {
-            newRightIndex = [this.rights.findIndex((right) => right === rightItem)];
-        } else if (rightItem.concept !== 'MemberExpression') {
-            newRightIndex = [this.rights.findIndex((right) => right === rightItem.parentNode)];
-        } else {
-            const selectMember = rightItem.getAncestor('SelectMembers');
-            const firstIndex = this.rights.findIndex((right) => right === selectMember);
-            const secondIndex = this.rights[firstIndex].members.findIndex((exp: any) => exp === rightItem);
-            newRightIndex = [firstIndex, secondIndex];
-        }
-        // 左边同一个属性只能有一个连线
-        if (rightToLeft) {
-            newLines = newLines.filter(({ leftIndex: index }) => !(newLeftIndex[0] === index[0] && newLeftIndex[1] === index[1]));
+          newLines.push(line);
         }
-
-        this.update({
-            assignmentLines: newLines,
-        });
-        this.left.update({
-            members: newMembers,
-        });
-        const Line: AssignmentLine = new AssignmentLine({
-            leftIndex: newLeftIndex,
-            rightIndex: newRightIndex,
-        });
-        this.addAssignmentLine(Line);
+      });
+      this.update({
+        rights: newRights,
+        assignmentLines: newLines,
+      });
     }
-
-    swapLocation(location1: number, location2: number) {
-        if (location1 === location2)
-            return;
-        const newRights = this.rights;
-        [newRights[location1], newRights[2]] = [newRights[location2], newRights[1]];
-        const newLines = this.assignmentLines.map((line) => {
-            if (line.rightIndex[0] === location1) {
-                line.rightIndex[0] = location2;
-            } else if (line.rightIndex[0] === location2) {
-                line.rightIndex[0] = location1;
-            }
-            return line;
-        });
-        this.update({
-            rigths: newRights,
-            assignmentLines: newLines,
-        });
-    }
-
-    deleteAssignmentLine(assignmentLine: AssignmentLine) {
-        const newLine = this.assignmentLines.filter((line) => line !== assignmentLine);
-        this.update({
-            assignmentLines: newLine,
-        });
-    }
-
-    changeLinesLocation(selectMember: SelectMembers) {
-        // 区分操作左边或者操作右边
-        if (selectMember === this.left) {
-            this.update({
-                left: null,
-                assignmentLines: [],
-            });
-        } else if (this.rights.findIndex((member) => selectMember === member) !== -1) {
-            const index = this.rights.findIndex((member) => selectMember === member);
-            const newRights = this.rights.filter((member) => selectMember !== member);
-            const filterLine = this.assignmentLines.filter((line) => line.rightIndex[0] !== index);
-            const newLines: Array<AssignmentLine> = [];
-            filterLine.forEach((line) => {
-                if (line.rightIndex[0] > index) {
-                    if (line.rightIndex[1] === undefined) {
-                        const newLine = Object.assign({}, line, { rightIndex: [line.rightIndex[0] - 1] });
-                        newLines.push(newLine);
-                    } else {
-                        const newLine = Object.assign({}, line, { rightIndex: [line.rightIndex[0] - 1, line.rightIndex[1]] });
-                        newLines.push(newLine);
-                    }
-                } else {
-                    newLines.push(line);
-                }
-            });
-            this.update({
-                rights: newRights,
-                assignmentLines: newLines,
-            });
+  }
+
+  changeMembers(oldNode: any, members: MemberExpression[], keepMembers: any, expression: LogicItem) {
+    this.app.emit('collect:start', {
+      actionMsg: '批量赋值修改变量',
+    });
+    const selectMember = oldNode.parentNode;
+    const autoConnectionIndex = this.rights.findIndex((right) => right === selectMember);
+    const newSelectMember = { ...selectMember, expression, members };
+    let newLines: any = [];
+    // 修改连线
+    if (selectMember.parentKey === 'left') {
+      members.forEach((item: any, index: any) => {
+        if (keepMembers?.has(item.completeName)) {
+          const lines = this.findlines(item, selectMember);
+          lines.forEach((line) => {
+            const newLine = { ...line, leftIndex: [line.leftIndex[0], index] };
+            newLines.push(newLine);
+          });
         }
-    }
-
-    changeMembers(oldNode:any, members: MemberExpression[], keepMembers: any, expression: LogicItem) {
-        this.app.emit('collect:start', {
-            actionMsg: '批量赋值修改变量',
-        });
-        const selectMember = oldNode.parentNode;
-        const autoConnectionIndex = this.rights.findIndex((right) => right === selectMember);
-        const newSelectMember = Object.assign({}, selectMember, { expression, members });
-        let newLines: any = [];
-        // 修改连线
-        if (selectMember.parentKey === 'left') {
-            members.forEach((item: any, index: any) => {
-                if (keepMembers?.has(item.completeName)) {
-                    const lines = this.findlines(item, selectMember);
-                    lines.forEach((line) => {
-                        const newLine = Object.assign({}, line, { leftIndex: [line.leftIndex[0], index] });
-                        newLines.push(newLine);
-                    });
-                }
-            });
-            this.update({
-                assignmentLines: newLines,
-                left: newSelectMember,
-            });
-        } else {
-            const splitIndex = this.rights.findIndex((right) => selectMember === right);
-            newLines = this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] !== splitIndex);
-            members.forEach((item, index) => {
-                if (keepMembers?.has(item.completeName)) {
-                    const lines = this.findlines(item, selectMember);
-                    lines.forEach((line) => {
-                        const newLine = Object.assign({}, line, { rightIndex: [line.rightIndex[0], index] });
-                        newLines.push(newLine);
-                    });
-                }
-            });
-            this.update({
-                assignmentLines: newLines,
-                rights: [...this.rights.slice(0, splitIndex), newSelectMember, ...this.rights.slice(splitIndex + 1, this.rights.length)],
-            });
+      });
+      this.update({
+        assignmentLines: newLines,
+        left: newSelectMember,
+      });
+    } else {
+      const splitIndex = this.rights.findIndex((right) => selectMember === right);
+      newLines = this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] !== splitIndex);
+      members.forEach((item, index) => {
+        if (keepMembers?.has(item.completeName)) {
+          const lines = this.findlines(item, selectMember);
+          lines.forEach((line) => {
+            const newLine = { ...line, rightIndex: [line.rightIndex[0], index] };
+            newLines.push(newLine);
+          });
         }
-        this.autoConnection && this.batchAutoConnection(autoConnectionIndex);
-        this.app.emit('collect:end');
+      });
+      this.update({
+        assignmentLines: newLines,
+        rights: [...this.rights.slice(0, splitIndex), newSelectMember, ...this.rights.slice(splitIndex + 1, this.rights.length)],
+      });
     }
-
-    findMember(arrIndex: Array<number>, place: string) {
-        const [firstIndex, secondIndex] = [arrIndex[0], arrIndex[1]];
-        if (place === 'left') {
-            if (secondIndex === undefined) {
-                return this.left.expression;
-            }
-            return this.left.members[secondIndex];
-        } else {
-            if (secondIndex === undefined) {
-                return this.rights[firstIndex].expression;
-            }
-            return this.rights[firstIndex].members[secondIndex];
-        }
+    this.autoConnection && this.batchAutoConnection(autoConnectionIndex);
+    this.app.emit('collect:end');
+  }
+
+  findMember(arrIndex: Array<number>, place: string) {
+    const [firstIndex, secondIndex] = [arrIndex[0], arrIndex[1]];
+    if (place === 'left') {
+      if (secondIndex === undefined) {
+        return this.left.expression;
+      }
+      return this.left.members[secondIndex];
     }
-
-    findlines(member: any, selectMember: any) {
-        const lines: Array<AssignmentLine> = [];
-        // 根节点的情况
-        if (selectMember === this) {
-            if (member === this.left)
-                return this.assignmentLines;
-            else {
-                const firstIndex = this.rights.findIndex((right) => right === member);
-                return this.assignmentLines.filter(({ rightIndex }) => rightIndex[1] === undefined && rightIndex[0] === firstIndex);
-            }
-        }
-
-        if (this.left === selectMember) {
-            const index2 = selectMember.members.findIndex((item: MemberExpression) => item.completeName === member.completeName);
-            this.assignmentLines.forEach((line) => {
-                if (line.leftIndex[1] === index2)
-                    lines.push(line);
-            });
-        } else {
-            const index1 = this.rights.findIndex((right) => right === selectMember);
-            const index2 = selectMember.members.findIndex((item: MemberExpression) => item.completeName === member.completeName);
-            this.assignmentLines.forEach((line) => {
-                if (line.rightIndex[0] === index1 && line.rightIndex[1] === index2)
-                    lines.push(line);
-            });
-        }
-        return lines;
+    if (secondIndex === undefined) {
+      return this.rights[firstIndex].expression;
     }
+    return this.rights[firstIndex].members[secondIndex];
+  }
 
-    replaceAssignment() {
-        if (this.assignmentLines.length > 1)
-            return false;
-        this.app.emit('collect:start', {
-            actionMsg: '批量赋值切换普通赋值',
-        });
-        const { parentKey, parentNode, logic }: { parentKey: string, parentNode: any, logic: Logic } = this;
-        let rightExpression;
-        let leftExpression;
-        let index;
-        if (this.assignmentLines.length === 1) {
-            const { leftIndex, rightIndex } = this.assignmentLines[0];
-            leftExpression = Object.assign({}, this.findMember(leftIndex, 'left'));
-            rightExpression = Object.assign({}, this.findMember(rightIndex, 'right'));
-        } else {
-            leftExpression = Object.assign({}, this.left.expression);
-        }
-        const assignment = new Assignment({
-            left: leftExpression,
-            right: rightExpression,
-            offsetX: this.offsetX,
-            offsetY: this.offsetY,
-        });
-        if (parentNode.concept === 'Logic') {
-            if (parentKey === 'body') {
-                index = logic.body.findIndex((item: any) => item === this);
-                logic.insertItemInBodyAt(assignment, index);
-            } else {
-                index = logic.playground.findIndex((item: any) => item === this);
-                logic.insertItemInPlaygroundAt(assignment, index);
-            }
-        } else {
-            index = parentNode[parentKey].findIndex((item: any) => item === this);
-            const firstUpperText = parentKey[0].toUpperCase() + parentKey.slice(1, parentKey.length);
-            if (parentNode[`insertItemIn${firstUpperText}At`])
-                parentNode[`insertItemIn${firstUpperText}At`](assignment, index);
-            else
-                parentNode.insertItemAt(assignment, index);
-        }
-        this.delete();
-        this.app.emit('collect:end');
-        return true;
-    }
+  findlines(member: any, selectMember: any) {
+    const lines: Array<AssignmentLine> = [];
+    // 根节点的情况
+    if (selectMember === this) {
+      if (member === this.left) return this.assignmentLines;
 
-    toVue(options?: ElementToVueOptions) {
-        let code = '';
-        this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
-            const leftValue = leftIndex.length === 1 ? this.left.expression.toVue(options) : this.left.members[leftIndex[1]]?.toVue(options);
-            code += `${leftValue}`;
-            code += ' = ';
-            const rightValue = rightIndex.length === 1 ? this.rights[rightIndex[0]]?.expression?.toVue(options) : this.rights[rightIndex[0]]?.members[rightIndex[1]]?.toVue(options);
-            code += `${rightValue}`;
-            code += ';';
-            code += '\n';
-        });
-        return code;
+      const firstIndex = this.rights.findIndex((right) => right === member);
+      return this.assignmentLines.filter(({ rightIndex }) => rightIndex[1] === undefined && rightIndex[0] === firstIndex);
     }
 
-    toUI(state?: TranslatorState): string {
-        let code = '';
-        this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
-            const leftValue = leftIndex.length === 1 ? this.left.expression.toUI(shiftState(state, code, { inline: true })) : this.left.members[leftIndex[1]]?.toUI(shiftState(state, code, { inline: true }));
-            code += `${leftValue}`;
-            code += ' = ';
-            const rightValue = rightIndex.length === 1 ? this.rights[rightIndex[0]]?.expression?.toUI(shiftState(state, code, { inline: true })) : this.rights[rightIndex[0]]?.members[rightIndex[1]]?.toUI(shiftState(state, code, { inline: true }));
-            code += `${rightValue}`;
-            code += ';';
-            code += '\n';
-        });
-        return code;
+    if (this.left === selectMember) {
+      const index2 = selectMember.members.findIndex((item: MemberExpression) => item.completeName === member.completeName);
+      this.assignmentLines.forEach((line) => {
+        if (line.leftIndex[1] === index2) lines.push(line);
+      });
+    } else {
+      const index1 = this.rights.findIndex((right) => right === selectMember);
+      const index2 = selectMember.members.findIndex((item: MemberExpression) => item.completeName === member.completeName);
+      this.assignmentLines.forEach((line) => {
+        if (line.rightIndex[0] === index1 && line.rightIndex[1] === index2) lines.push(line);
+      });
     }
-
-    toJS(state?: TranslatorState): string {
-        let code = '';
-        this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
-            const leftValue = leftIndex.length === 1 ? this.left.expression.toJS(shiftState(state, code, { inline: true })) : this.left.members[leftIndex[1]]?.toJS(shiftState(state, code, { inline: true }));
-            code += `${leftValue}`;
-            code += ' = ';
-            const rightValue = rightIndex.length === 1 ? this.rights[rightIndex[0]]?.expression?.toJS(shiftState(state, code, { inline: true })) : this.rights[rightIndex[0]]?.members[rightIndex[1]]?.toJS(shiftState(state, code, { inline: true }));
-            code += `${rightValue}`;
-            code += ';';
-            code += '\n';
-        });
-        return code;
+    return lines;
+  }
+
+  replaceAssignment() {
+    if (this.assignmentLines.length > 1) return false;
+    this.app.emit('collect:start', {
+      actionMsg: '批量赋值切换普通赋值',
+    });
+    const { parentKey, parentNode, logic }: { parentKey: string; parentNode: any; logic: Logic } = this;
+    let rightExpression;
+    let leftExpression;
+    let index;
+    if (this.assignmentLines.length === 1) {
+      const { leftIndex, rightIndex } = this.assignmentLines[0];
+      leftExpression = { ...this.findMember(leftIndex, 'left') };
+      rightExpression = { ...this.findMember(rightIndex, 'right') };
+    } else {
+      leftExpression = { ...this.left.expression };
     }
-
-    @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        let code = '// 以下是批量赋值的翻译代码\n';
-        // 提供sourcemap，获取类型标注和上下文可选变量
-        code += this.left.expression ? `${this.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))}` : '';
-        code += ';\n';
-        this.left.members.forEach((member) => {
-            code += member.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += '; ';
-        });
-        code += '\n';
-        this.rights.forEach((right) => {
-            code += `${right.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))}`;
-            code += ';\n';
-            right.members.forEach((member) => {
-                code += member.toEmbeddedTS(shiftState(state, code, { inline: true }));
-                code += '; ';
-            });
-            code += right.members.length ? '\n' : '';
-        });
-        // 根据连线状态，拆分成多个单赋值
-        this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
-            code += 'nasl.core.assign(';
-            const leftValue = leftIndex.length === 1 ? this.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : this.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += `${leftValue}`;
-            code += ', ';
-            const rightValue = rightIndex.length === 1 ? this.rights[rightIndex[0]]?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) : this.rights[rightIndex[0]]?.members[rightIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += `${rightValue}`;
-            code += ')';
-            code += ';';
-            code += '\n';
-        });
-        if (!this.assignmentLines.length)
-            code += `__assignmentLineEmpty__\n`;
-        code += '// 批量赋值的翻译代码结束---------\n';
-        return code;
+    const assignment = new Assignment({
+      left: leftExpression as any,
+      right: rightExpression as any,
+      offsetX: this.offsetX,
+      offsetY: this.offsetY,
+    });
+    if (parentNode.concept === 'Logic') {
+      if (parentKey === 'body') {
+        index = logic.body.findIndex((item: any) => item === this);
+        logic.insertItemInBodyAt(assignment, index);
+      } else {
+        index = logic.playground.findIndex((item: any) => item === this);
+        logic.insertItemInPlaygroundAt(assignment, index);
+      }
+    } else {
+      index = parentNode[parentKey].findIndex((item: any) => item === this);
+      const firstUpperText = parentKey[0].toUpperCase() + parentKey.slice(1, parentKey.length);
+      if (parentNode[`insertItemIn${firstUpperText}At`]) parentNode[`insertItemIn${firstUpperText}At`](assignment, index);
+      else parentNode.insertItemAt(assignment, index);
     }
-    //================================================================================
-    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-    //================================================================================
+    this.delete();
+    this.app.emit('collect:end');
+    return true;
+  }
+
+  toVue(options?: ElementToVueOptions) {
+    let code = '';
+    this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+      const leftValue = leftIndex.length === 1 ? this.left.expression.toVue(options) : this.left.members[leftIndex[1]]?.toVue(options);
+      code += `${leftValue}`;
+      code += ' = ';
+      const rightValue =
+        rightIndex.length === 1
+          ? this.rights[rightIndex[0]]?.expression?.toVue(options)
+          : this.rights[rightIndex[0]]?.members[rightIndex[1]]?.toVue(options);
+      code += `${rightValue}`;
+      code += ';';
+      code += '\n';
+    });
+    return code;
+  }
+
+  toUI(state?: TranslatorState): string {
+    let code = '';
+    this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+      const leftValue =
+        leftIndex.length === 1
+          ? this.left.expression.toUI(shiftState(state, code, { inline: true }))
+          : this.left.members[leftIndex[1]]?.toUI(shiftState(state, code, { inline: true }));
+      code += `${leftValue}`;
+      code += ' = ';
+      const rightValue =
+        rightIndex.length === 1
+          ? this.rights[rightIndex[0]]?.expression?.toUI(shiftState(state, code, { inline: true }))
+          : this.rights[rightIndex[0]]?.members[rightIndex[1]]?.toUI(shiftState(state, code, { inline: true }));
+      code += `${rightValue}`;
+      code += ';';
+      code += '\n';
+    });
+    return code;
+  }
+
+  toJS(state?: TranslatorState): string {
+    let code = '';
+    const rightMap = new Map();
+    this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+      const rightIndexJson = JSON.stringify(rightIndex);
+      if (rightMap.has(rightIndexJson)) {
+        rightMap.set(rightIndexJson, [...rightMap.get(rightIndexJson), leftIndex])
+      } else {
+        rightMap.set(rightIndexJson, [leftIndex]);
+      }
+    });
+    rightMap.forEach((leftIndexs, rightIndexJson) => {
+      const rightIndex = JSON.parse(rightIndexJson) || [];
+      const leftItems = leftIndexs.map((leftIndex: Array<number>) => {
+        const leftItem = leftIndex.length !== 1 ? this.left.members[leftIndex[1]] : this.left.expression;
+        return leftItem;
+      });
+      const [rightFirst, rightSecond] = [rightIndex[0], rightIndex[1]];
+      const rightItem = rightSecond !== undefined ? this.rights[rightFirst].members[rightSecond] : this.rights[rightFirst].expression;
+      leftItems.forEach((leftItem: LogicItem) => {
+        code += `${leftItem.toJS(shiftState(state, code, { inline: true }))}`;
+        code += ` = `;
+      })
+      code += `${rightItem.toJS(shiftState(state, code, { inline: true }))}`;
+      code += ';\n';
+    });
+    return code;
+  }
+
+  @withSourceMap()
+  toEmbeddedTS(state?: TranslatorState): string {
+    let code = '// 以下是批量赋值的翻译代码\n';
+    // 提供sourcemap，获取类型标注和上下文可选变量
+    code += this.left.expression ? `${this.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))}` : '';
+    code += ';\n';
+    this.left.members.forEach((member) => {
+      code += member.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += '; ';
+    });
+    code += '\n';
+    this.rights.forEach((right) => {
+      code += `${right.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))}`;
+      code += ';\n';
+      right.members.forEach((member) => {
+        code += member.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += '; ';
+      });
+      code += right.members.length ? '\n' : '';
+    });
+    // 根据连线状态，拆分成多个单赋值
+    this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+      code += 'nasl.core.assign(';
+      const leftValue =
+        leftIndex.length === 1
+          ? this.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
+          : this.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += `${leftValue}`;
+      code += ', ';
+      const rightValue =
+        rightIndex.length === 1
+          ? this.rights[rightIndex[0]]?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true }))
+          : this.rights[rightIndex[0]]?.members[rightIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += `${rightValue}`;
+      code += ')';
+      code += ';';
+      code += '\n';
+    });
+    if (!this.assignmentLines.length) code += `__assignmentLineEmpty__\n`;
+    code += '// 批量赋值的翻译代码结束---------\n';
+    return code;
+  }
+
+  @withSourceMap()
+  toNaturalTS(state?: TranslatorState): string {
+    let code = '';
+    // 根据连线状态，拆分成多个单赋值
+    this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+      const leftValue = leftIndex.length === 1 ? this.left.expression.toNaturalTS(shiftState(state, code, { inline: true })) : this.left.members[leftIndex[1]]?.toNaturalTS(shiftState(state, code, { inline: true }));
+      code += `${leftValue}`;
+      code += ' = ';
+      const rightValue = rightIndex.length === 1 ? this.rights[rightIndex[0]]?.expression?.toNaturalTS(shiftState(state, code, { inline: true })) : this.rights[rightIndex[0]]?.members[rightIndex[1]]?.toNaturalTS(shiftState(state, code, { inline: true }));
+      code += `${rightValue}`;
+      code += ';';
+      code += '\n';
+    });
+    return code;
+  }
+
+  //= ===============================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //= ===============================================================================
 }
 
 classMap.BatchAssignment = BatchAssignment;
 export default BatchAssignment;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================