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

package/src/concepts/CallInterface__.ts

@@ -1,23 +1,22 @@
+import { v4 as uuidv4 } from 'uuid';
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Interface from './Interface__';
 import NullLiteral from './NullLiteral__';
 import { ElementToVueOptions } from './ViewElement__';
-import { getConceptConstructor } from '../decorators';
+import { getConceptConstructor, concept, excludedInJSON, property } from '../decorators';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 import InterfaceParam from './InterfaceParam__';
 import Structure from './Structure__';
 import Module from './Module__';
 import AuthInterface from './AuthInterface__';
 import Frontend from './Frontend__';
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 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 Argument from './Argument__';
@@ -28,763 +27,791 @@ import LogicItem from './LogicItem__';
  */
 @concept('调用接口')
 export class CallInterface extends LogicItem {
-    /**
-     * 产品概念
-     */
-    @property()
-    concept: 'CallInterface' | 'CallAuthInterface' = 'CallInterface';
-
-    /**
-     * 调用接口标题
-     */
-    @property()
-    label: string = '调用接口';
-
-    /**
-     * calleeNamespace
-     */
-    @property()
-    calleeNamespace: string = undefined;
-
-    /**
-     * calleeName
-     */
-    @property()
-    calleeName: string = undefined;
-
-    /**
-     * shortcut
-     */
-    @property()
-    shortcut: boolean = undefined;
-
-    /**
-     * 实际参数
-     */
-    @property('Argument')
-    arguments: Array<Argument> = [];
-
-
-
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source?: Partial<CallInterface>) {
-        source = Object.assign({}, CallInterface.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
-    }
-    getClassName() {
-        return 'CallInterface';
+  /**
+   * 产品概念
+   */
+  @property()
+  concept: 'CallInterface' | 'CallAuthInterface' = 'CallInterface';
+
+  /**
+   * 调用接口标题
+   */
+  @property()
+  label: string = '调用接口';
+
+  /**
+   * calleeNamespace
+   */
+  @property()
+  calleeNamespace: string = undefined;
+
+  /**
+   * calleeName
+   */
+  @property()
+  calleeName: string = undefined;
+
+  /**
+   * shortcut
+   */
+  @property()
+  shortcut: boolean = undefined;
+
+  /**
+   * 实际参数
+   */
+  @property('Argument')
+  arguments: Array<Argument> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<CallInterface>) {
+    // @ts-ignore
+    source = { ...CallInterface.getDefaultOptions(), ...source };
+    super(source);
+    super.subConstructor(source);
+  }
+
+  getClassName() {
+    return 'CallInterface';
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): CallInterface {
+    return super.from(source, parentNode, parentKey) as CallInterface;
+  }
+
+  /**
+   * 插入实际参数
+   * @internal
+   * @param argumentOptions 实际参数参数
+   */
+  _insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
+
+  /**
+   * 插入实际参数
+   * @internal
+   * @param argument 已有的实际参数实例
+   */
+  _insertArgumentAt(argument: Argument, index: number): Argument;
+
+  _insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
+    const argumentOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'arguments' };
+    let argument: Argument;
+    if (options instanceof Argument) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      argument = options;
+      Object.assign(argument, relationOptions);
+    } else {
+      argument = Argument.from(
+        {
+          ...argumentOptions,
+          ...options,
+        },
+        this,
+        'arguments'
+      );
     }
-
-    static from(source: any, parentNode?: any, parentKey?: string): CallInterface {
-        return super.from(source, parentNode, parentKey) as CallInterface;
+    this.arguments.splice(index, 0, argument);
+    return argument;
+  }
+
+  /**
+   * 插入实际参数
+   * @param argumentOptions 实际参数参数
+   */
+  insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
+
+  /**
+   * 插入实际参数
+   * @param argument 已有的实际参数实例
+   */
+  insertArgumentAt(argument: Argument, index: number): Argument;
+
+  insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
+    const node = this._insertArgumentAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'arguments',
+    });
+    return node;
+  }
+
+  /**
+   * 添加实际参数
+   * @internal
+   * @param argumentOptions 实际参数参数
+   */
+  _addArgument(argumentOptions: Partial<Argument>): Argument;
+
+  /**
+   * 添加实际参数
+   * @internal
+   * @param argument 已有的实际参数实例
+   */
+  _addArgument(argument: Argument): Argument;
+
+  _addArgument(options?: Partial<Argument> | Argument) {
+    const index = this.arguments.length;
+    return this._insertArgumentAt(options as any, index);
+  }
+
+  /**
+   * 添加实际参数
+   * @param argumentOptions 实际参数参数
+   */
+  addArgument(argumentOptions: Partial<Argument>): Argument;
+
+  /**
+   * 添加实际参数
+   * @param argument 已有的实际参数实例
+   */
+  addArgument(argument: Argument): Argument;
+
+  addArgument(options?: Partial<Argument> | Argument) {
+    const node = this._addArgument(options as any);
+    const index = this.arguments.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'arguments',
+    });
+    return node;
+  }
+
+  /**
+   * 删除实际参数
+   * @param argument 已有的实际参数实例
+   */
+  removeArgument(argument: Argument): void;
+
+  removeArgument(options: Argument) {
+    const argument: Argument = options;
+    return argument.delete();
+  }
+
+  __removeLogicItem(logicItem: LogicItem) {
+    const { parentKey } = logicItem;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: logicItem,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(logicItem);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === logicItem) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
     }
-
-
-
-
-
-
-
-
-    /**
-    * 插入实际参数
-    * @internal
-    * @param argumentOptions 实际参数参数
-    */
-    _insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
-
-    /**
-    * 插入实际参数
-    * @internal
-    * @param argument 已有的实际参数实例
-    */
-    _insertArgumentAt(argument: Argument, index: number): Argument;
-
-    _insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
-        const argumentOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'arguments' };
-        let argument: Argument;
-        if (options instanceof Argument) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            argument = options;
-            Object.assign(argument, relationOptions);
-        } else {
-            argument = Argument.from({
-                ...argumentOptions,
-                ...options,
-            }, this, 'arguments');
+    return params;
+  }
+
+  //= ===============================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //= ===============================================================================
+
+  /**
+   * 标识当前删除是否为鉴权方式更新导致的删除。
+   * 针对此种删除，删除逻辑已经处理，无需再走 deleteCallNode 逻辑
+   */
+  @property('Boolean')
+  __authDelete: Boolean = false;
+
+  // 删除调用接口时且接口无引用，删除接口和数据结构
+  async deleteCallNode() {
+    if (this.calleeKey !== '__IDENTIFIER__' && !this.__authDelete) {
+      (this as any).__deleteCallNodeTimer = setTimeout(async () => {
+        clearTimeout((this as any).__deleteCallNodeTimer);
+        // 计算之前选择的接口的引用次数
+        const oldItf: Interface = this.getCallNode();
+        if (oldItf) {
+          let refCount = 0;
+          const refs = (await oldItf.findUsage()) as Map<any, any>;
+
+          const isOnlyUsedByFronted = refs.size === 1 && Array.from(refs.keys()).filter((key) => key instanceof Frontend).length > 0;
+          const isAuthInterface = oldItf instanceof AuthInterface;
+          // 当仅仅只有前端使用，且该接口是鉴权接口时需要将接口还原为普通接口
+          if (isOnlyUsedByFronted && isAuthInterface) {
+            this.replaceToInterface(oldItf);
+          }
+          refs.forEach((val: any) => {
+            const loopFindNode = (item: any) => {
+              if (item.children) {
+                item.children.forEach((child: any) => loopFindNode(child));
+              } else {
+                refCount++;
+              }
+            };
+            loopFindNode(val);
+          });
+          // 无引用则删除
+          if (!refCount) {
+            //  删除旧的接口、接口的数据结构
+            this.app.emit('collect:start', { actionMsg: '删除接口' });
+            const oldStructuresSet = oldItf.getRefStructures(oldItf.module.structures);
+            oldStructuresSet.forEach((s: Structure) => s.delete());
+            oldItf.delete();
+            oldItf.afterDelete();
+            this.app.emit('collect:end');
+          }
         }
-        this.arguments.splice(index, 0, argument);
-        return argument;
-    }
-
-
-
-    /**
-     * 插入实际参数
-     * @param argumentOptions 实际参数参数
-     */
-    insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
-
-    /**
-     * 插入实际参数
-     * @param argument 已有的实际参数实例
-     */
-    insertArgumentAt(argument: Argument, index: number): Argument;
-
-    insertArgumentAt(options: Partial<Argument> | Argument, index: number) {
-        const node = this._insertArgumentAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'arguments',
-        });
-        return node;
-    }
-
-
-
-    /**
-     * 添加实际参数
-     * @internal
-     * @param argumentOptions 实际参数参数
-     */
-    _addArgument(argumentOptions: Partial<Argument>): Argument;
-
-    /**
-     * 添加实际参数
-     * @internal
-     * @param argument 已有的实际参数实例
-     */
-    _addArgument(argument: Argument): Argument;
-
-    _addArgument(options?: Partial<Argument> | Argument) {
-        const index = this.arguments.length;
-        return this._insertArgumentAt(options as any, index);
+      }, 200);
     }
-
-
-
-    /**
-     * 添加实际参数
-     * @param argumentOptions 实际参数参数
-     */
-    addArgument(argumentOptions: Partial<Argument>): Argument;
-
-    /**
-     * 添加实际参数
-     * @param argument 已有的实际参数实例
-     */
-    addArgument(argument: Argument): Argument;
-
-    addArgument(options?: Partial<Argument> | Argument) {
-        const node = this._addArgument(options as any);
-        const index = this.arguments.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'arguments',
-        });
-        return node;
+  }
+
+  replaceToInterface(oldItf: AuthInterface) {
+    this.app.emit('collect:start', { actionMsg: '调用接口恢复为非鉴权' });
+    const { name, originLogicName, path, method, description, params, returns, protocol, protocolParams } = oldItf;
+    const newInterface = new Interface({
+      name,
+      originLogicName,
+      path,
+      method,
+      description,
+      params,
+      returns,
+      protocol,
+      protocolParams,
+    });
+    const m = oldItf.parentNode as Module;
+    const interfaceIndex = m?.interfaces?.findIndex?.((item) => item.name === oldItf.name);
+    oldItf.delete();
+    m.insertInterfaceAt(newInterface, interfaceIndex);
+    this.app.emit('collect:end');
+  }
+
+  get tsCalleeNamespace() {
+    if (this.calleeNamespace) {
+      let tsCalleeNamespace = this.calleeNamespace;
+      tsCalleeNamespace = tsCalleeNamespace.replace(/\.[0-9]/g, (m) => m.replace('.', '.$'));
+      tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
+      return tsCalleeNamespace;
     }
-
-
-
-
-    /**
-     * 删除实际参数
-     * @param argument 已有的实际参数实例
-     */
-    removeArgument(argument: Argument): void;
-
-    removeArgument(options: Argument) {
-        const argument: Argument = options;
-        return argument.delete();
+    return '';
+  }
+
+  toVue(options?: ElementToVueOptions): string {
+    let code = this.calleeName;
+    code += '(';
+    this.arguments?.forEach((arg, index) => {
+      code += arg?.toVue(options);
+      if (index !== this.arguments?.length - 1) code += ', ';
+    });
+    code += ')';
+    return code;
+  }
+
+  toUI(state?: TranslatorState): string {
+    let code = this.calleeName;
+    code += '(';
+    this.arguments?.forEach((arg, index) => {
+      code += arg?.toUI();
+      if (index !== this.arguments?.length - 1) code += ', ';
+    });
+    code += ')';
+    return code;
+  }
+
+  toJS(state?: TranslatorState): string {
+    const { calleewholeKey, app, completeArguments } = this;
+    const [, _name, , _interfaceName] = calleewholeKey.split('.');
+    const _module = app?.interfaceDependencies?.find?.((item) => item.name === _name);
+    const _interface = _module?.interfaces?.find?.((item) => item.name === _interfaceName);
+    if (!_interface) {
+      if (!this.calleeNamespace || !this.calleeName) throw new Error('调用接口为空');
+      throw new Error(`${_name}下的${_interfaceName}接口未找到`);
     }
-
-    __removeLogicItem(logicItem: LogicItem) {
-        const parentKey = logicItem.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: logicItem,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(logicItem);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === logicItem) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
+    let isSimpleBody = false; // 兼容body只有基本类型的
+    const _params = _interface.params;
+    const _queries = _params.filter((item) => item.in === 'query').map((item) => item.name);
+    const _headers = _params.filter((item) => item.in === 'header').map((item) => item.name);
+    const _body = _params
+      .filter((item) => item.in === 'body')
+      .map((item) => {
+        if (item.typeAnnotation.typeKind === 'primitive') {
+          isSimpleBody = true;
         }
-        return params;
-    }
-
-    //================================================================================
-    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-    // 自动生成的代码已结束。下面可以手动编写。
-    //================================================================================
-
-    /**
-     * 标识当前删除是否为鉴权方式更新导致的删除。
-     * 针对此种删除，删除逻辑已经处理，无需再走 deleteCallNode 逻辑
-     */
-    @property('Boolean')
-    __authDelete: Boolean = false;
-
-    // 删除调用接口时且接口无引用，删除接口和数据结构
-    async deleteCallNode() {
-        if (this.calleeKey !== '__IDENTIFIER__' && !this.__authDelete) {
-            (this as any).__deleteCallNodeTimer = setTimeout(async () => {
-                clearTimeout((this as any).__deleteCallNodeTimer);
-                // 计算之前选择的接口的引用次数
-                const oldItf: Interface = this.getCallNode();
-                if (oldItf) {
-                    let refCount = 0;
-                    const refs = await oldItf.findUsage() as Map<any, any>;
-
-                    const isOnlyUsedByFronted = refs.size === 1 && Array.from(refs.keys()).filter(key => key instanceof Frontend).length > 0;
-                    const isAuthInterface = oldItf instanceof AuthInterface;
-                    // 当仅仅只有前端使用，且该接口是鉴权接口时需要将接口还原为普通接口
-                    if (isOnlyUsedByFronted && isAuthInterface) {
-                        this.replaceToInterface(oldItf);
-                    }
-                    refs.forEach((val: any) => {
-                        const loopFindNode = (item: any) => {
-                            if (item.children) {
-                                item.children.forEach((child: any) => loopFindNode(child));
-                            } else {
-                                refCount++;
-                            }
-                        };
-                        loopFindNode(val);
-                    });
-                    // 无引用则删除
-                    if (!refCount) {
-                        //  删除旧的接口、接口的数据结构
-                        this.app.emit('collect:start', { actionMsg: '删除接口' });
-                        const oldStructuresSet = oldItf.getRefStructures(oldItf.module.structures);
-                        oldStructuresSet.forEach((s: Structure) => s.delete());
-                        oldItf.delete();
-                        oldItf.afterDelete();
-                        this.app.emit('collect:end');
-                    }
-                }
-            }, 200);
+        return item.name;
+      });
+    const _paths = _params.filter((item) => item.in === 'path').map((item) => item.name);
+
+    /** 填充参数信息 */
+    const setArgumentCode = (args: Argument[], keys: string[], code: string, useKeyWord: boolean, useRest: boolean) => {
+      const filledArgs = args
+        // 维持原样，暂时不过滤没有填入值的参数
+        // .filter((arg) => Boolean(arg?.expression))
+        .filter((arg) => keys.includes(arg.keyword));
+
+      filledArgs.forEach((arg, index) => {
+        if (useRest) {
+          code += ` ...${arg?.toJS(shiftState(state, code))}`;
+        } else if (useKeyWord) {
+          code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+        } else {
+          code += ` ${arg?.toJS(shiftState(state, code))}`;
         }
-    }
-
-    replaceToInterface(oldItf: AuthInterface) {
-        this.app.emit('collect:start', { actionMsg: '调用接口恢复为非鉴权' });
-        const {
-            name, originLogicName, path, method, description, params, returns,
-            protocol, protocolParams,
-        } = oldItf;
-        const newInterface =  new Interface({
-            name, originLogicName, path, method, description, params, returns,
-            protocol, protocolParams,
-        });
-        const m = oldItf.parentNode as Module;
-        const interfaceIndex = m?.interfaces?.findIndex?.((item) => item.name === oldItf.name);
-        oldItf.delete();
-        m.insertInterfaceAt(newInterface, interfaceIndex);
-        this.app.emit('collect:end');
-    }
 
-    get tsCalleeNamespace() {
-        if (this.calleeNamespace) {
-            let tsCalleeNamespace = this.calleeNamespace;
-            tsCalleeNamespace = tsCalleeNamespace.replace(/\.[0-9]/g, (m) => m.replace('.', '.$'));
-            tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
-            return tsCalleeNamespace;
+        if (index !== args.length - 1) {
+          code += ', ';
         }
-        return '';
+      });
+
+      if (filledArgs.length === 0 && !useKeyWord && !useRest) {
+        code += 'undefined';
+      }
+
+      return code;
+    };
+
+    let code = `await this.$services['_custom']['${this.calleeNamespace}.${this.calleeName}']`;
+
+    code += `({ config: {\ndownload: false,\n },\nquery: {`;
+    code = setArgumentCode(completeArguments, _queries, code, true, false);
+    code += `}, path: {`;
+    code = setArgumentCode(completeArguments, _paths, code, true, false);
+    code += `}, headers: {`;
+    code = setArgumentCode(completeArguments, _headers, code, true, false);
+    code += `},\n`;
+
+    if (isSimpleBody) {
+      code += `body: `;
+      code = setArgumentCode(completeArguments, _body, code, false, false);
+    } else {
+      code += `body: {`;
+      code = setArgumentCode(completeArguments, _body, code, false, true);
+      code += '}';
     }
 
-    toVue(options?: ElementToVueOptions): string {
-        let code = this.calleeName;
-        code += '(';
-        this.arguments?.forEach((arg, index) => {
-            code += arg?.toVue(options);
-            if (index !== this.arguments?.length - 1)
-                code += ', ';
-        });
-        code += ')';
-        return code;
+    code += '\n})';
+    const typeAnnotation = (this as any).typeAnnotation || this.__TypeAnnotation;
+    const needGenInitFromSchema = typeAnnotation && !['primitive', 'union'].includes(typeAnnotation.typeKind);
+    if (needGenInitFromSchema) {
+      code = `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', ${code})`;
     }
-
-    toUI(state?: TranslatorState): string {
-        let code = this.calleeName;
-        code += '(';
-        this.arguments?.forEach((arg, index) => {
-            code += arg?.toUI();
-            if (index !== this.arguments?.length - 1)
-                code += ', ';
-        });
-        code += ')';
-        return code;
+    return code;
+  }
+
+  @withSourceMap()
+  toEmbeddedTS(state?: TranslatorState): string {
+    const { completeArguments, parentNode, parentKey, tsCalleeKey } = this;
+
+    let code = `${tsCalleeKey}(`;
+
+    if (completeArguments?.length) {
+      code += '{';
+      completeArguments?.forEach((arg, index) => {
+        code += arg?.toEmbeddedTS(shiftState(state, code), arg.paramRequired, true);
+        if (index !== this.arguments?.length - 1) code += ', ';
+      });
+      code += '}';
     }
-
-    toJS(state?: TranslatorState): string {
-        const _arr = this.calleewholeKey.split('.');
-        const _name = _arr[1];
-        const _interfaceName = _arr[3];
-        const _module = this.app?.interfaceDependencies?.find?.((item) => item.name === _name);
-        const _interface = _module?.interfaces?.find?.((item) => item.name === _interfaceName);
-        if (!_interface) {
-            if (!this.calleeNamespace || !this.calleeName)
-                throw new Error('调用接口为空');
-            throw new Error(`${_name}下的${_interfaceName}接口未找到`);
-        }
-        let isSimpleBody = false; // 兼容body只有基本类型的
-        const _params = _interface.params;
-        const _queries = _params.filter((item) => item.in === 'query').map((item) => item.name);
-        const _headers = _params.filter((item) => item.in === 'header').map((item) => item.name);
-        const _body = _params
-            .filter((item) => item.in === 'body')
-            .map((item) => {
-                if (item.typeAnnotation.typeKind === 'primitive') {
-                    isSimpleBody = true;
-                }
-                return item.name;
-            });
-        const _paths = _params.filter((item) => item.in === 'path').map((item) => item.name);
-        const completeArguments = this.completeArguments;
-        let code = `await this.$services['_custom']['${this.calleeNamespace}.${this.calleeName}']`;
-        code += `({
-            config: {
-                download: false,
-            },
-            query: {`;
-        completeArguments
-            .filter((arg) => _queries.includes(arg?.keyword))
-            .forEach((arg, index) => {
-                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
-                if (index !== completeArguments.length - 1)
-                    code += ', ';
-            });
-        code += `},
-            path: {`;
-        completeArguments
-            .filter((arg) => _paths.includes(arg?.keyword))
-            .forEach((arg, index) => {
-                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
-                if (index !== completeArguments.length - 1)
-                    code += ', ';
-            });
-        code += `},
-            headers: {`;
-        completeArguments
-            .filter((arg) => _headers.includes(arg?.keyword))
-            .forEach((arg, index) => {
-                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
-                if (index !== completeArguments.length - 1)
-                    code += ', ';
-            });
-        code += `},\n`;
-        if (isSimpleBody) {
-            code += `body: `;
-            completeArguments
-                .filter((arg) => _body.includes(arg?.keyword))
-                .forEach((arg, index) => {
-                    code += ` ${arg?.toJS(shiftState(state, code))}`;
-                });
-        } else {
-            code += `body: {`;
-            completeArguments
-                .filter((arg) => _body.includes(arg?.keyword))
-                .forEach((arg, index) => {
-                    code += ` ...${arg?.toJS(shiftState(state, code))}`;
-                    if (index !== completeArguments.length - 1)
-                        code += ', ';
-                });
-            code += '}';
-        }
-
-        code += '\n})';
-        const typeAnnotation = (this as any).typeAnnotation || this.__TypeAnnotation;
-        const needGenInitFromSchema = typeAnnotation && !['primitive', 'union'].includes(typeAnnotation.typeKind);
-        if (needGenInitFromSchema) {
-            code = `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', ${code})`;
-        }
-        return code;
+    code += ')';
+    if (
+      parentNode.concept !== 'Argument' &&
+      parentKey !== 'test' &&
+      parentKey !== 'patterns' &&
+      parentKey !== 'returnExpression' &&
+      parentNode.concept !== 'Assignment' &&
+      parentNode.concept !== 'ForEachStatement' &&
+      parentNode.concept !== 'SelectMembers' &&
+      parentNode.concept !== 'UnaryExpression' &&
+      parentNode.concept !== 'BinaryExpression' &&
+      parentNode.concept !== 'MemberExpression' &&
+      parentNode.concept !== 'StringInterpolation' &&
+      !['NewMap', 'NewList'].includes(parentNode.concept)
+    ) {
+      code += ';';
     }
-
-    @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        let code = this.tsCalleeKey;
-        const completeArguments = this.completeArguments;
-        code += '(';
-        if (completeArguments?.length) {
-            code += '{';
-            completeArguments?.forEach((arg, index) => {
-                code += arg?.toEmbeddedTS(shiftState(state, code), arg.paramRequired, true);
-                if (index !== this.arguments?.length - 1)
-                    code += ', ';
-            });
-            code += '}';
-        }
-        code += ')';
-        if (this.parentNode.concept !== 'Argument'
-            && this.parentKey !== 'test'
-            && this.parentKey !== 'patterns'
-            && this.parentNode.concept !== 'Assignment'
-            && this.parentNode.concept !== 'ForEachStatement'
-            && this.parentNode.concept !== 'SelectMembers'
-            && this.parentNode.concept !== 'UnaryExpression'
-            && this.parentNode.concept !== 'BinaryExpression'
-            && this.parentNode.concept !== 'MemberExpression'
-            && this.parentNode.concept !== 'StringInterpolation'
-            && !['NewMap', 'NewList'].includes(this.parentNode.concept)
-            && this.parentKey !== 'returnExpression') {
-            code += ';';
-        }
-        code += '\n';
-        return code;
+    code += '\n';
+    return code;
+  }
+
+  @withSourceMap()
+  toNaturalTS(state?: TranslatorState): string {
+    const { completeArguments, parentNode, parentKey, tsCalleeKey } = this;
+
+    let code = `${tsCalleeKey}(`;
+
+    if (completeArguments?.length) {
+      code += '{';
+      completeArguments?.forEach((arg, index) => {
+        code += arg?.toNaturalTS(shiftState(state, code), arg.paramRequired, true);
+        if (index !== this.arguments?.length - 1) code += ', ';
+      });
+      code += '}';
     }
-
-    toBrief(): string {
-        return this.arguments.map((a) => a.toBrief()).join('<br />');
+    code += ')';
+    if (
+      parentNode.concept !== 'Argument' &&
+      parentKey !== 'test' &&
+      parentKey !== 'patterns' &&
+      parentKey !== 'returnExpression' &&
+      parentNode.concept !== 'Assignment' &&
+      parentNode.concept !== 'ForEachStatement' &&
+      parentNode.concept !== 'SelectMembers' &&
+      parentNode.concept !== 'UnaryExpression' &&
+      parentNode.concept !== 'BinaryExpression' &&
+      parentNode.concept !== 'MemberExpression' &&
+      parentNode.concept !== 'StringInterpolation' &&
+      !['NewMap', 'NewList'].includes(parentNode.concept)
+    ) {
+      code += ';';
     }
-
-    get calleeKey(): string {
-        const tsCalleeNamespace = this.tsCalleeNamespace;
-        const calleeName = this.calleeName;
-        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+    code += '\n';
+    return code;
+  }
+
+  toBrief(): string {
+    return this.arguments.map((a) => a.toBrief()).join('<br />');
+  }
+
+  get calleeKey(): string {
+    const { tsCalleeNamespace } = this;
+    const { calleeName } = this;
+    return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+  }
+
+  // 用于logic回填
+  get calleewholeKey(): string {
+    return `${this.calleeNamespace}.${this.calleeName}`;
+  }
+
+  get tsCalleeName(): string {
+    const excludeds = [
+      'abstract',
+      'arguments',
+      'await',
+      'boolean',
+      'break',
+      'byte',
+      'case',
+      'catch',
+      'char',
+      'class',
+      'const',
+      'continue',
+      'debugger',
+      'default',
+      'delete',
+      'do',
+      'double',
+      'decimal',
+      'else',
+      'enum',
+      'eval',
+      'export',
+      'extends',
+      'false',
+      'final',
+      'finally',
+      'float',
+      'for',
+      'function',
+      'goto',
+      'if',
+      'implements',
+      'import',
+      'in',
+      'instanceof',
+      'int',
+      'interface',
+      'let',
+      'long',
+      'native',
+      'new',
+      'null',
+      'package',
+      'private',
+      'protected',
+      'public',
+      'return',
+      'short',
+      'static',
+      'super',
+      'switch',
+      'synchronized',
+      'this',
+      'throw',
+      'throws',
+      'transient',
+      'true',
+      'try',
+      'typeof',
+      'var',
+      'void',
+      'volatile',
+      'while',
+      'with',
+      'yield,as',
+      'any',
+      'number',
+      'string',
+      'get',
+      'type',
+      'typeof',
+      'instanceof',
+      'require',
+    ];
+    if (excludeds.includes(this.calleeName)) {
+      return `_${this.calleeName}`;
     }
-    // 用于logic回填
-    get calleewholeKey(): string {
-        return this.calleeNamespace + '.' + this.calleeName;
+    return this.calleeName;
+  }
+
+  get tsCalleeKey(): string {
+    const { tsCalleeNamespace } = this;
+    const calleeName = this.tsCalleeName;
+    return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+  }
+
+  get calleeDefaultKey(): string {
+    return `${this.calleeNamespace}.${this.calleeName}`;
+  }
+
+  _setCallee(_interface: Interface) {
+    this.arguments = [];
+    _interface.params.forEach((param) => {
+      this._addArgument({
+        keyword: param.name,
+      });
+    });
+  }
+
+  setCallee(_interface: Interface) {
+    const calleeNamespace = _interface.getNamespace();
+    const calleeName = _interface.name;
+    const params = _interface.params.map((param) => {
+      const relationOptions = { parentNode: this, parentKey: 'arguments' };
+      const argument = new Argument({
+        keyword: param.name,
+      });
+      Object.assign(argument, relationOptions);
+      return argument;
+    });
+
+    if (this.app) {
+      this.app.emit('collect:start', {
+        actionMsg: `切换调用逻辑`,
+      });
+      const { parentNode } = this;
+      this.update({
+        calleeNamespace,
+        calleeName,
+        arguments: params,
+        folded: false,
+      });
+      if (parentNode.concept === 'MemberExpression') {
+        const topNode = parentNode.firstMemberExpressionNode();
+        topNode.replaceNode(this);
+      }
+      this.app.emit('collect:end');
+    } else {
+      this.update({
+        calleeNamespace,
+        calleeName,
+        arguments: params,
+        folded: false,
+      });
     }
-    get tsCalleeName(): string {
-        const excludeds = [
-            'abstract',
-            'arguments',
-            'await',
-            'boolean',
-            'break',
-            'byte',
-            'case',
-            'catch',
-            'char',
-            'class',
-            'const',
-            'continue',
-            'debugger',
-            'default',
-            'delete',
-            'do',
-            'double',
-            'decimal',
-            'else',
-            'enum',
-            'eval',
-            'export',
-            'extends',
-            'false',
-            'final',
-            'finally',
-            'float',
-            'for',
-            'function',
-            'goto',
-            'if',
-            'implements',
-            'import',
-            'in',
-            'instanceof',
-            'int',
-            'interface',
-            'let',
-            'long',
-            'native',
-            'new',
-            'null',
-            'package',
-            'private',
-            'protected',
-            'public',
-            'return',
-            'short',
-            'static',
-            'super',
-            'switch',
-            'synchronized',
-            'this',
-            'throw',
-            'throws',
-            'transient',
-            'true',
-            'try',
-            'typeof',
-            'var',
-            'void',
-            'volatile',
-            'while',
-            'with',
-            'yield,as',
-            'any',
-            'number',
-            'string',
-            'get',
-            'type',
-            'typeof',
-            'instanceof',
-            'require',
-        ];
-        if (excludeds.includes(this.calleeName)) {
-            return '_' + this.calleeName;
+  }
+
+  // 通过内容过去节点
+  getCallNode() {
+    let node;
+    // 如果是其余app下自定义逻辑
+    try {
+      node = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: any, tempPoint: any) => {
+        // 处理 NASL 中未定义的假的节点
+        if (key === tempPoint.name) {
+          return {
+            tempPoint,
+            state: 1,
+          };
         }
-        return this.calleeName;
-    }
-
-    get tsCalleeKey(): string {
-        const tsCalleeNamespace = this.tsCalleeNamespace;
-        const calleeName = this.tsCalleeName;
-        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+        const t = tempPoint[key];
+        return {
+          tempPoint: t,
+          state: Array.isArray(t) ? 2 : 1,
+        };
+      });
+    } catch (err) {}
+    return node;
+  }
+
+  get completeArguments() {
+    const node = this.getCallNode();
+    let logicParam: InterfaceParam[] = [];
+    const Arguments: Argument[] = [];
+    if (node?.params) {
+      logicParam = node.params;
     }
-    get calleeDefaultKey(): string {
-        return `${this.calleeNamespace}.${this.calleeName}`;
+    if (this.arguments?.length) {
+      this.arguments.forEach((arg) => {
+        const idx = logicParam.findIndex((params) => arg.keyword === params.name);
+        const param = logicParam[idx];
+
+        arg.paramRequired = param?.required;
+        arg.paramTypeAnnotation = undefined;
+        arg.paramDefaultValue = undefined;
+        // 取到是不是必填放入参数中
+        if (param && !arg.expression) {
+          // 非必填时 才会有默认值
+          // 因为之前接口这里的必填非必填，一直是有值的，而且不允许修改
+          arg.paramTypeAnnotation = param.typeAnnotation;
+          arg.paramDefaultValue = param.defaultValue;
+        }
+        Arguments.push(arg);
+      });
     }
-    _setCallee(_interface: Interface) {
-        this.arguments = [];
-        _interface.params.forEach((param) => {
-            this._addArgument({
-                keyword: param.name,
-            });
-        });
+    return Arguments;
+  }
+
+  /**
+   * 反向查找对应 module 和 interface
+   */
+  getModuleInterface() {
+    if (!this.calleeNamespace || !this.calleeName)
+      return {
+        _module: null,
+        _interface: null,
+      };
+    const _arr = this.calleewholeKey.split('.');
+    const _name = _arr[1];
+    const _interfaceName = _arr[3];
+    const _module = this.app.interfaceDependencies.find((item) => item.name === _name);
+    const _interface = _module?.interfaces.find((item) => item.name === _interfaceName);
+    return {
+      _module,
+      _interface,
+    };
+  }
+
+  // 导入接口
+  async createOrUpdateInterface({ moduleData, selectedModule }: { moduleData: Partial<Module>; selectedModule: any }) {
+    const moduleName = moduleData.name;
+    const itfData = moduleData.interfaces[0];
+    this.app.emit('collect:start', { actionMsg: '调用接口' });
+
+    let module = this.app.interfaceDependencies.find((item) => item.name === moduleName);
+    if (!module) {
+      module = this.app.addModuleInInterfaceDependencies({
+        name: moduleName,
+        configuration: moduleData.configuration,
+        type: 'interface',
+        isAdd: true,
+      });
     }
-
-    setCallee(_interface: Interface) {
-        const calleeNamespace = _interface.getNamespace();
-        const calleeName = _interface.name;
-        const params = _interface.params.map((param) => {
-            const relationOptions = { parentNode: this, parentKey: 'arguments' };
-            const argument = new Argument({
-                keyword: param.name,
-            });
-            Object.assign(argument, relationOptions);
-            return argument;
-        });
-
-        if (this.app) {
-            this.app.emit('collect:start', {
-                actionMsg: `切换调用逻辑`,
-            });
-            const parentNode: any = this.parentNode;
-            this.update({
-                calleeNamespace,
-                calleeName,
-                arguments: params,
-                folded: false,
-            });
-            if (parentNode.concept === 'MemberExpression') {
-                const topNode = parentNode.firstMemberExpressionNode();
-                topNode.replaceNode(this);
+    // 将依赖库的config添加到APP的config中
+    if (selectedModule.appType === 'DUBBO' && moduleData.configuration && moduleData.configuration.groups) {
+      const configGroupData = moduleData.configuration.groups[0];
+      if (configGroupData) {
+        const configGroup = this.app.configuration.getGroup(configGroupData.name);
+        if (configGroup) {
+          const propertyData = configGroupData.properties[0];
+          if (propertyData) {
+            const property = configGroup.getProperty(propertyData.name);
+            // 已导入的不覆盖
+            if (!property) {
+              configGroup.addConfigProperty(propertyData);
             }
-            this.app.emit('collect:end');
-        } else {
-            this.update({
-                calleeNamespace,
-                calleeName,
-                arguments: params,
-                folded: false,
-            });
+          }
         }
+      }
     }
-    // 通过内容过去节点
-    getCallNode() {
-        let node;
-        // 如果是其余app下自定义逻辑
-        try {
-            node = getNodeByNodeCallee(this.app, this.calleewholeKey, (key: any, tempPoint: any) => {
-                // 处理 NASL 中未定义的假的节点
-                if (key === tempPoint.name) {
-                    return {
-                        tempPoint,
-                        state: 1,
-                    };
-                }
-                const t = tempPoint[key];
-                return {
-                    tempPoint: t,
-                    state: Array.isArray(t) ? 2 : 1,
-                };
-            });
-        } catch (err) { }
-        return node;
-    }
-    get completeArguments() {
-        const node = this.getCallNode();
-        let logicParam: InterfaceParam[] = [];
-        const Arguments: Argument[] = [];
-        if (node?.params) {
-            logicParam = node.params;
-        }
-        if (this.arguments?.length) {
-            this.arguments.forEach((arg) => {
-                const idx = logicParam.findIndex((params) => arg.keyword === params.name);
-                const param = logicParam[idx];
-
-                arg.paramRequired = param?.required;
-                arg.paramTypeAnnotation = undefined;
-                arg.paramDefaultValue = undefined;
-                // 取到是不是必填放入参数中
-                if (param && !arg.expression) {
-                    // 非必填时 才会有默认值
-                    // 因为之前接口这里的必填非必填，一直是有值的，而且不允许修改
-                    arg.paramTypeAnnotation = param.typeAnnotation;
-                    arg.paramDefaultValue = param.defaultValue;
-                }
-                Arguments.push(arg);
-            });
-        }
-        return Arguments;
+
+    let targetItf = module.interfaces.find((item) => item.name === itfData.name);
+    // 根据 targetItf 是否是AuthInterface 来确定生成什么类型的接口
+    let newItf;
+    if (targetItf && targetItf.concept === 'AuthInterface') {
+      newItf = new AuthInterface({
+        ...itfData,
+        authLogic: (targetItf as AuthInterface).authLogic,
+        concept: targetItf.concept,
+      });
+    } else {
+      newItf = new Interface(itfData);
     }
-    /**
-     * 反向查找对应 module 和 interface
-     */
-    getModuleInterface() {
-        if (!this.calleeNamespace || !this.calleeName)
-            return {
-                _module: null,
-                _interface: null,
-            };
-        const _arr = this.calleewholeKey.split('.');
-        const _name = _arr[1];
-        const _interfaceName = _arr[3];
-        const _module = this.app.interfaceDependencies.find((item) => item.name === _name);
-        const _interface = _module?.interfaces.find((item) => item.name === _interfaceName);
-        return {
-            _module,
-            _interface,
-        };
+    if (targetItf) {
+      // 更新已有接口
+      targetItf.update(newItf.toJSON());
+    } else {
+      targetItf = newItf;
+      module.addInterface(targetItf);
     }
 
-    // 导入接口
-    async createOrUpdateInterface({ moduleData, selectedModule }: {moduleData: Partial<Module>, selectedModule: any}) {
-        const moduleName = moduleData.name;
-        const itfData = moduleData.interfaces[0];
-        this.app.emit('collect:start', { actionMsg: '调用接口' });
-
-        let module = this.app.interfaceDependencies.find((item) => item.name === moduleName);
-        if (!module) {
-            module = this.app.addModuleInInterfaceDependencies({
-                name: moduleName,
-                configuration: moduleData.configuration,
-                type: 'interface',
-                isAdd: true,
-            });
+    // 计算之前选择的接口的引用次数
+    let oldItf;
+    if (this.calleeKey !== '__IDENTIFIER__') {
+      oldItf = this.getCallNode();
+      if (oldItf) {
+        let refCount = 0;
+        let isSelfRef = false;
+        let isSameItf = false;
+        if (selectedModule.appCode === oldItf.parentNode.name && newItf.name === oldItf.name) {
+          isSameItf = true;
         }
-        // 将依赖库的config添加到APP的config中
-        if (selectedModule.appType === 'DUBBO' && moduleData.configuration && moduleData.configuration.groups) {
-            const configGroupData = moduleData.configuration.groups[0];
-            if (configGroupData) {
-                const configGroup = this.app.configuration.getGroup(configGroupData.name);
-                if (configGroup) {
-                    const propertyData = configGroupData.properties[0];
-                    if (propertyData) {
-                        const property = configGroup.getProperty(propertyData.name);
-                        // 已导入的不覆盖
-                        if (!property) {
-                            configGroup.addConfigProperty(propertyData);
-                        }
-                    }
-                }
+        const refs = await oldItf.findUsage();
+        refs.forEach((val: any) => {
+          const loopFindNode = (item: any) => {
+            if (item.children) {
+              item.children.forEach((i: any) => loopFindNode(i));
+            } else {
+              refCount++;
+              if (item.node === this) {
+                isSelfRef = true;
+              } else if (isSameItf) {
+                item.node.setCallee?.(targetItf);
+              }
             }
-        }
-
-        let targetItf = module.interfaces.find((item) => item.name === itfData.name);
-        // 根据 targetItf 是否是AuthInterface 来确定生成什么类型的接口
-        let newItf;
-        if (targetItf && targetItf.concept === 'AuthInterface') {
-            newItf = new AuthInterface({
-                ...itfData,
-                authLogic: (targetItf as AuthInterface).authLogic,
-                concept: targetItf.concept,
-            });
-        } else {
-            newItf = new Interface(itfData);
-        }
-        if (targetItf) {
-            // 更新已有接口
-            targetItf.update(newItf.toJSON());
-        } else {
-            targetItf = newItf;
-            module.addInterface(targetItf);
-        }
+          };
+          loopFindNode(val);
+        });
 
-        // 计算之前选择的接口的引用次数
-        let oldItf;
-        if (this.calleeKey !== '__IDENTIFIER__') {
-            oldItf = this.getCallNode();
-            if (oldItf) {
-                let refCount = 0;
-                let isSelfRef = false;
-                let isSameItf = false;
-                if (selectedModule.appCode === oldItf.parentNode.name && newItf.name === oldItf.name) {
-                    isSameItf = true;
-                }
-                const refs = await oldItf.findUsage();
-                refs.forEach((val: any) => {
-                    const loopFindNode = (item: any) => {
-                        if (item.children) {
-                            item.children.forEach((i: any) => loopFindNode(i));
-                        } else {
-                            refCount++;
-                            if (item.node === this) {
-                                isSelfRef = true;
-                            } else if (isSameItf) {
-                                item.node.setCallee?.(targetItf);
-                            }
-                        }
-                    };
-                    loopFindNode(val);
-                });
-
-                // 之前选的接口不存在时则删除
-                // if (selectedModule.appCode === oldItf.parentNode.name && selectedModule.apis && !selectedModule.apis.find((api) => api.apiCode === oldItf.name)) {
-                //     oldItf.delete();
-                // } else {
-                // 仅被自己引用则删除
-                if (!isSameItf && isSelfRef && refCount === 1) {
-                    //  删除旧的数据结构
-                    const oldStructuresSet = oldItf.getRefStructures(oldItf.module.structures);
-                    oldStructuresSet.forEach((s: Structure) => s.delete());
-                    oldItf.delete();
-                    oldItf.afterDelete();
-                }
-                // }
-            }
+        // 之前选的接口不存在时则删除
+        // if (selectedModule.appCode === oldItf.parentNode.name && selectedModule.apis && !selectedModule.apis.find((api) => api.apiCode === oldItf.name)) {
+        //     oldItf.delete();
+        // } else {
+        // 仅被自己引用则删除
+        if (!isSameItf && isSelfRef && refCount === 1) {
+          //  删除旧的数据结构
+          const oldStructuresSet = oldItf.getRefStructures(oldItf.module.structures);
+          oldStructuresSet.forEach((s: Structure) => s.delete());
+          oldItf.delete();
+          oldItf.afterDelete();
         }
-
-        this.setCallee(targetItf);
-
-        // 删除旧的数据结构
-        const oldStructuresSet = targetItf.getRefStructures(targetItf.module.structures);
-        oldStructuresSet.forEach((s) => s.delete());
-        // 递归找出 response/request 的 Body/Returns 引用的数据结构
-        const structuresSet = targetItf.getRefStructures(moduleData.structures);
-        structuresSet.forEach((s) => module.addStructure(Structure.from(s)));
-        this.app.emit('collect:end');
+        // }
+      }
     }
-    //================================================================================
-    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-    //================================================================================
+
+    this.setCallee(targetItf);
+
+    // 删除旧的数据结构
+    const oldStructuresSet = targetItf.getRefStructures(targetItf.module.structures);
+    oldStructuresSet.forEach((s) => s.delete());
+    // 递归找出 response/request 的 Body/Returns 引用的数据结构
+    const structuresSet = targetItf.getRefStructures(moduleData.structures);
+    structuresSet.forEach((s) => module.addStructure(Structure.from(s)));
+    this.app.emit('collect:end');
+  }
+  //= ===============================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //= ===============================================================================
 }
 
 classMap.CallInterface = CallInterface;
 export default CallInterface;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================