npm - @lcap/nasl - Versions diffs - 4.1.0-creator.3 → 4.1.0-rc.10 - Mend

@lcap/nasl 4.1.0-creator.3 → 4.1.0-rc.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (146) hide show

package/out/natural/transforms/transform2LogicItem.js CHANGED Viewed

@@ -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.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 = void 0;
+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;
 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')
-                return (0, utils_1.throwError)(options?.parsingId, '不支持连续调用！', node.callee);
+                (0, utils_1.throwError)(`不支持连续调用！`);
             const callee = flatMemberExpression(node.callee);
             if (callee[0]
                 && callee[0].type === 'CallExpression'
@@ -36,8 +36,9 @@ class TransformManager {
             }
             else {
                 for (const calleeItem of callee) {
-                    if (calleeItem.type !== 'Identifier' && !(calleeItem.type === 'FunctionExpression' && calleeItem.id?.name === 'match')) {
-                        return (0, utils_1.throwError)(options?.parsingId, '不支持连续调用！', node.callee);
+                    if (calleeItem.type !== 'Identifier') {
+                        const calleeName = (0, utils_1.generate)(node.callee).code;
+                        (0, utils_1.throwError)(`不支持连续调用！${calleeName}`);
                     }
                 }
             }
@@ -47,7 +48,7 @@ class TransformManager {
                     return transform(node, calleeName, callee, options);
                 }
             }
-            return (0, utils_1.throwError)(options?.parsingId, `不支持的节点类型 ${callee.map((item) => item.name).join('.')}`, node.type, node);
+            (0, utils_1.throwError)(`Unhandled node ${callee.map((item) => item.name).join('.')} ${node.type}`);
         }
         else {
             for (const [type, transform] of this.transforms) {
@@ -55,7 +56,7 @@ class TransformManager {
                     return transform(node, options);
                 }
             }
-            return (0, utils_1.throwError)(options?.parsingId, '不支持的节点类型', node.type, node);
+            (0, utils_1.throwError)(`Unhandled node ${node.type}`);
         }
     }
 }
@@ -77,7 +78,7 @@ function transformTSCode2SubLogic(node, options) {
         statements = [...node?.body?.directives, ...node?.body?.body];
     }
     parameters.forEach((node) => {
-        const param = transform2Param(node, options);
+        const param = transform2Param(node);
         param && logic.addParam(param);
     });
     const newStatements = [];
@@ -121,9 +122,9 @@ function transformTSCode2SubLogic(node, options) {
     }
     return logic;
 }
-function assertAssignmentRightIsNotAnonymousFunction(expression, options) {
+function assertAssignmentRightIsNotAnonymousFunction(expression) {
     if (expression?.concept === 'AnonymousFunction')
-        return (0, utils_1.throwError)(options?.parsingId, 'Anonymous function is not allowed in assignment');
+        (0, utils_1.throwError)('Anonymous function is not allowed in assignment');
     return expression;
 }
 function fixExpression(arg, options, supportSubLogic = false) {
@@ -242,18 +243,13 @@ function flatMatchPatternsExpression(node) {
     return [node];
 }
 exports.flatMatchPatternsExpression = flatMatchPatternsExpression;
-function flatIfStatementForMatch(node) {
+function flatIfStatement(node) {
     if (node.alternate.type === 'IfStatement') {
-        return [node, ...flatIfStatementForMatch(node.alternate)];
+        return [...flatIfStatement(node.alternate), node];
     }
-    return [node, {
-            type: 'IfStatement',
-            test: null,
-            consequent: node.alternate,
-            alternate: node.alternate,
-        }];
+    return [node];
 }
-exports.flatIfStatementForMatch = flatIfStatementForMatch;
+exports.flatIfStatement = flatIfStatement;
 /**
  * 这个函数是修复 AI 翻译出错的情况，与正常的 transform 做个区分
  * @param node
@@ -269,7 +265,7 @@ function fixLogicNode(node) {
     }
 }
 exports.fixLogicNode = fixLogicNode;
-function transform2Param(node, options) {
+function transform2Param(node) {
     const exclude = ['event'];
     if (node.type === 'ObjectProperty') {
         const typeAnnotation = node?.value?.name ? utils_1.naslTypes.TypeAnnotation.createPrimitive((node?.value).name) : null;
@@ -281,7 +277,7 @@ function transform2Param(node, options) {
             name,
             typeAnnotation,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
             }),
         });
     }
@@ -293,9 +289,9 @@ function transform2Param(node, options) {
         let defaultValueExpression = node.optional ? { type: 'NullLiteral' } : undefined;
         return new utils_1.naslTypes.Param({
             name,
-            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
+            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
             }),
         });
     }
@@ -308,9 +304,9 @@ function transform2Param(node, options) {
         return new utils_1.naslTypes.Param({
             name,
             required: !node.optional,
-            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
+            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
             }),
         });
     }
@@ -331,14 +327,14 @@ function transform2Param(node, options) {
             return null;
         return new utils_1.naslTypes.Param({
             name,
-            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
+            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
             }),
         });
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, '在输入参数中不支持节点类型', node);
+        (0, utils_1.throwError)(`Unhandled node ${node}`);
     }
 }
 exports.transform2Param = transform2Param;
@@ -357,12 +353,6 @@ function transformCallExpressionToBinaryExpression(node, calleeName, callee, opt
         IN: 'in',
         IS_NULL: 'isNull',
     };
-    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),
@@ -442,21 +432,11 @@ function transform2BinaryExpression(node, options) {
             right: transformNodeFunction(node.right, options),
         });
     }
-    return (0, utils_1.throwError)(options?.parsingId, '在二元表达式中不支持节点类型', node.type, node);
+    (0, utils_1.throwError)(`Unhandled node ${node.type}`);
 }
 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);
@@ -479,12 +459,12 @@ function transformConditionalExpression(node, options) {
         cases: [
             new utils_1.naslTypes.MatchCase({
                 patterns: [new utils_1.naslTypes.BooleanLiteral({ value: 'true' })],
-                body: consequent ? [consequent] : [],
+                body: [consequent],
                 isMatchedTypeEnumable: true,
             }),
             new utils_1.naslTypes.MatchCase({
-                patterns: [],
-                body: alternate ? [alternate] : [],
+                patterns: [alternate],
+                body: [alternate],
             }),
         ],
     });
@@ -495,34 +475,17 @@ 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 })).filter(Boolean),
+        items: node?.elements?.map((arg) => transformNodeFunction(arg, { ...options, typeAnnotation: undefined })),
     });
 }
 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: arg.naslType || null,
+            typeAnnotation: null
         }));
     });
     newComposite.typeAnnotation = utils_1.naslTypes.TypeAnnotation.createTypeAnonymousStructure(structureProperties);
@@ -545,15 +508,15 @@ function transform2NewExpression(calleeName, node, options) {
         }
         else {
             typeAnnotation = utils_1.naslTypes.TypeAnnotation.createGeneric('List', {
-                typeArguments: node?.typeParameters?.params.map((type) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(type, options)).filter(Boolean),
+                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
             });
         }
         if (node?.arguments && node?.arguments?.[0]?.type !== 'ArrayExpression') {
-            return (0, utils_1.throwError)(options?.parsingId, 'NewList 中不允许出现非数组表达式', node);
+            (0, utils_1.throwError)(`Not allowed code ${(0, utils_1.generate)(node).code} in NewList`);
         }
         return new utils_1.naslTypes.NewList({
             typeAnnotation: node?.typeParameters ? typeAnnotation : undefined,
-            items: node?.arguments?.[0]?.elements?.map((arg) => transformNodeFunction(arg, options)).filter(Boolean),
+            items: node?.arguments?.[0]?.elements?.map((arg) => transformNodeFunction(arg, options)),
         });
     }
     if (calleeName === 'NewMap') {
@@ -569,7 +532,7 @@ function transform2NewExpression(calleeName, node, options) {
         }
         else {
             typeAnnotation = utils_1.naslTypes.TypeAnnotation.createGeneric('Map', {
-                typeArguments: node?.typeParameters?.params.map((type) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(type, options)).filter(Boolean),
+                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
             });
         }
         return new utils_1.naslTypes.NewMap({
@@ -582,13 +545,13 @@ function transform2NewExpression(calleeName, node, options) {
         const typeParam = node.typeParameters?.params[0];
         const typeNamespaceAndName = typeParam ? (0, utils_1.generate)(typeParam).code : '';
         if (!typeNamespaceAndName)
-            return (0, utils_1.throwError)(options?.parsingId, 'NewEntity 中必须指定类型', node);
+            (0, utils_1.throwError)(`Not allowed empty namespace in NewEntity`);
         return transform2NewStructure(typeNamespaceAndName, node.arguments[0], options);
     }
     if (calleeName === 'NewAnonymousStructure') {
         return transform2NewAnonymousStructure(node.arguments[0], options);
     }
-    return (0, utils_1.throwError)(options?.parsingId, '在新建表达式中不支持节点类型', node.type, node);
+    (0, utils_1.throwError)(`Unhandled ArrowFunctionExpression node ${node.type}`);
 }
 function pushElseIf(ifNode, switchStatement, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
@@ -653,7 +616,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, options) || undefined,
+                    typeAnnotation: varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation),
                 }));
             }
         }
@@ -685,7 +648,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) {
@@ -696,7 +659,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, options) || undefined;
+            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation);
             options.logic.variables.push(new utils_1.naslTypes.Variable({
                 name: variableName,
                 typeAnnotation,
@@ -705,14 +668,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, options) || undefined;
+            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation);
             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 }), options) || undefined,
+                right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(decl.init, { ...options, typeAnnotation })),
             });
         }
     });
@@ -822,16 +785,6 @@ 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,
     });
@@ -860,7 +813,7 @@ function transform2SelectQueryFieldExpression(node, options) {
         // @TODO
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, '在 QueryFieldExpression 不支持表达式类型', expression.type, expression);
+        (0, utils_1.throwError)(`Unsupported expression type: ${expression.type} for QueryFieldExpression`);
     }
 }
 function transform2QueryAggregateExpression(node, options) {
@@ -869,10 +822,10 @@ function transform2QueryAggregateExpression(node, options) {
     const arg = callExpression.arguments[0];
     if (arg.type !== 'MemberExpression') {
         const code = (0, utils_1.generate)(arg).code;
-        return (0, utils_1.throwError)(options?.parsingId, `聚合函数的输入只能是表字段(实体.属性)，但AVG(${code})中的${code}不是表字段`);
+        (0, utils_1.throwError)(`聚合函数的输入只能是表字段(实体.属性)，但AVG(${code})中的${code}不是表字段`);
     }
     if (callExpression.arguments?.length > 1) {
-        return (0, utils_1.throwError)(options?.parsingId, `聚合函数${callExpression.callee.name}只支持一个参数`);
+        (0, utils_1.throwError)(`聚合函数${callExpression.callee.name}只支持一个参数`);
     }
     return new utils_1.naslTypes.QueryAggregateExpression({
         asName: asNameNode.name,
@@ -882,10 +835,10 @@ function transform2QueryAggregateExpression(node, options) {
 }
 function transform2AnonymousFunction(node, options) {
     if (node.body.type === 'BlockStatement')
-        return (0, utils_1.throwError)(options?.parsingId, 'Anonymous function with block statement is not supported', node);
+        (0, utils_1.throwError)('Anonymous function with block statement is not supported');
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     return new utils_1.naslTypes.AnonymousFunction({
-        params: node.params.map((param) => transform2Param(param, options)).filter(Boolean),
+        params: node.params.map((param) => transform2Param(param)),
         body: transformNodeFunction(node.body, options),
     });
 }
@@ -914,7 +867,7 @@ function transform2Assignment(node, options) {
     }
     return new utils_1.naslTypes.Assignment({
         left: transformNodeFunction(node.left, options),
-        right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(node.right, options), options) || undefined,
+        right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(node.right, options)),
     });
 }
 exports.transform2Assignment = transform2Assignment;
@@ -991,15 +944,15 @@ function transformReturnStatement2AssignmentOrEnd(node, options) {
         }
     }
     if (!logic.returns.length) {
-        const typeAnnotation = node?.argument?.type === 'TSAsExpression' ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.argument?.typeAnnotation, options) || undefined : undefined;
+        const typeAnnotation = node?.argument?.type === 'TSAsExpression' ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.argument?.typeAnnotation) : undefined;
         logic.returns.push(new utils_1.naslTypes.Return({
             name: 'result',
             typeAnnotation
         }));
     }
     const leftName = logic.returns[0].name;
-    const right = assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(argument, options), options) || undefined;
-    if (right && right.concept === 'Identifier' && right.name === leftName) {
+    const right = assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(argument, options));
+    if (right.concept === 'Identifier' && right.name === leftName) {
         return new utils_1.naslTypes.End();
     }
     else {
@@ -1049,7 +1002,7 @@ function transform2PartialNewComposite(node, options) {
     const rights = [];
     const structureProperties = [];
     const assignmentLines = [];
-    const newProperties = (node?.properties || node?.arguments?.[0]?.properties);
+    const newProperties = (node?.properties || node?.arguments?.[0]?.properties)?.filter((arg) => arg?.value?.type !== 'ConditionalExpression');
     let idx = 0;
     newProperties?.forEach((arg, index) => {
         properties.push(transformNodeFunction(arg.key, options));
@@ -1142,7 +1095,8 @@ function transformNewExpression(node, options) {
     else if (calleeName.includes('.entities.') || calleeName.includes('.structures.')) {
         return transform2NewStructure(calleeName, node.arguments[0], options);
     }
-    return (0, utils_1.throwError)(options?.parsingId, '在新建表达式中不支持节点类型', node.type, node);
+    const errCode = (0, utils_1.generate)(node).code;
+    (0, utils_1.throwError)(`Unhandled node ${node.type}: ${errCode}`);
 }
 exports.transformNewExpression = transformNewExpression;
 function transformMemberExpression(node, options) {
@@ -1179,31 +1133,18 @@ function transformMemberExpression(node, options) {
         });
     }
     if (calleeName?.startsWith('$refs.')) {
-        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 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)) {
@@ -1258,88 +1199,12 @@ function transformMemberExpression(node, options) {
     });
 }
 exports.transformMemberExpression = transformMemberExpression;
-/**
- * @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;
+function transformCallCall2Match(node, options) {
+    // (function match() {})(...) 的情况
+    return undefined;
 }
-exports.transformCallFunctionExpression2Match = transformCallFunctionExpression2Match;
+exports.transformCallCall2Match = transformCallCall2Match;
 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;
@@ -1374,8 +1239,6 @@ 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({
@@ -1388,8 +1251,6 @@ 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$/, '');
@@ -1448,10 +1309,6 @@ 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 })),
@@ -1461,13 +1318,11 @@ function transformCall2OQLQuery(node, calleeName, callee, options) {
         return new utils_1.naslTypes.OqlQueryComponent({
             dataSource: 'app.dataSources.defaultDS',
             code,
-            typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.typeAnnotations, options) || undefined,
+            typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.typeAnnotations)
         });
     }
 }
 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',
@@ -1479,8 +1334,6 @@ 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()
@@ -1512,7 +1365,7 @@ function transformCall2JSONFunctions(node, calleeName, callee, options) {
                 keyword: 'arg',
             }),
         ],
-        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean),
+        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType })),
     });
 }
 exports.transformCall2JSONFunctions = transformCall2JSONFunctions;
@@ -1529,12 +1382,12 @@ function transform2CallFunction(node, calleeName, argument, options) {
             keyword: func && func?.params[index]?.name || `param${index + 1}`,
         });
     });
-    let newTypeArguments = node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean);
-    // if (calleeName === 'ListRepeat') {
-    //   newTypeArguments = [
-    //     new naslTypes.TypeAnnotation()
-    //   ];
-    // }
+    let newTypeArguments = node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation);
+    if (calleeName === 'ListRepeat') {
+        newTypeArguments = [
+            new utils_1.naslTypes.TypeAnnotation()
+        ];
+    }
     if (calleeName === 'Concat') {
         const expressions = newArguments.map((item) => item.expression);
         return new utils_1.naslTypes.StringInterpolation({
@@ -1563,7 +1416,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
             const content = np?.toNaturalTS();
             const noContent = np?.toNaturalTS()?.includes('__IDENTIFIER__');
             if (!np && !p?.defaultExpression) {
-                return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}生成不符合标准的函数调用`, content);
+                (0, utils_1.throwError)(`函数${calleeName}生成不符合标准的函数调用`);
             }
             if (np && calleeName === 'ListDistinctBy') {
                 if (idx === 1) {
@@ -1596,7 +1449,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         });
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}不存在`, node.callee, node);
+        (0, utils_1.throwError)(`函数${calleeName}不存在`);
     }
     if (!func.params?.length) {
         const needDefaultParam = ['CurrDate', 'CurrTime', 'CurrDateTime'];
@@ -1618,7 +1471,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         // 这两个参数比较特殊，可以无限加参数，不再判断参数数量
         const excludes = ['HasValue', 'ListSort'];
         if (func.params?.length !== newArguments?.length && !excludes.includes(calleeName)) {
-            return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}生成不符合标准的函数调用，参数数量不匹配`, node.callee, node);
+            (0, utils_1.throwError)(`函数${calleeName}生成不符合标准的函数调用，参数数量不匹配`);
         }
         else {
             newArguments?.forEach((arg, idx) => {
@@ -1635,22 +1488,19 @@ function transform2CallFunction(node, calleeName, argument, options) {
         // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
     });
     if (calleeName === 'ListSort') {
-        const handledNode = (0, utils_1.handleListSort)(nodeElement?.toJSON(), options);
-        return handledNode && new utils_1.naslTypes.CallFunction(handledNode);
+        return new utils_1.naslTypes.CallFunction((0, utils_1.handleListSort)(nodeElement?.toJSON()));
     }
     if (options.transformType === 'logic' && options?.inCallQueryComponentField) {
-        return (0, utils_1.throwError)(options?.parsingId, '数据查询中不支持使用内置函数', nodeElement.calleeName, node);
+        (0, utils_1.throwError)(`数据查询中不支持内置函数${nodeElement.calleeName}`);
     }
     return nodeElement;
 }
 exports.transform2CallFunction = transform2CallFunction;
 function transform2SqlFunction(node, calleeName, argument, options) {
     if (options.inCallQueryComponentField && !['WHERE', 'HAVING', 'ORDER_BY'].includes(options.inCallQueryComponentField)) {
-        return (0, utils_1.throwError)(options?.parsingId, `数据查询中只有 WHERE, HAVING, ORDER_BY 支持 SQL 函数，而当前字段为 ${options.inCallQueryComponentField}`, node.callee, node);
+        (0, utils_1.throwError)(`数据查询中只有 WHERE, HAVING, ORDER_BY 支持 SQL 函数，而当前字段为 ${options.inCallQueryComponentField}`);
     }
     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';
@@ -1663,20 +1513,20 @@ function transform2SqlFunction(node, calleeName, argument, options) {
     }
     const newArguments = argument.map((arg, index) => new utils_1.naslTypes.Argument({
         expression: fixExpression(arg, options),
-        keyword: func?.params[index]?.name || `param${index + 1}`,
+        keyword: 'str', // `arg${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((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean),
+        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
         // 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;
@@ -1684,10 +1534,11 @@ 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);
     }
@@ -1696,31 +1547,10 @@ function transformCall2CallFunction(node, calleeName, callee, options) {
 exports.transformCall2CallFunction = transformCall2CallFunction;
 function transform2UIFunction(node, calleeName, callee, options) {
     if (callee[2].name === 'destination') {
-        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 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') {
@@ -1736,7 +1566,7 @@ function transform2UIFunction(node, calleeName, callee, options) {
             }));
         }
         return new utils_1.naslTypes.Destination({
-            viewNamespace,
+            viewNamespace: `app.frontendTypes.${pageType}.frontends.${pageType}.views${nsArr?.map((item) => `.${item}.views`)?.join('')}`,
             viewName,
             arguments: argument,
         });
@@ -1746,8 +1576,6 @@ function transform2UIFunction(node, calleeName, callee, options) {
             link: fixExpression(node?.arguments[0], options),
         });
     }
-    if (options?.isRestricted)
-        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: callee[2].name,
@@ -1784,11 +1612,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], options) || undefined : new utils_1.naslTypes.Param({
+        item: arrowFunction?.params?.[0] ? transform2Param(arrowFunction.params[0]) : new utils_1.naslTypes.Param({
             name: 'item',
             typeAnnotation: undefined,
         }),
-        index: arrowFunction?.params?.[1] ? transform2Param(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
+        index: arrowFunction?.params?.[1] ? transform2Param(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 4)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1815,8 +1643,8 @@ function transformForOf2ForEachStatement(node, options) {
     let endNode;
     if (node?.right?.type === 'CallExpression') {
         const rightNode = node?.right;
-        const calleeName = (0, utils_1.generate)(rightNode.callee).code;
-        const hasListEntries = ['ListEntries', 'nasl.util.ListEntries'].includes(calleeName);
+        const calleeName = rightNode?.callee?.type === 'Identifier' && rightNode?.callee?.name;
+        const hasListEntries = calleeName === 'ListEntries';
         const areaArguments = rightNode?.arguments;
         eachNode = hasListEntries ? areaArguments?.[0] : rightNode;
         startNode = hasListEntries ? areaArguments?.[1] : undefined;
@@ -1832,11 +1660,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, options) || undefined : new utils_1.naslTypes.Param({
+        item: itemNode ? transform2Param(itemNode) : new utils_1.naslTypes.Param({
             name: 'item',
             typeAnnotation: undefined,
         }),
-        index: indexNode ? transform2Param(indexNode, options) || undefined : new utils_1.naslTypes.Param({
+        index: indexNode ? transform2Param(indexNode) : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 2)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1856,8 +1684,8 @@ function transformForEach2ForEachStatement(node, calleeName, callee, options) {
             value: '0',
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
-        item: transform2Param(arrowFunction.params[0], options) || undefined,
-        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
+        item: transform2Param(arrowFunction.params[0]),
+        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 2)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1867,8 +1695,6 @@ 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);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: 'showMessage',
@@ -1880,8 +1706,6 @@ 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,
@@ -1893,15 +1717,13 @@ 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') {
-            return (0, utils_1.throwError)(options?.parsingId, '调用 connector 的 connect 参数不正确，只允许使用字符串字面量', node);
+            (0, utils_1.throwError)(`调用 connector 的 connect 参数不正确，只允许使用字符串字面量`);
         }
         calleeConnectionName = connectArg.value;
         const noNamespace = callee[3].name === 'logics';
@@ -1916,7 +1738,7 @@ function transformCall2Connector(node, calleeName, callee, options) {
         calleeNamespace = calleeNamespacePrefix;
     }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, `调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`, node);
+        (0, utils_1.throwError)(`调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`);
     }
     return new utils_1.naslTypes.CallConnector({
         calleeConnectionName,
@@ -1929,8 +1751,6 @@ 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,
@@ -1940,26 +1760,70 @@ 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, options) || undefined });
+        return transform2NumericLiteral(node.expression, { ...options, typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation) });
     }
     else if (node.expression.type === 'ArrayExpression') {
-        const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation, options) || undefined;
+        const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation);
         if (typeAnnotation.typeName !== 'List' && typeAnnotation.typeNamespace !== 'nasl.collection')
-            return (0, utils_1.throwError)(options?.parsingId, `列表 as 必须为 List 类型`, node);
+            (0, utils_1.throwError)(`列表 as 必须为 List 类型`);
         return transformArrayExpression(node.expression, { ...options, typeAnnotation });
     }
-    else if (node.expression.type === 'NullLiteral') {
-        return transform2NullLiteral(node.expression, options);
-    }
     else {
-        return (0, utils_1.throwError)(options?.parsingId, '表达式不支持使用 as 关键字', node.expression.type, node.expression);
+        (0, utils_1.throwError)(`表达式 ${node.expression.type} 不支持使用 as 关键字`);
     }
 }
 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),
@@ -1970,13 +1834,11 @@ 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 (server_1.default.getSqlFunction('mysql', calleeName) || calleeName === 'COUNTD') {
+    else if (utils_1.sqlFunctions.includes(calleeName) || calleeName === 'COUNTD') {
         return transform2SqlFunction(node, calleeName, node?.arguments || [], options);
     }
     let newCalleeName = calleeName?.includes('__IDENTIFIER__') ? undefined : calleeName;
@@ -1996,8 +1858,6 @@ 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,
@@ -2022,10 +1882,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')
-                return (0, utils_1.throwError)(options?.parsingId, 'FROM should have a ArrowFunctionExpression as the second argument', node.arguments[1], node);
+                (0, utils_1.throwError)('FROM should have a ArrowFunctionExpression as the second argument');
             const arrowFunctionExpression = node.arguments[1];
             if (arrowFunctionExpression.body.type !== 'CallExpression')
-                return (0, utils_1.throwError)(options?.parsingId, 'FROM should have a CallExpression as the body of ArrowFunctionExpression', arrowFunctionExpression.body, node);
+                (0, utils_1.throwError)('FROM should have a CallExpression as the body of ArrowFunctionExpression');
             const body = arrowFunctionExpression.body;
             const callExpressions = flatChainCallExpression(body);
             const joinNode = callExpressions?.filter((item) => item?.callee?.name.includes('_JOIN'));
@@ -2035,13 +1895,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}的回调函数中进行
 `;
-                return (0, utils_1.throwError)(options?.parsingId, error, node);
+                (0, utils_1.throwError)(error);
             }
             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) {
-                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);
+                (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);
             }
             const result = [{
                     calleeName: calleeName,
@@ -2053,7 +1913,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({
@@ -2086,37 +1946,33 @@ function flatOnExpressions(node) {
         return [node];
     }
 }
-function transformMemberExpression2Entity(node, node2, options) {
+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$/, '');
     if (!entityNamespace?.includes('.entities')) {
-        return (0, utils_1.throwError)(options?.parsingId, `${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询`, node);
+        (0, utils_1.throwError)(`${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询。`);
     }
     const asName = node2.name === entityName ? undefined : node2.name;
     if (asName) {
-        return (0, utils_1.throwError)(options?.parsingId, `FROM 中回调函数的入参名称应为${entityName}，但实际为${node2.name}`);
+        (0, utils_1.throwError)(`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')) {
-        return (0, utils_1.throwError)(options?.parsingId, '数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理', code);
+        (0, utils_1.throwError)('数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理');
     }
     if (!code?.includes('.SELECT(') && !code?.includes('.AGGR_SELECT(')) {
-        return (0, utils_1.throwError)(options?.parsingId, '缺少 SELECT 或 AGGR_SELECT 语句', code);
+        (0, utils_1.throwError)('缺少 SELECT 或 AGGR_SELECT 语句');
     }
     const flatted = flatCallQueryComponentChainNode(node, options);
-    const calleeNames = flatted && flatted.map((item) => item?.calleeName).filter((name) => name !== '$');
+    const calleeNames = flatted.map((item) => item?.calleeName).filter((name) => name !== '$');
     const isOrderCorrect = (0, utils_1.checkOQLCalleeNameOrder)(calleeNames);
     if (!isOrderCorrect) {
-        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);
+        (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);
     }
     let from;
     let where;
@@ -2129,13 +1985,11 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
     let hasErrorTSScopeColumn = false;
     let useResultItem = false;
     // 这里只是一个示例，具体的逻辑需要根据flatted的内容来构建
-    flatted && flatted.forEach((item) => {
+    flatted.forEach((item) => {
         // console.log(item.calleeName)
         switch (item.calleeName) {
             case 'FROM':
-                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1], options);
-                if (!entity)
-                    return;
+                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
                 const entityName = entity.asName || entity.entityName;
                 entityAsNames.push(entityName);
                 from = new utils_1.naslTypes.QueryFromExpression({
@@ -2147,15 +2001,11 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
             case 'LEFT_JOIN':
             case 'RIGHT_JOIN':
             case 'OUTER_JOIN':
-                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1], options);
-                if (!entity)
-                    break;
+                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;
                 const onExpressions = flatOnExpressions(item.arguments[2]);
-                if (!from)
-                    return; // throwError(options?.parsingId, 'FROM 不存在或异常，无法添加 JOIN 子句', node);
                 from.addJoinPart(new utils_1.naslTypes.QueryJoinExpression({
                     ...entity,
                     joinType,
@@ -2172,50 +2022,27 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                 break;
             case 'AGGR_SELECT':
                 if (groupBy?.length) {
-                    return (0, utils_1.throwError)(options?.parsingId, '存在 GROUP_BY，应使用 SELECT 进行查询，但实际为 AGGR_SELECT', node);
+                    (0, utils_1.throwError)('存在 GROUP_BY，应使用 SELECT 进行查询，但实际为 AGGR_SELECT');
                 }
                 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: '',
                         })],
                 });
-                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) {
+                item.arguments[0].properties?.forEach((arg) => {
+                    if (arg?.value.type === 'CallExpression') {
+                        let selectElements = transform2QueryAggregateExpression(arg, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
                         const newSelectElements = [...select.selectElements, selectElements];
                         select.setSelectElements(newSelectElements);
                     }
-                }
-                else {
-                    return (0, utils_1.throwError)(options?.parsingId, 'Unsupported expression type for QueryAggregateExpression', item.arguments[0].type, item.arguments[0]);
-                }
+                    else {
+                        (0, utils_1.throwError)(`Unsupported expression type: ${arg?.value.type} for QueryAggregateExpression`);
+                    }
+                });
                 break;
             case 'SELECT':
                 select = new utils_1.naslTypes.QuerySelectExpression({
@@ -2223,7 +2050,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: '',
                         })] : [],
                 });
@@ -2234,17 +2061,17 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                     else if (arg.value.type === 'ObjectExpression') {
                         if (groupBy?.length) {
-                            return (0, utils_1.throwError)(options?.parsingId, '存在 GROUP_BY，SELECT应为单层结构，不应使用双层局部列', node);
+                            (0, utils_1.throwError)('存在 GROUP_BY，SELECT应为单层结构，不应使用双层局部列');
                         }
                         const originName = arg.key?.name || '';
                         if (originName && originName.charAt(0) === originName.charAt(0).toUpperCase()) {
                             const needName = (0, utils_2.firstLowerCase)(originName);
-                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第一层命名不符合规范, 应为${needName}, 但实际为${originName}`, node);
+                            (0, utils_1.throwError)(`SELECT 局部列第一层命名不符合规范, 应为${needName}, 但实际为${originName}`);
                         }
                         const entityName = (0, utils_2.firstUpperCase)(originName);
                         const needNameList = entityAsNames.map(item => (0, utils_2.firstLowerCase)(item))?.join('或');
                         if (!entityAsNames.includes(entityName)) {
-                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`, node);
+                            (0, utils_1.throwError)(`SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`);
                         }
                         selectElements = arg.value.properties?.map((property) => {
                             const columnAsName = property.key?.name;
@@ -2252,7 +2079,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
-                                return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第二层命名不符合规范, 应为${columnPropertyName}, 但实际为${columnAsName}`, node);
+                                (0, utils_1.throwError)(`SELECT 局部列第二层命名不符合规范, 应为${columnPropertyName}, 但实际为${columnAsName}`);
                             }
                             selectElement.isDotStar = false;
                             return selectElement;
@@ -2287,7 +2114,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, 'HAVING 不符合规范，请使用箭头函数', havingNode, node);
+                    (0, utils_1.throwError)('HAVING 不符合规范，请使用箭头函数');
                 }
                 having = transformNodeFunction(havingNode, { ...options, ...restParams });
                 break;
@@ -2302,7 +2129,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    return (0, utils_1.throwError)(options?.parsingId, 'ORDER_BY 不符合规范，请使用箭头函数', orderNode, node);
+                    (0, utils_1.throwError)('ORDER_BY 不符合规范，请使用箭头函数');
                 }
                 orderBy = orderNode.map((arg) => {
                     let orderElementCode = (0, utils_1.generate)(arg)?.code || '';
@@ -2328,26 +2155,24 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
         ideVersion: '2.22',
     });
     if (hasErrorTSScopeColumn && !groupBy?.length && !having) {
-        return (0, utils_1.throwError)(options?.parsingId, 'SELECT 局部列不符合规范，需要按两层对象返回', node);
+        (0, utils_1.throwError)('SELECT 局部列不符合规范，需要按两层对象返回');
     }
     const hasScopeColumn = select?.selectElements?.find((selectElement) => selectElement?.concept === 'QueryFieldExpression' && !selectElement?.isDotStar);
     if (hasScopeColumn && (groupBy?.length || having)) {
-        return (0, utils_1.throwError)(options?.parsingId, '分组聚合与表字段局部列不允许同时出现', node);
+        (0, utils_1.throwError)('分组聚合与表字段局部列不允许同时出现');
     }
     if (hasScopeColumn && useResultItem) {
-        return (0, utils_1.throwError)(options?.parsingId, "对于局部列的排序，只支持 实体.属性名 的格式，例如 ORDER_BY((resultItem) => [[Student.age, 'ASC']])", node);
+        (0, utils_1.throwError)("对于局部列的排序，只支持 实体.属性名 的格式，例如 ORDER_BY((resultItem) => [[Student.age, 'ASC']])");
     }
     const isOnlyAggr = select?.selectElements?.find((selectElement) => selectElement?.concept !== 'QueryAggregateExpression');
     // 如果 select 中只有聚合属性时，并且没有用 AGGR_SELECT 来指定列
     if (!isOnlyAggr && !calleeNames?.includes('AGGR_SELECT')) {
-        return (0, utils_1.throwError)(options?.parsingId, 'SELECT 不符合规范，请使用 AGGR_SELECT', node);
+        (0, utils_1.throwError)('SELECT 不符合规范，请使用 AGGR_SELECT');
     }
     // 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];
@@ -2386,7 +2211,6 @@ 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);
@@ -2424,8 +2248,7 @@ function transform2LogicItem(node, options) {
         }
     });
     transformManager.register('MemberExpression', transformMemberExpression);
-    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.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);
@@ -2447,14 +2270,15 @@ 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 && !['ArrowFunctionExpression', 'FunctionExpression'].includes(callee[0].type), transformCall2Logic);
+    transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1, transformCall2Logic);
     let result = transformManager.apply(node, options);
     delete options.typeAnnotation;
-    return result || undefined;
+    return result;
 }
 exports.transform2LogicItem = transform2LogicItem;
 //# sourceMappingURL=transform2LogicItem.js.map