@lcap/nasl 3.3.0-alpha.3 → 3.4.0-alpha.1

package/src/natural/transformTSCode.ts

@@ -6,40 +6,42 @@ import generate from '@babel/generator';
 import * as naslTypes from '../concepts';
 import { traverse } from '../utils';
 
+const debug = false;
+
 export function tryParseTS(tsCode: string) {
-    try {
-        const root = babel.parseSync(tsCode, {
-            filename: 'result.ts',
-            presets: [require('@babel/preset-typescript')],
-        }) as babelTypes.File;
-        // console.log((root as any).program.body[0].body.body.map((item) => item.trailingComments));
-        return root;
-    } catch (e) {
-        return null;
-    }
+  try {
+    const root = babel.parseSync(tsCode, {
+      filename: 'result.ts',
+      presets: [require('@babel/preset-typescript')],
+    }) as babelTypes.File;
+    // console.log((root as any).program.body[0].body.body.map((item) => item.trailingComments));
+    return root;
+  } catch (e) {
+    return null;
+  }
 }
 
 function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
   if (node.type === 'MemberExpression')
-      return [...flatMemberExpression(node.object), node.property];
+    return [...flatMemberExpression(node.object), node.property];
   return [node];
 }
 function flatMatchPatternsExpression(node: any): Array<babelTypes.Node> {
   if (node.concept === 'BinaryExpression') {
-      if (node.operator === '||') {
-          return [...flatMatchPatternsExpression(node.left), ...flatMatchPatternsExpression(node.right)];
-      }
-      if (node.operator === '==') {
-          return [node.right];
-      }
-      return [node];
+    if (node.operator === '||') {
+      return [...flatMatchPatternsExpression(node.left), ...flatMatchPatternsExpression(node.right)];
+    }
+    if (node.operator === '==') {
+      return [node.right];
+    }
+    return [node];
   }
   return [node];
 }
 
 function flatIfStatement(node: any): Array<babelTypes.Node> {
   if (node.alternate.type === 'IfStatement') {
-      return [...flatIfStatement(node.alternate), node];
+    return [...flatIfStatement(node.alternate), node];
   }
   return [node];
 }
@@ -50,631 +52,783 @@ function flatIfStatement(node: any): Array<babelTypes.Node> {
  * @returns
  */
 function fixLogicNode(node: babelTypes.Node): void {
-    if (node?.type === 'CallExpression') {
-        const calleeName = generate(node.callee as any).code;
-        if (calleeName === 'nasl.util.ForEach') {
-            const callee = flatMemberExpression(node.callee);
-            node.callee = callee[2] as babelTypes.Identifier;
-        }
+  if (node?.type === 'CallExpression') {
+    const calleeName = generate(node.callee as any).code;
+    if (calleeName === 'nasl.util.ForEach') {
+      const callee = flatMemberExpression(node.callee);
+      node.callee = callee[2] as babelTypes.Identifier;
     }
+  }
 }
 
+
 export function transformTSCode(tsCode: string, contextLogicName: string, type?: string) {
-    const logic = new naslTypes.Logic();
-    logic.body = [];
+  const logic = new naslTypes.Logic();
+  logic.body = [];
 
-    function transformTypeAnnotation(node: babelTypes.TSType): naslTypes.TypeAnnotation {
-        if (node.type === 'TSTypeReference') {
-            const typeName = (node.typeName as babelTypes.Identifier).name;
-            const primitiveType = naslTypes.primitiveTypeList.find((ta) => ta.typeName === typeName);
-            if ((node as any)?.typeNamespace) {
-                return naslTypes.TypeAnnotation.createReference(typeName, {
-                    typeNamespace: (node as any).typeNamespace,
-                });
-            }
-            if (primitiveType) {
-                return naslTypes.TypeAnnotation.createPrimitive(typeName);
-            }
-            if (['List', 'Map', 'Current'].includes(typeName) && node.typeParameters) {
-                return naslTypes.TypeAnnotation.createGeneric(typeName, {
-                    typeArguments: node.typeParameters.params.map(transformTypeAnnotation),
-                });
-            }
-            if (!node.typeParameters) {
-                return naslTypes.TypeAnnotation.createReference(typeName, {
-                    typeNamespace: 'app.dataSources.defaultDS',
-                });
-            }
-            console.error(node);
-            throw new Error(`Unhandled node ${node.type}`);
-        } else if (node.type === 'TSTypeLiteral') {
-            return naslTypes.TypeAnnotation.createTypeAnonymousStructure(node.members.map((member: babelTypes.TSPropertySignature) => new naslTypes.StructureProperty({
-                name: (member.key as babelTypes.Identifier).name,
-                typeAnnotation: transformTypeAnnotation(member.typeAnnotation.typeAnnotation),
-            })));
-        } else if (node.type === 'TSBooleanKeyword') {
-            return naslTypes.TypeAnnotation.createPrimitive('Boolean');
-        } else if (node.type === 'TSStringKeyword') {
-            return naslTypes.TypeAnnotation.createPrimitive('String');
-        } else if (node.type === 'TSNumberKeyword') {
-            return naslTypes.TypeAnnotation.createPrimitive('Double');
-        } else if (node.type === 'TSUnionType') {
-            const union = naslTypes.TypeAnnotation.createPrimitive('Union');
-            union.typeArguments = [];
-            node.types.forEach((curType) => {
-                union.typeArguments.push(transformTypeAnnotation(curType));
-            });
-            return union;
-        } else {
-            console.error(node);
-            throw new Error(`Unhandled node ${node.type}`);
-        }
-    }
-    function transformParam(node: babelTypes.Identifier): naslTypes.Param {
-        const typeAnnotation = (node.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
-        return new naslTypes.Param({
-            name: node.name,
-            typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
+  function transformTypeAnnotation(node: babelTypes.TSType): naslTypes.TypeAnnotation {
+    if (node.type === 'TSTypeReference') {
+      const typeName = (node.typeName as babelTypes.Identifier).name;
+      const primitiveType = naslTypes.primitiveTypeList.find((ta) => ta.typeName === typeName);
+      if ((node as any)?.typeNamespace) {
+        return naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace: (node as any).typeNamespace,
+        });
+      }
+      if (typeName === 'Integer') {
+        return naslTypes.TypeAnnotation.createPrimitive('Long');
+      }
+      if (primitiveType) {
+        return naslTypes.TypeAnnotation.createPrimitive(typeName);
+      }
+      if (['List', 'Map', 'Current'].includes(typeName) && node.typeParameters) {
+        return naslTypes.TypeAnnotation.createGeneric(typeName, {
+          typeArguments: node.typeParameters.params.map(transformTypeAnnotation),
+        });
+      }
+      if (!node.typeParameters) {
+        return naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace: 'app.dataSources.defaultDS',
         });
+      }
+      console.error(node);
+      if (debug) {
+        throw new Error(`Unhandled node ${node.type}`);
+      }
+    } else if (node.type === 'TSTypeLiteral') {
+      return naslTypes.TypeAnnotation.createTypeAnonymousStructure(node.members.map((member: babelTypes.TSPropertySignature) => new naslTypes.StructureProperty({
+        name: (member.key as babelTypes.Identifier).name,
+        typeAnnotation: transformTypeAnnotation(member.typeAnnotation.typeAnnotation),
+      })));
+    } else if (node.type === 'TSBooleanKeyword') {
+      return naslTypes.TypeAnnotation.createPrimitive('Boolean');
+    } else if (node.type === 'TSStringKeyword') {
+      return naslTypes.TypeAnnotation.createPrimitive('String');
+    } else if (node.type === 'TSNumberKeyword') {
+      return naslTypes.TypeAnnotation.createPrimitive('Double');
+    } else if (node.type === 'TSUnionType') {
+      const union = naslTypes.TypeAnnotation.createPrimitive('Union');
+      union.typeArguments = [];
+      node.types.forEach((curType) => {
+        union.typeArguments.push(transformTypeAnnotation(curType));
+      });
+      return union;
+    } else {
+      console.error(node);
+      if (debug) {
+        throw new Error(`Unhandled node ${node.type}`);
+      }
     }
-    function pushElseIf(ifNode: babelTypes.IfStatement, switchStatement: naslTypes.SwitchStatement) {
+  }
+  function transformParam(node: babelTypes.Identifier): naslTypes.Param {
+    const typeAnnotation = (node.typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
+    return new naslTypes.Param({
+      name: node.name,
+      typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
+    });
+  }
+  function pushElseIf(ifNode: babelTypes.IfStatement, switchStatement: naslTypes.SwitchStatement) {
+    switchStatement.cases.push(new naslTypes.SwitchCase({
+      test: transformLogicNode(ifNode.test),
+      consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+    }));
+    if (ifNode.alternate && ifNode.alternate.type === 'IfStatement') {
+      pushElseIf(ifNode.alternate, switchStatement);
+    } else {
       switchStatement.cases.push(new naslTypes.SwitchCase({
-          test: transformLogicNode(ifNode.test),
-          consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+        test: undefined,
+        consequent: !ifNode?.alternate ? [] : (ifNode?.alternate as babelTypes.BlockStatement)?.body.map((item) => transformLogicNode(item)).filter((item) => !!item),
       }));
-      if (ifNode.alternate && ifNode.alternate.type === 'IfStatement') {
-          pushElseIf(ifNode.alternate, switchStatement);
-      } else {
-          switchStatement.cases.push(new naslTypes.SwitchCase({
-              test: undefined,
-              consequent: !ifNode.consequent ? [] : (ifNode.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-          }));
-      }
+    }
   }
 
-    function transformLogicNode(node: babelTypes.Node, typeAnnotation?: naslTypes.TypeAnnotation): naslTypes.LogicItem {
-        fixLogicNode(node);
-        // console.log('lemon ~~~ node--1:', node);
-        if (node.type === 'VariableDeclaration') { // 拆成局部变量和赋值
-            const declList = node?.declarations || [];
-            declList?.forEach((decl) => {
-              const variableName = (decl.id as babelTypes.Identifier).name;
-              if (!logic.variables.find((variable) => variable.name === variableName)) {
-                const varTypeAnnotation = ((decl.id as babelTypes.Identifier).typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
-                logic.variables.push(new naslTypes.Variable({
-                  name: variableName,
-                  typeAnnotation: varTypeAnnotation && transformTypeAnnotation(varTypeAnnotation),
-                }));
-              }
-              if (decl.init) {
-                if (decl.init.type !== 'ArrayExpression') {
-                  if (type === 'expression') {
-                    return transformLogicNode(decl.init);
-                  }
-                  const item = new naslTypes.Assignment({
-                    left: new naslTypes.Identifier({
-                      name: variableName,
-                    }),
-                    right: transformLogicNode(decl.init),
-                  });
-                  item && logic.body.push(item);
-                }
-              }
-            });
-        } else if (node.type === 'CallExpression') {
-            const callee = flatMemberExpression(node.callee);
-            const calleeName = generate(node.callee as any).code;
-            // console.log('lemon ~~~ node--2', node, callee, calleeName);
-            if (/^\$refs\./.test(calleeName)) {
-                return new naslTypes.CallLogic({
-                    calleeNamespace: `elements.${(callee[1] as babelTypes.Identifier).name}.logics`,
-                    calleeName: (callee[2] as babelTypes.Identifier).name,
-                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
-                        expression: transformLogicNode(arg),
-                    })) as naslTypes.Argument[],
-                });
-            }
-            if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
-                const entityName = callee[0].name.replace(/Entity$/, '');
-                return new naslTypes.CallLogic({
-                    calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
-                    calleeName: (callee[1] as babelTypes.Identifier).name,
-                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
-                        expression: transformLogicNode(arg),
-                    })) as naslTypes.Argument[],
-                });
-            }
-            if (calleeName === 'nasl.oql.query') {
-                return new naslTypes.OqlQueryComponent({
-                    dataSource: 'app.dataSources.defaultDS',
-                    code: generate(node.arguments[0] as any).code.trim().slice(1, -1),
-                });
-            }
-            if (calleeName.startsWith('nasl.util.')) {
-                const curCalleeName = callee.length === 3 ? (callee[callee.length - 1] as babelTypes.Identifier).name : (callee[0] as any).callee.property.name;
-                const argument = callee.length === 3 ? node.arguments : (callee[0] as any).arguments as any;
-                let typeNamespace: string;
-                if (argument?.[argument.length - 1]?.type === 'ObjectExpression') {
-                    typeNamespace = argument.splice(-1)[0].properties[0].value.value;
-                }
-                const nodeElement = new naslTypes.CallFunction({
-                    calleeNamespace: 'nasl.util',
-                    calleeName: curCalleeName,
-                    arguments: argument.map((arg: any, index: number) => new naslTypes.Argument({
-                        expression: transformLogicNode(arg),
-                        keyword: `str${index + 1}`,
-                    })) as naslTypes.Argument[],
-                    typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType, typeNamespace })),
+  function handleBinaryExpression(calleeName: String, argument: any) {
+    const map: Record<'plus' | 'minus' | 'multiply' | 'divide' | 'remainder', '+' | '-' | '*' | '/' | '%'> = {
+      plus: '+',
+      minus: '-',
+      multiply: '*',
+      divide: '/',
+      remainder: '%',
+    };
+    return new naslTypes.BinaryExpression({
+      operator: map?.[calleeName as keyof typeof map],
+      left: transformLogicNode(argument?.[0]),
+      right: transformLogicNode(argument?.[1]),
+    });
+  }
 
-                });
-                // console.log('lemon ~ callFunction ~ 3:', nodeElement);
-                return nodeElement;
-            }
-            if (callee.length === 3 && calleeName.startsWith('nasl.ui.')) {
-                return new naslTypes.CallLogic({
-                    calleeNamespace: 'nasl.ui',
-                    calleeName: (callee[2] as babelTypes.Identifier).name,
-                    shortcut: true,
-                    /**
-                     * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
-                     * @param node
-                     * @returns
-                     */
-                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
-                        expression: transformLogicNode(arg),
-                    })) as naslTypes.Argument[],
-                });
-            }
-            if (calleeName === 'ForEach') {
-                const newCallee = node.arguments;
-                const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
-                const nodeElement = new naslTypes.ForEachStatement({
-                  each: transformLogicNode(newCallee[0]),
-                  start: transformLogicNode(newCallee[1]),
-                  end: transformLogicNode(newCallee[2]),
-                  item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
-                  index: transformParam(arrowFunction.params[1] as babelTypes.Identifier),
-                  body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-                });
-                return nodeElement;
-            }
-            if (callee.length === 2) {
-                const curCalleeName = (node.callee as any).property.name;
-                if (curCalleeName === 'forEach') {
-                    const newCallee = (node.callee as any).object;
-                    const arrowFunction = node.arguments[0] as babelTypes.ArrowFunctionExpression;
-                    const nodeElement = new naslTypes.ForEachStatement({
-                        each: transformLogicNode(newCallee.callee.object),
-                        start: transformLogicNode(newCallee?.arguments?.[0]),
-                        end: transformLogicNode(newCallee?.arguments?.[1]),
-                        item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
-                        index: transformParam(arrowFunction.params[1] as babelTypes.Identifier),
-                        body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-                    });
-                    return nodeElement;
-                }
-            } else if (['plus', 'minus', 'multiply', 'divide', 'remainder'].includes(calleeName)) {
-                const map: Record<'plus' | 'minus' | 'multiply' | 'divide' | 'remainder', '+' | '-' | '*' | '/' | '%'> = {
-                    plus: '+',
-                    minus: '-',
-                    multiply: '*',
-                    divide: '/',
-                    remainder: '%',
-                };
-                return new naslTypes.BinaryExpression({
-                    operator: map[calleeName as keyof typeof map],
-                    left: transformLogicNode(node.arguments[0]),
-                    right: transformLogicNode(node.arguments[1]),
-                });
-            } else if (calleeName === 'alert') {
-                return new naslTypes.CallLogic({
-                    calleeNamespace: 'nasl.ui',
-                    calleeName: 'showMessage',
-                    shortcut: true,
-                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
-                        expression: transformLogicNode(arg),
-                    })) as naslTypes.Argument[],
-                });
-            } else if (calleeName === 'console.log') {
-                return new naslTypes.CallLogic({
-                    calleeNamespace: 'nasl.logging',
-                    calleeName: 'INFO',
-                    shortcut: true,
-                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
-                        expression: transformLogicNode(arg),
-                    })) as naslTypes.Argument[],
-                });
-            } else if (/^app.dataSources|app.logics|load/.test(calleeName)) {
-                return new naslTypes.CallLogic({
-                    calleeNamespace: generate((node.callee as any).object).code,
-                    calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
-                        expression: transformLogicNode(arg),
-                    })) as naslTypes.Argument[],
-                });
-            } else if (callee.length === 1) {
-                return new naslTypes.CallLogic({
-                    calleeNamespace: `app.logics`,
-                    calleeName,
-                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
-                        expression: transformLogicNode(arg),
-                    })) as naslTypes.Argument[],
-                });
-            } else if (/interfaces/.test(calleeName)) {
-                return new naslTypes.CallInterface({
-                    calleeNamespace: generate((node.callee as any).object).code,
-                    calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-                    arguments: node.arguments.map((arg: any) => new naslTypes.Argument({
-                        keyword: arg.properties[0].key.name,
-                        expression: transformLogicNode(arg.properties[0].value),
-                    })) as naslTypes.Argument[],
-                });
-            } else if (/destination/.test(calleeName)) {
-                const newCallee = flatMemberExpression((node.callee as any).object);
-                return new naslTypes.Destination({
-                    viewNamespace: generate((node.callee as any).object.object).code,
-                    viewName: (newCallee[newCallee.length - 1] as babelTypes.Identifier).name,
-                    target: (node.arguments[0] as any).properties[1].value.value,
-                    anchor: new naslTypes.Anchor({
-                        expression: transformLogicNode((node.arguments[0] as any).properties[0].value),
-                    }),
-                });
-            } else if (node.callee.type === 'ArrowFunctionExpression') {
-                // NOTE: 适用于 if else
-                const newCallee = (node.callee.body as any).body;
-                if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFuntion') {
-                    const match = new naslTypes.Match({
-                        expression: transformLogicNode(newCallee[0]),
-                        isExpression: type === 'expression',
-                        cases: flatIfStatement(newCallee[1].body.body[0]).map((_case: any) => new naslTypes.MatchCase({
-                            patterns: !_case.test ? [] : flatMatchPatternsExpression(transformLogicNode(_case.test)) as any,
-                            body: _case.consequent.body.filter((item: any) => item.type !== 'BreakStatement').map((item: any) => transformLogicNode(item)).filter((item: any) => !!item),
-                        })),
-                    });
-                    if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
-                        match.cases.push(new naslTypes.MatchCase({
-                            patterns: [],
-                            body: [],
-                        }));
-                    }
-                    match.cases.forEach((case_: any) => {
-                        if (case_.body.length && (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
-                            case_.isMatchedTypeEnumable = true;
-                        }
-                        if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
-                            case_.isMatchedTypeEnumable = true;
-                            case_.patterns[0] = new naslTypes.MemberExpression({
-                                object: { concept: 'Identifier',
-                                    name: case_.patterns[0].object.property.name,
-                                    folded: false,
-                                    namespace: 'app.enums' } as any,
-                                property: {
-                                    concept: 'Identifier',
-                                    name: case_.patterns[0].property.value,
-                                    folded: false,
-                                } as any,
-                            });
-                        }
-                    });
-                    return match;
-                }
-                if (newCallee[newCallee.length - 1].argument?.callee?.name === '__SwitchExpressionFuntion') {
-                    const switchStatement = transformLogicNode(newCallee[0].body.body[0]);
-                    return switchStatement;
-                }
-                console.error(node);
-                throw new Error(`Unhandled ArrowFunctionExpression node ${node.type}`);
-            } else {
-                console.error(node);
-                throw new Error(`Unhandled node ${callee.map((item: babelTypes.Identifier) => item.name).join('.')} ${node.type}`);
-            }
-        } else if (node.type === 'IfStatement') {
-            if (node.alternate && node.alternate.type === 'IfStatement') {
-                const switchStatement = new naslTypes.SwitchStatement({
-                    cases: [],
-                });
-                pushElseIf(node, switchStatement);
-                return switchStatement;
-            }
-            return new naslTypes.IfStatement({
-                test: transformLogicNode(node.test),
-                consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-                alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-            });
-        } else if (node.type === 'WhileStatement') {
-            return new naslTypes.WhileStatement({
-                test: transformLogicNode(node.test),
-                body: (node.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-            });
-        } else if (node.type === 'SwitchStatement') {
-            const match = new naslTypes.Match({
-                expression: transformLogicNode(node.discriminant),
-                isExpression: type === 'expression',
-                cases: node.cases.map((_case) => new naslTypes.MatchCase({
-                    patterns: !_case.test ? [] : [transformLogicNode(_case.test)],
-                    body: _case.consequent.filter((item) => item.type !== 'BreakStatement').map((item) => transformLogicNode(item)).filter((item) => !!item),
-                })),
-            });
-            if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
-                match.cases.push(new naslTypes.MatchCase({
-                    patterns: [],
-                    body: [],
-                }));
-            }
-            match.cases.forEach((case_: any) => {
-                if (case_.body.length && (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
-                    case_.isMatchedTypeEnumable = true;
-                }
-                if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
-                    case_.isMatchedTypeEnumable = true;
-                    case_.patterns[0].object.namespace = 'app.enums';
-                }
-            });
-            return match;
-        } else if (node.type === 'MemberExpression') {
-            if (node.property.type === 'NumericLiteral') {
-                return new naslTypes.CallFunction({
-                    calleeNamespace: 'nasl.util',
-                    calleeName: 'Get',
-                    arguments: [
-                        new naslTypes.Argument({
-                            expression: transformLogicNode(node.object),
-                        }),
-                        new naslTypes.Argument({
-                            expression: transformLogicNode(node.property),
-                        }),
-                    ],
-                });
-            }
-            return new naslTypes.MemberExpression({
-                object: transformLogicNode(node.object),
-                property: transformLogicNode(node.property),
-            });
-        } else if (node.type === 'Identifier') {
-            return new naslTypes.Identifier({
-                name: node.name,
-            });
-        } else if (node.type === 'ExpressionStatement') {
-            return transformLogicNode(node.expression);
-        } else if (node.type === 'AssignmentExpression') {
-            if (node.operator === '+=' || node.operator === '-=') {
-                if (type === 'expression') {
-                    return new naslTypes.BinaryExpression({
-                        operator: node.operator[0] as '+' | '-',
-                        left: transformLogicNode(node.left),
-                        right: transformLogicNode(node.right),
-                    });
-                }
-                return new naslTypes.Assignment({
-                    left: transformLogicNode(node.left),
-                    right: new naslTypes.BinaryExpression({
-                        operator: node.operator[0] as '+' | '-',
-                        left: transformLogicNode(node.left),
-                        right: transformLogicNode(node.right),
-                    }),
-                });
-            }
+  function handleNewExpression(calleeName: String, node: any) {
+    if (calleeName === 'NewList') {
+      return new naslTypes.NewList({
+        typeAnnotation: naslTypes.TypeAnnotation.createGeneric('List', {
+          typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
+        }),
+        items: node?.arguments?.[0]?.elements?.map((arg: any) => transformLogicNode(arg)),
+      });
+    }
+    if (calleeName === 'NewMap') {
+      const keys: any = [];
+      const values: any = [];
+      node?.arguments?.[0]?.properties.forEach((arg: any) => {
+        keys.push(transformLogicNode(arg.key));
+        values.push(transformLogicNode(arg.value));
+      });
+      return new naslTypes.NewMap({
+        typeAnnotation: naslTypes.TypeAnnotation.createGeneric('Map', {
+          typeArguments: node?.typeParameters?.params.map(transformTypeAnnotation),
+        }),
+        keys,
+        values,
+      });
+    }
+    if (calleeName === 'NewEntity') {
+      const properties: any = [];
+      const rights: any = [];
+      node?.arguments?.[0]?.properties.forEach((arg: any) => {
+        properties.push(transformLogicNode(arg.key));
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformLogicNode(arg.value)
+        }));
+      });
+      const typeName = node?.typeParameters?.params?.[0]?.typeName?.name;
+      return new naslTypes.NewComposite({
+        typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace: 'app.dataSources.defaultDS.entities',
+          typeName
+        }),
+        properties,
+        rights,
+      });
+    }
+    if (calleeName === 'NewAnonymityStructure') {
+      const properties: any = [];
+      const rights: any = [];
+      const structureProperties: any = [];
+      node?.arguments?.[0]?.properties?.forEach((arg: any) => {
+        properties.push(transformLogicNode(arg.key));
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformLogicNode(arg.value)
+        }));
+        structureProperties.push(new naslTypes.StructureProperty({
+          name: arg?.key?.name,
+          typeAnnotation: null
+        }));
+      });
+      return new naslTypes.NewComposite({
+        typeAnnotation: naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
+        properties,
+        rights,
+      });
+    }
+    return node;
+  }
+
+  function transformLogicNode(node: babelTypes.Node, typeAnnotation?: naslTypes.TypeAnnotation): naslTypes.LogicItem {
+    fixLogicNode(node);
+    // console.log('lemon ~~~ node--1:', node);
+    if (node.type === 'VariableDeclaration') { // 拆成局部变量和赋值
+      const declList = node?.declarations || [];
+      declList?.forEach((decl) => {
+        const variableName = (decl.id as babelTypes.Identifier).name;
+        if (!logic.variables.find((variable) => variable.name === variableName)) {
+          const varTypeAnnotation = ((decl.id as babelTypes.Identifier).typeAnnotation as babelTypes.TSTypeAnnotation)?.typeAnnotation;
+          logic.variables.push(new naslTypes.Variable({
+            name: variableName,
+            typeAnnotation: varTypeAnnotation && transformTypeAnnotation(varTypeAnnotation),
+          }));
+        }
+        if (decl.init) {
+          if (decl.init.type !== 'ArrayExpression' && decl.init.type !== 'ObjectExpression') {
             if (type === 'expression') {
-                return transformLogicNode(node.right);
+              return transformLogicNode(decl.init);
             }
-            return new naslTypes.Assignment({
-                left: transformLogicNode(node.left),
-                right: transformLogicNode(node.right),
+            const item = new naslTypes.Assignment({
+              left: new naslTypes.Identifier({
+                name: variableName,
+              }),
+              right: transformLogicNode(decl.init),
             });
-        } else if (node.type === 'NewExpression') {
-            const calleeName = generate(node.callee as any).code;
-            if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
-                return transformLogicNode(node.arguments[0], naslTypes.TypeAnnotation.createPrimitive(calleeName));
-            }
-            console.error(node);
-            throw new Error(`Unhandled node ${node.type}`);
-        } else if (node.type === 'ArrowFunctionExpression') {
-            return new naslTypes.AnonymousFunction({
-                params: node.params.map((param: babelTypes.Identifier) => transformParam(param)),
-                body: transformLogicNode(node.body),
-            }) as any as naslTypes.LogicItem;
-        } else if (node.type === 'BooleanLiteral') {
-            return new naslTypes.BooleanLiteral({
-                value: String(node.value),
-            });
-        } else if (node.type === 'StringLiteral') {
-            return new naslTypes.StringLiteral({
-                value: node.value,
-            });
-        } else if (node.type === 'NumericLiteral') {
-            const literal = new naslTypes.NumericLiteral({
-                value: String(node.value),
-                typeAnnotation: typeAnnotation || naslTypes.TypeAnnotation.createPrimitive('Integer'),
-            });
-            literal.typeAnnotation.typeName = literal.changeType(String(node.value));
-            return literal;
-        } else if (node.type === 'NullLiteral') {
-            return new naslTypes.NullLiteral();
-        } else if (node.type === 'TemplateLiteral') {
-            const expressions = [...node.expressions as babelTypes.Expression[], ...node.quasis.map((element) => ({
-                type: 'StringLiteral',
-                value: element.value.raw,
-                start: element.start,
-                end: element.end,
-            })) as babelTypes.StringLiteral[]];
-            expressions.sort((a, b) => a.start - b.start);
+            item && logic.body.push(item);
+          }
+        }
+      });
+    } else if (node.type === 'CallExpression') {
+      const callee = flatMemberExpression(node.callee);
+      const calleeName = generate(node.callee as any).code;
+      // console.log('lemon ~~~ node--2', node, callee, calleeName);
+      if (/^\$refs\./.test(calleeName)) {
+        return new naslTypes.CallLogic({
+          calleeNamespace: `elements.${(callee[1] as babelTypes.Identifier).name}.logics`,
+          calleeName: (callee[2] as babelTypes.Identifier).name,
+          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          })) as naslTypes.Argument[],
+        });
+      }
+      if (callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity')) {
+        const entityName = callee[0].name.replace(/Entity$/, '');
+        return new naslTypes.CallLogic({
+          calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
+          calleeName: (callee[1] as babelTypes.Identifier).name,
+          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          })) as naslTypes.Argument[],
+        });
+      }
+      if (calleeName === 'nasl.oql.query') {
+        return new naslTypes.OqlQueryComponent({
+          dataSource: 'app.dataSources.defaultDS',
+          code: generate(node.arguments[0] as any).code.trim().slice(1, -1),
+        });
+      }
+      if (calleeName === 'nasl.util.consoleLog' || calleeName === 'console.log') {
+        if (contextLogicName.includes('on_') || contextLogicName.includes('viewLogic_')) {
+          return new naslTypes.CallLogic({
+            calleeNamespace: 'nasl.util',
+            calleeName: 'consoleLog',
+            shortcut: true,
+            arguments: node.arguments.map((arg) => new naslTypes.Argument({
+              expression: transformLogicNode(arg),
+            })) as naslTypes.Argument[],
+          });
+        }
+        return new naslTypes.CallLogic({
+          calleeNamespace: 'nasl.logging',
+          calleeName: 'INFO',
+          shortcut: true,
+          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          })) as naslTypes.Argument[],
+        });
+      }
+      if (calleeName === 'nasl.util.jsonSerialize' || calleeName === 'nasl.util.jsonDeserialize') {
+        const curCalleeName = (node.callee as any).property.name;
+        return new naslTypes.CallLogic({
+          calleeNamespace: 'nasl.util',
+          calleeName: curCalleeName,
+          shortcut: true,
+          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          })) as naslTypes.Argument[],
+          typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType })),
+        });
+      };
+      if (calleeName.startsWith('nasl.util.')) {
+        const curCalleeName = callee.length === 3 ? (callee[callee.length - 1] as babelTypes.Identifier).name : (callee[0] as any).callee.property.name;
+        const argument = callee.length === 3 ? node.arguments : (callee[0] as any).arguments as any;
 
-            return new naslTypes.StringInterpolation({
-                expressions: expressions.map((item) => transformLogicNode(item)),
-            });
-        } else if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
-            if (node.operator === '===')
-                node.operator = '==';
-            if (node.operator === '!==')
-                node.operator = '!=';
-            if (['+', '-', '*', '/', '%', '==', '!=', '>', '<', '>=', '<=', '&&', '||', 'startwith', 'endwith', 'like', 'in'].includes(node.operator)) {
-                return new naslTypes.BinaryExpression({
-                    operator: node.operator as any,
-                    left: transformLogicNode(node.left),
-                    right: transformLogicNode(node.right),
-                });
-            }
-            console.error(node);
-            throw new Error(`Unhandled node ${node.type}`);
-        } else if (node.type === 'UnaryExpression') {
-            if (['!'].includes(node.operator)) {
-                return new naslTypes.UnaryExpression({
-                    operator: node.operator as any,
-                    argument: transformLogicNode(node.argument),
-                });
-            }
-            if (['-'].includes(node.operator) && node.argument.type === 'NumericLiteral') {
-                return transformLogicNode({
-                    type: 'NumericLiteral',
-                    value: -node.argument.value,
-                } as babelTypes.NumericLiteral);
-            }
-            console.error(node);
-            throw new Error(`Unhandled node ${node.type}`);
-        } else if (node.type === 'UpdateExpression') {
-            if (node.operator === '++' || node.operator === '--') {
-                return new naslTypes.Assignment({
-                    left: transformLogicNode(node.argument),
-                    right: new naslTypes.BinaryExpression({
-                        operator: node.operator[0] as '+' | '-',
-                        left: transformLogicNode(node.argument),
-                        right: new naslTypes.NumericLiteral({
-                            value: '1',
-                            typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Integer'),
-                        }),
-                    }),
-                });
+        if (['plus', 'minus', 'multiply', 'divide', 'remainder'].includes(curCalleeName)) {
+          return handleBinaryExpression(curCalleeName, argument);
+        };
+
+        if (['NewList', 'NewMap', 'NewEntity', 'NewAnonymityStructure'].includes(curCalleeName)) {
+          return handleNewExpression(curCalleeName, node);
+        }
+
+        let typeNamespace: string;
+        if (argument?.[argument.length - 1]?.type === 'ObjectExpression') {
+          typeNamespace = argument.splice(-1)[0].properties[0].value.value;
+        }
+        const nodeElement = new naslTypes.CallFunction({
+          calleeNamespace: 'nasl.util',
+          calleeName: curCalleeName,
+          arguments: argument.map((arg: any, index: number) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+            keyword: `str${index + 1}`,
+          })) as naslTypes.Argument[],
+          typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType, typeNamespace })),
+
+        });
+        // console.log('lemon ~ callFunction ~ 3:', nodeElement);
+        return nodeElement;
+      }
+      if (callee.length === 3 && calleeName.startsWith('nasl.ui.')) {
+        if ((callee[2] as babelTypes.Identifier).name === 'destination') {
+          const namespace = (node.arguments[0] as babelTypes.StringLiteral).value;
+          const nsArr = namespace.split('.').map((item) => item.replace(/_view$/, ''));
+          const viewName = nsArr.pop();
+
+          return new naslTypes.Destination({
+            viewNamespace: `app.frontends.pc.views${nsArr.map((item) => `.${item}.views`).join('')}`, // viewNamespace
+            viewName, // viewName
+            arguments: node.arguments.slice(1).map((arg) => new naslTypes.Argument({
+              expression: transformLogicNode(arg),
+            })) as naslTypes.Argument[],
+          });
+        }
+        return new naslTypes.CallLogic({
+          calleeNamespace: 'nasl.ui',
+          calleeName: (callee[2] as babelTypes.Identifier).name,
+          shortcut: true,
+          /**
+           * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
+           * @param node
+           * @returns
+           */
+          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          })) as naslTypes.Argument[],
+        });
+      }
+      if (calleeName === 'ForEach') {
+        const newCallee = node.arguments;
+        const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
+        const nodeElement = new naslTypes.ForEachStatement({
+          each: transformLogicNode(newCallee[0]),
+          start: transformLogicNode(newCallee[1]),
+          end: transformLogicNode(newCallee[2]),
+          item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
+          index: transformParam(arrowFunction.params[1] as babelTypes.Identifier),
+          body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+        });
+        return nodeElement;
+      }
+      if (callee.length === 2) {
+        const curCalleeName = (node.callee as any).property.name;
+        if (curCalleeName === 'forEach') {
+          const newCallee = (node.callee as any).object;
+          const arrowFunction = node.arguments[0] as babelTypes.ArrowFunctionExpression;
+          const nodeElement = new naslTypes.ForEachStatement({
+            each: transformLogicNode(newCallee.callee.object),
+            start: transformLogicNode(newCallee?.arguments?.[0]),
+            end: transformLogicNode(newCallee?.arguments?.[1]),
+            item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
+            index: transformParam(arrowFunction.params[1] as babelTypes.Identifier),
+            body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+          });
+          return nodeElement;
+        }
+      } else if (['plus', 'minus', 'multiply', 'divide', 'remainder'].includes(calleeName)) {
+        return handleBinaryExpression(calleeName, node?.arguments);
+      } else if (calleeName === 'alert') {
+        return new naslTypes.CallLogic({
+          calleeNamespace: 'nasl.ui',
+          calleeName: 'showMessage',
+          shortcut: true,
+          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          })) as naslTypes.Argument[],
+        });
+      } else if (/^app.dataSources|app.logics|load/.test(calleeName)) {
+        return new naslTypes.CallLogic({
+          calleeNamespace: generate((node.callee as any).object).code,
+          calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
+          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          })) as naslTypes.Argument[],
+        });
+      } else if (callee.length === 1) {
+        if (calleeName.startsWith('viewLogic_')) {
+          return new naslTypes.CallLogic({
+            calleeNamespace: '',
+            calleeName: calleeName.slice('viewLogic_'.length),
+            arguments: node.arguments.map((arg) => new naslTypes.Argument({
+              expression: transformLogicNode(arg),
+            })) as naslTypes.Argument[],
+          });
+        }
+        return new naslTypes.CallLogic({
+          calleeNamespace: `app.logics`,
+          calleeName,
+          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            expression: transformLogicNode(arg),
+          })) as naslTypes.Argument[],
+        });
+      } else if (/interfaces/.test(calleeName)) {
+        return new naslTypes.CallInterface({
+          calleeNamespace: generate((node.callee as any).object).code,
+          calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
+          arguments: node.arguments.map((arg: any) => new naslTypes.Argument({
+            keyword: arg.properties[0].key.name,
+            expression: transformLogicNode(arg.properties[0].value),
+          })) as naslTypes.Argument[],
+        });
+      }
+      // else if (/destination/.test(calleeName)) {
+      //   const newCallee = flatMemberExpression((node.callee as any).object);
+      //   return new naslTypes.Destination({
+      //     viewNamespace: generate((node.callee as any).object.object).code,
+      //     viewName: (newCallee[newCallee.length - 1] as babelTypes.Identifier).name,
+      //     target: (node.arguments[0] as any).properties[1].value.value,
+      //     anchor: new naslTypes.Anchor({
+      //       expression: transformLogicNode((node.arguments[0] as any).properties[0].value),
+      //     }),
+      //   });
+      // }
+      else if (node.callee.type === 'ArrowFunctionExpression') {
+        // NOTE: 适用于 if else
+        const newCallee = (node.callee.body as any).body;
+        if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFuntion') {
+          const match = new naslTypes.Match({
+            expression: transformLogicNode(newCallee[0]),
+            isExpression: type === 'expression',
+            cases: flatIfStatement(newCallee[1].body.body[0]).map((_case: any) => new naslTypes.MatchCase({
+              patterns: !_case.test ? [] : flatMatchPatternsExpression(transformLogicNode(_case.test)) as any,
+              body: _case.consequent.body.filter((item: any) => item.type !== 'BreakStatement').map((item: any) => transformLogicNode(item)).filter((item: any) => !!item),
+            })),
+          });
+          if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
+            match.cases.push(new naslTypes.MatchCase({
+              patterns: [],
+              body: [],
+            }));
+          }
+          match.cases.forEach((case_: any) => {
+            if (case_.body.length && (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
+              case_.isMatchedTypeEnumable = true;
             }
-        } else if (node.type === 'ReturnStatement') {
-            if (node.argument) {
-                if (type === 'expression') {
-                    return transformLogicNode(node.argument);
-                }
-                if (!logic.returns.length) {
-                    logic.returns.push(new naslTypes.Return({
-                        name: 'result',
-                    }));
-                }
-                return new naslTypes.Assignment({
-                    left: new naslTypes.Identifier({
-                        name: logic.returns[0].name,
-                    }),
-                    right: transformLogicNode(node.argument),
-                });
+            if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
+              case_.isMatchedTypeEnumable = true;
+              case_.patterns[0] = new naslTypes.MemberExpression({
+                object: {
+                  concept: 'Identifier',
+                  name: case_.patterns[0].object.property.name,
+                  folded: false,
+                  namespace: 'app.enums'
+                } as any,
+                property: {
+                  concept: 'Identifier',
+                  name: case_.patterns[0].property.value,
+                  folded: false,
+                } as any,
+              });
             }
-        } else if (node.type === 'EmptyStatement') {
-            return node.leadingComments && new naslTypes.Comment({
-                value: String(node.leadingComments[0].value),
-            });
-        } else if (node.type === 'BlockStatement') {
-            return transformLogicNode(node?.body?.[0]);
-        } else {
-          console.error(node);
-          throw new Error(`Unhandled node ${node.type}`);
+          });
+          return match;
+        }
+        if (newCallee[newCallee.length - 1].argument?.callee?.name === '__SwitchExpressionFuntion') {
+          const switchStatement = transformLogicNode(newCallee[0].body.body[0]);
+          return switchStatement;
+        }
+        console.error(node);
+        if (debug) {
+          throw new Error(`Unhandled ArrowFunctionExpression node ${node.type}`);
+        }
+      } else {
+        console.error(node);
+        if (debug) {
+          throw new Error(`Unhandled node ${callee.map((item: babelTypes.Identifier) => item.name).join('.')} ${node.type}`);
+        }
+      }
+    } else if (node.type === 'IfStatement') {
+      if (node.alternate && node.alternate.type === 'IfStatement') {
+        const switchStatement = new naslTypes.SwitchStatement({
+          cases: [],
+        });
+        pushElseIf(node, switchStatement);
+        return switchStatement;
+      }
+      return new naslTypes.IfStatement({
+        test: transformLogicNode(node.test),
+        consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+        alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+      });
+    } else if (node.type === 'WhileStatement') {
+      return new naslTypes.WhileStatement({
+        test: transformLogicNode(node.test),
+        body: (node.body as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+      });
+    } else if (node.type === 'SwitchStatement') {
+      const match = new naslTypes.Match({
+        expression: transformLogicNode(node.discriminant),
+        isExpression: type === 'expression',
+        cases: node.cases.map((_case) => new naslTypes.MatchCase({
+          patterns: !_case.test ? [] : [transformLogicNode(_case.test)],
+          body: _case.consequent.filter((item) => item.type !== 'BreakStatement').map((item) => transformLogicNode(item)).filter((item) => !!item),
+        })),
+      });
+      if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
+        match.cases.push(new naslTypes.MatchCase({
+          patterns: [],
+          body: [],
+        }));
+      }
+      match.cases.forEach((case_: any) => {
+        if (case_.body.length && (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
+          case_.isMatchedTypeEnumable = true;
+        }
+        if (case_.patterns.length && case_.patterns[0].concept === 'MemberExpression') {
+          case_.isMatchedTypeEnumable = true;
+          case_.patterns[0].object.namespace = 'app.enums';
+        }
+      });
+      return match;
+    } else if (node.type === 'MemberExpression') {
+      if (node.property.type === 'NumericLiteral') {
+        return new naslTypes.CallFunction({
+          calleeNamespace: 'nasl.util',
+          calleeName: 'Get',
+          arguments: [
+            new naslTypes.Argument({
+              expression: transformLogicNode(node.object),
+            }),
+            new naslTypes.Argument({
+              expression: transformLogicNode(node.property),
+            }),
+          ],
+        });
+      }
+      return new naslTypes.MemberExpression({
+        object: transformLogicNode(node.object),
+        property: transformLogicNode(node.property),
+      });
+    } else if (node.type === 'Identifier') {
+      return new naslTypes.Identifier({
+        name: node.name,
+      });
+    } else if (node.type === 'ExpressionStatement') {
+      return transformLogicNode(node.expression);
+    } else if (node.type === 'AssignmentExpression') {
+      if (node.operator === '+=' || node.operator === '-=') {
+        if (type === 'expression') {
+          return new naslTypes.BinaryExpression({
+            operator: node.operator[0] as '+' | '-',
+            left: transformLogicNode(node.left),
+            right: transformLogicNode(node.right),
+          });
+        }
+        return new naslTypes.Assignment({
+          left: transformLogicNode(node.left),
+          right: new naslTypes.BinaryExpression({
+            operator: node.operator[0] as '+' | '-',
+            left: transformLogicNode(node.left),
+            right: transformLogicNode(node.right),
+          }),
+        });
+      }
+      if (type === 'expression') {
+        return transformLogicNode(node.right);
+      }
+      return new naslTypes.Assignment({
+        left: transformLogicNode(node.left),
+        right: transformLogicNode(node.right),
+      });
+    } else if (node.type === 'NewExpression') {
+      const calleeName = generate(node.callee as any).code;
+      if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
+        return transformLogicNode(node.arguments[0], naslTypes.TypeAnnotation.createPrimitive(calleeName));
+      }
+      console.error(node);
+      if (debug) {
+        throw new Error(`Unhandled node ${node.type}`);
+      }
+    } else if (node.type === 'ArrowFunctionExpression') {
+      return new naslTypes.AnonymousFunction({
+        params: node.params.map((param: babelTypes.Identifier) => transformParam(param)),
+        body: transformLogicNode(node.body),
+      }) as any as naslTypes.LogicItem;
+    } else if (node.type === 'BooleanLiteral') {
+      return new naslTypes.BooleanLiteral({
+        value: String(node.value),
+      });
+    } else if (node.type === 'StringLiteral') {
+      return new naslTypes.StringLiteral({
+        value: node.value,
+      });
+    } else if (node.type === 'NumericLiteral') {
+      const literal = new naslTypes.NumericLiteral({
+        value: String(node.value),
+        typeAnnotation: typeAnnotation || naslTypes.TypeAnnotation.createPrimitive('Integer'),
+      });
+      literal.typeAnnotation.typeName = literal.changeType(String(node.value));
+      return literal;
+    } else if (node.type === 'NullLiteral') {
+      return new naslTypes.NullLiteral();
+    } else if (node.type === 'TemplateLiteral') {
+      const expressions = [...node.expressions as babelTypes.Expression[], ...node.quasis.map((element) => ({
+        type: 'StringLiteral',
+        value: element.value.raw,
+        start: element.start,
+        end: element.end,
+      })) as babelTypes.StringLiteral[]];
+      expressions.sort((a, b) => a.start - b.start);
+
+      return new naslTypes.StringInterpolation({
+        expressions: expressions.map((item) => transformLogicNode(item)),
+      });
+    } else if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
+      if (node.operator === '===')
+        node.operator = '==';
+      if (node.operator === '!==')
+        node.operator = '!=';
+      if (['+', '-', '*', '/', '%', '==', '!=', '>', '<', '>=', '<=', '&&', '||', 'startwith', 'endwith', 'like', 'in'].includes(node.operator)) {
+        return new naslTypes.BinaryExpression({
+          operator: node.operator as any,
+          left: transformLogicNode(node.left),
+          right: transformLogicNode(node.right),
+        });
+      }
+      console.error(node);
+      if (debug) {
+        throw new Error(`Unhandled node ${node.type}`);
+      }
+    } else if (node.type === 'UnaryExpression') {
+      if (['!'].includes(node.operator)) {
+        return new naslTypes.UnaryExpression({
+          operator: node.operator as any,
+          argument: transformLogicNode(node.argument),
+        });
+      }
+      if (['-'].includes(node.operator) && node.argument.type === 'NumericLiteral') {
+        return transformLogicNode({
+          type: 'NumericLiteral',
+          value: -node.argument.value,
+        } as babelTypes.NumericLiteral);
+      }
+      console.error(node);
+      if (debug) {
+        throw new Error(`Unhandled node ${node.type}`);
+      }
+    } else if (node.type === 'UpdateExpression') {
+      if (node.operator === '++' || node.operator === '--') {
+        return new naslTypes.Assignment({
+          left: transformLogicNode(node.argument),
+          right: new naslTypes.BinaryExpression({
+            operator: node.operator[0] as '+' | '-',
+            left: transformLogicNode(node.argument),
+            right: new naslTypes.NumericLiteral({
+              value: '1',
+              typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Integer'),
+            }),
+          }),
+        });
+      }
+    } else if (node.type === 'ReturnStatement') {
+      if (node.argument) {
+        if (type === 'expression') {
+          return transformLogicNode(node.argument);
+        }
+        if (!logic.returns.length) {
+          logic.returns.push(new naslTypes.Return({
+            name: 'result',
+          }));
         }
+        return new naslTypes.Assignment({
+          left: new naslTypes.Identifier({
+            name: logic.returns[0].name,
+          }),
+          right: transformLogicNode(node.argument),
+        });
+      }
+    } else if (node.type === 'EmptyStatement') {
+      return node.leadingComments && new naslTypes.Comment({
+        value: String(node.leadingComments[0].value),
+      });
+    } else if (node.type === 'BlockStatement') {
+      return transformLogicNode(node?.body?.[0]);
+    } else {
+      console.error(node);
+      if (debug) {
+        throw new Error(`Unhandled node ${node.type}`);
+      }
     }
+  }
 
-    const root = babel.parseSync(tsCode, {
-        filename: 'result.ts',
-        presets: [require('@babel/preset-typescript')],
-    }) as babelTypes.File;
+  const root = babel.parseSync(tsCode, {
+    filename: 'result.ts',
+    presets: [require('@babel/preset-typescript')],
+  }) as babelTypes.File;
 
-    let parameters: babelTypes.Identifier[] = [];
-    let statements: babelTypes.Statement[] = root.program.body;
+  let parameters: babelTypes.Identifier[] = [];
+  let statements: babelTypes.Statement[] = [];
 
-    traverse<babelTypes.Node>((current) => {
-        if (current.node.type === 'FunctionDeclaration' && (current.node.id.name === contextLogicName || type === 'expression')) {
-            parameters = current.node.params as babelTypes.Identifier[];
-            statements = current.node.body.body;
-            return true;
-        }
-    }, { node: root.program }, { mode: 'anyObject' });
+  let func: babelTypes.FunctionDeclaration;
+  if (root.program.body[0].type === 'ExportNamedDeclaration') {
+    func = root.program.body[0].declaration as babelTypes.FunctionDeclaration;
+  }
+  parameters = func.params as babelTypes.Identifier[];
+  statements = func.body.body;
+  // traverse<babelTypes.Node>((current) => {
+  //     if (current.node.type === 'FunctionDeclaration' && (current.node.id.name === contextLogicName || type === 'expression')) {
+  //         return true;
+  //     }
+  // }, { node: root.program }, { mode: 'anyObject' });
 
-    const currentPositionComment = root.comments.find((comment) => comment.type === 'CommentLine' && comment.value === ' 当前位置');
-    if (currentPositionComment) {
-        statements = statements.filter((stat) => stat.start > currentPositionComment.start);
-    }
+  const currentPositionComment = root.comments.find((comment) => comment.type === 'CommentLine' && comment.value === ' 当前位置');
+  if (currentPositionComment) {
+    statements = statements.filter((stat) => stat.start > currentPositionComment.start);
+  }
 
-    // traverse<babelTypes.Node>((current) => {
-    //     if (!current.node.type)
-    //         console.log(current.key, current.node);
-    //     // console.log(current.node.type);
-    // }, { node: {
-    //     type: 'BlockStatement',
-    //     body: statements,
-    // } as babelTypes.BlockStatement }, {
-    //     mode: 'anyObject',
-    //     depthFirst: true,
-    //     excludedKeySet: new Set(['loc']),
-    // });
+  // traverse<babelTypes.Node>((current) => {
+  //     if (!current.node.type)
+  //         console.log(current.key, current.node);
+  //     // console.log(current.node.type);
+  // }, { node: {
+  //     type: 'BlockStatement',
+  //     body: statements,
+  // } as babelTypes.BlockStatement }, {
+  //     mode: 'anyObject',
+  //     depthFirst: true,
+  //     excludedKeySet: new Set(['loc']),
+  // });
 
-    parameters.forEach((node) => {
-        const param = transformParam(node);
-        param && logic.params.push(param);
-    });
-    statements.forEach((node) => {
-        const item = transformLogicNode(node);
-        item && logic.body.push(item);
-    });
+  parameters.forEach((node) => {
+    const param = transformParam(node);
+    param && logic.params.push(param);
+  });
+  statements.forEach((node) => {
+    const item = transformLogicNode(node);
+    item && logic.body.push(item);
+  });
 
-    // console.log(JSON.stringify(logic));
-    // try {
-    //     console.log(logic.toNaturalTS());
-    // } catch (e) {
-    //     console.error(e);
-    // }
+  // console.log(JSON.stringify(logic));
+  // try {
+  //     console.log(logic.toNaturalTS());
+  // } catch (e) {
+  //     console.error(e);
+  // }
 
-    return logic;
+  return logic;
 }
 
 export function tryTransformTSCode(tsCode: string, contextLogicName: string, type?: string): naslTypes.Logic {
-    if (tsCode.includes('```')) {
-        const cap = tsCode.match(/```.*\n([\s\S]+?)```/);
-        if (cap)
-            tsCode = cap[1].trim();
-    }
+  if (tsCode.includes('```')) {
+    const cap = tsCode.match(/```.*\n([\s\S]+?)```/);
+    if (cap)
+      tsCode = cap[1].trim();
+  }
 
-    return transformTSCode(tsCode, contextLogicName, type);
+  return transformTSCode(tsCode, contextLogicName, type);
 }
 
 export function transformTSCodeEx(answer: any, activeLogic: any, context: any) {
-    let logicName = activeLogic.name;
-    const { app, nasl } = context;
-    if (activeLogic.parentNode instanceof nasl.BindEvent && activeLogic.parentNode.parentNode instanceof nasl.View) {
-        logicName = `on_view_${activeLogic.name}`;
-    } else if (activeLogic.parentNode instanceof nasl.BindEvent && activeLogic.parentNode.parentNode instanceof nasl.ViewElement) {
-        logicName = `on_${(activeLogic.parentNode).element.name}_${activeLogic.name}`;
-    } else {
-        logicName = activeLogic.name;
-    }
+  let logicName = activeLogic.name;
+  const { app, nasl } = context;
+  if (activeLogic.parentNode instanceof nasl.BindEvent && activeLogic.parentNode.parentNode instanceof nasl.View) {
+    logicName = `viewLogic_${activeLogic.name}`;
+  } else if (activeLogic.parentNode instanceof nasl.BindEvent && activeLogic.parentNode.parentNode instanceof nasl.ViewElement) {
+    logicName = `on_${(activeLogic.parentNode).element.name}_${activeLogic.name}`;
+  } else {
+    logicName = activeLogic.name;
+  }
 
-    const logic = tryTransformTSCode(answer, logicName);
-    app.emit('collect:start', { actionMsg: '自然语言生成代码' });
-    logic.params.forEach((param: any) => {
-        if (!activeLogic.params.find((_: any) => _.name === param.name))
-            activeLogic.addParam(param.toJSON());
-    });
-    logic.variables.forEach((variable: any) => {
-        if (!activeLogic.variables.find((_: any) => _.name === variable.name))
-            activeLogic.addVariable(variable.toJSON());
-    });
-    if (logic.returns.length && !activeLogic.returns.length) {
-        activeLogic.addReturn(logic.returns[0].toJSON());
-    }
-    logic.body.forEach((item: any) => activeLogic.insertItemInBodyAt(item.toJSON(), activeLogic.body.length - 1));
-    app.emit('collect:end');
+  const logic = tryTransformTSCode(answer, logicName);
+  app.emit('collect:start', { actionMsg: '自然语言生成代码' });
+  logic.params.forEach((param: any) => {
+    if (!activeLogic.params.find((_: any) => _.name === param.name))
+      activeLogic.addParam(param.toJSON());
+  });
+  logic.variables.forEach((variable: any) => {
+    if (!activeLogic.variables.find((_: any) => _.name === variable.name))
+      activeLogic.addVariable(variable.toJSON());
+  });
+  if (logic.returns.length && !activeLogic.returns.length) {
+    activeLogic.addReturn(logic.returns[0].toJSON());
+  }
+  logic.body.forEach((item: any) => activeLogic.insertItemInBodyAt(item.toJSON(), activeLogic.body.length - 1));
+  app.emit('collect:end');
 }
 
 export function transformTSCodeToExpression(answer: any, context: any) {
-    let logic;
-    try {
-        logic = tryTransformTSCode(answer, '', 'expression');
-    } catch (error) {
-        throw new Error(error);
-    }
-    const { app } = context;
-    app.emit('collect:start', { actionMsg: '自然语言生成代码' });
-    const { body } = logic;
-    app.emit('collect:end');
-    return body;
+  let logic;
+  try {
+    logic = tryTransformTSCode(answer, '', 'expression');
+  } catch (error) {
+    throw new Error(error);
+  }
+  const { app } = context;
+  app.emit('collect:start', { actionMsg: '自然语言生成代码' });
+  const { body } = logic;
+  app.emit('collect:end');
+  return body;
 }