@lcap/nasl 4.1.0-beta.9 → 4.1.0-creator.10

package/out/natural/transforms/transform2LogicItem.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCall2Extension = exports.transformCall2Connector = exports.transformCall2Interface = exports.transformAlert2ShowMessage = exports.transformForEach2ForEachStatement = exports.transformForOf2ForEachStatement = exports.transform2ForEachStatement = exports.transformMap2ListTransform = exports.transform2UIFunction = exports.transformCall2CallFunction = exports.transform2CallFunction = exports.transformCall2JSONFunctions = exports.transformCall2Logging = exports.transformCall2ConsoleLog = exports.transformCall2CallDataSourceLogic = exports.transformCall2CallEntityLogic = exports.transformCall2CallViewElementLogic = exports.transformCallCall2Match = exports.transformMemberExpression = exports.transformNewExpression = exports.transform2PartialNewComposite = exports.transform2Comment = exports.transform2StringInterpolation = exports.transformReturnStatement2AssignmentOrEnd = exports.transform2NullLiteral = exports.transform2NumericLiteral = exports.transform2DirectiveLiteral = exports.transform2StringLiteral = exports.transform2BooleanLiteral = exports.transformUpdateExpression2Assignment = exports.transform2Assignment = exports.transform2AnonymousFunction = exports.transformIdentifier = exports.transformSwitchStatement2Match = exports.transform2WhileStatement = exports.transform2Break = exports.transform2Continue = exports.transform2IfStatement = exports.transform2BinaryExpression = exports.transform2VariadicExpression = exports.transformCallExpressionToBinaryExpression = exports.transform2Param = exports.fixLogicNode = exports.flatIfStatement = exports.flatMatchPatternsExpression = exports.getSelectMembers = exports.unflatMemberExpression = exports.flatMemberExpression = exports.fixExpression = exports.TransformManager = void 0;
-exports.transform2LogicItem = exports.transformCall2Paginate = exports.transformCall2LogicWithAuth = exports.transformCall2Logic = exports.transformCall2CallViewLogic = exports.transformArrowFunction2Match = void 0;
+exports.transformCall2Interface = exports.transformAlert2ShowMessage = exports.transformForEach2ForEachStatement = exports.transformForOf2ForEachStatement = exports.transform2ForEachStatement = exports.transformMap2ListTransform = exports.transform2UIFunction = exports.transformCall2CallFunction = exports.transform2CallFunction = exports.transform2CallOtherNASLLogic = exports.transform2CallEventLogic = exports.transformCall2JSONFunctions = exports.transformCall2Logging = exports.transformCall2ConsoleLog = exports.transformCall2CallDataSourceLogic = exports.transformCall2CallEntityLogic = exports.transformCall2CallViewElementLogic = exports.transformCallFunctionExpression2Match = exports.transformMemberExpression = exports.transformNewExpression = exports.transform2PartialNewComposite = exports.transform2Comment = exports.transform2StringInterpolation = exports.transformReturnStatement2AssignmentOrEnd = exports.transform2NullLiteral = exports.transform2NumericLiteral = exports.transform2DirectiveLiteral = exports.transform2StringLiteral = exports.transform2BooleanLiteral = exports.transformUpdateExpression2Assignment = exports.transform2Assignment = exports.transform2AnonymousFunction = exports.transformIdentifier = exports.transformSwitchStatement2Match = exports.transform2WhileStatement = exports.transform2Break = exports.transform2Continue = exports.transform2IfStatement = exports.transform2BinaryExpression = exports.transform2VariadicExpression = exports.transformCallExpressionToBinaryExpression = exports.transform2Param = exports.fixLogicNode = exports.flatIfStatementForMatch = exports.flatMatchPatternsExpression = exports.getSelectMembers = exports.unflatMemberExpression = exports.flatMemberExpression = exports.fixExpression = exports.TransformManager = void 0;
+exports.transform2LogicItem = exports.transformCall2Paginate = exports.transformCall2LogicWithAuth = exports.transformCall2Logic = exports.transformCall2CallViewLogic = exports.transformCall2Extension = exports.transformCall2Connector = void 0;
 const utils_1 = require("./utils");
 const transform2TypeAnnotation_1 = require("./transform2TypeAnnotation");
 const utils_2 = require("../../utils");
@@ -24,7 +24,7 @@ class TransformManager {
     apply(node, options) {
         if (node.type === 'CallExpression') {
             if (node.callee.type === 'CallExpression')
-                (0, utils_1.throwError)(`不支持连续调用！`);
+                return (0, utils_1.throwError)(options?.parsingId, '不支持连续调用！', node.callee);
             const callee = flatMemberExpression(node.callee);
             if (callee[0]
                 && callee[0].type === 'CallExpression'
@@ -36,9 +36,8 @@ class TransformManager {
             }
             else {
                 for (const calleeItem of callee) {
-                    if (calleeItem.type !== 'Identifier') {
-                        const calleeName = (0, utils_1.generate)(node.callee).code;
-                        (0, utils_1.throwError)(`不支持连续调用！${calleeName}`);
+                    if (calleeItem.type !== 'Identifier' && !(calleeItem.type === 'FunctionExpression' && calleeItem.id?.name === 'match')) {
+                        return (0, utils_1.throwError)(options?.parsingId, '不支持连续调用！', node.callee);
                     }
                 }
             }
@@ -48,7 +47,7 @@ class TransformManager {
                     return transform(node, calleeName, callee, options);
                 }
             }
-            (0, utils_1.throwError)(`Unhandled node ${callee.map((item) => item.name).join('.')} ${node.type}`);
+            return (0, utils_1.throwError)(options?.parsingId, `不支持的节点类型 ${callee.map((item) => item.name).join('.')}`, node.type, node);
         }
         else {
             for (const [type, transform] of this.transforms) {
@@ -56,7 +55,7 @@ class TransformManager {
                     return transform(node, options);
                 }
             }
-            (0, utils_1.throwError)(`Unhandled node ${node.type}`);
+            return (0, utils_1.throwError)(options?.parsingId, '不支持的节点类型', node.type, node);
         }
     }
 }
@@ -78,7 +77,10 @@ function transformTSCode2SubLogic(node, options) {
         statements = [...node?.body?.directives, ...node?.body?.body];
     }
     parameters.forEach((node) => {
-        const param = transform2Param(node);
+        const param = transform2Param(node, options);
+        if (param && !param?.typeAnnotation) {
+            param.typeAnnotation = null;
+        }
         param && logic.addParam(param);
     });
     const newStatements = [];
@@ -122,9 +124,9 @@ function transformTSCode2SubLogic(node, options) {
     }
     return logic;
 }
-function assertAssignmentRightIsNotAnonymousFunction(expression) {
+function assertAssignmentRightIsNotAnonymousFunction(expression, options) {
     if (expression?.concept === 'AnonymousFunction')
-        (0, utils_1.throwError)('Anonymous function is not allowed in assignment');
+        return (0, utils_1.throwError)(options?.parsingId, 'Anonymous function is not allowed in assignment');
     return expression;
 }
 function fixExpression(arg, options, supportSubLogic = false) {
@@ -232,16 +234,29 @@ function flatMatchPatternsExpression(node) {
         }
         return [node];
     }
+    else if (node.concept === 'VariadicExpression') {
+        if (node.operator === '||') {
+            return node.expressions
+                ?.filter((item) => item?.concept === 'BinaryExpression' && item?.right?.concept === 'StringLiteral')
+                ?.map((item) => new utils_1.naslTypes.StringLiteral({ value: item?.right?.value })) || [node];
+        }
+        return [node];
+    }
     return [node];
 }
 exports.flatMatchPatternsExpression = flatMatchPatternsExpression;
-function flatIfStatement(node) {
+function flatIfStatementForMatch(node) {
     if (node.alternate.type === 'IfStatement') {
-        return [...flatIfStatement(node.alternate), node];
+        return [node, ...flatIfStatementForMatch(node.alternate)];
     }
-    return [node];
+    return [node, {
+            type: 'IfStatement',
+            test: null,
+            consequent: node.alternate,
+            alternate: node.alternate,
+        }];
 }
-exports.flatIfStatement = flatIfStatement;
+exports.flatIfStatementForMatch = flatIfStatementForMatch;
 /**
  * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
  * @param node
@@ -257,7 +272,7 @@ function fixLogicNode(node) {
     }
 }
 exports.fixLogicNode = fixLogicNode;
-function transform2Param(node) {
+function transform2Param(node, options) {
     const exclude = ['event'];
     if (node.type === 'ObjectProperty') {
         const typeAnnotation = node?.value?.name ? utils_1.naslTypes.TypeAnnotation.createPrimitive((node?.value).name) : null;
@@ -269,7 +284,7 @@ function transform2Param(node) {
             name,
             typeAnnotation,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
+                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -281,9 +296,9 @@ function transform2Param(node) {
         let defaultValueExpression = node.optional ? { type: 'NullLiteral' } : undefined;
         return new utils_1.naslTypes.Param({
             name,
-            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
+            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
+                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -296,9 +311,9 @@ function transform2Param(node) {
         return new utils_1.naslTypes.Param({
             name,
             required: !node.optional,
-            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
+            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
+                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -319,14 +334,14 @@ function transform2Param(node) {
             return null;
         return new utils_1.naslTypes.Param({
             name,
-            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
+            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
+                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
     else {
-        (0, utils_1.throwError)(`Unhandled node ${node}`);
+        return (0, utils_1.throwError)(options?.parsingId, '在输入参数中不支持节点类型', node);
     }
 }
 exports.transform2Param = transform2Param;
@@ -345,6 +360,16 @@ function transformCallExpressionToBinaryExpression(node, calleeName, callee, opt
         IN: 'in',
         IS_NULL: 'isNull',
     };
+    const limitMap = ['STARTS_WITH', 'ENDS_WITH', 'LIKE', 'IN', 'IS_NULL'];
+    if (limitMap.includes(calleeName) && options.transformType === 'logic' && !options.inCallQueryComponentField) {
+        return (0, utils_1.throwError)(options?.parsingId, `${calleeName} 仅支持在数据查询中使用`, node);
+    }
+    if (calleeName === 'IS_NULL') {
+        return new utils_1.naslTypes.UnaryExpression({
+            operator: 'isNull',
+            argument: transformNodeFunction(argument?.[0], options),
+        });
+    }
     return new utils_1.naslTypes.BinaryExpression({
         operator: map[calleeName],
         left: transformNodeFunction(argument?.[0], options),
@@ -424,11 +449,21 @@ function transform2BinaryExpression(node, options) {
             right: transformNodeFunction(node.right, options),
         });
     }
-    (0, utils_1.throwError)(`Unhandled node ${node.type}`);
+    return (0, utils_1.throwError)(options?.parsingId, '在二元表达式中不支持节点类型', node.type, node);
 }
 exports.transform2BinaryExpression = transform2BinaryExpression;
+function transformDefaultExpression(node, options) {
+    const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
+    return transformNodeFunction(node.left, options);
+}
 function transformConditionalExpression(node, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
+    if (options?.inCallQueryComponentField) {
+        const expr = (0, utils_1.generate)(node.test)?.code;
+        const then_expr = (0, utils_1.generate)(node.consequent)?.code;
+        const else_expr = (0, utils_1.generate)(node.alternate)?.code;
+        return (0, utils_1.throwError)(options?.parsingId, `数据查询中不支持条件表达式！${(0, utils_1.generate)(node)?.code}, 请使用 SQL函数 IF(${expr} == null, ${then_expr}, ${else_expr})`);
+    }
     const test = transformNodeFunction(node.test, options);
     const consequent = transformNodeFunction(node.consequent, options);
     const alternate = transformNodeFunction(node.alternate, options);
@@ -451,12 +486,12 @@ function transformConditionalExpression(node, options) {
         cases: [
             new utils_1.naslTypes.MatchCase({
                 patterns: [new utils_1.naslTypes.BooleanLiteral({ value: 'true' })],
-                body: [consequent],
+                body: consequent ? [consequent] : [],
                 isMatchedTypeEnumable: true,
             }),
             new utils_1.naslTypes.MatchCase({
-                patterns: [alternate],
-                body: [alternate],
+                patterns: [],
+                body: alternate ? [alternate] : [],
             }),
         ],
     });
@@ -467,17 +502,34 @@ function transformArrayExpression(node, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     return new utils_1.naslTypes.NewList({
         typeAnnotation,
-        items: node?.elements?.map((arg) => transformNodeFunction(arg, { ...options, typeAnnotation: undefined })),
+        items: node?.elements?.map((arg) => transformNodeFunction(arg, { ...options, typeAnnotation: undefined })).filter(Boolean),
     });
 }
 function transform2NewAnonymousStructure(node, options) {
+    for (let i = 0; i < node.properties.length; i++) {
+        const item = node.properties[i];
+        const itemValue = item?.value;
+        if (itemValue.type === 'NullLiteral') {
+            const currentType = options?.typeAnnotation?.properties?.[i];
+            if (currentType?.typeAnnotation) {
+                item.naslType = currentType.typeAnnotation;
+            }
+            else {
+                return (0, utils_1.throwError)(options?.parsingId, '匿名数据结构的属性中, 不允许出现没有类型的 null 值，请使用 as 关键字来指定类型，如 { price: null as Decimal }', node);
+            }
+        }
+        else if (itemValue.type === 'TSAsExpression') {
+            const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(itemValue.typeAnnotation, options);
+            item.naslType = typeAnnotation;
+        }
+    }
     const newComposite = transform2PartialNewComposite(node, options);
     const newProperties = node.properties.filter((prop) => prop.type === 'ObjectProperty' && prop.value.type !== 'ConditionalExpression');
     const structureProperties = [];
     newProperties.forEach((arg, index) => {
         structureProperties.push(new utils_1.naslTypes.StructureProperty({
             name: arg.key.name,
-            typeAnnotation: null
+            typeAnnotation: arg.naslType || null,
         }));
     });
     newComposite.typeAnnotation = utils_1.naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties);
@@ -500,15 +552,15 @@ function transform2NewExpression(calleeName, node, options) {
         }
         else {
             typeAnnotation = utils_1.naslTypes.TypeAnnotation.createGeneric('List', {
-                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+                typeArguments: node?.typeParameters?.params.map((type) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(type, options)).filter(Boolean),
             });
         }
         if (node?.arguments && node?.arguments?.[0]?.type !== 'ArrayExpression') {
-            (0, utils_1.throwError)(`Not allowed code ${(0, utils_1.generate)(node).code} in NewList`);
+            return (0, utils_1.throwError)(options?.parsingId, 'NewList 中不允许出现非数组表达式', node);
         }
         return new utils_1.naslTypes.NewList({
             typeAnnotation: node?.typeParameters ? typeAnnotation : undefined,
-            items: node?.arguments?.[0]?.elements?.map((arg) => transformNodeFunction(arg, options)),
+            items: node?.arguments?.[0]?.elements?.map((arg) => transformNodeFunction(arg, options)).filter(Boolean),
         });
     }
     if (calleeName === 'NewMap') {
@@ -524,7 +576,7 @@ function transform2NewExpression(calleeName, node, options) {
         }
         else {
             typeAnnotation = utils_1.naslTypes.TypeAnnotation.createGeneric('Map', {
-                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+                typeArguments: node?.typeParameters?.params.map((type) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(type, options)).filter(Boolean),
             });
         }
         return new utils_1.naslTypes.NewMap({
@@ -537,13 +589,13 @@ function transform2NewExpression(calleeName, node, options) {
         const typeParam = node.typeParameters?.params[0];
         const typeNamespaceAndName = typeParam ? (0, utils_1.generate)(typeParam).code : '';
         if (!typeNamespaceAndName)
-            (0, utils_1.throwError)(`Not allowed empty namespace in NewEntity`);
+            return (0, utils_1.throwError)(options?.parsingId, 'NewEntity 中必须指定类型', node);
         return transform2NewStructure(typeNamespaceAndName, node.arguments[0], options);
     }
     if (calleeName === 'NewAnonymousStructure') {
         return transform2NewAnonymousStructure(node.arguments[0], options);
     }
-    (0, utils_1.throwError)(`Unhandled ArrowFunctionExpression node ${node.type}`);
+    return (0, utils_1.throwError)(options?.parsingId, '在新建表达式中不支持节点类型', node.type, node);
 }
 function pushElseIf(ifNode, switchStatement, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
@@ -608,7 +660,7 @@ function transform2ArrayPattern(decl, options) {
             if (options.transformType === 'logic') {
                 options.logic.variables.push(new utils_1.naslTypes.Variable({
                     name: element.name,
-                    typeAnnotation: varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation),
+                    typeAnnotation: varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation, options) || undefined,
                 }));
             }
         }
@@ -640,7 +692,7 @@ function transform2VariableAndAddAssignment(node, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     const declList = node?.declarations || [];
     let newNode;
-    declList?.forEach((decl) => {
+    declList.forEach((decl) => {
         const variableName = decl.id.name;
         const isArrayPattern = decl.id?.type === 'ArrayPattern';
         if (isArrayPattern && decl.init) {
@@ -651,7 +703,7 @@ function transform2VariableAndAddAssignment(node, options) {
         let typeAnnotation;
         if (options.transformType === 'logic' && ![...options.logic.variables, ...options.logic.returns].some((variable) => variable.name === variableName)) {
             const varTypeAnnotation = decl.id.typeAnnotation?.typeAnnotation;
-            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation);
+            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation, options) || undefined;
             options.logic.variables.push(new utils_1.naslTypes.Variable({
                 name: variableName,
                 typeAnnotation,
@@ -660,14 +712,14 @@ function transform2VariableAndAddAssignment(node, options) {
         if (decl.init) {
             const calleeName = (0, utils_1.generate)(decl?.init?.callee).code;
             const varTypeAnnotation = decl?.id?.typeAnnotation?.typeAnnotation;
-            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation);
+            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation, options) || undefined;
             if (calleeName === 'nasl.oql.query' && varTypeAnnotation) {
                 decl.init.typeAnnotations = varTypeAnnotation;
             }
             options.typeAnnotation = typeAnnotation;
             newNode = new utils_1.naslTypes.Assignment({
                 left: transformNodeFunction(decl.id, options),
-                right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(decl.init, { ...options, typeAnnotation })),
+                right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(decl.init, { ...options, typeAnnotation }), options) || undefined,
             });
         }
     });
@@ -777,6 +829,16 @@ function transformIdentifier(node, options) {
     if (placeholderMap.includes(node.name)) {
         return new utils_1.naslTypes.Identifier({});
     }
+    if (node.name === '$self') {
+        return new utils_1.naslTypes.MemberExpression({
+            object: new utils_1.naslTypes.Identifier({
+                name: 'elements',
+            }),
+            property: new utils_1.naslTypes.Identifier({
+                name: '$ce',
+            }),
+        });
+    }
     return new utils_1.naslTypes.Identifier({
         name: node.name,
     });
@@ -786,6 +848,10 @@ function transform2SelectQueryFieldExpression(node, options) {
     let expression = node.value;
     let asNameNode = node.key;
     if (expression.type === 'Identifier') {
+        const isSameName = (0, utils_2.firstUpperCase)(asNameNode.name) === expression.name;
+        if (!isSameName) {
+            return (0, utils_1.throwError)(options?.parsingId, `字段名需为 ${(0, utils_2.firstLowerCase)(expression.name)}, 目前为: ${asNameNode.name}, 相关代码如下`, node);
+        }
         return new utils_1.naslTypes.QueryFieldExpression({
             isDotStar: true,
             asName: (0, utils_2.firstUpperCase)(asNameNode.name) === expression.name ? undefined : asNameNode.name,
@@ -805,7 +871,7 @@ function transform2SelectQueryFieldExpression(node, options) {
         // @TODO
     }
     else {
-        (0, utils_1.throwError)(`Unsupported expression type: ${expression.type} for QueryFieldExpression`);
+        return (0, utils_1.throwError)(options?.parsingId, '在 QueryFieldExpression 不支持表达式类型', expression.type, expression);
     }
 }
 function transform2QueryAggregateExpression(node, options) {
@@ -814,10 +880,10 @@ function transform2QueryAggregateExpression(node, options) {
     const arg = callExpression.arguments[0];
     if (arg.type !== 'MemberExpression') {
         const code = (0, utils_1.generate)(arg).code;
-        (0, utils_1.throwError)(`聚合函数的输入只能是表字段(实体.属性)，但AVG(${code})中的${code}不是表字段`);
+        return (0, utils_1.throwError)(options?.parsingId, `聚合函数的输入只能是表字段(实体.属性)，但AVG(${code})中的${code}不是表字段`);
     }
     if (callExpression.arguments?.length > 1) {
-        (0, utils_1.throwError)(`聚合函数${callExpression.callee.name}只支持一个参数`);
+        return (0, utils_1.throwError)(options?.parsingId, `聚合函数${callExpression.callee.name}只支持一个参数`);
     }
     return new utils_1.naslTypes.QueryAggregateExpression({
         asName: asNameNode.name,
@@ -827,10 +893,10 @@ function transform2QueryAggregateExpression(node, options) {
 }
 function transform2AnonymousFunction(node, options) {
     if (node.body.type === 'BlockStatement')
-        (0, utils_1.throwError)('Anonymous function with block statement is not supported');
+        return (0, utils_1.throwError)(options?.parsingId, 'Anonymous function with block statement is not supported', node);
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     return new utils_1.naslTypes.AnonymousFunction({
-        params: node.params.map((param) => transform2Param(param)),
+        params: node.params.map((param) => transform2Param(param, options)).filter(Boolean),
         body: transformNodeFunction(node.body, options),
     });
 }
@@ -859,7 +925,7 @@ function transform2Assignment(node, options) {
     }
     return new utils_1.naslTypes.Assignment({
         left: transformNodeFunction(node.left, options),
-        right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(node.right, options)),
+        right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(node.right, options), options) || undefined,
     });
 }
 exports.transform2Assignment = transform2Assignment;
@@ -905,10 +971,11 @@ function transform2NumericLiteral(node, options) {
         typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Integer'),
     });
     literal.typeAnnotation.typeName = literal.changeType(value);
-    if (options.typeAnnotation && ['Integer', 'Long', 'Decimal'].includes(options.typeAnnotation.typeName)) {
-        literal.typeAnnotation = options.typeAnnotation;
-        delete options.typeAnnotation;
-    }
+    // 新版本依赖自转换
+    // if (options.typeAnnotation && ['Integer', 'Long', 'Decimal'].includes(options.typeAnnotation.typeName)) {
+    //   literal.typeAnnotation = options.typeAnnotation;
+    //   delete options.typeAnnotation;
+    // }
     return literal;
 }
 exports.transform2NumericLiteral = transform2NumericLiteral;
@@ -936,15 +1003,15 @@ function transformReturnStatement2AssignmentOrEnd(node, options) {
         }
     }
     if (!logic.returns.length) {
-        const typeAnnotation = node?.argument?.type === 'TSAsExpression' ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.argument?.typeAnnotation) : undefined;
+        const typeAnnotation = node?.argument?.type === 'TSAsExpression' ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.argument?.typeAnnotation, options) || undefined : undefined;
         logic.returns.push(new utils_1.naslTypes.Return({
             name: 'result',
             typeAnnotation
         }));
     }
     const leftName = logic.returns[0].name;
-    const right = assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(argument, options));
-    if (right.concept === 'Identifier' && right.name === leftName) {
+    const right = assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(argument, options), options) || undefined;
+    if (right && right.concept === 'Identifier' && right.name === leftName) {
         return new utils_1.naslTypes.End();
     }
     else {
@@ -994,7 +1061,7 @@ function transform2PartialNewComposite(node, options) {
     const rights = [];
     const structureProperties = [];
     const assignmentLines = [];
-    const newProperties = (node?.properties || node?.arguments?.[0]?.properties)?.filter((arg) => arg?.value?.type !== 'ConditionalExpression');
+    const newProperties = (node?.properties || node?.arguments?.[0]?.properties);
     let idx = 0;
     newProperties?.forEach((arg, index) => {
         properties.push(transformNodeFunction(arg.key, options));
@@ -1087,8 +1154,7 @@ function transformNewExpression(node, options) {
     else if (calleeName.includes('.entities.') || calleeName.includes('.structures.')) {
         return transform2NewStructure(calleeName, node.arguments[0], options);
     }
-    const errCode = (0, utils_1.generate)(node).code;
-    (0, utils_1.throwError)(`Unhandled node ${node.type}: ${errCode}`);
+    return (0, utils_1.throwError)(options?.parsingId, '在新建表达式中不支持节点类型', node.type, node);
 }
 exports.transformNewExpression = transformNewExpression;
 function transformMemberExpression(node, options) {
@@ -1125,18 +1191,31 @@ function transformMemberExpression(node, options) {
         });
     }
     if (calleeName?.startsWith('$refs.')) {
-        const componentName = callee?.[1]?.name;
-        const propertyName = callee?.[2]?.name;
-        return new utils_1.naslTypes.MemberExpression({
-            object: new utils_1.naslTypes.Identifier({
-                namespace: `elements.${componentName}.property`,
-                name: componentName,
-            }),
-            property: new utils_1.naslTypes.Identifier({
-                namespace: propertyName,
-                name: propertyName,
-            }),
-        });
+        if (callee[0].type === 'CallExpression') {
+            const callExpression = callee[0];
+            const callCallee = flatMemberExpression(callExpression.callee);
+            const callCalleeName = (0, utils_1.generate)(callExpression)?.code;
+            let callResult = transformCall2CallViewElementLogic(callExpression, callCalleeName, callCallee, options);
+            const remainingCallee = callee.slice(1);
+            if (remainingCallee.length > 0 && callResult) {
+                return unflatMemberExpression(remainingCallee, options, callResult);
+            }
+            return callResult;
+        }
+        else {
+            const componentName = callee?.[1]?.name;
+            const propertyName = callee?.[2]?.name;
+            return new utils_1.naslTypes.MemberExpression({
+                object: new utils_1.naslTypes.Identifier({
+                    namespace: `elements.${componentName}.property`,
+                    name: componentName,
+                }),
+                property: new utils_1.naslTypes.Identifier({
+                    namespace: propertyName,
+                    name: propertyName,
+                }),
+            });
+        }
     }
     const regex = /^(app\..+?)\.variables\.(.+)$/;
     if (regex.test(calleeName)) {
@@ -1191,12 +1270,88 @@ function transformMemberExpression(node, options) {
     });
 }
 exports.transformMemberExpression = transformMemberExpression;
-function transformCallCall2Match(node, options) {
-    // (function match() {})(...) 的情况
-    return undefined;
+/**
+ * @example (function match(_value) {
+   if (_value === true) {
+        return 'green'
+    } else {
+        return 'red'
+    }
+})(nasl.util.Convert<Boolean>(enabled))
+ */
+function transformCallFunctionExpression2Match(node, calleeName, callee, options) {
+    const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
+    const arg = node.arguments[0];
+    const ifStatement = node.callee.body.body[0];
+    if (ifStatement.type !== 'IfStatement') {
+        return (0, utils_1.throwError)(options?.parsingId, 'Match 函数体内必须是一个 if 语句', ifStatement);
+    }
+    const flatedIfStatements = flatIfStatementForMatch(ifStatement);
+    const match = new utils_1.naslTypes.Match({
+        expression: transformNodeFunction(arg, options),
+        isExpression: true,
+        cases: flatedIfStatements.map((_case) => {
+            let argument;
+            if (_case.consequent.type === 'BlockStatement') {
+                if (_case.consequent.body.length === 1 && _case.consequent.body[0].type === 'ReturnStatement') {
+                    argument = _case.consequent.body[0].argument;
+                }
+                else {
+                    return (0, utils_1.throwError)(options?.parsingId, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                }
+            }
+            else {
+                if (_case.consequent.type === 'ReturnStatement') {
+                    argument = _case.consequent.argument;
+                }
+                else {
+                    return (0, utils_1.throwError)(options?.parsingId, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                }
+            }
+            const bodyNode = transformNodeFunction(argument, options);
+            return new utils_1.naslTypes.MatchCase({
+                isMatchedTypeEnumable: false,
+                patterns: !_case.test ? [] : flatMatchPatternsExpression(transformNodeFunction(_case.test, options)),
+                body: bodyNode ? [bodyNode] : [],
+            });
+        }).filter(Boolean),
+    });
+    if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
+        match.cases.push(new utils_1.naslTypes.MatchCase({
+            isMatchedTypeEnumable: false,
+            patterns: [],
+            body: [],
+        }));
+    }
+    match.cases.forEach((case_) => {
+        if (case_.patterns.length) {
+            if (case_.patterns[0].concept === 'BooleanLiteral' || case_.patterns[0].concept === 'StringLiteral') {
+                case_.isMatchedTypeEnumable = true;
+            }
+            if (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;
 }
-exports.transformCallCall2Match = transformCallCall2Match;
+exports.transformCallFunctionExpression2Match = transformCallFunctionExpression2Match;
 function transformCall2CallViewElementLogic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     if (calleeName?.includes('getPropValue') || calleeName?.includes('setPropValue')) {
         const componentName = callee?.[1]?.name;
         const propertyName = node?.arguments?.[0]?.value;
@@ -1231,6 +1386,8 @@ function transformCall2CallViewElementLogic(node, calleeName, callee, options) {
 }
 exports.transformCall2CallViewElementLogic = transformCall2CallViewElementLogic;
 function transformCall2CallEntityLogic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     const entityName = callee[0].name.replace(/Entity$/, '');
     // console.log('callee', callee);
     return new utils_1.naslTypes.CallLogic({
@@ -1243,6 +1400,8 @@ function transformCall2CallEntityLogic(node, calleeName, callee, options) {
 }
 exports.transformCall2CallEntityLogic = transformCall2CallEntityLogic;
 function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     if (calleeName?.includes('.entities.')) {
         const calleeNamespace = (0, utils_1.generate)(node?.callee?.object?.object)?.code;
         const entityName = node?.callee?.object?.property?.name?.replace(/Entity$/, '');
@@ -1301,6 +1460,10 @@ function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
 }
 exports.transformCall2CallDataSourceLogic = transformCall2CallDataSourceLogic;
 function transformCall2OQLQuery(node, calleeName, callee, options) {
+    if (options?.isInFrontend)
+        return (0, utils_1.throwError)(options?.parsingId, 'OQL组件不支持在前端使用', node);
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, 'OQL组件不支持在组件或默认值表达式中使用', node);
     if (options.transformType === 'logic' && options?.logicType === 'global_logic') {
         // const _typeAnnotation = node?.typeParameters?.params?.length > 0 ? naslTypes.TypeAnnotation.createGeneric('List', {
         //   typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType })),
@@ -1310,11 +1473,13 @@ function transformCall2OQLQuery(node, calleeName, callee, options) {
         return new utils_1.naslTypes.OqlQueryComponent({
             dataSource: 'app.dataSources.defaultDS',
             code,
-            typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.typeAnnotations)
+            typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.typeAnnotations, options) || undefined,
         });
     }
 }
 function transformCall2ConsoleLog(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.logging',
         calleeName: 'INFO',
@@ -1326,6 +1491,8 @@ function transformCall2ConsoleLog(node, calleeName, callee, options) {
 }
 exports.transformCall2ConsoleLog = transformCall2ConsoleLog;
 function transformCall2Logging(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     const newArguments = node.arguments.map((arg) => new utils_1.naslTypes.Argument({
         expression: arg?.name === "undefined" ?
             new utils_1.naslTypes.StringLiteral()
@@ -1357,10 +1524,32 @@ function transformCall2JSONFunctions(node, calleeName, callee, options) {
                 keyword: 'arg',
             }),
         ],
-        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType })),
+        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean),
     });
 }
 exports.transformCall2JSONFunctions = transformCall2JSONFunctions;
+function transform2CallEventLogic(node, calleeName, callee, options) {
+    const lastName = callee[callee.length - 1].name;
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: 'nasl.event',
+        calleeName: lastName,
+        shortcut: true,
+        arguments: [],
+    });
+}
+exports.transform2CallEventLogic = transform2CallEventLogic;
+function transform2CallOtherNASLLogic(node, calleeName, callee, options) {
+    const arr = calleeName.split('.');
+    const lastName = arr.pop();
+    return new utils_1.naslTypes.CallLogic({
+        calleeNamespace: arr.join('.'),
+        calleeName: lastName,
+        arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options),
+        })),
+    });
+}
+exports.transform2CallOtherNASLLogic = transform2CallOtherNASLLogic;
 function transform2CallFunction(node, calleeName, argument, options) {
     calleeName = utils_1.replaceCallFunctionMap?.[calleeName] || calleeName;
     const func = server_1.default ? server_1.default.getBuildInFunction(calleeName) : null;
@@ -1374,8 +1563,13 @@ function transform2CallFunction(node, calleeName, argument, options) {
             keyword: func && func?.params[index]?.name || `param${index + 1}`,
         });
     });
-    let newTypeArguments = node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation);
-    if (calleeName === 'ListRepeat') {
+    let newTypeArguments = node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean);
+    // if (calleeName === 'ListRepeat') {
+    //   newTypeArguments = [
+    //     new naslTypes.TypeAnnotation()
+    //   ];
+    // }
+    if (calleeName === 'Convert' && !newTypeArguments) {
         newTypeArguments = [
             new utils_1.naslTypes.TypeAnnotation()
         ];
@@ -1408,7 +1602,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
             const content = np?.toNaturalTS();
             const noContent = np?.toNaturalTS()?.includes('__IDENTIFIER__');
             if (!np && !p?.defaultExpression) {
-                (0, utils_1.throwError)(`函数${calleeName}生成不符合标准的函数调用`);
+                return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}生成不符合标准的函数调用`, content);
             }
             if (np && calleeName === 'ListDistinctBy') {
                 if (idx === 1) {
@@ -1441,7 +1635,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         });
     }
     else {
-        (0, utils_1.throwError)(`函数${calleeName}不存在`);
+        return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}不存在`, node.callee, node);
     }
     if (!func.params?.length) {
         const needDefaultParam = ['CurrDate', 'CurrTime', 'CurrDateTime'];
@@ -1463,7 +1657,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         // 这两个参数比较特殊，可以无限加参数，不再判断参数数量
         const excludes = ['HasValue', 'ListSort'];
         if (func.params?.length !== newArguments?.length && !excludes.includes(calleeName)) {
-            (0, utils_1.throwError)(`函数${calleeName}生成不符合标准的函数调用，参数数量不匹配`);
+            return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}生成不符合标准的函数调用，参数数量不匹配`, node.callee, node);
         }
         else {
             newArguments?.forEach((arg, idx) => {
@@ -1480,19 +1674,22 @@ function transform2CallFunction(node, calleeName, argument, options) {
         // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
     });
     if (calleeName === 'ListSort') {
-        return new utils_1.naslTypes.CallFunction((0, utils_1.handleListSort)(nodeElement?.toJSON()));
+        const handledNode = (0, utils_1.handleListSort)(nodeElement?.toJSON(), options);
+        return handledNode && new utils_1.naslTypes.CallFunction(handledNode);
     }
     if (options.transformType === 'logic' && options?.inCallQueryComponentField) {
-        (0, utils_1.throwError)(`数据查询中不支持内置函数${nodeElement.calleeName}`);
+        return (0, utils_1.throwError)(options?.parsingId, '数据查询中不支持使用内置函数', nodeElement.calleeName, node);
     }
     return nodeElement;
 }
 exports.transform2CallFunction = transform2CallFunction;
 function transform2SqlFunction(node, calleeName, argument, options) {
     if (options.inCallQueryComponentField && !['WHERE', 'HAVING', 'ORDER_BY'].includes(options.inCallQueryComponentField)) {
-        (0, utils_1.throwError)(`数据查询中只有 WHERE, HAVING, ORDER_BY 支持 SQL 函数，而当前字段为 ${options.inCallQueryComponentField}`);
+        return (0, utils_1.throwError)(options?.parsingId, `数据查询中只有 WHERE, HAVING, ORDER_BY 支持 SQL 函数，而当前字段为 ${options.inCallQueryComponentField}`, node.callee, node);
     }
     const specFunList = ['COUNT', 'COUNTD', 'SUM', 'AVG', 'MAX', 'MIN'];
+    // TODO: 先写死了 mysql，后续需要传入: 参考 requestSqlFunctions
+    const func = server_1.default ? server_1.default?.getSqlFunction('mysql', calleeName) : null;
     let addArguments = [];
     if (specFunList.includes(calleeName)) {
         const value = calleeName === 'COUNTD' ? 'DISTINCT' : 'ALL';
@@ -1505,20 +1702,20 @@ function transform2SqlFunction(node, calleeName, argument, options) {
     }
     const newArguments = argument.map((arg, index) => new utils_1.naslTypes.Argument({
         expression: fixExpression(arg, options),
-        keyword: 'str', // `arg${index + 1}`,
+        keyword: func?.params[index]?.name || `param${index + 1}`,
     }));
     const nodeElement = new utils_1.naslTypes.CallFunction({
         calleeNamespace: 'nasl.sqlFunction',
         calleeName: utils_1.replaceCallFunctionMap?.[calleeName] || calleeName,
         arguments: [...addArguments, ...newArguments],
-        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean),
         // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
     });
     return nodeElement;
 }
 function transformCall2CallFunction(node, calleeName, callee, options) {
     let curCalleeName;
-    if (callee.length === 3)
+    if (callee.length >= 3)
         curCalleeName = callee[callee.length - 1].name;
     else {
         let _callee = callee[0].callee;
@@ -1526,11 +1723,10 @@ function transformCall2CallFunction(node, calleeName, callee, options) {
             _callee = _callee.callee;
         curCalleeName = _callee.property.name;
     }
-    const argument = callee.length === 3 ? node.arguments : callee[0].arguments;
-    if (['plus', 'minus', 'multiply', 'divide', 'remainder', 'STARTS_WITH', 'ENDS_WITH', 'LIKE', 'IN'].includes(curCalleeName)) {
-        return transformCallExpressionToBinaryExpression(node, curCalleeName, callee, options);
-    }
-    ;
+    const argument = callee.length >= 3 ? node.arguments : callee[0].arguments;
+    // if (['plus', 'minus', 'multiply', 'divide', 'remainder', 'STARTS_WITH', 'ENDS_WITH', 'LIKE', 'IN'].includes(curCalleeName)) {
+    //   return transformCallExpressionToBinaryExpression(node, curCalleeName, callee, options);
+    // };
     if (['NewList', 'NewMap', 'NewEntity', 'NewStructure', 'NewAnonymousStructure'].includes(curCalleeName)) {
         return transform2NewExpression(curCalleeName, node, options);
     }
@@ -1539,10 +1735,31 @@ function transformCall2CallFunction(node, calleeName, callee, options) {
 exports.transformCall2CallFunction = transformCall2CallFunction;
 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();
+        let namespaceNode = node.arguments[0];
+        let namespace = '';
+        if (namespaceNode.type === 'TemplateLiteral') {
+            namespace = namespaceNode.quasis[0]?.value?.cooked;
+        }
+        else if (namespaceNode.type === 'StringLiteral') {
+            namespace = namespaceNode.value;
+        }
+        else {
+            namespace = (0, utils_1.generate)(namespaceNode).code;
+        }
+        let nsArr;
+        let viewNamespace = '';
+        let viewName = '';
+        if (namespace.startsWith('app.frontendTypes.')) {
+            nsArr = namespace.split('.');
+            viewName = nsArr.pop();
+            viewNamespace = nsArr.join('.');
+        }
+        else {
+            nsArr = namespace.split('.').map((item) => item.replace(/_view$/, ''));
+            const pageType = nsArr.shift();
+            viewName = nsArr.pop();
+            viewNamespace = `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((item) => `.${item}.views`)?.join('')}`;
+        }
         const newArguments = node?.arguments?.slice(1);
         let argument = [];
         if (newArguments?.[0]?.type === 'ObjectExpression') {
@@ -1558,7 +1775,7 @@ function transform2UIFunction(node, calleeName, callee, options) {
             }));
         }
         return new utils_1.naslTypes.Destination({
-            viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((item) => `.${item}.views`)?.join('')}`,
+            viewNamespace,
             viewName,
             arguments: argument,
         });
@@ -1568,6 +1785,11 @@ function transform2UIFunction(node, calleeName, callee, options) {
             link: fixExpression(node?.arguments[0], options),
         });
     }
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+    if (options.transformType === 'logic' && options?.logicType === 'global_logic') {
+        return transformCall2ConsoleLog(node, calleeName, callee, options);
+    }
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: callee[2].name,
@@ -1604,11 +1826,11 @@ function transform2ForEachStatement(node, calleeName, callee, options) {
         each: transformNodeFunction(newCallee[0], options),
         start: transformNodeFunction(newCallee[1], options),
         end: newCallee[2]?.name === '__IDENTIFIER__' ? undefined : transformNodeFunction(newCallee[2], options),
-        item: arrowFunction?.params?.[0] ? transform2Param(arrowFunction.params[0]) : new utils_1.naslTypes.Param({
+        item: arrowFunction?.params?.[0] ? transform2Param(arrowFunction.params[0], options) || undefined : new utils_1.naslTypes.Param({
             name: 'item',
             typeAnnotation: undefined,
         }),
-        index: arrowFunction?.params?.[1] ? transform2Param(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
+        index: arrowFunction?.params?.[1] ? transform2Param(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 4)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1635,8 +1857,8 @@ function transformForOf2ForEachStatement(node, options) {
     let endNode;
     if (node?.right?.type === 'CallExpression') {
         const rightNode = node?.right;
-        const calleeName = rightNode?.callee?.type === 'Identifier' && rightNode?.callee?.name;
-        const hasListEntries = calleeName === 'ListEntries';
+        const calleeName = (0, utils_1.generate)(rightNode.callee).code;
+        const hasListEntries = ['ListEntries', 'nasl.util.ListEntries'].includes(calleeName);
         const areaArguments = rightNode?.arguments;
         eachNode = hasListEntries ? areaArguments?.[0] : rightNode;
         startNode = hasListEntries ? areaArguments?.[1] : undefined;
@@ -1652,11 +1874,11 @@ function transformForOf2ForEachStatement(node, options) {
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
         end: endNode?.name === '__IDENTIFIER__' ? undefined : endNode ? transformNodeFunction(endNode, options) : undefined,
-        item: itemNode ? transform2Param(itemNode) : new utils_1.naslTypes.Param({
+        item: itemNode ? transform2Param(itemNode, options) || undefined : new utils_1.naslTypes.Param({
             name: 'item',
             typeAnnotation: undefined,
         }),
-        index: indexNode ? transform2Param(indexNode) : new utils_1.naslTypes.Param({
+        index: indexNode ? transform2Param(indexNode, options) || undefined : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 2)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1676,8 +1898,8 @@ function transformForEach2ForEachStatement(node, calleeName, callee, options) {
             value: '0',
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
-        item: transform2Param(arrowFunction.params[0]),
-        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
+        item: transform2Param(arrowFunction.params[0], options) || undefined,
+        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 2)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1687,6 +1909,11 @@ function transformForEach2ForEachStatement(node, calleeName, callee, options) {
 }
 exports.transformForEach2ForEachStatement = transformForEach2ForEachStatement;
 function transformAlert2ShowMessage(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
+    if (options.transformType === 'logic' && options?.logicType === 'global_logic') {
+        return transformCall2ConsoleLog(node, calleeName, callee, options);
+    }
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: 'showMessage',
@@ -1698,6 +1925,8 @@ function transformAlert2ShowMessage(node, calleeName, callee, options) {
 }
 exports.transformAlert2ShowMessage = transformAlert2ShowMessage;
 function transformCall2Interface(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用接口不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallInterface({
         calleeNamespace: (0, utils_1.generate)(node.callee.object).code,
         calleeName: callee[callee.length - 1].name,
@@ -1709,13 +1938,15 @@ function transformCall2Interface(node, calleeName, callee, options) {
 }
 exports.transformCall2Interface = transformCall2Interface;
 function transformCall2Connector(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用连接器不支持在组件或默认值表达式中使用', node);
     let calleeConnectionName = undefined;
     let calleeNamespace = undefined;
     let calleeNamespacePrefix = `connector.${callee[1].name}`;
     if (callee.length === 5) {
         const connectArg = callee[2].arguments[0];
         if (!connectArg || connectArg.type !== 'StringLiteral') {
-            (0, utils_1.throwError)(`调用 connector 的 connect 参数不正确，只允许使用字符串字面量`);
+            return (0, utils_1.throwError)(options?.parsingId, '调用 connector 的 connect 参数不正确，只允许使用字符串字面量', node);
         }
         calleeConnectionName = connectArg.value;
         const noNamespace = callee[3].name === 'logics';
@@ -1730,7 +1961,7 @@ function transformCall2Connector(node, calleeName, callee, options) {
         calleeNamespace = calleeNamespacePrefix;
     }
     else {
-        (0, utils_1.throwError)(`调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`);
+        return (0, utils_1.throwError)(options?.parsingId, `调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`, node);
     }
     return new utils_1.naslTypes.CallConnector({
         calleeConnectionName,
@@ -1743,6 +1974,8 @@ function transformCall2Connector(node, calleeName, callee, options) {
 }
 exports.transformCall2Connector = transformCall2Connector;
 function transformCall2Extension(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用扩展逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: (0, utils_1.generate)(node?.callee?.object)?.code,
         calleeName: callee?.[callee?.length - 1]?.name,
@@ -1752,70 +1985,26 @@ function transformCall2Extension(node, calleeName, callee, options) {
     });
 }
 exports.transformCall2Extension = transformCall2Extension;
-function transformArrowFunction2Match(node, calleeName, callee, options) {
-    const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
-    // NOTE: 适用于 if else
-    const newCallee = node.callee.body.body;
-    if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFunction') {
-        const match = new utils_1.naslTypes.Match({
-            expression: fixExpression(newCallee[0], options),
-            isExpression: options.transformType !== 'logic',
-            cases: flatIfStatement(newCallee[1].body.body[0]).map((_case) => new utils_1.naslTypes.MatchCase({
-                patterns: !_case.test ? [] : flatMatchPatternsExpression(transformNodeFunction(_case.test, options)),
-                body: transformBlockBody(_case.consequent.body.filter((item) => item.type !== 'BreakStatement'), options),
-            })),
-        });
-        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 = transformNodeFunction(newCallee[0].body.body[0], options);
-        return switchStatement;
-    }
-    (0, utils_1.throwError)(`Unhandled ArrowFunctionExpression node ${node.type}`);
-}
-exports.transformArrowFunction2Match = transformArrowFunction2Match;
 function transformTSAsExpression(node, options) {
     if (node.expression.type === 'NumericLiteral') {
-        return transform2NumericLiteral(node.expression, { ...options, typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation) });
+        return transform2NumericLiteral(node.expression, { ...options, typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation, options) || undefined });
     }
     else if (node.expression.type === 'ArrayExpression') {
-        const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation);
+        const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation, options) || undefined;
         if (typeAnnotation.typeName !== 'List' && typeAnnotation.typeNamespace !== 'nasl.collection')
-            (0, utils_1.throwError)(`列表 as 必须为 List 类型`);
+            return (0, utils_1.throwError)(options?.parsingId, `列表 as 必须为 List 类型`, node);
         return transformArrayExpression(node.expression, { ...options, typeAnnotation });
     }
+    else if (node.expression.type === 'NullLiteral') {
+        return transform2NullLiteral(node.expression, options);
+    }
     else {
-        (0, utils_1.throwError)(`表达式 ${node.expression.type} 不支持使用 as 关键字`);
+        return (0, utils_1.throwError)(options?.parsingId, '表达式不支持使用 as 关键字', node.expression.type, node.expression);
     }
 }
 function transformCall2CallViewLogic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用页面逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: '',
         calleeName: calleeName.slice('viewLogic_'.length),
@@ -1826,11 +2015,13 @@ function transformCall2CallViewLogic(node, calleeName, callee, options) {
 }
 exports.transformCall2CallViewLogic = transformCall2CallViewLogic;
 function transformCall2Logic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     if (utils_1.callFunctionMap.includes(calleeName)) {
         // 未带前缀，补一下
         return transform2CallFunction(node, calleeName, node?.arguments || [], options);
     }
-    else if (utils_1.sqlFunctions.includes(calleeName) || calleeName === 'COUNTD') {
+    else if (server_1.default.getSqlFunction('mysql', calleeName) || calleeName === 'COUNTD') {
         return transform2SqlFunction(node, calleeName, node?.arguments || [], options);
     }
     let newCalleeName = calleeName?.includes('__IDENTIFIER__') ? undefined : calleeName;
@@ -1850,6 +2041,8 @@ function transformCall2Logic(node, calleeName, callee, options) {
 }
 exports.transformCall2Logic = transformCall2Logic;
 function transformCall2LogicWithAuth(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用，请尝试单独赋值', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: `nasl.auth`,
         calleeName: callee[callee.length - 1].name,
@@ -1874,10 +2067,10 @@ function flatCallQueryComponentChainNode(node, options) {
         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');
+                return (0, utils_1.throwError)(options?.parsingId, 'FROM should have a ArrowFunctionExpression as the second argument', node.arguments[1], node);
             const arrowFunctionExpression = node.arguments[1];
             if (arrowFunctionExpression.body.type !== 'CallExpression')
-                (0, utils_1.throwError)('FROM should have a CallExpression as the body of ArrowFunctionExpression');
+                return (0, utils_1.throwError)(options?.parsingId, 'FROM should have a CallExpression as the body of ArrowFunctionExpression', arrowFunctionExpression.body, node);
             const body = arrowFunctionExpression.body;
             const callExpressions = flatChainCallExpression(body);
             const joinNode = callExpressions?.filter((item) => item?.callee?.name.includes('_JOIN'));
@@ -1887,13 +2080,13 @@ function flatCallQueryComponentChainNode(node, options) {
 FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id)).SELECT(...)); // 错误用法, ${name}的回调函数必须是完整的QueryChain
 FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id).SELECT(...))); // 正确用法, 后续查询都在${name}的回调函数中进行
 `;
-                (0, utils_1.throwError)(error);
+                return (0, utils_1.throwError)(options?.parsingId, error, node);
             }
             const joinCode = (0, utils_1.generate)(joinNode[0])?.code || '';
             const count = joinCode.match(/_JOIN/g)?.length || 0;
             const errorOrder = count >= 1 && !callExpressions?.[callExpressions?.length - 1]?.callee?.name?.includes('_JOIN');
             if (errorOrder) {
-                (0, utils_1.throwError)('调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', options.needThrowError);
+                return (0, utils_1.throwError)(options?.parsingId, '调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', node);
             }
             const result = [{
                     calleeName: calleeName,
@@ -1905,7 +2098,7 @@ FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id).SELECT(...))); /
                         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, options));
+                        result.push(...(flatCallQueryComponentChainNode(item, options) || []));
                     }
                     else {
                         result.push({
@@ -1938,33 +2131,39 @@ function flatOnExpressions(node) {
         return [node];
     }
 }
-function transformMemberExpression2Entity(node, node2) {
+function transformMemberExpression2Entity(node, node2, options) {
     const entityPath = flatMemberExpression(node);
     const entityNamespace = entityPath.slice(0, -1).map(n => n.name).join('.');
     const entityName = entityPath[entityPath.length - 1].name.replace(/Entity$/, '');
     if (!entityNamespace?.includes('.entities')) {
-        (0, utils_1.throwError)(`${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询。`);
+        return (0, utils_1.throwError)(options?.parsingId, `${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询`, node);
     }
     const asName = node2.name === entityName ? undefined : node2.name;
     if (asName) {
-        (0, utils_1.throwError)(`FROM 中回调函数的入参名称应为${entityName}，但实际为${node2.name}`);
+        return (0, utils_1.throwError)(options?.parsingId, `FROM 中回调函数的入参名称应为${entityName}，但实际为${node2.name}`);
     }
     return { entityNamespace, entityName, asName };
 }
 function transformCall2DataQuery(node, calleeName, callee, options) {
+    if (options?.isInFrontend)
+        return (0, utils_1.throwError)(options?.parsingId, '数据查询组件不支持在前端使用', node);
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '数据查询组件不支持在组件或默认值表达式中使用', node);
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     const code = (0, utils_1.generate)(node)?.code || '';
     if (code?.includes('nasl.util')) {
-        (0, utils_1.throwError)('数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理');
+        return (0, utils_1.throwError)(options?.parsingId, '数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理', code);
     }
     if (!code?.includes('.SELECT(') && !code?.includes('.AGGR_SELECT(')) {
-        (0, utils_1.throwError)('缺少 SELECT 或 AGGR_SELECT 语句');
+        return (0, utils_1.throwError)(options?.parsingId, '缺少 SELECT 或 AGGR_SELECT 语句', code);
     }
     const flatted = flatCallQueryComponentChainNode(node, options);
-    const calleeNames = flatted.map((item) => item?.calleeName).filter((name) => name !== '$');
+    if (!flatted)
+        return;
+    const calleeNames = flatted && flatted.map((item) => item?.calleeName).filter((name) => name !== '$');
     const isOrderCorrect = (0, utils_1.checkOQLCalleeNameOrder)(calleeNames);
     if (!isOrderCorrect) {
-        (0, utils_1.throwError)('调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', options.needThrowError);
+        return (0, utils_1.throwError)(options?.parsingId, '调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', node);
     }
     let from;
     let where;
@@ -1977,11 +2176,13 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
     let hasErrorTSScopeColumn = false;
     let useResultItem = false;
     // 这里只是一个示例，具体的逻辑需要根据flatted的内容来构建
-    flatted.forEach((item) => {
+    flatted && flatted.forEach((item) => {
         // console.log(item.calleeName)
         switch (item.calleeName) {
             case 'FROM':
-                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
+                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1], options);
+                if (!entity)
+                    return;
                 const entityName = entity.asName || entity.entityName;
                 entityAsNames.push(entityName);
                 from = new utils_1.naslTypes.QueryFromExpression({
@@ -1993,11 +2194,15 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
             case 'LEFT_JOIN':
             case 'RIGHT_JOIN':
             case 'OUTER_JOIN':
-                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
+                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1], options);
+                if (!entity)
+                    break;
                 entityAsNames.push(entity.asName || entity.entityName);
                 const rawJoinType = item.calleeName.slice(0, -5);
                 const joinType = rawJoinType === 'OUTER' ? 'FULL' : rawJoinType;
                 const onExpressions = flatOnExpressions(item.arguments[2]);
+                if (!from)
+                    return; // throwError(options?.parsingId, 'FROM 不存在或异常，无法添加 JOIN 子句', node);
                 from.addJoinPart(new utils_1.naslTypes.QueryJoinExpression({
                     ...entity,
                     joinType,
@@ -2014,27 +2219,50 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                 break;
             case 'AGGR_SELECT':
                 if (groupBy?.length) {
-                    (0, utils_1.throwError)('存在 GROUP_BY，应使用 SELECT 进行查询，但实际为 AGGR_SELECT');
+                    return (0, utils_1.throwError)(options?.parsingId, '存在 GROUP_BY，应使用 SELECT 进行查询，但实际为 AGGR_SELECT', node);
                 }
                 select = new utils_1.naslTypes.QuerySelectExpression({
                     distinct: false,
                     star: true,
                     selectElements: [new utils_1.naslTypes.QueryFieldExpression({
                             isDotStar: true,
-                            entityAsName: from.entityName,
+                            entityAsName: from?.entityName,
                             propertyName: '',
                         })],
                 });
-                item.arguments[0].properties?.forEach((arg) => {
-                    if (arg?.value.type === 'CallExpression') {
-                        let selectElements = transform2QueryAggregateExpression(arg, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
+                if (item.arguments[0].type === 'ObjectExpression') {
+                    item.arguments[0].properties?.forEach((arg) => {
+                        if (arg?.value.type === 'CallExpression') {
+                            let selectElements = transform2QueryAggregateExpression(arg, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
+                            if (selectElements) {
+                                const newSelectElements = [...select.selectElements, selectElements];
+                                select.setSelectElements(newSelectElements);
+                            }
+                        }
+                        else {
+                            return (0, utils_1.throwError)(options?.parsingId, `Unsupported expression type for QueryAggregateExpression`, arg?.value.type, arg?.value);
+                        }
+                    });
+                }
+                else if (item.arguments[0].type === 'CallExpression') { // 只有一个的简写：AGGR_SELECT(SUM(Entity1.age))
+                    const selectElements = transform2QueryAggregateExpression({
+                        type: 'ObjectProperty',
+                        key: {
+                            type: 'Identifier',
+                            name: 'resultItem',
+                        },
+                        value: item.arguments[0],
+                        computed: false,
+                        shorthand: false,
+                    }, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
+                    if (selectElements) {
                         const newSelectElements = [...select.selectElements, selectElements];
                         select.setSelectElements(newSelectElements);
                     }
-                    else {
-                        (0, utils_1.throwError)(`Unsupported expression type: ${arg?.value.type} for QueryAggregateExpression`);
-                    }
-                });
+                }
+                else {
+                    return (0, utils_1.throwError)(options?.parsingId, 'Unsupported expression type for QueryAggregateExpression', item.arguments[0].type, item.arguments[0]);
+                }
                 break;
             case 'SELECT':
                 select = new utils_1.naslTypes.QuerySelectExpression({
@@ -2042,7 +2270,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     star: true,
                     selectElements: groupBy?.length ? [new utils_1.naslTypes.QueryFieldExpression({
                             isDotStar: true,
-                            entityAsName: from.entityName,
+                            entityAsName: from?.entityName,
                             propertyName: '',
                         })] : [],
                 });
@@ -2053,17 +2281,17 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                     else if (arg.value.type === 'ObjectExpression') {
                         if (groupBy?.length) {
-                            (0, utils_1.throwError)('存在 GROUP_BY，SELECT应为单层结构，不应使用双层局部列');
+                            return (0, utils_1.throwError)(options?.parsingId, '存在 GROUP_BY，SELECT应为单层结构，不应使用双层局部列', node);
                         }
                         const originName = arg.key?.name || '';
                         if (originName && originName.charAt(0) === originName.charAt(0).toUpperCase()) {
                             const needName = (0, utils_2.firstLowerCase)(originName);
-                            (0, utils_1.throwError)(`SELECT 局部列第一层命名不符合规范, 应为${needName}, 但实际为${originName}`);
+                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第一层命名不符合规范, 应为${needName}, 但实际为${originName}`, node);
                         }
                         const entityName = (0, utils_2.firstUpperCase)(originName);
                         const needNameList = entityAsNames.map(item => (0, utils_2.firstLowerCase)(item))?.join('或');
                         if (!entityAsNames.includes(entityName)) {
-                            (0, utils_1.throwError)(`SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`);
+                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`, node);
                         }
                         selectElements = arg.value.properties?.map((property) => {
                             const columnAsName = property.key?.name;
@@ -2071,7 +2299,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                             const selectElement = transform2SelectQueryFieldExpression(property, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
                             if (columnAsName !== columnPropertyName) {
                                 // eg: comment: Topic_Comment.comment_stu
-                                (0, utils_1.throwError)(`SELECT 局部列第二层命名不符合规范, 应为${columnPropertyName}, 但实际为${columnAsName}`);
+                                return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第二层命名不符合规范, 应为${columnPropertyName}, 但实际为${columnAsName}`, node);
                             }
                             selectElement.isDotStar = false;
                             return selectElement;
@@ -2081,6 +2309,9 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                         if (arg.value.type === 'MemberExpression') {
                             hasErrorTSScopeColumn = true;
                         }
+                        if (arg.type === 'ObjectProperty' && select?.selectElements?.find(item => item?.concept === 'QueryFieldExpression' && item.entityAsName === arg.value?.name)) {
+                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 禁止在一次查询中对同一实体设置多个别名，请修改`, node);
+                        }
                         selectElements = [transform2SelectQueryFieldExpression(arg, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName })];
                     }
                     const selectElement = selectElements?.[0];
@@ -2106,7 +2337,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    (0, utils_1.throwError)('HAVING 不符合规范，请使用箭头函数');
+                    return (0, utils_1.throwError)(options?.parsingId, 'HAVING 不符合规范，请使用箭头函数', havingNode, node);
                 }
                 having = transformNodeFunction(havingNode, { ...options, ...restParams });
                 break;
@@ -2115,13 +2346,16 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                 let restOptionParams = { entityAsNames };
                 if (orderNode?.length === 1 && orderNode?.[0]?.type === 'ArrowFunctionExpression') {
                     const params = orderNode?.[0]?.params;
+                    if (orderNode?.[0]?.body?.type !== 'ArrayExpression') {
+                        return (0, utils_1.throwError)(options?.parsingId, 'ORDER_BY 不符合规范，请使用箭头函数，并返回数组', orderNode, node);
+                    }
                     orderNode = orderNode?.[0]?.body?.elements;
                     if (params?.length && params?.[0]?.name) {
                         restOptionParams = { inOqlIdentifierNamespace: params?.[0]?.name, entityAsNames };
                     }
                 }
                 else {
-                    (0, utils_1.throwError)('ORDER_BY 不符合规范，请使用箭头函数');
+                    return (0, utils_1.throwError)(options?.parsingId, 'ORDER_BY 不符合规范，请使用箭头函数，并返回数组', orderNode, node);
                 }
                 orderBy = orderNode.map((arg) => {
                     let orderElementCode = (0, utils_1.generate)(arg)?.code || '';
@@ -2147,24 +2381,26 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
         ideVersion: '2.22',
     });
     if (hasErrorTSScopeColumn && !groupBy?.length && !having) {
-        (0, utils_1.throwError)('SELECT 局部列不符合规范，需要按两层对象返回');
+        return (0, utils_1.throwError)(options?.parsingId, 'SELECT 局部列不符合规范，需要按两层对象返回', node);
     }
     const hasScopeColumn = select?.selectElements?.find((selectElement) => selectElement?.concept === 'QueryFieldExpression' && !selectElement?.isDotStar);
     if (hasScopeColumn && (groupBy?.length || having)) {
-        (0, utils_1.throwError)('分组聚合与表字段局部列不允许同时出现');
+        return (0, utils_1.throwError)(options?.parsingId, '分组聚合与表字段局部列不允许同时出现', node);
     }
     if (hasScopeColumn && useResultItem) {
-        (0, utils_1.throwError)("对于局部列的排序，只支持 实体.属性名 的格式，例如 ORDER_BY((resultItem) => [[Student.age, 'ASC']])");
+        return (0, utils_1.throwError)(options?.parsingId, "对于局部列的排序，只支持 实体.属性名 的格式，例如 ORDER_BY((resultItem) => [[Student.age, 'ASC']])", node);
     }
     const isOnlyAggr = select?.selectElements?.find((selectElement) => selectElement?.concept !== 'QueryAggregateExpression');
     // 如果 select 中只有聚合属性时，并且没有用 AGGR_SELECT 来指定列
     if (!isOnlyAggr && !calleeNames?.includes('AGGR_SELECT')) {
-        (0, utils_1.throwError)('SELECT 不符合规范，请使用 AGGR_SELECT');
+        return (0, utils_1.throwError)(options?.parsingId, 'SELECT 不符合规范，请使用 AGGR_SELECT', node);
     }
     // callQueryComponent.typeAnnotation = callQueryComponent.computeStructure();
     return callQueryComponent;
 }
 function transformCall2LaunchProcess(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        return (0, utils_1.throwError)(options?.parsingId, '调用流程逻辑不支持在组件或默认值表达式中使用', node);
     const args = node.arguments;
     const dataArg = args?.[0];
     const procDefKeyArg = args?.[1];
@@ -2203,6 +2439,7 @@ function transform2LogicItem(node, options) {
     transformManager.register('NumericLiteral', transform2NumericLiteral);
     transformManager.register('NullLiteral', transform2NullLiteral);
     transformManager.register('TemplateLiteral', transform2StringInterpolation);
+    transformManager.register((node) => node.type === 'LogicalExpression' && node.operator === '??', transformDefaultExpression);
     transformManager.register('BinaryExpression', transform2BinaryExpression);
     transformManager.register('LogicalExpression', transform2BinaryExpression);
     transformManager.register('UpdateExpression', transformUpdateExpression2Assignment);
@@ -2240,7 +2477,8 @@ function transform2LogicItem(node, options) {
         }
     });
     transformManager.register('MemberExpression', transformMemberExpression);
-    transformManager.register((node) => node.type === 'CallExpression' && node.callee.type === 'CallExpression', transformCallCall2Match);
+    transformManager.register('OptionalMemberExpression', transformMemberExpression);
+    transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1 && (node.callee.type === 'FunctionExpression' && node.callee.id?.name === 'match' || node.callee.type === 'ArrowFunctionExpression'), transformCallFunctionExpression2Match);
     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);
@@ -2249,10 +2487,12 @@ function transform2LogicItem(node, options) {
     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.event.') || calleeName.startsWith('event.')) && (calleeName.endsWith('.preventDefault') || calleeName.endsWith('.stopPropagation')), transform2CallEventLogic);
     transformManager.registerCallExpression((node, calleeName) => calleeName.endsWith('.forEach'), transformForEach2ForEachStatement);
     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.startsWith('nasl.browser.'), transform2CallOtherNASLLogic);
     transformManager.registerCallExpression((node, calleeName) => calleeName.endsWith('.map'), transformMap2ListTransform);
     transformManager.registerCallExpression('ForEach', transform2ForEachStatement);
     transformManager.registerCallExpression('alert', transformAlert2ShowMessage);
@@ -2262,15 +2502,14 @@ function transform2LogicItem(node, options) {
     transformManager.registerCallExpression('extensions.lcap_process_framework.logics.launchProcess', transformCall2LaunchProcess);
     transformManager.registerCallExpression((node, calleeName) => /extensions\./.test(calleeName), transformCall2Extension);
     transformManager.registerCallExpression((node, calleeName) => /connectors\./.test(calleeName), transformCall2Connector);
-    transformManager.registerCallExpression((node) => node.callee.type === 'ArrowFunctionExpression', transformArrowFunction2Match);
     transformManager.registerCallExpression((node, calleeName) => ['plus', 'minus', 'multiply', 'divide', 'remainder', 'STARTS_WITH', 'ENDS_WITH', 'LIKE', 'IN', 'IS_NULL'].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);
+    transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1 && !['ArrowFunctionExpression', 'FunctionExpression'].includes(callee[0].type), transformCall2Logic);
     let result = transformManager.apply(node, options);
     delete options.typeAnnotation;
-    return result;
+    return result || undefined;
 }
 exports.transform2LogicItem = transform2LogicItem;
 //# sourceMappingURL=transform2LogicItem.js.map