@lcap/nasl 3.3.0-beta.0 → 3.4.0-alpha.1

package/out/natural/transformTSCode.js

@@ -0,0 +1,878 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTSCodeToExpression = exports.transformTSCodeEx = exports.tryTransformTSCode = exports.transformTSCode = exports.tryParseTS = void 0;
+/* eslint-disable global-require */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+const babel = __importStar(require("@babel/core"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const naslTypes = __importStar(require("../concepts"));
+const debug = false;
+function tryParseTS(tsCode) {
+    try {
+        const root = babel.parseSync(tsCode, {
+            filename: 'result.ts',
+            presets: [require('@babel/preset-typescript')],
+        });
+        // console.log((root as any).program.body[0].body.body.map((item) => item.trailingComments));
+        return root;
+    }
+    catch (e) {
+        return null;
+    }
+}
+exports.tryParseTS = tryParseTS;
+function flatMemberExpression(node) {
+    if (node.type === 'MemberExpression')
+        return [...flatMemberExpression(node.object), node.property];
+    return [node];
+}
+function flatMatchPatternsExpression(node) {
+    if (node.concept === 'BinaryExpression') {
+        if (node.operator === '||') {
+            return [...flatMatchPatternsExpression(node.left), ...flatMatchPatternsExpression(node.right)];
+        }
+        if (node.operator === '==') {
+            return [node.right];
+        }
+        return [node];
+    }
+    return [node];
+}
+function flatIfStatement(node) {
+    if (node.alternate.type === 'IfStatement') {
+        return [...flatIfStatement(node.alternate), node];
+    }
+    return [node];
+}
+/**
+ * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
+ * @param node
+ * @returns
+ */
+function fixLogicNode(node) {
+    if (node?.type === 'CallExpression') {
+        const calleeName = (0, generator_1.default)(node.callee).code;
+        if (calleeName === 'nasl.util.ForEach') {
+            const callee = flatMemberExpression(node.callee);
+            node.callee = callee[2];
+        }
+    }
+}
+function transformTSCode(tsCode, contextLogicName, type) {
+    const logic = new naslTypes.Logic();
+    logic.body = [];
+    function transformTypeAnnotation(node) {
+        if (node.type === 'TSTypeReference') {
+            const typeName = node.typeName.name;
+            const primitiveType = naslTypes.primitiveTypeList.find((ta) => ta.typeName === typeName);
+            if (node?.typeNamespace) {
+                return naslTypes.TypeAnnotation.createReference(typeName, {
+                    typeNamespace: node.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) => new naslTypes.StructureProperty({
+                name: member.key.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 transformParam(node) {
+        const typeAnnotation = node.typeAnnotation?.typeAnnotation;
+        return new naslTypes.Param({
+            name: node.name,
+            typeAnnotation: typeAnnotation ? transformTypeAnnotation(typeAnnotation) : null,
+        });
+    }
+    function pushElseIf(ifNode, switchStatement) {
+        switchStatement.cases.push(new naslTypes.SwitchCase({
+            test: transformLogicNode(ifNode.test),
+            consequent: !ifNode.consequent ? [] : ifNode.consequent.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?.alternate ? [] : ifNode?.alternate?.body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+            }));
+        }
+    }
+    function handleBinaryExpression(calleeName, argument) {
+        const map = {
+            plus: '+',
+            minus: '-',
+            multiply: '*',
+            divide: '/',
+            remainder: '%',
+        };
+        return new naslTypes.BinaryExpression({
+            operator: map?.[calleeName],
+            left: transformLogicNode(argument?.[0]),
+            right: transformLogicNode(argument?.[1]),
+        });
+    }
+    function handleNewExpression(calleeName, node) {
+        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) => transformLogicNode(arg)),
+            });
+        }
+        if (calleeName === 'NewMap') {
+            const keys = [];
+            const values = [];
+            node?.arguments?.[0]?.properties.forEach((arg) => {
+                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 = [];
+            const rights = [];
+            node?.arguments?.[0]?.properties.forEach((arg) => {
+                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 = [];
+            const rights = [];
+            const structureProperties = [];
+            node?.arguments?.[0]?.properties?.forEach((arg) => {
+                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, typeAnnotation) {
+        fixLogicNode(node);
+        // console.log('lemon ~~~ node--1:', node);
+        if (node.type === 'VariableDeclaration') { // 拆成局部变量和赋值
+            const declList = node?.declarations || [];
+            declList?.forEach((decl) => {
+                const variableName = decl.id.name;
+                if (!logic.variables.find((variable) => variable.name === variableName)) {
+                    const varTypeAnnotation = decl.id.typeAnnotation?.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(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 = (0, generator_1.default)(node.callee).code;
+            // console.log('lemon ~~~ node--2', node, callee, calleeName);
+            if (/^\$refs\./.test(calleeName)) {
+                return new naslTypes.CallLogic({
+                    calleeNamespace: `elements.${callee[1].name}.logics`,
+                    calleeName: callee[2].name,
+                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                        expression: transformLogicNode(arg),
+                    })),
+                });
+            }
+            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].name,
+                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                        expression: transformLogicNode(arg),
+                    })),
+                });
+            }
+            if (calleeName === 'nasl.oql.query') {
+                return new naslTypes.OqlQueryComponent({
+                    dataSource: 'app.dataSources.defaultDS',
+                    code: (0, generator_1.default)(node.arguments[0]).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),
+                        })),
+                    });
+                }
+                return new naslTypes.CallLogic({
+                    calleeNamespace: 'nasl.logging',
+                    calleeName: 'INFO',
+                    shortcut: true,
+                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                        expression: transformLogicNode(arg),
+                    })),
+                });
+            }
+            if (calleeName === 'nasl.util.jsonSerialize' || calleeName === 'nasl.util.jsonDeserialize') {
+                const curCalleeName = node.callee.property.name;
+                return new naslTypes.CallLogic({
+                    calleeNamespace: 'nasl.util',
+                    calleeName: curCalleeName,
+                    shortcut: true,
+                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                        expression: transformLogicNode(arg),
+                    })),
+                    typeArguments: node?.typeParameters?.params.map((curType) => transformTypeAnnotation({ ...curType })),
+                });
+            }
+            ;
+            if (calleeName.startsWith('nasl.util.')) {
+                const curCalleeName = callee.length === 3 ? callee[callee.length - 1].name : callee[0].callee.property.name;
+                const argument = callee.length === 3 ? node.arguments : callee[0].arguments;
+                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;
+                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, index) => new naslTypes.Argument({
+                        expression: transformLogicNode(arg),
+                        keyword: `str${index + 1}`,
+                    })),
+                    typeArguments: node?.typeParameters?.params.map((curType) => transformTypeAnnotation({ ...curType, typeNamespace })),
+                });
+                // console.log('lemon ~ callFunction ~ 3:', nodeElement);
+                return nodeElement;
+            }
+            if (callee.length === 3 && calleeName.startsWith('nasl.ui.')) {
+                if (callee[2].name === 'destination') {
+                    const namespace = node.arguments[0].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('')}`,
+                        viewName,
+                        arguments: node.arguments.slice(1).map((arg) => new naslTypes.Argument({
+                            expression: transformLogicNode(arg),
+                        })),
+                    });
+                }
+                return new naslTypes.CallLogic({
+                    calleeNamespace: 'nasl.ui',
+                    calleeName: callee[2].name,
+                    shortcut: true,
+                    /**
+                     * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
+                     * @param node
+                     * @returns
+                     */
+                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                        expression: transformLogicNode(arg),
+                    })),
+                });
+            }
+            if (calleeName === 'ForEach') {
+                const newCallee = node.arguments;
+                const arrowFunction = node.arguments[3];
+                const nodeElement = new naslTypes.ForEachStatement({
+                    each: transformLogicNode(newCallee[0]),
+                    start: transformLogicNode(newCallee[1]),
+                    end: transformLogicNode(newCallee[2]),
+                    item: transformParam(arrowFunction.params[0]),
+                    index: transformParam(arrowFunction.params[1]),
+                    body: arrowFunction.body.body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+                });
+                return nodeElement;
+            }
+            if (callee.length === 2) {
+                const curCalleeName = node.callee.property.name;
+                if (curCalleeName === 'forEach') {
+                    const newCallee = node.callee.object;
+                    const arrowFunction = node.arguments[0];
+                    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]),
+                        index: transformParam(arrowFunction.params[1]),
+                        body: arrowFunction.body.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),
+                    })),
+                });
+            }
+            else if (/^app.dataSources|app.logics|load/.test(calleeName)) {
+                return new naslTypes.CallLogic({
+                    calleeNamespace: (0, generator_1.default)(node.callee.object).code,
+                    calleeName: callee[callee.length - 1].name,
+                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                        expression: transformLogicNode(arg),
+                    })),
+                });
+            }
+            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),
+                        })),
+                    });
+                }
+                return new naslTypes.CallLogic({
+                    calleeNamespace: `app.logics`,
+                    calleeName,
+                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                        expression: transformLogicNode(arg),
+                    })),
+                });
+            }
+            else if (/interfaces/.test(calleeName)) {
+                return new naslTypes.CallInterface({
+                    calleeNamespace: (0, generator_1.default)(node.callee.object).code,
+                    calleeName: callee[callee.length - 1].name,
+                    arguments: node.arguments.map((arg) => new naslTypes.Argument({
+                        keyword: arg.properties[0].key.name,
+                        expression: transformLogicNode(arg.properties[0].value),
+                    })),
+                });
+            }
+            // 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.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) => new naslTypes.MatchCase({
+                            patterns: !_case.test ? [] : flatMatchPatternsExpression(transformLogicNode(_case.test)),
+                            body: _case.consequent.body.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_) => {
+                        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'
+                                },
+                                property: {
+                                    concept: 'Identifier',
+                                    name: case_.patterns[0].property.value,
+                                    folded: false,
+                                },
+                            });
+                        }
+                    });
+                    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) => 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.body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+                alternate: !node.alternate ? [] : node.alternate.body.map((item) => transformLogicNode(item)).filter((item) => !!item),
+            });
+        }
+        else if (node.type === 'WhileStatement') {
+            return new naslTypes.WhileStatement({
+                test: transformLogicNode(node.test),
+                body: node.body.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_) => {
+                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],
+                        left: transformLogicNode(node.left),
+                        right: transformLogicNode(node.right),
+                    });
+                }
+                return new naslTypes.Assignment({
+                    left: transformLogicNode(node.left),
+                    right: new naslTypes.BinaryExpression({
+                        operator: node.operator[0],
+                        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 = (0, generator_1.default)(node.callee).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) => transformParam(param)),
+                body: transformLogicNode(node.body),
+            });
+        }
+        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, ...node.quasis.map((element) => ({
+                    type: 'StringLiteral',
+                    value: element.value.raw,
+                    start: element.start,
+                    end: element.end,
+                }))];
+            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,
+                    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,
+                    argument: transformLogicNode(node.argument),
+                });
+            }
+            if (['-'].includes(node.operator) && node.argument.type === 'NumericLiteral') {
+                return transformLogicNode({
+                    type: 'NumericLiteral',
+                    value: -node.argument.value,
+                });
+            }
+            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],
+                        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')],
+    });
+    let parameters = [];
+    let statements = [];
+    let func;
+    if (root.program.body[0].type === 'ExportNamedDeclaration') {
+        func = root.program.body[0].declaration;
+    }
+    parameters = func.params;
+    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);
+    }
+    // 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);
+    });
+    // console.log(JSON.stringify(logic));
+    // try {
+    //     console.log(logic.toNaturalTS());
+    // } catch (e) {
+    //     console.error(e);
+    // }
+    return logic;
+}
+exports.transformTSCode = transformTSCode;
+function tryTransformTSCode(tsCode, contextLogicName, type) {
+    if (tsCode.includes('```')) {
+        const cap = tsCode.match(/```.*\n([\s\S]+?)```/);
+        if (cap)
+            tsCode = cap[1].trim();
+    }
+    return transformTSCode(tsCode, contextLogicName, type);
+}
+exports.tryTransformTSCode = tryTransformTSCode;
+function transformTSCodeEx(answer, activeLogic, context) {
+    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) => {
+        if (!activeLogic.params.find((_) => _.name === param.name))
+            activeLogic.addParam(param.toJSON());
+    });
+    logic.variables.forEach((variable) => {
+        if (!activeLogic.variables.find((_) => _.name === variable.name))
+            activeLogic.addVariable(variable.toJSON());
+    });
+    if (logic.returns.length && !activeLogic.returns.length) {
+        activeLogic.addReturn(logic.returns[0].toJSON());
+    }
+    logic.body.forEach((item) => activeLogic.insertItemInBodyAt(item.toJSON(), activeLogic.body.length - 1));
+    app.emit('collect:end');
+}
+exports.transformTSCodeEx = transformTSCodeEx;
+function transformTSCodeToExpression(answer, context) {
+    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;
+}
+exports.transformTSCodeToExpression = transformTSCodeToExpression;
+//# sourceMappingURL=transformTSCode.js.map