@lcap/nasl 2.13.0-beta.1 → 2.13.0-beta.2

package/src/concepts/CallQueryComponent__.ts

@@ -59,6 +59,12 @@ export class CallQueryComponent extends LogicItem {
     @property('LogicItem')
     where: LogicItem = undefined;
 
+    /**
+     * where 草稿态
+     */
+    @property('LogicItem')
+    wherePlayground: Array<LogicItem> = [];
+
     /**
      * groupBy
      */
@@ -71,6 +77,12 @@ export class CallQueryComponent extends LogicItem {
     @property('LogicItem')
     having: LogicItem = undefined;
 
+    /**
+     * having 草稿态
+     */
+    @property('LogicItem')
+    havingPlayground: Array<LogicItem> = [];
+
     /**
      * orderBy
      */
@@ -204,20 +216,113 @@ export class CallQueryComponent extends LogicItem {
         });
     }
 
-        getQueryGroupByExpressionExistingNames(excludedList: Array<QueryGroupByExpression> = []) {
-        const excludedSet = new Set(excludedList);
-        return (this.groupBy || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getQueryGroupByExpressionUniqueName(name = 'queryGroupByExpression1') {
-        return utils.unique(name, this.getQueryGroupByExpressionExistingNames(), undefined, false);
-    }
+    
+
+    
 
     /**
-    * 插入查询分组
+    * 插入逻辑项
+    * @internal
+    * @param logicItemOptions 逻辑项参数
+    */
+    _insertItemInWherePlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+    * 插入逻辑项
     * @internal
-    * @param name 查询分组名称，如果不填会自动生成一个唯一名称
+    * @param logicItem 已有的逻辑项实例
     */
-    _insertQueryGroupByExpressionInGroupByAt(name: string, index: number): QueryGroupByExpression;
+    _insertItemInWherePlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+
+    _insertItemInWherePlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+        const logicItemOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'wherePlayground' };
+        let logicItem: LogicItem;
+        if (options instanceof LogicItem) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            logicItem = options;
+            Object.assign(logicItem, relationOptions);
+        } else {
+            logicItem = LogicItem.from({
+                ...logicItemOptions,
+                ...options,
+            }, this, 'wherePlayground');
+        }
+        this.wherePlayground.splice(index, 0, logicItem);
+        return logicItem;
+    }
+
+    
+
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInWherePlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInWherePlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+
+    insertItemInWherePlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+        const node = this._insertItemInWherePlaygroundAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'wherePlayground',
+        });
+        return node;
+    }
+
+    
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInWherePlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInWherePlayground(logicItem: LogicItem): LogicItem;
+
+    _addItemInWherePlayground(options?: Partial<LogicItem> | LogicItem) {
+        const index = this.wherePlayground.length;
+        return this._insertItemInWherePlaygroundAt(options as any, index);
+    }
+
+    
+
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInWherePlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInWherePlayground(logicItem: LogicItem): LogicItem;
+
+    addItemInWherePlayground(options?: Partial<LogicItem> | LogicItem) {
+        const node = this._addItemInWherePlayground(options as any);
+        const index = this.wherePlayground.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'wherePlayground',
+        });
+        return node;
+    }
+
+    
 
     /**
     * 插入查询分组
@@ -233,21 +338,11 @@ export class CallQueryComponent extends LogicItem {
     */
     _insertQueryGroupByExpressionInGroupByAt(queryGroupByExpression: QueryGroupByExpression, index: number): QueryGroupByExpression;
 
-    _insertQueryGroupByExpressionInGroupByAt(options: string | Partial<QueryGroupByExpression> | QueryGroupByExpression, index: number) {
+    _insertQueryGroupByExpressionInGroupByAt(options: Partial<QueryGroupByExpression> | QueryGroupByExpression, index: number) {
         const queryGroupByExpressionOptions: any = {};
         const relationOptions = { parentNode: this, parentKey: 'groupBy' };
         let queryGroupByExpression: QueryGroupByExpression;
-        if (!options) {
-            queryGroupByExpression = QueryGroupByExpression.from({
-                ...queryGroupByExpressionOptions,
-                name: this.getQueryGroupByExpressionUniqueName(),
-            }, this, 'groupBy');
-        } else if (typeof options === 'string') {
-            queryGroupByExpression = QueryGroupByExpression.from({
-                ...queryGroupByExpressionOptions,
-                name: options,
-            }, this, 'groupBy');
-        } else if (options instanceof QueryGroupByExpression) {
+        if (options instanceof QueryGroupByExpression) {
             options.ensureDelete(); // 同一实例不支持多处存在
             queryGroupByExpression = options;
             Object.assign(queryGroupByExpression, relationOptions);
@@ -261,11 +356,7 @@ export class CallQueryComponent extends LogicItem {
         return queryGroupByExpression;
     }
 
-    /**
-     * 插入查询分组
-     * @param name 查询分组名称，如果不填会自动生成一个唯一名称
-     */
-    insertQueryGroupByExpressionInGroupByAt(name: string, index: number): QueryGroupByExpression;
+    
 
     /**
      * 插入查询分组
@@ -279,7 +370,7 @@ export class CallQueryComponent extends LogicItem {
      */
     insertQueryGroupByExpressionInGroupByAt(queryGroupByExpression: QueryGroupByExpression, index: number): QueryGroupByExpression;
 
-    insertQueryGroupByExpressionInGroupByAt(options: string | Partial<QueryGroupByExpression> | QueryGroupByExpression, index: number) {
+    insertQueryGroupByExpressionInGroupByAt(options: Partial<QueryGroupByExpression> | QueryGroupByExpression, index: number) {
         const node = this._insertQueryGroupByExpressionInGroupByAt(options as any, index);
         node.create({
             index,
@@ -289,12 +380,7 @@ export class CallQueryComponent extends LogicItem {
         return node;
     }
 
-    /**
-     * 添加查询分组
-     * @internal
-     * @param name 查询分组名称，如果不填会自动生成一个唯一名称
-     */
-    _addQueryGroupByExpressionInGroupBy(name?: string): QueryGroupByExpression;
+    
 
     /**
      * 添加查询分组
@@ -310,17 +396,12 @@ export class CallQueryComponent extends LogicItem {
      */
     _addQueryGroupByExpressionInGroupBy(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
 
-    _addQueryGroupByExpressionInGroupBy(options?: string | Partial<QueryGroupByExpression> | QueryGroupByExpression) {
+    _addQueryGroupByExpressionInGroupBy(options?: Partial<QueryGroupByExpression> | QueryGroupByExpression) {
         const index = this.groupBy.length;
         return this._insertQueryGroupByExpressionInGroupByAt(options as any, index);
     }
 
-    /**
-     * 添加查询分组
-     * @internal
-     * @param name 查询分组名称，如果不填会自动生成一个唯一名称
-     */
-    addQueryGroupByExpressionInGroupBy(name?: string): QueryGroupByExpression;
+    
 
     /**
      * 添加查询分组
@@ -334,7 +415,7 @@ export class CallQueryComponent extends LogicItem {
      */
     addQueryGroupByExpressionInGroupBy(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
 
-    addQueryGroupByExpressionInGroupBy(options?: string | Partial<QueryGroupByExpression> | QueryGroupByExpression) {
+    addQueryGroupByExpressionInGroupBy(options?: Partial<QueryGroupByExpression> | QueryGroupByExpression) {
         const node = this._addQueryGroupByExpressionInGroupBy(options as any);
         const index = this.groupBy.indexOf(node);
         node.create({
@@ -347,6 +428,110 @@ export class CallQueryComponent extends LogicItem {
 
     
 
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItemOptions 逻辑项参数
+    */
+    _insertItemInHavingPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+    * 插入逻辑项
+    * @internal
+    * @param logicItem 已有的逻辑项实例
+    */
+    _insertItemInHavingPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+
+    _insertItemInHavingPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+        const logicItemOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'havingPlayground' };
+        let logicItem: LogicItem;
+        if (options instanceof LogicItem) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            logicItem = options;
+            Object.assign(logicItem, relationOptions);
+        } else {
+            logicItem = LogicItem.from({
+                ...logicItemOptions,
+                ...options,
+            }, this, 'havingPlayground');
+        }
+        this.havingPlayground.splice(index, 0, logicItem);
+        return logicItem;
+    }
+
+    
+
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInHavingPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInHavingPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+
+    insertItemInHavingPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+        const node = this._insertItemInHavingPlaygroundAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'havingPlayground',
+        });
+        return node;
+    }
+
+    
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInHavingPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInHavingPlayground(logicItem: LogicItem): LogicItem;
+
+    _addItemInHavingPlayground(options?: Partial<LogicItem> | LogicItem) {
+        const index = this.havingPlayground.length;
+        return this._insertItemInHavingPlaygroundAt(options as any, index);
+    }
+
+    
+
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInHavingPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInHavingPlayground(logicItem: LogicItem): LogicItem;
+
+    addItemInHavingPlayground(options?: Partial<LogicItem> | LogicItem) {
+        const node = this._addItemInHavingPlayground(options as any);
+        const index = this.havingPlayground.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'havingPlayground',
+        });
+        return node;
+    }
+
+    
+
     /**
     * 插入查询排序子句
     * @internal
@@ -584,10 +769,17 @@ export class CallQueryComponent extends LogicItem {
     
 
     /**
-    * 删除查询分组
-    * @param name 查询分组名称
-    */
-    removeQueryGroupByExpressionInGroupBy(name: string): void;
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInWherePlayground(logicItem: LogicItem): void;
+
+    removeItemInWherePlayground(options: LogicItem) {
+        let logicItem: LogicItem = options;
+        return logicItem.delete();
+    }
+
+    
 
     /**
      * 删除查询分组
@@ -595,16 +787,8 @@ export class CallQueryComponent extends LogicItem {
      */
     removeQueryGroupByExpressionInGroupBy(queryGroupByExpression: QueryGroupByExpression): void;
 
-    removeQueryGroupByExpressionInGroupBy(options: string | QueryGroupByExpression) {
-        let queryGroupByExpression: QueryGroupByExpression;
-        if (typeof options === 'string') {
-            queryGroupByExpression = this.groupBy.find((item) => item.name === options);
-            if (!queryGroupByExpression) {
-                throw new Error('找不到查询分组 ' + options);
-            }
-        } else {
-            queryGroupByExpression = options;
-        }
+    removeQueryGroupByExpressionInGroupBy(options: QueryGroupByExpression) {
+        let queryGroupByExpression: QueryGroupByExpression = options;
         return queryGroupByExpression.delete();
     }
 
@@ -637,6 +821,19 @@ export class CallQueryComponent extends LogicItem {
 
     
 
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInHavingPlayground(logicItem: LogicItem): void;
+
+    removeItemInHavingPlayground(options: LogicItem) {
+        let logicItem: LogicItem = options;
+        return logicItem.delete();
+    }
+
+    
+
     /**
      * 删除查询排序子句
      * @param queryOrderByExpression 已有的查询排序子句实例

package/src/concepts/CompletionProperty__.ts

@@ -239,6 +239,7 @@ export class CompletionProperty extends BaseNode {
 
     isProcess: boolean = false;
 
+    noFurther: boolean = false;
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Destination__.ts

@@ -1,4 +1,5 @@
 import View from './View__';
+import { getNodeByNodeCallee } from '../automate/engine/utils';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import { BindAttribute } from '..';
@@ -431,7 +432,7 @@ export class Destination extends LogicItem {
         let code = '';
 
         if (this.parentNode instanceof BindAttribute) {
-            code = `${utils.firstLowerCase(this.concept)}: () => {\n`;
+            code = `() => {\n`;
             code += indent((state?.tabSize || 0) + 2);
             if (this.tsCalleeNamespace && this.tsName) {
                 code += `${this.tsCalleeNamespace}.${this.tsName}.$destination({`;
@@ -475,6 +476,10 @@ export class Destination extends LogicItem {
         code += `${indent((state?.tabSize || 0) + 1)}}\n`;
         return code;
     }
+
+    get viewNode() {
+        return getNodeByNodeCallee(this.app, this.viewNamespace + '.' + this.viewName);
+    }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Function__.ts

@@ -150,7 +150,7 @@ export class Function extends BaseNode {
         });
     }
 
-        getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
+    getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
         const excludedSet = new Set(excludedList);
         return (this.typeParams || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -291,7 +291,6 @@ export class Function extends BaseNode {
         return node;
     }
 
-
     getParamUniqueName(name = 'param1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -429,7 +428,6 @@ export class Function extends BaseNode {
         return node;
     }
 
-
     getReturnUniqueName(name = 'result') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -567,7 +565,6 @@ export class Function extends BaseNode {
         return node;
     }
 
-
     getVariableUniqueName(name = 'variable1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -705,9 +702,6 @@ export class Function extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
     * 删除类型参数
     * @param name 类型参数名称
@@ -756,8 +750,6 @@ export class Function extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除输入参数
     * @param name 输入参数名称
@@ -806,8 +798,6 @@ export class Function extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除输出参数
     * @param name 输出参数名称
@@ -856,8 +846,6 @@ export class Function extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除局部变量
     * @param name 局部变量名称
@@ -906,8 +894,6 @@ export class Function extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除逻辑项
     * @param name 逻辑项名称

package/src/concepts/Logic__.ts

@@ -2,7 +2,6 @@ import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState
 import Namespace from './Namespace__';
 import CallQueryComponent from './CallQueryComponent__';
 import ForEachStatement from './ForEachStatement__';
-import BindEvent from './BindEvent__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1379,7 +1378,16 @@ export class Logic extends BaseNode {
         return varList.filter((item) => !excludedSet.has(item)).map((item) => item?.name);
     }
 
-    toJSContent(code: string, state?: TranslatorState): string {
+    toJS(state?: TranslatorState): string {
+        let code = `methods['${this.name}'] = async function (`;
+        if (Array.isArray(this.params)) {
+            this.params.forEach((param, index) => {
+                code += param.name;
+                if (index !== this.params.length - 1)
+                    code += ', ';
+            });
+        }
+        code += `) {\n`;
         // params
         if (Array.isArray(this.params)) {
             this.params.forEach((param) => {
@@ -1412,27 +1420,8 @@ export class Logic extends BaseNode {
             });
         }
 
-        return code;
-    }
-    toJS(state?: TranslatorState, type?: string): string {
-        let code = '';
-        if (type === 'IIFE') {
-            code += `(async () => {\n`;
-            code = this.toJSContent(code, state);
-            code += indent((state?.tabSize || 0)) + '})();\n';
-            return code;
-        }
-        code += `methods['${this.name}'] = async function (`;
-        if (Array.isArray(this.params)) {
-            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;
     }
 
@@ -1543,9 +1532,6 @@ export class Logic extends BaseNode {
         if (!this.body.length && this.returns.length) {
             code += indent((state?.tabSize || 0) + 1) + `return ${this.returns[0].name};\n`;
         } else {
-            if (this.body.length <= 2 && !(this.parentNode instanceof Namespace)) {
-                code += 'const $LogicEmpty: any = null;';
-            }
             this.body.forEach((item) => {
                 code += item.toEmbeddedTS && item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
                 code += '\n';
@@ -1577,8 +1563,6 @@ export class Logic extends BaseNode {
             code += `function ${this.name}(`;
         } else if (prefix === 'inObject') {
             code += `${this.name}(`;
-        } else if (prefix === 'arrowFunction') {
-            code += `(`;
         }
         this.params.forEach((param, index) => {
             code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
@@ -1590,9 +1574,6 @@ export class Logic extends BaseNode {
             code += ': ';
             code += this.returns[0].typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true }));
         }
-        if (prefix === 'arrowFunction') {
-            code += ` => `;
-        }
         code += '{\n';
 
         this.variables.forEach((variable) => {
@@ -1610,10 +1591,6 @@ export class Logic extends BaseNode {
         if (!this.body.length && this.returns.length) {
             code += indent((state?.tabSize || 0) + 1) + `return ${this.returns[0].name};\n`;
         } else {
-            // 如果长度小于2 并且不是虚拟节点就 加 报错，
-            if (this.body.length <= 2 && !(this.parentNode instanceof Namespace) && !(this.parentNode instanceof ProcessElement)) {
-                code += 'const $LogicEmpty: any = null;';
-            }
             this.body.forEach((item) => {
                 code += item.toEmbeddedTS && item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
                 code += '\n';
@@ -1756,49 +1733,6 @@ export class Logic extends BaseNode {
         this.app?.emit('collect:end');
     }
 
-    // 是不是内部有错误
-    haveError: boolean = false;
-
-    // 是否body为空
-    isSmpty: boolean = false;
-
-    get pathName() {
-        if (this.view) {
-            return this.getEventLogicName('chinese');
-        }
-        const nameMap = {
-            OnProcessStart: '流程开始时',
-            OnTasksCreate: '任务创建时',
-            OnTasksOpen: '任务打开时',
-            OnTasksClose: '任务关闭时',
-            OnCreate: '用户任务创建时',
-            OnOpen: '用户任务打开时',
-            OnClose: '用户任务关闭时',
-        };
-        const pathName = [this.name];
-        let parentNode = this.parentNode;
-        while (parentNode && parentNode.concept !== 'Process') {
-            const name = (nameMap as any)[parentNode.name] || parentNode.name;
-            pathName.unshift(name);
-            parentNode = parentNode.parentNode;
-        }
-        return pathName.join('-');
-    }
-    // 获取bindEvent下的logic的名称
-    getEventLogicName(type?: string) {
-        if (this.parentNode instanceof BindEvent) {
-            if (type === 'chinese') {
-                const bindEvent = this.parentNode;
-                const bindChineseName = bindEvent.getPageViewEventChineseName();
-                return `${bindChineseName}-${this.name}`;
-            }
-        }
-        return this.name;
-    }
-
-    // 虚拟输入参数列表
-    virtualParams: Array<Param> = [];
-
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Param__.ts

@@ -388,12 +388,6 @@ export class Param extends BaseNode {
             console.log(err);
         }
     }
-
-    setnNewTypeAnnotation(oldTypeAnnotation: TypeAnnotation) {
-        const json = oldTypeAnnotation.toJSON();
-        const typeAnnotation = TypeAnnotation.from(json);
-        this.typeAnnotation = typeAnnotation;
-    }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓