@lcap/nasl 3.7.3-beta.1 → 3.8.0-beta.2

package/src/concepts/SubLogic__.ts

@@ -0,0 +1,1516 @@
+import type BaseNode from '../common/BaseNode';
+import {
+  wrapForEachToGenerator as wrapForEach,
+  wrapIteratorToGenerator as wrapIterator,
+  runGeneratorSync as runSync,
+  returnOrigin,
+} from '../utils/time-slicing';
+import { invokeCommand } from '../common';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  embeddedTSEmitter,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
+import type App from './App__';
+import type Namespace from './Namespace__';
+import type CallQueryComponent from './CallQueryComponent__';
+import type ForEachStatement from './ForEachStatement__';
+import type Assignment from './Assignment__';
+import type Identifier from './Identifier__';
+import type BindEvent from './BindEvent__';
+import type BatchAssignment from './BatchAssignment__';
+import type OqlQueryComponent from './OqlQueryComponent__';
+import type Match from './Match__';
+import type MatchCase from './MatchCase__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type CallInterface from './CallInterface__';
+import type CallLogic from './CallLogic__';
+import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
+import type Interface from './Interface__';
+import type BusinessComponent from './BusinessComponent__';
+import type AnonymousFunction from './AnonymousFunction__';
+
+import type Module from './Module__';
+import type Connector from './Connector__';
+import type View from './View__';
+import type Frontend from './Frontend__';
+import type ProcessElement from './ProcessElement__';
+import type Process from './Process__';
+import type CallFunction from './CallFunction__';
+import ProcessElementV2 from './ProcessElementV2__';
+import ProcessV2 from './ProcessV2__';
+import type Logic from './Logic__';
+
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
+
+import * as utils from '../utils';
+import { createUUID } from '../utils/create';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+
+import Param from './Param__';
+import Return from './Return__';
+import Variable from './Variable__';
+import LogicItem from './LogicItem__';
+
+/**
+ * 子逻辑
+ */
+@concept('子逻辑')
+export class SubLogic extends LogicItem {
+  /** 类名 */
+  static readonly ConceptName: string = 'SubLogic';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'SubLogic';
+  /**
+   * 逻辑名称
+   */
+  @property()
+  name: string = '';
+
+  /**
+   * 输入参数列表
+   */
+  @property({
+    objectRef: 'Param',
+    isArray: true,
+    defaultValue: [],
+  })
+  params: Array<Param> = [];
+
+  /**
+   * 输出参数列表
+   */
+  @property({
+    objectRef: 'Return',
+    isArray: true,
+    defaultValue: [],
+  })
+  returns: Array<Return> = [];
+
+  /**
+   * 变量列表
+   */
+  @property({
+    objectRef: 'Variable',
+    isArray: true,
+    defaultValue: [],
+  })
+  variables: Array<Variable> = [];
+
+  /**
+   * 逻辑项列表
+   */
+  @property({
+    objectRef: 'LogicItem',
+    isArray: true,
+    defaultValue: [],
+  })
+  body: Array<LogicItem> = [];
+
+  /**
+   * 逻辑项列表
+   */
+  @property({
+    objectRef: 'LogicItem',
+    isArray: true,
+    defaultValue: [],
+  })
+  playground: Array<LogicItem> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<SubLogic>) {
+    source = Object.assign({}, SubLogic.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): SubLogic {
+    return super.from(source, parentNode, parentKey) as SubLogic;
+  }
+
+  /**
+   * 设置逻辑名称
+   */
+  setName(name: string) {
+    const object = {
+      name,
+    };
+    this.update({
+      ...object,
+      field: 'name',
+    });
+  }
+
+  getParamUniqueName(name = 'param1') {
+    return utils.unique(name, this.getVarExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入输入参数
+   * @internal
+   * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+   */
+  _insertParamAt(name: string, index: number): Param;
+
+  /**
+   * 插入输入参数
+   * @internal
+   * @param paramOptions 输入参数参数
+   */
+  _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+  /**
+   * 插入输入参数
+   * @internal
+   * @param param 已有的输入参数实例
+   */
+  _insertParamAt(param: Param, index: number): Param;
+
+  _insertParamAt(options: string | Partial<Param> | Param, index: number) {
+    const paramOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'params' };
+    const Param = getConceptConstructor('Param');
+    let param: Param;
+    if (!options) {
+      param = Param.from(
+        {
+          ...paramOptions,
+          name: this.getParamUniqueName(),
+        },
+        this,
+        'params',
+      );
+    } else if (typeof options === 'string') {
+      param = Param.from(
+        {
+          ...paramOptions,
+          name: options,
+        },
+        this,
+        'params',
+      );
+    } else if (asserts.isParam(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      param = options;
+      Object.assign(param, relationOptions);
+    } else {
+      param = Param.from(
+        {
+          ...paramOptions,
+          ...options,
+        },
+        this,
+        'params',
+      );
+    }
+    this.params.splice(index, 0, param);
+    return param;
+  }
+
+  /**
+   * 插入输入参数
+   * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+   */
+  insertParamAt(name: string, index: number): Param;
+
+  /**
+   * 插入输入参数
+   * @param paramOptions 输入参数参数
+   */
+  insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+  /**
+   * 插入输入参数
+   * @param param 已有的输入参数实例
+   */
+  insertParamAt(param: Param, index: number): Param;
+
+  insertParamAt(options: string | Partial<Param> | Param, index: number) {
+    const node = this._insertParamAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'params',
+    });
+    return node;
+  }
+
+  /**
+   * 添加输入参数
+   * @internal
+   * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+   */
+  _addParam(name?: string): Param;
+
+  /**
+   * 添加输入参数
+   * @internal
+   * @param paramOptions 输入参数参数
+   */
+  _addParam(paramOptions: Partial<Param>): Param;
+
+  /**
+   * 添加输入参数
+   * @internal
+   * @param param 已有的输入参数实例
+   */
+  _addParam(param: Param): Param;
+
+  _addParam(options?: string | Partial<Param> | Param) {
+    const index = this.params.length;
+    return this._insertParamAt(options as any, index);
+  }
+
+  /**
+   * 添加输入参数
+   * @internal
+   * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+   */
+  addParam(name?: string): Param;
+
+  /**
+   * 添加输入参数
+   * @param paramOptions 输入参数参数
+   */
+  addParam(paramOptions: Partial<Param>): Param;
+
+  /**
+   * 添加输入参数
+   * @param param 已有的输入参数实例
+   */
+  addParam(param: Param): Param;
+
+  addParam(options?: string | Partial<Param> | Param) {
+    const node = this._addParam(options as any);
+    const index = this.params.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'params',
+    });
+    return node;
+  }
+
+  getReturnUniqueName(name = 'result') {
+    return utils.unique(name, this.getVarExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入输出参数
+   * @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' };
+    const Return = getConceptConstructor('Return');
+    let ret: Return;
+    if (!options) {
+      ret = Return.from(
+        {
+          ...retOptions,
+          name: this.getReturnUniqueName(),
+        },
+        this,
+        'returns',
+      );
+    } else if (typeof options === 'string') {
+      ret = Return.from(
+        {
+          ...retOptions,
+          name: options,
+        },
+        this,
+        'returns',
+      );
+    } else if (asserts.isReturn(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      ret = options;
+      Object.assign(ret, relationOptions);
+    } else {
+      ret = Return.from(
+        {
+          ...retOptions,
+          ...options,
+        },
+        this,
+        'returns',
+      );
+    }
+    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.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'returns',
+    });
+    return node;
+  }
+
+  getVariableUniqueName(name = 'variable1') {
+    return utils.unique(name, this.getVarExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入变量
+   * @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' };
+    const Variable = getConceptConstructor('Variable');
+    let variable: Variable;
+    if (!options) {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          name: this.getVariableUniqueName(),
+        },
+        this,
+        'variables',
+      );
+    } else if (typeof options === 'string') {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          name: options,
+        },
+        this,
+        'variables',
+      );
+    } else if (asserts.isVariable(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      variable = options;
+      Object.assign(variable, relationOptions);
+    } else {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          ...options,
+        },
+        this,
+        'variables',
+      );
+    }
+    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.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'variables',
+    });
+    return node;
+  }
+
+  /**
+   * 插入逻辑项
+   * @internal
+   * @param logicItemOptions 逻辑项参数
+   */
+  _insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+  /**
+   * 插入逻辑项
+   * @internal
+   * @param logicItem 已有的逻辑项实例
+   */
+  _insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
+
+  _insertItemInBodyAt(options: Partial<LogicItem> | LogicItem, index: number) {
+    const logicItemOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'body' };
+    const LogicItem = getConceptConstructor('LogicItem');
+    let logicItem: LogicItem;
+    if (asserts.isLogicItem(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      logicItem = options;
+      Object.assign(logicItem, relationOptions);
+    } else {
+      logicItem = LogicItem.from(
+        {
+          ...logicItemOptions,
+          ...options,
+        },
+        this,
+        'body',
+      );
+    }
+    this.body.splice(index, 0, logicItem);
+    return logicItem;
+  }
+
+  /**
+   * 插入逻辑项
+   * @param logicItemOptions 逻辑项参数
+   */
+  insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+  /**
+   * 插入逻辑项
+   * @param logicItem 已有的逻辑项实例
+   */
+  insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
+
+  insertItemInBodyAt(options: Partial<LogicItem> | LogicItem, index: number) {
+    const node = this._insertItemInBodyAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'body',
+    });
+    return node;
+  }
+
+  /**
+   * 添加逻辑项
+   * @internal
+   * @param logicItemOptions 逻辑项参数
+   */
+  _addItemInBody(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+  /**
+   * 添加逻辑项
+   * @internal
+   * @param logicItem 已有的逻辑项实例
+   */
+  _addItemInBody(logicItem: LogicItem): LogicItem;
+
+  _addItemInBody(options?: Partial<LogicItem> | LogicItem) {
+    const index = this.body.length;
+    return this._insertItemInBodyAt(options as any, index);
+  }
+
+  /**
+   * 添加逻辑项
+   * @param logicItemOptions 逻辑项参数
+   */
+  addItemInBody(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+  /**
+   * 添加逻辑项
+   * @param logicItem 已有的逻辑项实例
+   */
+  addItemInBody(logicItem: LogicItem): LogicItem;
+
+  addItemInBody(options?: Partial<LogicItem> | LogicItem) {
+    const node = this._addItemInBody(options as any);
+    const index = this.body.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'body',
+    });
+    return node;
+  }
+
+  /**
+   * 插入逻辑项
+   * @internal
+   * @param logicItemOptions 逻辑项参数
+   */
+  _insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+  /**
+   * 插入逻辑项
+   * @internal
+   * @param logicItem 已有的逻辑项实例
+   */
+  _insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+
+  _insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+    const logicItemOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'playground' };
+    const LogicItem = getConceptConstructor('LogicItem');
+    let logicItem: LogicItem;
+    if (asserts.isLogicItem(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      logicItem = options;
+      Object.assign(logicItem, relationOptions);
+    } else {
+      logicItem = LogicItem.from(
+        {
+          ...logicItemOptions,
+          ...options,
+        },
+        this,
+        'playground',
+      );
+    }
+    this.playground.splice(index, 0, logicItem);
+    return logicItem;
+  }
+
+  /**
+   * 插入逻辑项
+   * @param logicItemOptions 逻辑项参数
+   */
+  insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+  /**
+   * 插入逻辑项
+   * @param logicItem 已有的逻辑项实例
+   */
+  insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+
+  insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+    const node = this._insertItemInPlaygroundAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'playground',
+    });
+    return node;
+  }
+
+  /**
+   * 添加逻辑项
+   * @internal
+   * @param logicItemOptions 逻辑项参数
+   */
+  _addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+  /**
+   * 添加逻辑项
+   * @internal
+   * @param logicItem 已有的逻辑项实例
+   */
+  _addItemInPlayground(logicItem: LogicItem): LogicItem;
+
+  _addItemInPlayground(options?: Partial<LogicItem> | LogicItem) {
+    const index = this.playground.length;
+    return this._insertItemInPlaygroundAt(options as any, index);
+  }
+
+  /**
+   * 添加逻辑项
+   * @param logicItemOptions 逻辑项参数
+   */
+  addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+  /**
+   * 添加逻辑项
+   * @param logicItem 已有的逻辑项实例
+   */
+  addItemInPlayground(logicItem: LogicItem): LogicItem;
+
+  addItemInPlayground(options?: Partial<LogicItem> | LogicItem) {
+    const node = this._addItemInPlayground(options as any);
+    const index = this.playground.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'playground',
+    });
+    return node;
+  }
+
+  /**
+   * 删除输入参数
+   * @param name 输入参数名称
+   */
+  removeParam(name: string): void;
+
+  /**
+   * 删除输入参数
+   * @param param 已有的输入参数实例
+   */
+  removeParam(param: Param): void;
+
+  removeParam(options: string | Param) {
+    let param: Param;
+    if (typeof options === 'string') {
+      param = (this.params as Param[]).find((item) => item.name === options);
+      if (!param) {
+        throw new Error('找不到输入参数 ' + options);
+      }
+    } else {
+      param = options;
+    }
+    return param.delete();
+  }
+
+  /**
+   * 删除输出参数
+   * @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 as Return[]).find((item) => item.name === options);
+      if (!ret) {
+        throw new Error('找不到输出参数 ' + options);
+      }
+    } else {
+      ret = options;
+    }
+    return ret.delete();
+  }
+
+  /**
+   * 删除变量
+   * @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 as Variable[]).find((item) => item.name === options);
+      if (!variable) {
+        throw new Error('找不到变量 ' + options);
+      }
+    } else {
+      variable = options;
+    }
+    return variable.delete();
+  }
+
+  /**
+   * 删除逻辑项
+   * @param logicItem 已有的逻辑项实例
+   */
+  removeItemInBody(logicItem: LogicItem): void;
+
+  removeItemInBody(options: LogicItem) {
+    let logicItem: LogicItem = options;
+    return logicItem.delete();
+  }
+
+  /**
+   * 删除逻辑项
+   * @param logicItem 已有的逻辑项实例
+   */
+  removeItemInPlayground(logicItem: LogicItem): void;
+
+  removeItemInPlayground(options: LogicItem) {
+    let logicItem: LogicItem = options;
+    return logicItem.delete();
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  completionChildren: Array<SubLogic> = [];
+
+  getVarExistingNames(excludedList: Array<Param> = []) {
+    const excludedSet = new Set(excludedList);
+    return [...this.params].filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  toJSContent(code: string, state?: TranslatorState): string {
+    // params
+    if (Array.isArray(this.params)) {
+      this.params.forEach((param) => {
+        code += `${indent((state?.tabSize || 0) + 1)}`;
+        code += param.toJS(state);
+        code += ';\n';
+      });
+    }
+    // variables
+    if (Array.isArray(this.variables)) {
+      this.variables.forEach((variable) => {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += variable.toJS(state);
+        code += ';\n';
+      });
+    }
+
+    // returns
+    if (Array.isArray(this.returns)) {
+      this.returns.forEach((ret) => {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += ret.toJS(state);
+        code += ';\n';
+      });
+    }
+    if (Array.isArray(this.body)) {
+      this.body.forEach((item) => {
+        code += item.toJS && item.toJS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+        code += '\n';
+      });
+    }
+
+    return code;
+  }
+
+  toJS(state?: TranslatorState, type?: string): string {
+    let code = '';
+    code += `async (`;
+
+    if (this.params?.length) {
+      this.params.forEach((param, index) => {
+        code += param.name;
+        if (index !== this.params.length - 1) code += ', ';
+      });
+    }
+    code += ') => {\n';
+
+    code = this.toJSContent(code, state);
+    code += `${indent(state?.tabSize || 0)}}\n`;
+    return code;
+  }
+
+  public static getDefaultOptions(): Partial<{
+    body: Array<any>;
+    params: Array<any>;
+    returns: Array<any>;
+  }> {
+    return {
+      body: [
+        {
+          concept: 'Start',
+          label: '开始',
+          kind: 'Statement',
+          type: 'Start',
+        },
+        {
+          concept: 'End',
+          label: '结束',
+          kind: 'Statement',
+          type: 'End',
+        },
+      ],
+    };
+  }
+
+  *getRightCode(code: string, assignment: Assignment | BatchAssignment | CallFunction, rightNode: any) {
+    code = code.replaceAll('\n', ' ');
+    // 赋值语句的右侧或者集合内置函数的参数
+    if (
+      (asserts.isAssignment(assignment) && !assignment.right) ||
+      (asserts.isCallFunction(assignment) &&
+        ((assignment.isDerivableList && !assignment.itemOfCollection) ||
+          (assignment.isDerivableMap && !(assignment.keyOfCollection && assignment.itemOfCollection))))
+    ) {
+      return code;
+    }
+
+    // 调用接口，参数替换成 null
+    if (asserts.isCallInterface(rightNode)) {
+      const { _interface } = rightNode.getModuleInterface();
+      return _interface
+        ? `${rightNode.tsCalleeKey}(${(_interface as unknown as Interface).params.map(() => 'null').join(',')})`
+        : null;
+    }
+
+    // 调用服务端逻辑，参数替换成 null
+    if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace === 'app.logics') {
+      const calleeName = rightNode?.calleeName;
+      const calleeLogic = this.app.logics.find((l) => l.name === calleeName);
+      return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
+    }
+
+    // ForEachStatement 内部变量需要替换处理，如 item、index
+    const forEachStatement = assignment.getAncestor('ForEachStatement') as ForEachStatement;
+    if (forEachStatement) {
+      code = yield* this.handleForEachCode(code, forEachStatement);
+    }
+    // 可迭代的集合
+    const callFunction = assignment.getAncestor('CallFunction') as CallFunction;
+    if (callFunction && callFunction.isLoopCollection) {
+      const anonymousFunction = assignment.getAncestor('AnonymousFunction') as AnonymousFunction;
+      code = yield* this.handleCollectionCode(code, anonymousFunction, callFunction);
+    }
+    // Match 需要针对分支缩小类型范围
+    const matchCase = assignment.getAncestor('MatchCase') as MatchCase;
+    if (matchCase) {
+      code = yield* this.handleMatchCaseCode(code, matchCase);
+    }
+    return code;
+  }
+
+  *handleForEachCode(code: string, forEachStatement: ForEachStatement): Generator<any, string, any> {
+    const { item, index, each } = forEachStatement;
+    if (code.includes(item.name)) {
+      const eachTSCode = each ? yield* each.toEmbeddedTS() : '__IDENTIFIER__';
+      code = this.handleReplaceCode(
+        code,
+        item.name,
+        eachTSCode === '__IDENTIFIER__' ? eachTSCode : `${eachTSCode}.__get(0)`,
+      );
+    }
+    if (code.includes(index.name)) {
+      code = this.handleReplaceCode(code, index.name, 'new nasl.core.Long(0)');
+    }
+
+    const parentForEachStatement = forEachStatement.getAncestor('ForEachStatement') as ForEachStatement;
+    if (parentForEachStatement) {
+      code = yield* this.handleForEachCode(code, parentForEachStatement);
+    }
+    return code;
+  }
+
+  *handleCollectionCode(
+    code: string,
+    anonymousFunction: AnonymousFunction,
+    callFunction: CallFunction,
+  ): Generator<any, string, any> {
+    const { collection } = callFunction;
+    const self = this;
+    yield* wrapForEach(anonymousFunction.params, function* warpForEachGenerator(param, index) {
+      if (code.includes(param?.name)) {
+        const collectionTSCode = collection ? yield* collection.toEmbeddedTS() : '__IDENTIFIER__';
+        code = self.handleReplaceCode(
+          code,
+          param.name,
+          collectionTSCode === '__IDENTIFIER__'
+            ? collectionTSCode
+            : callFunction.isLoopMap && index === 0
+            ? `${collectionTSCode}.__getKey(0)`
+            : `${collectionTSCode}.__get(0)`,
+        );
+      }
+    });
+    const parentForEachStatement = callFunction.getAncestor('ForEachStatement') as ForEachStatement;
+    if (parentForEachStatement) {
+      code = yield* this.handleForEachCode(code, parentForEachStatement);
+    }
+    const parentCallFunction = callFunction.getAncestor('CallFunction') as CallFunction;
+    if (parentCallFunction?.isLoopCollection) {
+      const parentAnonymousFunction = callFunction.getAncestor('AnonymousFunction') as AnonymousFunction;
+      code = yield* this.handleCollectionCode(code, parentAnonymousFunction, parentCallFunction);
+    }
+    return code;
+  }
+
+  handleReplaceCode(code: string, variable: string, replaceCode: string) {
+    return code.replace(/\S+/g, ($1) => {
+      if ($1 === `${variable},`) return `${replaceCode},`;
+      if ($1 === variable) return replaceCode;
+
+      let fnCode = $1;
+      if ($1.startsWith(`${variable}.`)) fnCode = $1.replaceAll(`${variable}.`, `${replaceCode}.`);
+      if ($1.startsWith(`${variable},`)) fnCode = $1.replaceAll(`${variable},`, `${replaceCode},`);
+      if ($1.includes(`(${variable},`)) fnCode = $1.replaceAll(`(${variable},`, `(${replaceCode},`);
+      if ($1.includes(`(${variable}.`)) fnCode = $1.replaceAll(`(${variable}.`, `(${replaceCode}.`);
+      if ($1.includes(`(${variable})`)) fnCode = $1.replaceAll(`(${variable})`, `(${replaceCode})`);
+      if ($1.includes(`,${variable},`)) fnCode = $1.replaceAll(`,${variable},`, `,${replaceCode},`);
+      if ($1.includes(`,${variable}.`)) fnCode = $1.replaceAll(`,${variable}.`, `,${replaceCode}.`);
+      if ($1.includes(`,${variable})`)) fnCode = $1.replaceAll(`,${variable})`, `,${replaceCode})`);
+      if ($1.includes(`...[${variable}.`)) fnCode = $1.replaceAll(`...[${variable}.`, `...[${replaceCode}.`);
+      return fnCode;
+    });
+  }
+
+  *handleMatchCaseCode(code: string, matchCase: MatchCase): Generator<any, string, any> {
+    const match = matchCase.getAncestor('Match') as Match;
+    const expressionTsCode = yield* match.expression.toEmbeddedTS();
+    if (code.includes(expressionTsCode)) {
+      let typeCode = '';
+      yield* wrapForEach(matchCase.patterns, function* wrapForEach(pattern, index) {
+        if (asserts.isTypeAnnotation(pattern)) {
+          if (index === 0) {
+            typeCode += yield* pattern.toEmbeddedTS();
+          } else {
+            typeCode += '|';
+            typeCode += yield* pattern.toEmbeddedTS();
+          }
+        }
+      });
+      if (typeCode) {
+        code = this.handleReplaceCode(code, expressionTsCode, `(${expressionTsCode} as ${typeCode})`);
+      }
+    }
+    const parentMatchCase = match.getAncestor('MatchCase') as MatchCase;
+    if (parentMatchCase) {
+      code = yield* this.handleMatchCaseCode(code, parentMatchCase);
+    }
+    return code;
+  }
+
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), prefix?: string, hideDefaultValue?: boolean): TranslatorGenerator {
+    const self = this;
+    // 获取所有子节点用于树上填充
+    self.getSubLogics()
+
+    // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
+    let code = '';
+    // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
+    const IDENTIFIERMAP = new Set<Variable | Return>();
+
+    code += `function ${self.tsName}`;
+
+    code += '(';
+    // 有参数长度
+    if (self.params.length) {
+      yield* wrapForEach(self.params, function* warpForEachGenerator(param, index) {
+        code += yield* param.toEmbeddedTS(shiftState(state, code));
+        if (index !== self.params.length - 1) code += ', ';
+      });
+    }
+    code += ')';
+    const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
+    const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
+    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
+      if (
+        el &&
+        // 批量赋值
+        (asserts.isBatchAssignment(el) ||
+          // 赋值
+          (asserts.isAssignment(el) && el.left?.name) ||
+          // 内置函数对集合类型的推导
+          (asserts.isCallFunction(el) && el.derivablecollection?.name))
+      ) {
+        if (asserts.isAssignment(el)) {
+          const advanceVar = self.variables?.find(
+            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
+          );
+          if (advanceVar && !advanceMap.get(advanceVar)) {
+            advanceMap.set(advanceVar, el);
+          }
+          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
+          if (advanceRn && !advanceMap.get(advanceRn)) {
+            advanceMap.set(advanceRn, el);
+          }
+        } else if (asserts.isCallFunction(el)) {
+          // 需要被推导的集合
+          const expression = el.derivablecollection;
+          // 宽泛意义上的变量（变量+出参）
+          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
+            return !variable.typeAnnotation && expression?.name === variable.name;
+          });
+          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
+            callFunctionAdvanceMap.set(advanceVar, el);
+          }
+        } else if (asserts.isBatchAssignment(el)) {
+          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
+            const leftCode =
+              leftIndex.length === 1
+                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
+                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                    returnOrigin('');
+            const advanceVar = self.variables?.find(
+              (variable) => !variable.typeAnnotation && leftCode === variable.name,
+            );
+            if (advanceVar && !advanceMap.get(advanceVar)) {
+              advanceMap.set(advanceVar, el);
+            }
+            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
+            if (advanceRn && !advanceMap.get(advanceRn)) {
+              advanceMap.set(advanceRn, el);
+            }
+          });
+        }
+      }
+    });
+
+    // 兼容 return 没有类型情况
+    if (self.returns.length && self.returns[0].typeAnnotation) {
+      code += ': ';
+      code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+        returnOrigin('');
+    }
+    code += '{\n';
+
+    for (const variable of self.variables) {
+      const ts = yield* variable.defaultValue?.toEmbeddedTS?.() ?? utils.returnOrigin('');
+      if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
+        IDENTIFIERMAP.add(variable);
+      }
+      if (!advanceMap.get(variable) && !callFunctionAdvanceMap.get(variable)) {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += yield* variable.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += ';\n';
+      }
+    }
+
+    for (const ret of self.returns) {
+      const ts = yield* ret.defaultValue?.toEmbeddedTS?.() ?? returnOrigin('');
+      if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
+        IDENTIFIERMAP.add(ret);
+      }
+      if (!advanceMap.get(ret) && !callFunctionAdvanceMap.get(ret)) {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += yield* ret.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += ';\n';
+      }
+    }
+
+    // 变量提升
+    state.isVariableHost = true;
+
+    yield* wrapIterator(advanceMap.entries(), function* warpForEachGenerator([node, assignment]) {
+      // 有默认值的用默认值来推导类型, 但是如果是__IDENTIFIER__或者__IDENTIFIER__()，就不需要默认值来推导了
+      if (node.defaultValue?.expression && !IDENTIFIERMAP.has(node)) {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        return;
+      }
+      code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
+      code += `${indent((state?.tabSize || 0) + 1)}let `;
+      code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      if (asserts.isBatchAssignment(assignment)) {
+        yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
+          const leftCode =
+            leftIndex.length === 1
+              ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
+              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                  returnOrigin('');
+          if (leftCode === node.name) {
+            const rightNode: any =
+              rightIndex.length === 1
+                ? assignment.rights[rightIndex[0]]?.expression
+                : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
+            // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
+            if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
+              if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'anonymousStructure') {
+                code += '= ';
+                code += (yield* rightNode.getInitCode(shiftState(state, code, { inline: true }))) || 'null';
+              } else if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'generic') {
+                code += '= ';
+                code += (yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }))) || 'null';
+              } else {
+                code += ': ';
+                code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                  returnOrigin('null');
+              }
+            } else {
+              code += ' = ';
+              const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
+              code += yield* self.getRightCode(rightCode, assignment, rightNode);
+            }
+          }
+        });
+      } else if (
+        ['NewList', 'NewMap'].includes((assignment as Assignment).right?.concept) &&
+        !((assignment as Assignment).right as any)?.typeAnnotation
+      ) {
+        const rightNode: any = (assignment as Assignment).right;
+        code += ' = ';
+        code += yield* rightNode.getInitCode(shiftState(state, code, { inline: true }));
+      } else if (
+        (assignment as Assignment).right?.concept === 'NewComposite' &&
+        ((assignment as Assignment).right as any)?.typeAnnotation?.typeKind === 'anonymousStructure'
+      ) {
+        const rightNode: any = (assignment as Assignment).right;
+        code += ' = ';
+        code += yield* rightNode.getInitCode(shiftState(state, code, { inline: true }));
+      } else if (
+        (assignment as Assignment).right?.concept === 'NewComposite' &&
+        ((assignment as Assignment).right as any)?.typeAnnotation?.typeKind === 'generic'
+      ) {
+        const rightNode: any = (assignment as Assignment).right;
+        code += ' = ';
+        code += yield* rightNode.getNewCompositeCode(shiftState(state, code, { inline: true }));
+      } else {
+        const rightNode: any = (assignment as Assignment).right;
+        // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
+        if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
+          code += ': ';
+          code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+            returnOrigin('null');
+        } else {
+          code += ' = ';
+          let rightCode = '';
+          // 因为右侧枚举要赋值就得new 一下；
+          if (
+            rightNode &&
+            asserts.isIdentifier(rightNode) &&
+            rightNode.namespace &&
+            rightNode.namespace.endsWith('enums')
+          ) {
+            rightCode += 'new ';
+          }
+          rightCode +=
+            rightNode && rightNode.toEmbeddedTS
+              ? yield* rightNode.toEmbeddedTS(shiftState(state, code, { inline: true }))
+              : '__RIGHT__';
+          code += yield* self.getRightCode(rightCode, assignment, rightNode);
+        }
+      }
+      code += ';\n';
+    });
+
+    yield* wrapIterator(callFunctionAdvanceMap.entries(), function* warpForEachGenerator([node, assignment]) {
+      //
+      if (advanceMap.get(node)) {
+        return;
+      }
+      // 有默认值的用默认值来推导类型, 但是如果是__IDENTIFIER__或者__IDENTIFIER__()，就不需要默认值来推导了
+      if (node.defaultValue?.expression && !IDENTIFIERMAP.has(node)) {
+        code += `${indent((state?.tabSize || 0) + 1)}let `;
+        code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        return;
+      }
+      code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
+      yield* wrapForEach(
+        [
+          {
+            key: 'key',
+            node: assignment.keyOfCollection,
+          },
+          {
+            key: 'item',
+            node: assignment.itemOfCollection,
+          },
+        ],
+        function* warpForEachGenerator({ key, node: itemNode }) {
+          if (itemNode) {
+            code += `const __${key}_${node?.name} = `;
+            const itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
+            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            code += ';\n';
+          }
+        },
+      );
+      code += `${indent((state?.tabSize || 0) + 1)}let `;
+      code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      const nodeName = node?.name;
+      const keyNode = (assignment as CallFunction).keyOfCollection;
+      const itemNode = (assignment as CallFunction).itemOfCollection;
+      if ((assignment as CallFunction).isDerivableMap && keyNode && itemNode) {
+        code += `: nasl.collection.Map<typeof __key_${nodeName}, typeof __item_${nodeName}>`;
+      } else if ((assignment as CallFunction).isDerivableList && itemNode) {
+        code += `: nasl.collection.List<typeof __item_${nodeName}>;`;
+      }
+      code += ';\n';
+    });
+
+    // 变量提升结束
+    delete state.isVariableHost;
+
+    // 参数的默认值是__IDENTIFIER__或者__IDENTIFIER__()时不赋默认值，但是需要ts翻译出来进行报错校验
+    if (!hideDefaultValue) {
+      for (const node of IDENTIFIERMAP.values()) {
+        code += yield* node.defaultValue.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += '; ';
+      }
+      code += '\n';
+    }
+
+    if (!this.body.length && this.returns.length) {
+      code += `${indent((state?.tabSize || 0) + 1)}return ${this.returns[0].name};\n`;
+    } else {
+      // 如果长度小于2 并且不是虚拟节点就 加 报错，
+      if (self.body.length <= 2 && !asserts.isNamespace(self.parentNode)) {
+        if (self.body.length && self.body[0].concept === 'JavaLogic') {
+          code += '';
+        } else {
+          code += indent((state?.tabSize || 0) + 1);
+          code += 'const __LogicEmpty: any = null;';
+        }
+      }
+      yield* wrapForEach(self.body, function* warpForEachGenerator(item) {
+        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ??
+          returnOrigin('');
+        code += ';\n';
+      });
+    }
+    // 在body渲染完成之后把其余的节点放到下面
+    yield* wrapForEach(self.playground, function* warpForEachGenerator(item) {
+      code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+      code += ';\n';
+    });
+
+    if (!hideDefaultValue) {
+      function* setPlaygroundCode(arr: Variable[] | Param[] | Return[], name: string) {
+        if (arr.length) {
+          code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是 ${name} 的默认值草稿------ */\n`;
+        }
+
+        for (const item1 of arr) {
+          for (const item of item1.defaultValue?.playground ?? []) {
+            code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+            code += ';\n';
+          }
+        }
+      }
+
+      yield* setPlaygroundCode(self.variables, 'variables');
+      yield* setPlaygroundCode(self.returns, 'returns');
+      yield* setPlaygroundCode(self.params, 'params');
+    }
+
+    code += `${indent(state?.tabSize || 0)}}`;
+    if (prefix === 'inObject') {
+      code += `,`;
+    }
+    code += '\n';
+    return code;
+  }
+  async saveStructureOfCallQueryComponents(root?: BaseNode | Logic) {
+    if (!root) root = this;
+    const set = new Set();
+    utils.traverse(
+      ({ node }) => {
+        if (asserts.isCallQueryComponent(node)) {
+          set.add(node);
+        }
+      },
+      { node: root },
+      {
+        mode: 'anyObject',
+        excludedKeySet: new Set(['parentNode', '__assignment__']),
+      },
+    );
+    for (const node of set) {
+      (<CallQueryComponent>node).saveStructure();
+    }
+  }
+
+  subLogics: SubLogic[] = [];
+
+  getSubLogics() {
+    const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
+      if (asserts.isSubLogic(node)) {
+        return true;
+      }
+    });
+    this.subLogics = subLogics as SubLogic[];
+  }
+
+  genActionListener($event: EventPayload): void {
+    super.genActionListener($event);
+    invokeCommand('logic.update', this);
+  }
+
+  // 用于展示的名称
+  get __name__() {
+    const callLogic = this.getAncestor('CallLogic') as CallLogic;
+    return `${callLogic?.calleeName || ''}_${this.name}`;
+  }
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default SubLogic;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================