@lcap/nasl 4.1.0-beta.8 → 4.1.0-creator.1

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.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;
 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)(`不支持连续调用！`);
+                (0, utils_1.throwError)('不支持连续调用！', 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')) {
+                        (0, utils_1.throwError)('不支持连续调用！', 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}`);
+            (0, utils_1.throwError)(`Unhandled node ${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}`);
+            (0, utils_1.throwError)('Unhandled node', node.type, node);
         }
     }
 }
@@ -124,17 +123,21 @@ function transformTSCode2SubLogic(node, options) {
 }
 function assertAssignmentRightIsNotAnonymousFunction(expression) {
     if (expression?.concept === 'AnonymousFunction')
-        (0, utils_1.throwError)('Anonymous function is not allowed in assignment');
+        (0, utils_1.throwError)('Anonymous function is not allowed in assignment', expression.toNaturalTS());
     return expression;
 }
 function fixExpression(arg, options, supportSubLogic = false) {
     let expression;
     if (options.transformType === 'logic' && supportSubLogic &&
-        (arg?.type === 'FunctionExpression' ||
-            (arg?.type === 'ArrowFunctionExpression' && arg?.body?.type === 'BlockStatement'))) {
-        // 如果是匿名函数，且有多个表达式，返回 SubLogic
-        // 如果是具名函数，返回 SubLogic
-        expression = transformTSCode2SubLogic(arg, options);
+        (arg?.type === 'FunctionExpression' || (arg?.type === 'ArrowFunctionExpression'))) {
+        if (arg?.body?.type === 'BlockStatement') {
+            expression = transformTSCode2SubLogic(arg, options);
+        }
+        else {
+            const babelReturnStatement = utils_1.babelTypes.returnStatement(arg.body);
+            arg.body = utils_1.babelTypes.blockStatement([babelReturnStatement]);
+            expression = transformTSCode2SubLogic(arg, options);
+        }
     }
     else {
         if (arg?.body?.type === 'ReturnStatement') {
@@ -228,16 +231,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
@@ -265,7 +281,7 @@ function transform2Param(node) {
             name,
             typeAnnotation,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
+                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -279,7 +295,7 @@ function transform2Param(node) {
             name,
             typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
+                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -294,7 +310,7 @@ function transform2Param(node) {
             required: !node.optional,
             typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
+                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -317,12 +333,12 @@ function transform2Param(node) {
             name,
             typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr' }),
+                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr', isRestricted: true }),
             }),
         });
     }
     else {
-        (0, utils_1.throwError)(`Unhandled node ${node}`);
+        (0, utils_1.throwError)('Unhandled node', node);
     }
 }
 exports.transform2Param = transform2Param;
@@ -341,6 +357,12 @@ 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),
@@ -420,11 +442,21 @@ function transform2BinaryExpression(node, options) {
             right: transformNodeFunction(node.right, options),
         });
     }
-    (0, utils_1.throwError)(`Unhandled node ${node.type}`);
+    (0, utils_1.throwError)('Unhandled node', 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;
+        (0, utils_1.throwError)(`数据查询中不支持条件表达式！${(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,7 +483,7 @@ function transformConditionalExpression(node, options) {
                 isMatchedTypeEnumable: true,
             }),
             new utils_1.naslTypes.MatchCase({
-                patterns: [alternate],
+                patterns: [],
                 body: [alternate],
             }),
         ],
@@ -467,13 +499,30 @@ function transformArrayExpression(node, options) {
     });
 }
 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 {
+                (0, utils_1.throwError)('Do not allow NullLiteral without type, you can use as to carry the type', node);
+            }
+        }
+        else if (itemValue.type === 'TSAsExpression') {
+            const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(itemValue.typeAnnotation);
+            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,7 +549,7 @@ function transform2NewExpression(calleeName, node, options) {
             });
         }
         if (node?.arguments && node?.arguments?.[0]?.type !== 'ArrayExpression') {
-            (0, utils_1.throwError)(`Not allowed code ${(0, utils_1.generate)(node).code} in NewList`);
+            (0, utils_1.throwError)('Not allowed code in NewList', node);
         }
         return new utils_1.naslTypes.NewList({
             typeAnnotation: node?.typeParameters ? typeAnnotation : undefined,
@@ -533,13 +582,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`);
+            (0, utils_1.throwError)('Not allowed empty namespace in 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}`);
+    (0, utils_1.throwError)('Unhandled ArrowFunctionExpression node', node.type, node);
 }
 function pushElseIf(ifNode, switchStatement, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
@@ -636,7 +685,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) {
@@ -773,6 +822,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,
     });
@@ -801,7 +860,7 @@ function transform2SelectQueryFieldExpression(node, options) {
         // @TODO
     }
     else {
-        (0, utils_1.throwError)(`Unsupported expression type: ${expression.type} for QueryFieldExpression`);
+        (0, utils_1.throwError)('Unsupported expression type for QueryFieldExpression', expression.type, expression);
     }
 }
 function transform2QueryAggregateExpression(node, options) {
@@ -823,7 +882,7 @@ 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');
+        (0, utils_1.throwError)('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)),
@@ -990,7 +1049,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));
@@ -1083,8 +1142,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}`);
+    (0, utils_1.throwError)('Unhandled node', node.type, node);
 }
 exports.transformNewExpression = transformNewExpression;
 function transformMemberExpression(node, options) {
@@ -1121,18 +1179,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) {
+                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)) {
@@ -1187,12 +1258,87 @@ 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') {
+        (0, utils_1.throwError)('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 {
+                    (0, utils_1.throwError)('Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                }
+            }
+            else {
+                if (_case.consequent.type === 'ReturnStatement') {
+                    argument = _case.consequent.argument;
+                }
+                else {
+                    (0, utils_1.throwError)('Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                }
+            }
+            return new utils_1.naslTypes.MatchCase({
+                isMatchedTypeEnumable: false,
+                patterns: !_case.test ? [] : flatMatchPatternsExpression(transformNodeFunction(_case.test, options)),
+                body: [transformNodeFunction(argument, options)],
+            });
+        }),
+    });
+    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)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
     if (calleeName?.includes('getPropValue') || calleeName?.includes('setPropValue')) {
         const componentName = callee?.[1]?.name;
         const propertyName = node?.arguments?.[0]?.value;
@@ -1227,6 +1373,8 @@ function transformCall2CallViewElementLogic(node, calleeName, callee, options) {
 }
 exports.transformCall2CallViewElementLogic = transformCall2CallViewElementLogic;
 function transformCall2CallEntityLogic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
     const entityName = callee[0].name.replace(/Entity$/, '');
     // console.log('callee', callee);
     return new utils_1.naslTypes.CallLogic({
@@ -1239,6 +1387,8 @@ function transformCall2CallEntityLogic(node, calleeName, callee, options) {
 }
 exports.transformCall2CallEntityLogic = transformCall2CallEntityLogic;
 function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', 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$/, '');
@@ -1297,6 +1447,10 @@ function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
 }
 exports.transformCall2CallDataSourceLogic = transformCall2CallDataSourceLogic;
 function transformCall2OQLQuery(node, calleeName, callee, options) {
+    if (options?.isInFrontend)
+        (0, utils_1.throwError)('OQL组件不支持在前端使用', node);
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('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 })),
@@ -1311,6 +1465,8 @@ function transformCall2OQLQuery(node, calleeName, callee, options) {
     }
 }
 function transformCall2ConsoleLog(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.logging',
         calleeName: 'INFO',
@@ -1322,6 +1478,8 @@ function transformCall2ConsoleLog(node, calleeName, callee, options) {
 }
 exports.transformCall2ConsoleLog = transformCall2ConsoleLog;
 function transformCall2Logging(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
     const newArguments = node.arguments.map((arg) => new utils_1.naslTypes.Argument({
         expression: arg?.name === "undefined" ?
             new utils_1.naslTypes.StringLiteral()
@@ -1360,16 +1518,22 @@ exports.transformCall2JSONFunctions = transformCall2JSONFunctions;
 function transform2CallFunction(node, calleeName, argument, options) {
     calleeName = utils_1.replaceCallFunctionMap?.[calleeName] || calleeName;
     const func = server_1.default ? server_1.default.getBuildInFunction(calleeName) : null;
-    let newArguments = argument.map((arg, index) => new utils_1.naslTypes.Argument({
-        expression: fixExpression(arg, options, true),
-        keyword: func && func?.params[index]?.name || `param${index + 1}`,
-    }));
+    let newArguments = argument.map((arg, index) => {
+        let supportSubLogic = false;
+        if (arg?.type === 'FunctionExpression' || (arg?.type === 'ArrowFunctionExpression' && arg?.body?.type === 'BlockStatement')) {
+            supportSubLogic = true;
+        }
+        return new utils_1.naslTypes.Argument({
+            expression: fixExpression(arg, options, supportSubLogic),
+            keyword: func && func?.params[index]?.name || `param${index + 1}`,
+        });
+    });
     let newTypeArguments = node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation);
-    if (calleeName === 'ListRepeat') {
-        newTypeArguments = [
-            new utils_1.naslTypes.TypeAnnotation()
-        ];
-    }
+    // if (calleeName === 'ListRepeat') {
+    //   newTypeArguments = [
+    //     new naslTypes.TypeAnnotation()
+    //   ];
+    // }
     if (calleeName === 'Concat') {
         const expressions = newArguments.map((item) => item.expression);
         return new utils_1.naslTypes.StringInterpolation({
@@ -1431,7 +1595,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         });
     }
     else {
-        (0, utils_1.throwError)(`函数${calleeName}不存在`);
+        (0, utils_1.throwError)(`函数${calleeName}不存在`, node.callee);
     }
     if (!func.params?.length) {
         const needDefaultParam = ['CurrDate', 'CurrTime', 'CurrDateTime'];
@@ -1473,7 +1637,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         return new utils_1.naslTypes.CallFunction((0, utils_1.handleListSort)(nodeElement?.toJSON()));
     }
     if (options.transformType === 'logic' && options?.inCallQueryComponentField) {
-        (0, utils_1.throwError)(`数据查询中不支持内置函数${nodeElement.calleeName}`);
+        (0, utils_1.throwError)('数据查询中不支持使用内置函数', nodeElement.calleeName, node);
     }
     return nodeElement;
 }
@@ -1483,6 +1647,8 @@ function transform2SqlFunction(node, calleeName, argument, options) {
         (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';
@@ -1495,7 +1661,7 @@ 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',
@@ -1508,7 +1674,7 @@ function transform2SqlFunction(node, calleeName, argument, options) {
 }
 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;
@@ -1516,11 +1682,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);
     }
@@ -1529,10 +1694,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') {
@@ -1548,7 +1734,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,
         });
@@ -1558,6 +1744,8 @@ function transform2UIFunction(node, calleeName, callee, options) {
             link: fixExpression(node?.arguments[0], options),
         });
     }
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: callee[2].name,
@@ -1677,6 +1865,8 @@ function transformForEach2ForEachStatement(node, calleeName, callee, options) {
 }
 exports.transformForEach2ForEachStatement = transformForEach2ForEachStatement;
 function transformAlert2ShowMessage(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: 'showMessage',
@@ -1688,6 +1878,8 @@ function transformAlert2ShowMessage(node, calleeName, callee, options) {
 }
 exports.transformAlert2ShowMessage = transformAlert2ShowMessage;
 function transformCall2Interface(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用接口不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallInterface({
         calleeNamespace: (0, utils_1.generate)(node.callee.object).code,
         calleeName: callee[callee.length - 1].name,
@@ -1699,13 +1891,15 @@ function transformCall2Interface(node, calleeName, callee, options) {
 }
 exports.transformCall2Interface = transformCall2Interface;
 function transformCall2Connector(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用连接器不支持在组件或默认值表达式中使用', 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 参数不正确，只允许使用字符串字面量`);
+            (0, utils_1.throwError)('调用 connector 的 connect 参数不正确，只允许使用字符串字面量', node);
         }
         calleeConnectionName = connectArg.value;
         const noNamespace = callee[3].name === 'logics';
@@ -1720,7 +1914,7 @@ function transformCall2Connector(node, calleeName, callee, options) {
         calleeNamespace = calleeNamespacePrefix;
     }
     else {
-        (0, utils_1.throwError)(`调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`);
+        (0, utils_1.throwError)(`调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`, node);
     }
     return new utils_1.naslTypes.CallConnector({
         calleeConnectionName,
@@ -1733,64 +1927,17 @@ function transformCall2Connector(node, calleeName, callee, options) {
 }
 exports.transformCall2Connector = transformCall2Connector;
 function transformCall2Extension(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用扩展逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: (0, utils_1.generate)(node?.callee?.object)?.code,
         calleeName: callee?.[callee?.length - 1]?.name,
         arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
-            expression: fixExpression(arg, options),
+            expression: fixExpression(arg, options, true),
         })),
     });
 }
 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) });
@@ -1801,11 +1948,16 @@ function transformTSAsExpression(node, options) {
             (0, utils_1.throwError)(`列表 as 必须为 List 类型`);
         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 关键字`);
+        (0, utils_1.throwError)('表达式不支持使用 as 关键字', node.expression.type, node.expression);
     }
 }
 function transformCall2CallViewLogic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用页面逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: '',
         calleeName: calleeName.slice('viewLogic_'.length),
@@ -1816,11 +1968,13 @@ function transformCall2CallViewLogic(node, calleeName, callee, options) {
 }
 exports.transformCall2CallViewLogic = transformCall2CallViewLogic;
 function transformCall2Logic(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', 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;
@@ -1834,12 +1988,14 @@ function transformCall2Logic(node, calleeName, callee, options) {
         calleeNamespace,
         calleeName: newCalleeName,
         arguments: node?.arguments?.map((arg) => new utils_1.naslTypes.Argument({
-            expression: fixExpression(arg, options),
+            expression: fixExpression(arg, options, true),
         })),
     });
 }
 exports.transformCall2Logic = transformCall2Logic;
 function transformCall2LogicWithAuth(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: `nasl.auth`,
         calleeName: callee[callee.length - 1].name,
@@ -1864,10 +2020,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');
+                (0, utils_1.throwError)('FROM should have a ArrowFunctionExpression as the second argument', node.arguments[1]);
             const arrowFunctionExpression = node.arguments[1];
             if (arrowFunctionExpression.body.type !== 'CallExpression')
-                (0, utils_1.throwError)('FROM should have a CallExpression as the body of ArrowFunctionExpression');
+                (0, utils_1.throwError)('FROM should have a CallExpression as the body of ArrowFunctionExpression', arrowFunctionExpression.body);
             const body = arrowFunctionExpression.body;
             const callExpressions = flatChainCallExpression(body);
             const joinNode = callExpressions?.filter((item) => item?.callee?.name.includes('_JOIN'));
@@ -1883,7 +2039,7 @@ FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id).SELECT(...))); /
             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);
+                (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 的调用顺序。');
             }
             const result = [{
                     calleeName: calleeName,
@@ -1933,7 +2089,7 @@ function transformMemberExpression2Entity(node, node2) {
     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} 不是一个数据库表，无法使用数据查询。`);
+        (0, utils_1.throwError)(`${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询`);
     }
     const asName = node2.name === entityName ? undefined : node2.name;
     if (asName) {
@@ -1942,19 +2098,23 @@ function transformMemberExpression2Entity(node, node2) {
     return { entityNamespace, entityName, asName };
 }
 function transformCall2DataQuery(node, calleeName, callee, options) {
+    if (options?.isInFrontend)
+        (0, utils_1.throwError)('数据查询组件不支持在前端使用', node);
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('数据查询组件不支持在组件或默认值表达式中使用', 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内的库函数，请将对应操作放在数据查询外部进行处理');
+        (0, utils_1.throwError)('数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理', code);
     }
     if (!code?.includes('.SELECT(') && !code?.includes('.AGGR_SELECT(')) {
-        (0, utils_1.throwError)('缺少 SELECT 或 AGGR_SELECT 语句');
+        (0, utils_1.throwError)('缺少 SELECT 或 AGGR_SELECT 语句', code);
     }
     const flatted = flatCallQueryComponentChainNode(node, options);
     const calleeNames = 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);
+        (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 的调用顺序。');
     }
     let from;
     let where;
@@ -2015,16 +2175,35 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                             propertyName: '',
                         })],
                 });
-                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 {
-                        (0, utils_1.throwError)(`Unsupported expression type: ${arg?.value.type} for QueryAggregateExpression`);
-                    }
-                });
+                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 });
+                            const newSelectElements = [...select.selectElements, selectElements];
+                            select.setSelectElements(newSelectElements);
+                        }
+                        else {
+                            (0, utils_1.throwError)(`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 });
+                    const newSelectElements = [...select.selectElements, selectElements];
+                    select.setSelectElements(newSelectElements);
+                }
+                else {
+                    (0, utils_1.throwError)('Unsupported expression type for QueryAggregateExpression', item.arguments[0].type, item.arguments[0]);
+                }
                 break;
             case 'SELECT':
                 select = new utils_1.naslTypes.QuerySelectExpression({
@@ -2096,7 +2275,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    (0, utils_1.throwError)('HAVING 不符合规范，请使用箭头函数');
+                    (0, utils_1.throwError)('HAVING 不符合规范，请使用箭头函数', havingNode);
                 }
                 having = transformNodeFunction(havingNode, { ...options, ...restParams });
                 break;
@@ -2111,7 +2290,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    (0, utils_1.throwError)('ORDER_BY 不符合规范，请使用箭头函数');
+                    (0, utils_1.throwError)('ORDER_BY 不符合规范，请使用箭头函数', orderNode);
                 }
                 orderBy = orderNode.map((arg) => {
                     let orderElementCode = (0, utils_1.generate)(arg)?.code || '';
@@ -2155,6 +2334,8 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
     return callQueryComponent;
 }
 function transformCall2LaunchProcess(node, calleeName, callee, options) {
+    if (options?.isRestricted)
+        (0, utils_1.throwError)('调用流程逻辑不支持在组件或默认值表达式中使用', node);
     const args = node.arguments;
     const dataArg = args?.[0];
     const procDefKeyArg = args?.[1];
@@ -2193,6 +2374,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);
@@ -2230,7 +2412,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);
@@ -2252,12 +2435,11 @@ 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;