@lcap/nasl 3.9.0-beta.7 → 3.9.0-beta.9

package/out/natural/transforms/transform2LogicItem.js

@@ -0,0 +1,1262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform2LogicItem = exports.transform2Param = exports.TransformManager = void 0;
+const utils_1 = require("./utils");
+const transform2TypeAnnotation_1 = require("./transform2TypeAnnotation");
+const utils_2 = require("../../utils");
+class TransformManager {
+    constructor() {
+        this.transforms = [];
+        this.transformCallExpressions = [];
+    }
+    register(type, transform) {
+        this.transforms.push([type, transform]);
+    }
+    registerCallExpression(type, transform) {
+        this.transformCallExpressions.push([type, transform]);
+    }
+    apply(node, options) {
+        if (node.type === 'CallExpression' && node.callee.type !== 'CallExpression') {
+            const callee = flatMemberExpression(node.callee);
+            const calleeName = (0, utils_1.generate)(node.callee).code;
+            for (const [type, transform] of this.transformCallExpressions) {
+                if (typeof type === 'function' ? type(node, calleeName, callee) : type === calleeName) {
+                    return transform(node, calleeName, callee, options);
+                }
+            }
+            (0, utils_1.throwError)(`Unhandled node ${callee.map((item) => item.name).join('.')} ${node.type}`);
+        }
+        else {
+            for (const [type, transform] of this.transforms) {
+                if (typeof type === 'function' ? type(node) : type === node.type) {
+                    return transform(node, options);
+                }
+            }
+            (0, utils_1.throwError)(`Unhandled node ${node.type}`);
+        }
+    }
+}
+exports.TransformManager = TransformManager;
+function fixExpression(arg, options) {
+    let expression = transform2LogicItem(arg, options);
+    if (expression?.concept === 'Identifier' && expression?.name === 'undefined') {
+        expression = undefined;
+    }
+    return expression;
+}
+/**
+ * 铺平点选表达式
+ */
+function flatMemberExpression(node) {
+    if (node.type === 'MemberExpression')
+        return [...flatMemberExpression(node.object), node.property];
+    return [node];
+}
+/**
+ * 铺平链式调用表达式
+ */
+function flatChainCallExpression(node) {
+    if (node.callee.type === 'MemberExpression') {
+        if (node.callee.object.type === 'CallExpression' && node.callee.property.type === 'Identifier')
+            return [...flatChainCallExpression(node.callee.object), utils_1.babelTypes.callExpression(node.callee.property, node.arguments)];
+        else if (node.callee.object.type === 'Identifier' && node.callee.property.type === 'Identifier')
+            return [utils_1.babelTypes.callExpression(node.callee.property, node.arguments)];
+    }
+    return [node];
+}
+function flatMembers(node) {
+    if (node.concept === 'MemberExpression')
+        return [...flatMembers((node?.object)), node];
+    return [];
+}
+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, utils_1.generate)(node.callee).code;
+        if (calleeName === 'nasl.util.ForEach') {
+            const callee = flatMemberExpression(node.callee);
+            node.callee = callee[2];
+        }
+    }
+}
+function transform2Param(node) {
+    const typeAnnotation = node.typeAnnotation?.typeAnnotation;
+    const exclude = ['event'];
+    if (exclude.includes(node.name))
+        return null;
+    return new utils_1.naslTypes.Param({
+        name: node.name,
+        typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
+    });
+}
+exports.transform2Param = transform2Param;
+function transformCallExpressionToBinaryExpression(node, calleeName, callee, options) {
+    const argument = node?.arguments;
+    const map = {
+        plus: '+',
+        minus: '-',
+        multiply: '*',
+        divide: '/',
+        remainder: '%',
+        STARTWITH: 'startwith',
+        ENDWITH: 'endwith',
+        LIKE: 'like',
+        IN: 'in',
+    };
+    return new utils_1.naslTypes.BinaryExpression({
+        operator: map[calleeName],
+        left: transform2LogicItem(argument?.[0], options),
+        right: transform2LogicItem(argument?.[1], options),
+    });
+}
+function transform2BinaryExpression(node, options) {
+    if (node.operator === '===')
+        node.operator = '==';
+    if (node.operator === '!==')
+        node.operator = '!=';
+    if (['+', '-', '*', '/', '%', '==', '!=', '>', '<', '>=', '<=', '&&', '||', 'startwith', 'endwith', 'like', 'in'].includes(node.operator)) {
+        return new utils_1.naslTypes.BinaryExpression({
+            operator: node.operator,
+            left: transform2LogicItem(node.left, options),
+            right: transform2LogicItem(node.right, options),
+        });
+    }
+    (0, utils_1.throwError)(`Unhandled node ${node.type}`);
+}
+function transform2NewExpression(calleeName, node, options) {
+    if (calleeName === 'NewList') {
+        return new utils_1.naslTypes.NewList({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createGeneric('List', {
+                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+            }),
+            items: (node?.arguments?.[0]).elements?.map((arg) => transform2LogicItem(arg, options)),
+        });
+    }
+    if (calleeName === 'NewMap') {
+        const keys = [];
+        const values = [];
+        node?.arguments?.[0]?.properties.forEach((arg) => {
+            keys.push(transform2LogicItem(arg.key, options));
+            values.push(transform2LogicItem(arg.value, options));
+        });
+        return new utils_1.naslTypes.NewMap({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createGeneric('Map', {
+                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+            }),
+            keys,
+            values,
+        });
+    }
+    if (calleeName === 'NewEntity') {
+        const properties = [];
+        const rights = [];
+        const assignmentLines = [];
+        node?.arguments?.[0]?.properties.forEach((arg, index) => {
+            properties.push(transform2LogicItem(arg.key, options));
+            if (arg.value.type === 'MemberExpression') {
+                const expression = flatMemberExpression(arg.value);
+                const members = flatMembers(transform2LogicItem(arg.value, options));
+                rights.push(new utils_1.naslTypes.SelectMembers({
+                    expression: transform2LogicItem(expression[0], options),
+                    members,
+                }));
+                if (arg?.value) {
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
+                        leftIndex: [0, index],
+                        rightIndex: [index, members.length - 1],
+                    }));
+                }
+            }
+            else {
+                rights.push(new utils_1.naslTypes.SelectMembers({
+                    expression: transform2LogicItem(arg.value, options)
+                }));
+                if (arg?.value) {
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
+                        leftIndex: [0, index],
+                        rightIndex: [index],
+                    }));
+                }
+            }
+        });
+        const parameters = node?.typeParameters?.params?.[0];
+        if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
+            const { left, right } = parameters?.typeName || {};
+            const typeNamespace = (0, utils_1.generate)(left)?.code;
+            const typeName = right?.name;
+            return new utils_1.naslTypes.NewComposite({
+                typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(typeName, {
+                    typeNamespace,
+                    typeName
+                }),
+                properties,
+                rights,
+                assignmentLines
+            });
+        }
+        const typeName = parameters?.typeName?.name;
+        return new utils_1.naslTypes.NewComposite({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(typeName, {
+                typeNamespace: 'app.dataSources.defaultDS.entities',
+                typeName
+            }),
+            properties,
+            rights,
+            assignmentLines
+        });
+    }
+    if (calleeName === 'NewStructure') {
+        const properties = [];
+        const rights = [];
+        const assignmentLines = [];
+        node?.arguments?.[0]?.properties.forEach((arg, index) => {
+            properties.push(transform2LogicItem(arg.key, options));
+            if (arg.value.type === 'MemberExpression') {
+                const expression = flatMemberExpression(arg.value);
+                const members = flatMembers(transform2LogicItem(arg.value, options));
+                rights.push(new utils_1.naslTypes.SelectMembers({
+                    expression: transform2LogicItem(expression[0], options),
+                    members,
+                }));
+                if (arg?.value) {
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
+                        leftIndex: [0, index],
+                        rightIndex: [index, members.length - 1],
+                    }));
+                }
+            }
+            else {
+                rights.push(new utils_1.naslTypes.SelectMembers({
+                    expression: transform2LogicItem(arg.value, options)
+                }));
+                if (arg?.value) {
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
+                        leftIndex: [0, index],
+                        rightIndex: [index],
+                    }));
+                }
+            }
+        });
+        const parameters = node?.typeParameters?.params?.[0];
+        if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
+            const { left, right } = parameters?.typeName || {};
+            const typeNamespace = (0, utils_1.generate)(left)?.code;
+            const typeName = right?.name;
+            return new utils_1.naslTypes.NewComposite({
+                typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(typeName, {
+                    typeNamespace,
+                    typeName
+                }),
+                properties,
+                rights,
+                assignmentLines
+            });
+        }
+        const typeName = parameters?.typeName?.name;
+        return new utils_1.naslTypes.NewComposite({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createReference(typeName, {
+                typeNamespace: 'app.structures',
+                typeName
+            }),
+            properties,
+            rights,
+            assignmentLines
+        });
+    }
+    if (calleeName === 'NewAnonymousStructure') {
+        const properties = [];
+        const rights = [];
+        const structureProperties = [];
+        const assignmentLines = [];
+        node?.arguments?.[0]?.properties?.forEach((arg, index) => {
+            properties.push(transform2LogicItem(arg.key, options));
+            if (arg.value.type === 'MemberExpression') {
+                const expression = flatMemberExpression(arg.value);
+                const members = flatMembers(transform2LogicItem(arg.value, options));
+                rights.push(new utils_1.naslTypes.SelectMembers({
+                    expression: transform2LogicItem(expression[0], options),
+                    members,
+                }));
+                if (arg?.value) {
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
+                        leftIndex: [0, index],
+                        rightIndex: [index, members.length - 1],
+                    }));
+                }
+            }
+            else {
+                rights.push(new utils_1.naslTypes.SelectMembers({
+                    expression: transform2LogicItem(arg.value, options)
+                }));
+                if (arg?.value) {
+                    assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
+                        leftIndex: [0, index],
+                        rightIndex: [index],
+                    }));
+                }
+            }
+            structureProperties.push(new utils_1.naslTypes.StructureProperty({
+                name: arg?.key?.name,
+                typeAnnotation: null
+            }));
+        });
+        return new utils_1.naslTypes.NewComposite({
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
+            properties,
+            rights,
+            assignmentLines
+        });
+    }
+    (0, utils_1.throwError)(`Unhandled ArrowFunctionExpression node ${node.type}`);
+}
+function pushElseIf(ifNode, switchStatement, options) {
+    switchStatement.cases.push(new utils_1.naslTypes.SwitchCase({
+        test: transform2LogicItem(ifNode.test, options),
+        consequent: !ifNode.consequent ? [] : ifNode.consequent.body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+    }));
+    if (ifNode.alternate && ifNode.alternate.type === 'IfStatement') {
+        pushElseIf(ifNode.alternate, switchStatement, options);
+    }
+    else {
+        switchStatement.cases.push(new utils_1.naslTypes.SwitchCase({
+            test: undefined,
+            consequent: !ifNode?.alternate ? [] : ifNode?.alternate?.body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+        }));
+    }
+}
+function transform2VariableAndAddAssignment(node, options) {
+    const declList = node?.declarations || [];
+    let newNode;
+    declList?.forEach((decl) => {
+        const variableName = decl.id.name;
+        if (![...options.logic.variables, ...options.logic.returns].some((variable) => variable.name === variableName)) {
+            const varTypeAnnotation = decl.id.typeAnnotation?.typeAnnotation;
+            options.logic.variables.push(new utils_1.naslTypes.Variable({
+                name: variableName,
+                typeAnnotation: varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation),
+            }));
+        }
+        if (decl.init) {
+            if (decl.init.type !== 'ArrayExpression' && decl.init.type !== 'ObjectExpression') {
+                const calleeName = (0, utils_1.generate)(decl?.init?.callee).code;
+                const varTypeAnnotation = decl?.id?.typeAnnotation?.typeAnnotation;
+                if (calleeName === 'nasl.oql.query' && varTypeAnnotation) {
+                    decl.init.typeAnnotations = varTypeAnnotation;
+                }
+                newNode = new utils_1.naslTypes.Assignment({
+                    left: new utils_1.naslTypes.Identifier({
+                        name: variableName,
+                    }),
+                    right: transform2LogicItem(decl.init, options),
+                });
+            }
+        }
+    });
+    if (newNode)
+        return newNode;
+}
+function transform2IfStatement(node, options) {
+    if (node.alternate && node.alternate.type === 'IfStatement') {
+        const switchStatement = new utils_1.naslTypes.SwitchStatement({
+            cases: [],
+        });
+        pushElseIf(node, switchStatement, options);
+        return switchStatement;
+    }
+    let consequentIndex;
+    let alternateIndex;
+    const naslNode = new utils_1.naslTypes.IfStatement({
+        test: transform2LogicItem(node.test, options),
+        consequent: !node.consequent ? [] : node.consequent.body.map((item, index) => {
+            if (item?.type === 'ReturnStatement') {
+                item.ends = true;
+                if (item?.argument) {
+                    consequentIndex = index;
+                }
+            }
+            return transform2LogicItem(item, options);
+        }).filter((item) => !!item),
+        alternate: !node.alternate ? [] : node.alternate.body.map((item, index) => {
+            if (item?.type === 'ReturnStatement') {
+                item.ends = true;
+                if (item?.argument) {
+                    alternateIndex = index;
+                }
+            }
+            return transform2LogicItem(item, options);
+        }).filter((item) => !!item),
+    });
+    if (consequentIndex !== undefined) {
+        naslNode?.consequent?.splice(consequentIndex + 1, 0, new utils_1.naslTypes.End());
+    }
+    if (alternateIndex !== undefined) {
+        naslNode?.alternate?.splice(alternateIndex + 1, 0, new utils_1.naslTypes.End());
+    }
+    return naslNode;
+}
+function transform2WhileStatement(node, options) {
+    return new utils_1.naslTypes.WhileStatement({
+        test: transform2LogicItem(node.test, options),
+        body: node.body.body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+    });
+}
+function transformSwitchStatement2Match(node, options) {
+    const match = new utils_1.naslTypes.Match({
+        expression: transform2LogicItem(node.discriminant, options),
+        isExpression: false,
+        cases: node.cases.map((_case) => new utils_1.naslTypes.MatchCase({
+            patterns: !_case.test ? [] : [transform2LogicItem(_case.test, options)],
+            body: _case.consequent.filter((item) => item.type !== 'BreakStatement').map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+        })),
+    });
+    if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
+        match.cases.push(new utils_1.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;
+}
+function transformIdentifier(node, options) {
+    if (options.entityAsNames?.includes(node.name)) {
+        return new utils_1.naslTypes.QueryFieldExpression({
+            isDotStar: false,
+            asName: undefined,
+            entityAsName: node.name,
+            propertyName: '',
+        });
+    }
+    return new utils_1.naslTypes.Identifier({
+        name: node.name,
+    });
+}
+function transform2SelectQueryFieldExpression(node, options) {
+    // babelTypes.Identifier | babelTypes.MemberExpression
+    let expression;
+    let asNameNode;
+    // if (node.type === 'ObjectProperty') {
+    expression = node.value;
+    asNameNode = node.key;
+    // }
+    if (expression.type === 'Identifier') {
+        return new utils_1.naslTypes.QueryFieldExpression({
+            isDotStar: true,
+            asName: (0, utils_2.firstUpperCase)(asNameNode.name) === expression.name ? undefined : asNameNode.name,
+            entityAsName: expression.name,
+            propertyName: '',
+        });
+    }
+    else {
+        return new utils_1.naslTypes.QueryFieldExpression({
+            isDotStar: true,
+            asName: (0, utils_2.firstUpperCase)(asNameNode.name) === expression.property.name ? undefined : asNameNode.name,
+            entityAsName: expression.object.name,
+            propertyName: expression.property.name,
+        });
+    }
+}
+function transform2QueryAggregateExpression(node, options) {
+    const callExpression = node.value;
+    let asNameNode = node.key;
+    const arg = callExpression.arguments[0];
+    return new utils_1.naslTypes.QueryAggregateExpression({
+        asName: asNameNode.name,
+        aggregateName: callExpression.callee.name,
+        aggregateParam: (arg.type === 'MemberExpression' ? transformMemberExpression(arg, options) : transformIdentifier(arg, options)),
+    });
+}
+function transform2AnonymousFunction(node, options) {
+    return new utils_1.naslTypes.AnonymousFunction({
+        params: node.params.map((param) => transform2Param(param)),
+        body: transform2LogicItem(node.body, options),
+    });
+}
+function transform2Assignment(node, options) {
+    if (node.operator === '+=' || node.operator === '-=') {
+        return new utils_1.naslTypes.Assignment({
+            left: transform2LogicItem(node.left, options),
+            right: new utils_1.naslTypes.BinaryExpression({
+                operator: node.operator[0],
+                left: transform2LogicItem(node.left, options),
+                right: transform2LogicItem(node.right, options),
+            }),
+        });
+    }
+    return new utils_1.naslTypes.Assignment({
+        left: transform2LogicItem(node.left, options),
+        right: transform2LogicItem(node.right, options),
+    });
+}
+function transformUpdateExpression2Assignment(node, options) {
+    if (node.operator === '++' || node.operator === '--') {
+        return new utils_1.naslTypes.Assignment({
+            left: transform2LogicItem(node.argument, options),
+            right: new utils_1.naslTypes.BinaryExpression({
+                operator: node.operator[0],
+                left: transform2LogicItem(node.argument, options),
+                right: new utils_1.naslTypes.NumericLiteral({
+                    value: '1',
+                    typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Integer'),
+                }),
+            }),
+        });
+    }
+}
+function transform2BooleanLiteral(node, options) {
+    return new utils_1.naslTypes.BooleanLiteral({
+        value: String(node.value),
+    });
+}
+function transform2StringLiteral(node, options) {
+    return new utils_1.naslTypes.StringLiteral({
+        value: node.value,
+    });
+}
+function transform2NumericLiteral(node, options) {
+    const literal = new utils_1.naslTypes.NumericLiteral({
+        value: String(node.value),
+        typeAnnotation: options.typeAnnotation || utils_1.naslTypes.TypeAnnotation.createPrimitive('Integer'),
+    });
+    literal.typeAnnotation.typeName = literal.changeType(String(node.value));
+    return literal;
+}
+function transform2NullLiteral(node, options) {
+    return new utils_1.naslTypes.NullLiteral();
+}
+function transformReturnStatement2AssignmentOrEnd(node, options) {
+    if (!node.argument) {
+        return new utils_1.naslTypes.End();
+    }
+    const { logic } = options;
+    if (node.argument?.type === 'Identifier') {
+        if (!logic.returns.length) {
+            const curVariable = logic?.variables?.find((item) => item.name === node?.argument?.name);
+            if (curVariable) {
+                logic.variables = logic?.variables?.filter((item) => item.name !== node?.argument?.name);
+                logic.addReturn(curVariable);
+            }
+        }
+    }
+    else {
+        if (!logic.returns.length) {
+            logic.returns.push(new utils_1.naslTypes.Return({
+                name: 'result',
+            }));
+        }
+        return new utils_1.naslTypes.Assignment({
+            left: new utils_1.naslTypes.Identifier({
+                name: logic.returns[0].name,
+            }),
+            right: transform2LogicItem(node.argument, options),
+        });
+    }
+}
+function transform2StringInterpolation(node, options) {
+    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 utils_1.naslTypes.StringInterpolation({
+        expressions: expressions.map((item) => transform2LogicItem(item, options)),
+    });
+}
+function transform2Comment(node, options) {
+    return node.leadingComments && new utils_1.naslTypes.Comment({
+        value: String(node.leadingComments[0].value),
+    });
+}
+function transformBlockStatement(node, options) {
+    return transform2LogicItem(node?.body?.[0], options);
+}
+function transform2NewComposite(node, options) {
+    const properties = [];
+    const rights = [];
+    const structureProperties = [];
+    const assignmentLines = [];
+    node?.properties?.forEach((arg, index) => {
+        properties.push(transform2LogicItem(arg.key, options));
+        if (arg.value.type === 'MemberExpression') {
+            const expression = flatMemberExpression(arg.value);
+            const members = flatMembers(transform2LogicItem(arg.value, options));
+            rights.push(new utils_1.naslTypes.SelectMembers({
+                expression: transform2LogicItem(expression[0], options),
+                members,
+            }));
+            if (arg?.value) {
+                assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
+                    leftIndex: [0, index],
+                    rightIndex: [index, members.length - 1],
+                }));
+            }
+        }
+        else {
+            rights.push(new utils_1.naslTypes.SelectMembers({
+                expression: transform2LogicItem(arg?.value, options)
+            }));
+            if (arg?.value) {
+                assignmentLines.push(new utils_1.naslTypes.AssignmentLine({
+                    leftIndex: [0, index],
+                    rightIndex: [index],
+                }));
+            }
+        }
+        structureProperties.push(new utils_1.naslTypes.StructureProperty({
+            name: arg?.key?.name,
+            typeAnnotation: null
+        }));
+    });
+    return new utils_1.naslTypes.NewComposite({
+        typeAnnotation: utils_1.naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties),
+        properties,
+        rights,
+        assignmentLines
+    });
+}
+function transformNewExpression(node, options) {
+    const calleeName = (0, utils_1.generate)(node.callee).code;
+    if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
+        return transform2LogicItem(node.arguments[0], {
+            ...options,
+            typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive(calleeName),
+        });
+    }
+    (0, utils_1.throwError)(`Unhandled node ${node.type}`);
+}
+function transformMemberExpression(node, options) {
+    if (options.entityAsNames?.includes(node.object.name)) {
+        return new utils_1.naslTypes.QueryFieldExpression({
+            isDotStar: false,
+            asName: undefined,
+            entityAsName: node.object.name,
+            propertyName: node.property.name,
+        });
+    }
+    const callee = flatMemberExpression(node);
+    const calleeName = (0, utils_1.generate)(node)?.code;
+    if (calleeName?.includes('app.enums')) {
+        const name = callee?.[3]?.value || callee?.[3]?.name || callee?.[3]?.value;
+        return new utils_1.naslTypes.MemberExpression({
+            object: new utils_1.naslTypes.Identifier({
+                namespace: 'app.enums',
+                name: callee?.[2]?.name,
+            }),
+            property: new utils_1.naslTypes.Identifier({
+                name: String(name),
+            }),
+        });
+    }
+    if (calleeName?.includes('nasl.auth.')) {
+        return new utils_1.naslTypes.MemberExpression({
+            object: new utils_1.naslTypes.Identifier({
+                namespace: 'nasl.auth',
+                name: callee?.[2]?.name,
+            }),
+            property: new utils_1.naslTypes.Identifier({
+                name: callee?.[3]?.name,
+            }),
+        });
+    }
+    const regex = /^(app\..+?)\.variables\.(.+)$/;
+    if (regex.test(calleeName)) {
+        const [, namespace, variableName] = calleeName.match(regex);
+        return new utils_1.naslTypes.Identifier({
+            name: String(variableName),
+            namespace: `${namespace}.variables`
+        });
+    }
+    if (node.property.type === 'NumericLiteral') {
+        return new utils_1.naslTypes.CallFunction({
+            calleeNamespace: 'nasl.util',
+            calleeName: 'Get',
+            arguments: [
+                new utils_1.naslTypes.Argument({
+                    expression: transform2LogicItem(node.object, options),
+                }),
+                new utils_1.naslTypes.Argument({
+                    expression: transform2LogicItem(node.property, options),
+                }),
+            ],
+        });
+    }
+    return new utils_1.naslTypes.MemberExpression({
+        object: transform2LogicItem(node.object, options),
+        property: transform2LogicItem(node.property, options),
+    });
+}
+function transformCallCall2Match(node, options) {
+    // (function match() {})(...) 的情况
+    return undefined;
+}
+function transformCall2CallViewElementLogic(node, calleeNmae, callee, options) {
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: `elements.${callee[1].name}.logics`,
+        calleeName: callee[2].name,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2CallEntityLogic(node, calleeName, callee, options) {
+    const entityName = callee[0].name.replace(/Entity/, '');
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
+        calleeName: callee[1].name,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
+    if (calleeName?.includes('.entities.')) {
+        const calleeNamespace = (0, utils_1.generate)(node?.callee?.object?.object)?.code;
+        const entityName = node?.callee?.object?.property?.name?.replace(/Entity/, '');
+        return new utils_1.naslTypes.CallLogic({
+            calleeNamespace: `${calleeNamespace}.${entityName}.logics`,
+            calleeName: node?.callee?.property?.name,
+            arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+                expression: fixExpression(arg, options),
+            })),
+        });
+    }
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: (0, utils_1.generate)(node.callee.object).code,
+        calleeName: callee[callee.length - 1].name,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2OQLQuery(node, calleeName, callee, options) {
+    if (!options.isPageLogic) {
+        // const _typeAnnotation = node?.typeParameters?.params?.length > 0 ? naslTypes.TypeAnnotation.createGeneric('List', {
+        //   typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType })),
+        // }) : null;
+        let code = (0, utils_1.generate)(node.arguments[0]).code.trim().slice(1, -1);
+        code = code?.replace(/app\.enums\.(\w+)\[(\d+)\]/g, "app.enums.$1.$2").replace(/app\.enums\.(\w+)\['(\w+)'\]/g, "app.enums.$1.$2");
+        return new utils_1.naslTypes.OqlQueryComponent({
+            dataSource: 'app.dataSources.defaultDS',
+            code,
+            typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.typeAnnotations)
+        });
+    }
+}
+function transformCall2ConsoleLog(node, calleeName, callee, options) {
+    if (options.isPageLogic) {
+        return new utils_1.naslTypes.CallLogic({
+            calleeNamespace: 'nasl.util',
+            calleeName: 'consoleLog',
+            shortcut: true,
+            arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+                expression: fixExpression(arg, options),
+            })),
+        });
+    }
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: 'nasl.logging',
+        calleeName: 'INFO',
+        shortcut: true,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2Logging(node, calleeName, callee, options) {
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: 'nasl.logging',
+        calleeName: callee[2].name,
+        shortcut: true,
+        arguments: node.arguments.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2JSONFunctions(node, calleeName, callee, options) {
+    const curCalleeName = node.callee.property.name;
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: 'nasl.util',
+        calleeName: curCalleeName,
+        shortcut: true,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType })),
+    });
+}
+function transformCall2CallFunction(node, calleeName, callee, options) {
+    let curCalleeName;
+    if (callee.length === 3)
+        curCalleeName = callee[callee.length - 1].name;
+    else {
+        let _callee = callee[0].callee;
+        while (_callee.type === 'CallExpression')
+            _callee = _callee.callee;
+        curCalleeName = _callee.property.name;
+    }
+    const argument = callee.length === 3 ? node.arguments : callee[0].arguments;
+    if (['plus', 'minus', 'multiply', 'divide', 'remainder', 'STARTWITH', 'ENDWITH', 'LIKE', 'IN'].includes(curCalleeName)) {
+        return transformCallExpressionToBinaryExpression(node, curCalleeName, callee, options);
+    }
+    ;
+    if (['NewList', 'NewMap', 'NewEntity', 'NewStructure', 'NewAnonymousStructure'].includes(curCalleeName)) {
+        return transform2NewExpression(curCalleeName, node, options);
+    }
+    // let typeNamespace: string;
+    // if (argument?.[argument.length - 1]?.type === 'ObjectExpression') {
+    // typeNamespace = argument.splice(-1)[0].properties[0].value.value;
+    // }
+    const nodeElement = new utils_1.naslTypes.CallFunction({
+        calleeNamespace: 'nasl.util',
+        calleeName: curCalleeName,
+        arguments: argument.map((arg, index) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+            keyword: `str${index + 1}`,
+        })),
+        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+        // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
+    });
+    return nodeElement;
+}
+function transform2UIFunction(node, calleeName, callee, options) {
+    if (callee[2].name === 'destination') {
+        const namespace = node.arguments[0].value;
+        const nsArr = namespace.split('.').map((item) => item.replace(/_view$/, ''));
+        const pageType = nsArr.shift();
+        const viewName = nsArr.pop();
+        const newArguments = node?.arguments?.slice(1);
+        let argument = [];
+        if (newArguments?.[0]?.type === 'ObjectExpression') {
+            argument = newArguments?.[0]?.properties?.map((property) => new utils_1.naslTypes.Argument({
+                keyword: property?.key?.name,
+                expression: fixExpression(property?.value, options),
+            }));
+        }
+        else {
+            argument = node.arguments.slice(1).map((arg) => new utils_1.naslTypes.Argument({
+                expression: fixExpression(arg, options),
+            }));
+        }
+        return new utils_1.naslTypes.Destination({
+            viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((item) => `.${item}.views`)?.join('')}`,
+            viewName,
+            arguments: argument,
+        });
+    }
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: 'nasl.ui',
+        calleeName: callee[2].name,
+        shortcut: true,
+        /**
+         * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
+         * @param node
+         * @returns
+         */
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformMap2ListTransform(node, calleeName, callee, options) {
+    return new utils_1.naslTypes.CallFunction({
+        calleeNamespace: 'nasl.util',
+        calleeName: 'ListTransform',
+        arguments: [new utils_1.naslTypes.Argument({
+                expression: fixExpression(node.callee.object, options),
+            }), ...node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+                expression: fixExpression(arg, options),
+            }))],
+    });
+}
+function transform2ForEachStatement(node, calleeName, callee, options) {
+    const newCallee = node.arguments;
+    const arrowFunction = node.arguments[3];
+    const nodeElement = new utils_1.naslTypes.ForEachStatement({
+        each: transform2LogicItem(newCallee[0], options),
+        start: transform2LogicItem(newCallee[1], options),
+        end: transform2LogicItem(newCallee[2], options),
+        item: transform2Param(arrowFunction.params[0]),
+        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
+            name: 'index', typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
+        }),
+        body: arrowFunction.body.body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+    });
+    return nodeElement;
+}
+function transformForEach2ForEachStatement(node, calleeName, callee, options) {
+    const newCallee = node.callee.object;
+    const arrowFunction = node.arguments[0];
+    const nodeElement = new utils_1.naslTypes.ForEachStatement({
+        each: transform2LogicItem(newCallee.callee.object, options),
+        start: transform2LogicItem(newCallee?.arguments?.[0], options),
+        end: transform2LogicItem(newCallee?.arguments?.[1], options),
+        item: transform2Param(arrowFunction.params[0]),
+        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
+            name: 'index', typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
+        }),
+        body: arrowFunction.body.body.map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+    });
+    return nodeElement;
+}
+function transformAlert2ShowMessage(node, calleeName, callee, options) {
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: 'nasl.ui',
+        calleeName: 'showMessage',
+        shortcut: true,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2Interface(node, calleeName, callee, options) {
+    return new utils_1.naslTypes.CallInterface({
+        calleeNamespace: (0, utils_1.generate)(node.callee.object).code,
+        calleeName: callee[callee.length - 1].name,
+        arguments: node?.arguments?.map((arg) => arg?.properties?.map((item) => new utils_1.naslTypes.Argument({
+            keyword: item?.key?.name,
+            expression: fixExpression(item?.value, options),
+        })) || []).flat() || [],
+    });
+}
+function transformCall2Connector(node, calleeName, callee, options) {
+    let flatCalleeKey = (0, utils_1.generate)(node?.callee)?.code;
+    if (flatCalleeKey?.startsWith('connector.')) {
+        flatCalleeKey = flatCalleeKey?.replace('connector.', '');
+    }
+    const [, calleeConnectionName, calleeNamespace, calleeFunName] = flatCalleeKey?.match(/^(\w+)\.([\w.]+)\.(\w+)$/);
+    return new utils_1.naslTypes.CallConnector({
+        calleeConnectionName,
+        calleeNamespace,
+        calleeName: calleeFunName,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2Extension(node, calleeName, callee, options) {
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: (0, utils_1.generate)(node?.callee?.object)?.code,
+        calleeName: callee?.[callee?.length - 1]?.name,
+        handleError: true,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformArrowFunction2Match(node, calleeName, callee, options) {
+    // NOTE: 适用于 if else
+    const newCallee = node.callee.body.body;
+    if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFuntion') {
+        const match = new utils_1.naslTypes.Match({
+            expression: fixExpression(newCallee[0], options),
+            isExpression: false,
+            cases: flatIfStatement(newCallee[1].body.body[0]).map((_case) => new utils_1.naslTypes.MatchCase({
+                patterns: !_case.test ? [] : flatMatchPatternsExpression(transform2LogicItem(_case.test, options)),
+                body: _case.consequent.body.filter((item) => item.type !== 'BreakStatement').map((item) => transform2LogicItem(item, options)).filter((item) => !!item),
+            })),
+        });
+        if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
+            match.cases.push(new utils_1.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 utils_1.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 = transform2LogicItem(newCallee[0].body.body[0], options);
+        return switchStatement;
+    }
+    (0, utils_1.throwError)(`Unhandled ArrowFunctionExpression node ${node.type}`);
+}
+function transformCall2CallViewLogic(node, calleeName, callee, options) {
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: '',
+        calleeName: calleeName.slice('viewLogic_'.length),
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2Logic(node, calleeName, callee, options) {
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: ``,
+        calleeName,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2LogicWithAuth(node, calleeName, callee, options) {
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: `nasl.auth`,
+        calleeName: callee[callee.length - 1].name,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+function transformCall2Paginate(node, calleeName, callee, options) {
+    const newCallee = node.arguments || [];
+    return new utils_1.naslTypes.Paginate({
+        list: newCallee[0] && transform2LogicItem(newCallee[0], options),
+        page: newCallee[1] && transform2LogicItem(newCallee[1], options),
+        size: newCallee[2] && transform2LogicItem(newCallee[2], options),
+    });
+}
+function flatCallQueryComponentChainNode(node) {
+    if (node.callee.type === 'Identifier') {
+        const calleeName = node.callee.name;
+        if (['FROM', 'INNER_JOIN', 'LEFT_JOIN', 'RIGHT_JOIN', 'OUTER_JOIN'].includes(calleeName)) {
+            if (node.arguments[1].type !== 'ArrowFunctionExpression')
+                (0, utils_1.throwError)('FROM should have a ArrowFunctionExpression as the second argument');
+            const arrowFunctionExpression = node.arguments[1];
+            if (arrowFunctionExpression.body.type !== 'CallExpression')
+                (0, utils_1.throwError)('FROM should have a CallExpression as the body of ArrowFunctionExpression');
+            const body = arrowFunctionExpression.body;
+            const callExpressions = flatChainCallExpression(body);
+            const result = [{
+                    calleeName: calleeName,
+                    arguments: [node.arguments[0], arrowFunctionExpression.params[0], undefined],
+                }];
+            callExpressions.forEach((item) => {
+                if (item.callee.type === 'Identifier')
+                    if (item.callee.name === 'ON') {
+                        result[0].arguments[2] = item.arguments[0];
+                    }
+                    else if (['INNER_JOIN', 'LEFT_JOIN', 'RIGHT_JOIN', 'OUTER_JOIN'].includes(item.callee.name)) {
+                        result.push(...flatCallQueryComponentChainNode(item));
+                    }
+                    else {
+                        result.push({
+                            calleeName: item.callee.name,
+                            arguments: item.arguments,
+                        });
+                    }
+            });
+            return result;
+        }
+    }
+    return [];
+}
+function transformMemberExpression2Entity(node, node2) {
+    const entityPath = flatMemberExpression(node);
+    const entityNamespace = entityPath.slice(0, -1).map(n => n.name).join('.');
+    const entityName = entityPath[entityPath.length - 1].name.replace(/Entity/, '');
+    const asName = node2.name === entityName ? undefined : node2.name;
+    return { entityNamespace, entityName, asName };
+}
+function transformCall2DataQuery(node, calleeName, callee, options) {
+    const flatted = flatCallQueryComponentChainNode(node);
+    let from;
+    let where;
+    let having;
+    let groupBy = [];
+    let orderBy = [];
+    let select;
+    const entityAsNames = [];
+    let entity;
+    // 这里只是一个示例，具体的逻辑需要根据flatted的内容来构建
+    flatted.forEach((item) => {
+        // console.log(item.calleeName)
+        switch (item.calleeName) {
+            case 'FROM':
+                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
+                entityAsNames.push(entity.asName || entity.entityName);
+                from = new utils_1.naslTypes.QueryFromExpression({
+                    ...entity,
+                    joinParts: [],
+                });
+                break;
+            case 'INNER_JOIN':
+            case 'LEFT_JOIN':
+            case 'RIGHT_JOIN':
+            case 'OUTER_JOIN':
+                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
+                entityAsNames.push(entity.asName || entity.entityName);
+                const rawJoinType = item.calleeName.slice(0, -5);
+                const joinType = rawJoinType === 'OUTER' ? 'FULL' : rawJoinType;
+                from.joinParts.push(new utils_1.naslTypes.QueryJoinExpression({
+                    ...entity,
+                    joinType,
+                    onExpressions: [transform2BinaryExpression(item.arguments[2], { ...options, entityAsNames })], // toArray
+                }));
+                break;
+            case 'WHERE':
+                where = transform2LogicItem(item.arguments[0], { ...options, entityAsNames });
+                break;
+            case 'HAVING':
+                having = transform2LogicItem(item.arguments[0], { ...options, entityAsNames });
+                break;
+            case 'GROUP_BY':
+                groupBy = item.arguments.map((arg) => new utils_1.naslTypes.QueryGroupByExpression({
+                    groupElement: transform2LogicItem(arg, { ...options, entityAsNames }),
+                }));
+                break;
+            case 'ORDER_BY':
+                orderBy = item.arguments.map((arg) => new utils_1.naslTypes.QueryOrderByExpression({
+                    orderElement: transform2LogicItem(arg.elements[0], { ...options, entityAsNames }),
+                    order: transform2LogicItem(arg.elements[1], { ...options, entityAsNames })
+                }));
+                break;
+            case 'SELECT':
+                select = new utils_1.naslTypes.QuerySelectExpression({
+                    distinct: false,
+                    star: true,
+                    selectElements: [],
+                });
+                const asNames = [];
+                item.arguments[0].properties.forEach((arg) => {
+                    const selectElement = arg.value.type === 'CallExpression' ? transform2QueryAggregateExpression(arg, { ...options, entityAsNames }) : transform2SelectQueryFieldExpression(arg, { ...options, entityAsNames });
+                    asNames.push(arg.key.name);
+                    if (selectElement.concept === 'QueryFieldExpression') {
+                        const groupByExpression = groupBy.find((groupByExpression) => selectElement.propertyName === groupByExpression.groupElement.propertyName);
+                        if (groupByExpression) {
+                            groupByExpression.groupElement.asName = selectElement.asName;
+                            return;
+                        }
+                    }
+                    select.selectElements.push(selectElement);
+                });
+                orderBy.forEach((orderByExpression) => {
+                    const oe = orderByExpression.orderElement;
+                    if (asNames.includes(oe.name)) {
+                        oe.namespace = 'inner';
+                    }
+                });
+                break;
+        }
+    });
+    // 构建并返回 naslTypes.CallQueryComponent 实例
+    const callQueryComponent = new utils_1.naslTypes.CallQueryComponent({
+        select: select || null,
+        from: from || null,
+        where: where || null,
+        groupBy,
+        having: having || null,
+        orderBy,
+        ideVersion: '2.22',
+    });
+    // callQueryComponent.typeAnnotation = callQueryComponent.computeStructure();
+    return callQueryComponent;
+}
+function transform2LogicItem(node, options) {
+    fixLogicNode(node);
+    const transformManager = new TransformManager();
+    transformManager.register('VariableDeclaration', transform2VariableAndAddAssignment);
+    transformManager.register('IfStatement', transform2IfStatement);
+    transformManager.register('WhileStatement', transform2WhileStatement);
+    transformManager.register('SwitchStatement', transformSwitchStatement2Match);
+    transformManager.register('Identifier', transformIdentifier);
+    transformManager.register('ExpressionStatement', (node, options) => transform2LogicItem(node.expression, options));
+    transformManager.register('AssignmentExpression', transform2Assignment);
+    transformManager.register('ArrowFunctionExpression', transform2AnonymousFunction);
+    transformManager.register('BooleanLiteral', transform2BooleanLiteral);
+    transformManager.register('StringLiteral', transform2StringLiteral);
+    transformManager.register('NumericLiteral', transform2NumericLiteral);
+    transformManager.register('NullLiteral', transform2NullLiteral);
+    transformManager.register('TemplateLiteral', transform2StringInterpolation);
+    transformManager.register('BinaryExpression', transform2BinaryExpression);
+    transformManager.register('LogicalExpression', transform2BinaryExpression);
+    transformManager.register('UpdateExpression', transformUpdateExpression2Assignment);
+    transformManager.register('ReturnStatement', transformReturnStatement2AssignmentOrEnd);
+    transformManager.register('EmptyStatement', transform2Comment);
+    transformManager.register('BlockStatement', transformBlockStatement);
+    transformManager.register('ObjectExpression', transform2NewComposite);
+    transformManager.register('NewExpression', transformNewExpression);
+    transformManager.register((node) => node.type === 'UnaryExpression' && ['!'].includes(node.operator), (node, options) => {
+        return new utils_1.naslTypes.UnaryExpression({
+            operator: node.operator,
+            argument: transform2LogicItem(node.argument, options),
+        });
+    });
+    transformManager.register((node) => node.type === 'UnaryExpression' && ['-'].includes(node.operator) && node.argument.type === 'NumericLiteral', (node, options) => {
+        return transform2NumericLiteral({
+            type: 'NumericLiteral',
+            value: -node.argument.value,
+        }, options);
+    });
+    transformManager.register('MemberExpression', transformMemberExpression);
+    transformManager.register((node) => node.type === 'CallExpression' && node.callee.type === 'CallExpression', transformCallCall2Match);
+    transformManager.registerCallExpression((node, calleeName) => /^\$refs\./.test(calleeName), transformCall2CallViewElementLogic);
+    transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 2 && callee[0].type === 'Identifier' && callee[0].name.endsWith('Entity'), transformCall2CallEntityLogic);
+    transformManager.registerCallExpression('nasl.oql.query', transformCall2OQLQuery);
+    transformManager.registerCallExpression('nasl.util.consoleLog', transformCall2ConsoleLog);
+    transformManager.registerCallExpression('console.log', transformCall2ConsoleLog);
+    transformManager.registerCallExpression((node, calleeName) => calleeName.startsWith('nasl.logging.'), transformCall2Logging);
+    transformManager.registerCallExpression('nasl.util.jsonSerialize', transformCall2JSONFunctions);
+    transformManager.registerCallExpression('nasl.util.jsonDeserialize', transformCall2JSONFunctions);
+    transformManager.registerCallExpression((node, calleeName) => calleeName.startsWith('nasl.util.'), transformCall2CallFunction);
+    transformManager.registerCallExpression((node, calleeName) => calleeName.startsWith('nasl.auth.'), transformCall2LogicWithAuth);
+    transformManager.registerCallExpression((node, calleeName) => calleeName.startsWith('nasl.ui.'), transform2UIFunction);
+    transformManager.registerCallExpression((node, calleeName) => calleeName.endsWith('.map'), transformMap2ListTransform);
+    transformManager.registerCallExpression('ForEach', transform2ForEachStatement);
+    transformManager.registerCallExpression((node, calleeName) => calleeName.endsWith('.forEach'), transformForEach2ForEachStatement);
+    transformManager.registerCallExpression('alert', transformAlert2ShowMessage);
+    transformManager.registerCallExpression((node, calleeName) => /^app.dataSources|app.logics/.test(calleeName), transformCall2CallDataSourceLogic);
+    transformManager.registerCallExpression((node, calleeName) => /interfaces\./.test(calleeName), transformCall2Interface);
+    transformManager.registerCallExpression((node, calleeName) => /connectors\./.test(calleeName), transformCall2Connector);
+    transformManager.registerCallExpression((node, calleeName) => /extensions\./.test(calleeName), transformCall2Extension);
+    transformManager.registerCallExpression((node) => node.callee.type === 'ArrowFunctionExpression', transformArrowFunction2Match);
+    transformManager.registerCallExpression((node, calleeName) => ['plus', 'minus', 'multiply', 'divide', 'remainder', 'STARTWITH', 'ENDWITH', 'LIKE', 'IN'].includes(calleeName), transformCallExpressionToBinaryExpression);
+    transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1 && calleeName.startsWith('viewLogic_'), transformCall2CallViewLogic);
+    transformManager.registerCallExpression('PAGINATE', transformCall2Paginate);
+    transformManager.registerCallExpression('FROM', transformCall2DataQuery);
+    transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1, transformCall2Logic);
+    return transformManager.apply(node, options);
+}
+exports.transform2LogicItem = transform2LogicItem;
+//# sourceMappingURL=transform2LogicItem.js.map