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

package/out/concepts/Logic__.d.ts

@@ -1,6 +1,8 @@
 import { TranslatorState } from '../translator';
+import ForEachStatement from './ForEachStatement__';
 import Assignment from './Assignment__';
 import BatchAssignment from './BatchAssignment__';
+import MatchCase from './MatchCase__';
 import { EventPayload, Params } from '../common/EventEmitter';
 import BaseNode from '../common/BaseNode';
 import Transactional from './Transactional__';
@@ -13,6 +15,7 @@ import Module from './Module__';
 import View from './View__';
 import ProcessElement from './ProcessElement__';
 import App from './App__';
+import Frontend from './Frontend__';
 import Process from './Process__';
 /**
  * 逻辑
@@ -87,6 +90,10 @@ export declare class Logic extends BaseNode {
      * 祖先 View
      */
     get view(): View;
+    /**
+     * 祖先 Frontend
+     */
+    get frontend(): Frontend;
     /**
      * 祖先 ProcessElement
      */
@@ -128,22 +135,22 @@ export declare class Logic extends BaseNode {
     getTypeParamExistingNames(excludedList?: Array<TypeParam>): string[];
     getTypeParamUniqueName(name?: string): string;
     /**
-    * 插入类型参数
-    * @internal
-    * @param name 类型参数名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
     _insertTypeParamAt(name: string, index: number): TypeParam;
     /**
-    * 插入类型参数
-    * @internal
-    * @param typeParamOptions 类型参数参数
-    */
+     * 插入类型参数
+     * @internal
+     * @param typeParamOptions 类型参数参数
+     */
     _insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
     /**
-    * 插入类型参数
-    * @internal
-    * @param typeParam 已有的类型参数实例
-    */
+     * 插入类型参数
+     * @internal
+     * @param typeParam 已有的类型参数实例
+     */
     _insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
     /**
      * 插入类型参数
@@ -196,22 +203,22 @@ export declare class Logic extends BaseNode {
     addTypeParam(typeParam: TypeParam): TypeParam;
     getParamUniqueName(name?: string): string;
     /**
-    * 插入输入参数
-    * @internal
-    * @param name 输入参数名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
     _insertParamAt(name: string, index: number): Param;
     /**
-    * 插入输入参数
-    * @internal
-    * @param paramOptions 输入参数参数
-    */
+     * 插入输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
     _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
     /**
-    * 插入输入参数
-    * @internal
-    * @param param 已有的输入参数实例
-    */
+     * 插入输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
     _insertParamAt(param: Param, index: number): Param;
     /**
      * 插入输入参数
@@ -264,22 +271,22 @@ export declare class Logic extends BaseNode {
     addParam(param: Param): Param;
     getReturnUniqueName(name?: string): string;
     /**
-    * 插入输出参数
-    * @internal
-    * @param name 输出参数名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
     _insertReturnAt(name: string, index: number): Return;
     /**
-    * 插入输出参数
-    * @internal
-    * @param retOptions 输出参数参数
-    */
+     * 插入输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
     _insertReturnAt(retOptions: Partial<Return>, index: number): Return;
     /**
-    * 插入输出参数
-    * @internal
-    * @param ret 已有的输出参数实例
-    */
+     * 插入输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
     _insertReturnAt(ret: Return, index: number): Return;
     /**
      * 插入输出参数
@@ -332,22 +339,22 @@ export declare class Logic extends BaseNode {
     addReturn(ret: Return): Return;
     getVariableUniqueName(name?: string): string;
     /**
-    * 插入变量
-    * @internal
-    * @param name 变量名称，如果不填会自动生成一个唯一名称
-    */
+     * 插入变量
+     * @internal
+     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     */
     _insertVariableAt(name: string, index: number): Variable;
     /**
-    * 插入变量
-    * @internal
-    * @param variableOptions 变量参数
-    */
+     * 插入变量
+     * @internal
+     * @param variableOptions 变量参数
+     */
     _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
     /**
-    * 插入变量
-    * @internal
-    * @param variable 已有的变量实例
-    */
+     * 插入变量
+     * @internal
+     * @param variable 已有的变量实例
+     */
     _insertVariableAt(variable: Variable, index: number): Variable;
     /**
      * 插入变量
@@ -399,16 +406,16 @@ export declare class Logic extends BaseNode {
      */
     addVariable(variable: Variable): Variable;
     /**
-    * 插入逻辑项
-    * @internal
-    * @param logicItemOptions 逻辑项参数
-    */
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
     _insertItemInBodyAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
     /**
-    * 插入逻辑项
-    * @internal
-    * @param logicItem 已有的逻辑项实例
-    */
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
     _insertItemInBodyAt(logicItem: LogicItem, index: number): LogicItem;
     /**
      * 插入逻辑项
@@ -443,16 +450,16 @@ export declare class Logic extends BaseNode {
      */
     addItemInBody(logicItem: LogicItem): LogicItem;
     /**
-    * 插入逻辑项
-    * @internal
-    * @param logicItemOptions 逻辑项参数
-    */
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
     _insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
     /**
-    * 插入逻辑项
-    * @internal
-    * @param logicItem 已有的逻辑项实例
-    */
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
     _insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
     /**
      * 插入逻辑项
@@ -487,9 +494,9 @@ export declare class Logic extends BaseNode {
      */
     addItemInPlayground(logicItem: LogicItem): LogicItem;
     /**
-    * 删除事务
-    * @param name 事务名称
-    */
+     * 删除事务
+     * @param name 事务名称
+     */
     removeTransactional(name: string): void;
     /**
      * 删除事务
@@ -498,9 +505,9 @@ export declare class Logic extends BaseNode {
     removeTransactional(transactional: Transactional): void;
     __removeTransactional(transactional: Transactional): Params;
     /**
-    * 删除类型参数
-    * @param name 类型参数名称
-    */
+     * 删除类型参数
+     * @param name 类型参数名称
+     */
     removeTypeParam(name: string): void;
     /**
      * 删除类型参数
@@ -509,9 +516,9 @@ export declare class Logic extends BaseNode {
     removeTypeParam(typeParam: TypeParam): void;
     __removeTypeParam(typeParam: TypeParam): Params;
     /**
-    * 删除输入参数
-    * @param name 输入参数名称
-    */
+     * 删除输入参数
+     * @param name 输入参数名称
+     */
     removeParam(name: string): void;
     /**
      * 删除输入参数
@@ -520,9 +527,9 @@ export declare class Logic extends BaseNode {
     removeParam(param: Param): void;
     __removeParam(param: Param): Params;
     /**
-    * 删除输出参数
-    * @param name 输出参数名称
-    */
+     * 删除输出参数
+     * @param name 输出参数名称
+     */
     removeReturn(name: string): void;
     /**
      * 删除输出参数
@@ -531,9 +538,9 @@ export declare class Logic extends BaseNode {
     removeReturn(ret: Return): void;
     __removeReturn(ret: Return): Params;
     /**
-    * 删除变量
-    * @param name 变量名称
-    */
+     * 删除变量
+     * @param name 变量名称
+     */
     removeVariable(name: string): void;
     /**
      * 删除变量
@@ -584,7 +591,10 @@ export declare class Logic extends BaseNode {
     toEmbeddedTSInProcess(state?: TranslatorState, prependCode?: string, noName?: boolean, prefix?: boolean): string;
     toEmbeddedTSNoExport(state?: TranslatorState): string;
     toEmbeddedTS(state?: TranslatorState, prefix?: string): string;
-    getRightCode(code: string, assignment: Assignment | BatchAssignment): string;
+    getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any): string;
+    handleReplaceCode(code: string, variable: string, replaceCode: string): string;
+    handleForEachCode(code: string, forEachStatement: ForEachStatement): string;
+    handleMatchCaseCode(code: string, matchCase: MatchCase): string;
     getNamespace(): string;
     getTsNamespace(): string;
     /**
@@ -615,5 +625,6 @@ export declare class Logic extends BaseNode {
     get pathName(): string;
     getEventLogicName(type?: string): string;
     virtualParams: Array<Param>;
+    get getLogicBelongTo(): string;
 }
 export default Logic;

package/out/concepts/Logic__.js

@@ -41,6 +41,10 @@ const Assignment__1 = __importDefault(require("./Assignment__"));
 const Identifier__1 = __importDefault(require("./Identifier__"));
 const BindEvent__1 = __importDefault(require("./BindEvent__"));
 const BatchAssignment__1 = __importDefault(require("./BatchAssignment__"));
+const OqlQueryComponent__1 = __importDefault(require("./OqlQueryComponent__"));
+const TypeAnnotation__1 = __importDefault(require("./TypeAnnotation__"));
+const CallInterface__1 = __importDefault(require("./CallInterface__"));
+const CallLogic__1 = __importDefault(require("./CallLogic__"));
 const decorators_1 = require("../decorators");
 const utils = __importStar(require("../utils"));
 const BaseNode_1 = __importDefault(require("../common/BaseNode"));
@@ -126,6 +130,12 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
     get view() {
         return this.getAncestor('View');
     }
+    /**
+     * 祖先 Frontend
+     */
+    get frontend() {
+        return this.getAncestor('Frontend');
+    }
     /**
      * 祖先 ProcessElement
      */
@@ -710,11 +720,11 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         return params;
     }
     removeItemInBody(options) {
-        let logicItem = options;
+        const logicItem = options;
         return logicItem.delete();
     }
     removeItemInPlayground(options) {
-        let logicItem = options;
+        const logicItem = options;
         return logicItem.delete();
     }
     __removeLogicItem(logicItem) {
@@ -854,7 +864,7 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
     toJS(state, type) {
         let code = '';
         if (type === 'IIFE') {
-            code += `(async () => {\n`;
+            code += `await (async () => {\n`;
             code = this.toJSContent(code, state);
             code += (0, translator_1.indent)(state?.tabSize || 0) + '})();\n';
             return code;
@@ -1002,7 +1012,7 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
             }
             this.body.forEach((item) => {
                 code += item.toEmbeddedTS && item.toEmbeddedTS((0, translator_1.shiftState)(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-                code += '\n';
+                code += ';\n';
             });
         }
         // 在body渲染完成之后把其余的节点放到下面
@@ -1029,20 +1039,24 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         else if (prefix === 'inObject') {
             code += `${this.name}`;
         }
+        if (this.typeParams?.length) {
+            code += '<';
+            this.typeParams.forEach((typeParam, typeParamIndex) => {
+                code += typeParam.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true }));
+                if (typeParamIndex !== this.typeParams.length - 1)
+                    code += ', ';
+            });
+            code += '>';
+        }
         // 有参数长度
         if (this.params.length) {
             code += '(';
             this.params.forEach((param, index) => {
                 code += param.toEmbeddedTS((0, translator_1.shiftState)(state, code));
-                code += ',';
-            });
-            code += '\n,  __defaultValues?: { \n';
-            this.params.forEach((param, index) => {
-                code += `${param.name}: "${param.defaultValue || ''}"`;
                 if (index !== this.params.length - 1)
-                    code += ',\n';
+                    code += ', ';
             });
-            code += '})';
+            code += ')';
         }
         else {
             // 没有参数的
@@ -1050,6 +1064,7 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         }
         // 需要类型推导的局部变量/返回值需要调整申明顺序
         const advanceMap = new Map();
+        const needGetSourceMapOqlList = [];
         this.traverseChildren((el) => {
             if (el && (el instanceof BatchAssignment__1.default || (el instanceof Assignment__1.default && el.left?.name))) {
                 const jsCode = el.toJS();
@@ -1062,31 +1077,42 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
                     advanceMap.set(advanceRn, el);
                 }
             }
+            // 如果有sql查询组件就需要把他们存起来
+            if (el instanceof OqlQueryComponent__1.default) {
+                if (!el.codeSourceMap) {
+                    needGetSourceMapOqlList.push(el.requestEmbeddedTS());
+                }
+            }
         });
+        if (needGetSourceMapOqlList.length) {
+            Promise.all(needGetSourceMapOqlList).then(() => {
+                // 触发一下更新重新生成代码
+                this.app?.naslServer?.embeddedTSEmitter.emit('change', {
+                    value: [
+                        {
+                            originEvent: {
+                                action: 'update',
+                                target: this,
+                            },
+                        },
+                    ],
+                });
+            });
+        }
         // 兼容 return 没有类型情况
         if (this.returns.length && this.returns[0].typeAnnotation) {
             code += ': ';
             code += this.returns[0].typeAnnotation?.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true }));
         }
-        if (prefix === 'arrowFunction') {
-            code += ` => `;
-        }
         code += '{\n';
-        if (this.typeParams?.length) {
-            code += '<';
-            this.typeParams.forEach((typeParam, typeParamIndex) => {
-                code += typeParam.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true }));
-                if (typeParamIndex !== this.typeParams.length - 1)
-                    code += ', ';
-            });
-            code += '>';
-        }
         // 用于虚拟节点的查找引用
-        this.virtualParams && Array.isArray(this.virtualParams) && this.virtualParams.forEach((param) => {
-            code += (0, translator_1.indent)((state?.tabSize || 0) + 1);
-            code += param.toEmbeddedNameTS((0, translator_1.shiftState)(state, code, { inline: true }));
-            code += '\n';
-        });
+        this.virtualParams
+            && Array.isArray(this.virtualParams)
+            && this.virtualParams.forEach((param) => {
+                code += (0, translator_1.indent)((state?.tabSize || 0) + 1);
+                code += param.toEmbeddedNameTS((0, translator_1.shiftState)(state, code, { inline: true }));
+                code += '\n';
+            });
         this.variables.forEach((variable) => {
             if (!advanceMap.get(variable)) {
                 code += (0, translator_1.indent)((state?.tabSize || 0) + 1) + 'let ';
@@ -1102,25 +1128,49 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
             }
         });
         advanceMap.forEach((assignment, node) => {
+            code += (0, translator_1.indent)((state?.tabSize || 0) + 1) + '// @ts-ignore\n';
             code += (0, translator_1.indent)((state?.tabSize || 0) + 1) + 'let ';
             code += node.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true }));
-            code += ' = ';
             if (assignment instanceof BatchAssignment__1.default) {
                 assignment.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
                     const leftCode = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true }));
                     if (leftCode === node.name) {
-                        const rightCode = rightIndex.length === 1 ? assignment.rights[rightIndex[0]]?.expression?.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true })) : assignment.rights[rightIndex[0]]?.members[rightIndex[1]]?.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true }));
-                        code += this.getRightCode(rightCode, assignment);
+                        const rightNode = rightIndex.length === 1 ? assignment.rights[rightIndex[0]]?.expression : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
+                        // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
+                        if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent__1.default && rightNode.ideVersion !== '2.11')) {
+                            code += ': ';
+                            code += rightNode.typeAnnotation?.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true })) || 'null';
+                        }
+                        else {
+                            code += ' = ';
+                            const rightCode = rightNode?.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true }));
+                            code += this.getRightCode(rightCode, assignment, rightNode);
+                        }
                     }
                 });
             }
+            else if (['NewList', 'NewMap'].includes(assignment.right.concept) && !assignment.right.typeAnnotation) {
+                const rightNode = assignment.right;
+                code += ' = ';
+                code += rightNode.getInitCode((0, translator_1.shiftState)(state, code, { inline: true }));
+            }
             else {
-                // 因为右侧枚举要赋值就得new 一下；
-                if (assignment.right && assignment.right instanceof Identifier__1.default && assignment.right.namespace && assignment.right.namespace.endsWith('enums')) {
-                    code += 'new ';
+                const rightNode = assignment.right;
+                // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
+                if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent__1.default && rightNode.ideVersion !== '2.11')) {
+                    code += ': ';
+                    code += rightNode.typeAnnotation?.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true })) || 'null';
+                }
+                else {
+                    code += ' = ';
+                    let rightCode = '';
+                    // 因为右侧枚举要赋值就得new 一下；
+                    if (rightNode && rightNode instanceof Identifier__1.default && rightNode.namespace && rightNode.namespace.endsWith('enums')) {
+                        rightCode += 'new ';
+                    }
+                    rightCode += rightNode && rightNode.toEmbeddedTS ? rightNode.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true })) : '__RIGHT__';
+                    code += this.getRightCode(rightCode, assignment, rightNode);
                 }
-                const rightCode = (assignment.right && assignment.right.toEmbeddedTS) ? assignment.right.toEmbeddedTS((0, translator_1.shiftState)(state, code, { inline: true })) : '__RIGHT__';
-                code += this.getRightCode(rightCode, assignment);
             }
             code += ';\n';
         });
@@ -1135,7 +1185,7 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
             }
             this.body.forEach((item) => {
                 code += item.toEmbeddedTS && item.toEmbeddedTS((0, translator_1.shiftState)(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-                code += '\n';
+                code += ';\n';
             });
         }
         // 在body渲染完成之后把其余的节点放到下面
@@ -1150,34 +1200,97 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
         code += '\n';
         return code;
     }
-    getRightCode(code, assignment) {
+    getRightCode(code, assignment, rightNode) {
         if (assignment instanceof Assignment__1.default && !assignment.right)
             return code;
+        // 调用接口，参数替换成 null
+        if (rightNode instanceof CallInterface__1.default) {
+            const { _interface } = rightNode.getModuleInterface();
+            return _interface ? `${rightNode.tsCalleeKey}(${_interface.params.map(() => 'null').join(',')})` : null;
+        }
+        // 调用全局逻辑，参数替换成 null
+        if (rightNode instanceof CallLogic__1.default && 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');
         if (forEachStatement) {
-            const { item, index, each } = forEachStatement;
-            return code.replace(/\S+/g, ($1) => {
-                if ($1.includes('(') || $1.includes('['))
-                    return $1;
-                if ($1.includes(`${item.name},`)
-                    || $1.includes(`${item.name}.`)
-                    || $1.includes(`${item.name};`)
-                    || $1.includes(`${item.name})`)
-                    || $1 === item.name) {
-                    const eachTSCode = each.toEmbeddedTS();
-                    return $1.replaceAll(item.name, eachTSCode === '__IDENTIFIER__' ? eachTSCode : `${eachTSCode}.__get(0)`);
+            code = this.handleForEachCode(code, forEachStatement);
+        }
+        // Match 需要针对分支缩小类型范围
+        const matchCase = assignment.getAncestor('MatchCase');
+        if (matchCase) {
+            code = this.handleMatchCaseCode(code, matchCase);
+        }
+        return code;
+    }
+    handleReplaceCode(code, variable, replaceCode) {
+        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})`);
+            return fnCode;
+        });
+    }
+    handleForEachCode(code, forEachStatement) {
+        const { item, index, each } = forEachStatement;
+        if (code.includes(item.name)) {
+            const eachTSCode = each.toEmbeddedTS();
+            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.Integer(0)');
+        const parentForEachStatement = forEachStatement.getAncestor('ForEachStatement');
+        if (parentForEachStatement) {
+            this.handleForEachCode(code, parentForEachStatement);
+        }
+        return code;
+    }
+    handleMatchCaseCode(code, matchCase) {
+        const match = matchCase.getAncestor('Match');
+        const expressionTsCode = match.expression.toEmbeddedTS();
+        if (code.includes(expressionTsCode)) {
+            let typeCode = '';
+            matchCase.patterns.forEach((pattern, index) => {
+                if (pattern instanceof TypeAnnotation__1.default) {
+                    if (index === 0) {
+                        typeCode += pattern.toEmbeddedTS();
+                    }
+                    else {
+                        typeCode += '|';
+                        typeCode += pattern.toEmbeddedTS();
+                    }
                 }
-                if ($1.includes(`${index.name},`)
-                    || $1.includes(`${index.name};`)
-                    || $1.includes(`${index.name})`)
-                    || $1 === index.name)
-                    return $1.replaceAll(index.name, 'new nasl.core.Integer(0)');
-                return $1;
             });
+            if (typeCode) {
+                code = this.handleReplaceCode(code, expressionTsCode, `(${expressionTsCode} as ${typeCode})`);
+            }
         }
-        else
-            return code;
+        const parentMatchCase = match.getAncestor('MatchCase');
+        if (parentMatchCase) {
+            code = this.handleMatchCaseCode(code, parentMatchCase);
+        }
+        return code;
     }
     getNamespace() {
         if (this.parentNode) {
@@ -1188,7 +1301,8 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
+            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
+                && !namespace.includes('.logics')) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -1205,7 +1319,8 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
+            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
+                && !namespace.includes('.logics')) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -1334,6 +1449,10 @@ let Logic = Logic_1 = class Logic extends BaseNode_1.default {
     }
     // 虚拟输入参数列表
     virtualParams = [];
+    get getLogicBelongTo() {
+        const [, belongTo] = this.calleewholeKey.split('.');
+        return belongTo;
+    }
 };
 __decorate([
     (0, decorators_1.property)()