@lcap/nasl-language-server-core 4.3.0-beta.0 → 4.3.0-beta.3

package/out/typer/oql-checker/ts-parser.js

@@ -0,0 +1,706 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptNASLParser = void 0;
+const nasl_concepts_1 = require("@lcap/nasl-concepts");
+const ts = __importStar(require("typescript"));
+const chain_call_transformer_1 = require("./chain-call-transformer");
+class TypeScriptNASLParser {
+    constructor() {
+        this.unsupportedTypes = new Set();
+    }
+    /**
+     * 解析TypeScript代码为NASL语法树节点
+     * @param code TypeScript代码字符串
+     * @returns NASL语法树节点
+     */
+    parseToExpression(code) {
+        const ast = this.parseAndTransform(code)?.transformed;
+        if (!ast) {
+            throw new Error('Failed to parse TypeScript code');
+        }
+        const expr = ast.statements;
+        if (!expr) {
+            return undefined;
+        }
+        return undefined;
+    }
+    parseInLogicContext(code, returnName) {
+        const fn = new nasl_concepts_1.Logic();
+        const source = (0, chain_call_transformer_1.transformChainCalls)(code).transformed;
+        const variables = [];
+        const returns = [];
+        const body = [];
+        const syntaxKinds = []; // 收集所有遇到的SyntaxKind
+        // 如果指定了returnName，直接创建Return节点
+        if (returnName) {
+            const returnNode = nasl_concepts_1.Return.createProtoTypeOnly({ name: returnName });
+            returnNode.parentNode = fn;
+            returns.push(returnNode);
+        }
+        const interpret = (node) => {
+            // 记录遇到的node的Syntax类型
+            const syntaxKind = ts.SyntaxKind[node.kind];
+            syntaxKinds.push(syntaxKind); // 添加到数组中
+            if (ts.isVariableDeclaration(node)) {
+                if (!ts.isIdentifier(node.name) || !node.name.escapedText) {
+                    return;
+                }
+                const obj = {
+                    name: node.name.escapedText,
+                };
+                if (node.initializer) {
+                    const expr = interpret(node.initializer);
+                    if (expr) {
+                        const defaultValue = nasl_concepts_1.DefaultValue.createProtoTypeOnly({
+                            expression: expr,
+                            playground: [],
+                        });
+                        defaultValue.parentNode = fn;
+                        expr.parentNode = defaultValue;
+                        obj.defaultValue = defaultValue;
+                    }
+                }
+                if (obj.name === returnName) {
+                    // returnName对应的Return节点已经在方法开始时创建，这里只需要创建Assignment
+                    body.push(new nasl_concepts_1.Assignment({
+                        left: new nasl_concepts_1.Identifier({ name: returnName }),
+                        right: obj.defaultValue?.expression,
+                    }));
+                }
+                else {
+                    const v = nasl_concepts_1.Variable.createProtoTypeOnly(obj);
+                    if (v.defaultValue) {
+                        v.defaultValue.parentNode = v;
+                    }
+                    variables.push(v);
+                }
+                return;
+            }
+            else if (ts.isCallExpression(node)) {
+                const { namespace, name } = this.parseExpressionNamespace(node.expression);
+                const call = new nasl_concepts_1.CallLogic();
+                // 设置调用信息
+                call.calleeName = name;
+                call.calleeNamespace = namespace || '';
+                // 如果是临时变量的Identifier上的调用，在解释时hardcode静态分派
+                if (call.calleeNamespace?.startsWith('$')) {
+                    // 支持方法的动态分派需要大面积重构类型推导机制，非常困难，先不支持
+                    if (name === 'GET' && node.arguments.length > 0) {
+                        // 特殊处理：当callee名为'GET'且参数为boolean值时，根据boolean值是true还是false静态分派callee，并且清空 arguments
+                        const firstArg = node.arguments[0];
+                        if (firstArg.kind === ts.SyntaxKind.TrueKeyword) {
+                            call.calleeName = 'GET_NO_LIST';
+                        }
+                        else {
+                            call.calleeName = 'GET_LIST';
+                        }
+                        call.arguments = [];
+                        return call;
+                    }
+                    else if (name === 'FROM') {
+                        if (node.arguments.length === 0) {
+                            call.calleeName = 'FROM_0';
+                        }
+                        else if (node.arguments.length === 1) {
+                            call.calleeName = 'FROM_1';
+                        }
+                    }
+                    else if (name === 'JOIN') {
+                        if (node.arguments.length === 0) {
+                            call.calleeName = 'JOIN_0';
+                        }
+                        else if (node.arguments.length === 1) {
+                            call.calleeName = 'JOIN_1';
+                        }
+                    }
+                }
+                // 处理类型参数
+                if (node.typeArguments && node.typeArguments.length > 0) {
+                    const typeArgs = [];
+                    node.typeArguments.forEach((typeArg) => {
+                        // 使用interpretType函数解析类型参数
+                        const typeAnnotation = this.interpretType(typeArg);
+                        if (typeAnnotation) {
+                            typeArgs.push(typeAnnotation);
+                        }
+                    });
+                    call.typeArguments = typeArgs;
+                }
+                // 处理参数
+                const args = [];
+                node.arguments.forEach((arg, index) => {
+                    const expression = interpret(arg);
+                    const argument = new nasl_concepts_1.Argument({
+                        keyword: `param${index + 1}`, // 默认参数名
+                        expression: expression,
+                    });
+                    argument.parentNode = call;
+                    if (expression) {
+                        expression.parentNode = argument;
+                    }
+                    args.push(argument);
+                });
+                call.arguments = args;
+                return call;
+            }
+            else if (ts.isArrowFunction(node)) {
+                // ArrowFunction - 箭头函数
+                const func = new nasl_concepts_1.AnonymousFunction();
+                // 处理参数
+                const params = [];
+                node.parameters.forEach((param) => {
+                    if (ts.isParameter(param) && ts.isIdentifier(param.name)) {
+                        const p = new nasl_concepts_1.Param({ name: param.name.text });
+                        p.typeAnnotation = undefined;
+                        p.parentNode = func;
+                        params.push(p);
+                    }
+                    else {
+                        throw new Error('ArrowFunction parameter must be identifier');
+                    }
+                });
+                func.params = params;
+                const body = interpret(node.body);
+                if (body) {
+                    const bodyNode = interpret(node.body);
+                    func.body = bodyNode;
+                    if (bodyNode) {
+                        bodyNode.parentNode = func;
+                    }
+                }
+                else {
+                    // 报错
+                    throw new Error('ArrowFunction body must be non empty');
+                }
+                return func;
+            }
+            else if (node.kind === ts.SyntaxKind.TrueKeyword) {
+                // TrueKeyword - true 字面量
+                return new nasl_concepts_1.BooleanLiteral({ value: 'true' });
+            }
+            else if (node.kind === ts.SyntaxKind.FalseKeyword) {
+                // FalseKeyword - false 字面量
+                return new nasl_concepts_1.BooleanLiteral({ value: 'false' });
+            }
+            else if (ts.isNumericLiteral(node)) {
+                const literal = node;
+                return new nasl_concepts_1.NumericLiteral({ value: literal.text });
+            }
+            else if (ts.isStringLiteral(node)) {
+                // StringLiteral - 字符串字面量
+                return new nasl_concepts_1.StringLiteral({ value: node.text });
+            }
+            else if (ts.isIdentifier(node)) {
+                // Identifier - 标识符
+                return new nasl_concepts_1.Identifier({ name: node.text });
+            }
+            else if (ts.isNewExpression(node)) {
+                // NewExpression - new 表达式
+                const { namespace, name } = this.parseExpressionNamespace(node.expression);
+                // 检查是否是 nasl.core 命名空间下的基本类型构造函数
+                if (namespace === 'nasl.core' && node.arguments && node.arguments.length === 1) {
+                    const firstArg = node.arguments[0];
+                    switch (name) {
+                        case 'Long':
+                        case 'Integer':
+                        case 'Double':
+                        case 'Decimal':
+                            // 数值类型构造函数，转换为 NumericLiteral
+                            if (ts.isNumericLiteral(firstArg)) {
+                                return new nasl_concepts_1.NumericLiteral({ value: firstArg.text });
+                            }
+                            else if (ts.isStringLiteral(firstArg)) {
+                                // 支持字符串形式的数值
+                                return new nasl_concepts_1.NumericLiteral({ value: firstArg.text });
+                            }
+                            break;
+                        case 'String':
+                            // 字符串类型构造函数，转换为 StringLiteral
+                            if (ts.isStringLiteral(firstArg)) {
+                                return new nasl_concepts_1.StringLiteral({ value: firstArg.text });
+                            }
+                            else if (ts.isNumericLiteral(firstArg)) {
+                                // 支持数值转字符串
+                                return new nasl_concepts_1.StringLiteral({ value: firstArg.text });
+                            }
+                            break;
+                        case 'Boolean':
+                            // 布尔类型构造函数，转换为 BooleanLiteral
+                            if (firstArg.kind === ts.SyntaxKind.TrueKeyword) {
+                                return new nasl_concepts_1.BooleanLiteral({ value: 'true' });
+                            }
+                            else if (firstArg.kind === ts.SyntaxKind.FalseKeyword) {
+                                return new nasl_concepts_1.BooleanLiteral({ value: 'false' });
+                            }
+                            else if (ts.isStringLiteral(firstArg)) {
+                                // 支持字符串形式的布尔值
+                                const value = firstArg.text.toLowerCase();
+                                if (value === 'true' || value === 'false') {
+                                    return new nasl_concepts_1.BooleanLiteral({ value });
+                                }
+                            }
+                            break;
+                    }
+                }
+                else if (namespace === 'nasl.oql' && name === 'Query') {
+                    return new nasl_concepts_1.NewComposite({
+                        typeAnnotation: nasl_concepts_1.TypeAnnotation.createProtoTypeOnly({
+                            typeKind: 'reference',
+                            typeName: 'Query',
+                            typeNamespace: namespace,
+                            typeArguments: [
+                                nasl_concepts_1.TypeAnnotation.createProtoTypeOnly({
+                                    typeName: 'InternalTupleType',
+                                    typeNamespace: 'nasl.core',
+                                    typeKind: 'generic',
+                                    typeArguments: [],
+                                }),
+                            ],
+                        }),
+                    });
+                }
+                // 如果不是特殊构造函数，按普通 NewComposite 处理
+                return new nasl_concepts_1.NewComposite({
+                    typeAnnotation: nasl_concepts_1.TypeAnnotation.createReference(name, {
+                        typeNamespace: namespace,
+                    }),
+                });
+            }
+            else if (ts.isObjectLiteralExpression(node)) {
+                // ObjectLiteralExpression - 对象字面量
+                const hasSpread = node.properties.some((prop) => ts.isSpreadAssignment(prop));
+                const args = [];
+                let currentComposite = null;
+                function makeEmptyAnonymousStructure(properties) {
+                    // 为了让NewComposite成为匿名数据结构，需要指定typeAnnotation的typeKind=anonymousStructure；
+                    // 否则会被tpNewComposite判断为具名新建
+                    const res = new nasl_concepts_1.NewComposite({
+                        typeAnnotation: nasl_concepts_1.TypeAnnotation.createProtoTypeOnly({
+                            typeKind: 'anonymousStructure',
+                            properties: properties ?? [],
+                        }),
+                    });
+                    return res;
+                }
+                // 辅助函数：处理属性赋值
+                const processPropertyAssignment = (property, index, composite) => {
+                    let propertyName;
+                    if (ts.isIdentifier(property.name)) {
+                        propertyName = property.name.text;
+                    }
+                    else if (ts.isStringLiteral(property.name)) {
+                        propertyName = property.name.text;
+                    }
+                    else if (ts.isNumericLiteral(property.name)) {
+                        propertyName = property.name.text;
+                    }
+                    else {
+                        propertyName = `property${index}`;
+                    }
+                    const identifier = new nasl_concepts_1.Identifier({ name: propertyName });
+                    const propertyIndex = composite.properties.length;
+                    composite.properties.push(identifier);
+                    const valueExpression = interpret(property.initializer);
+                    if (valueExpression) {
+                        const selectMembers = new nasl_concepts_1.SelectMembers();
+                        selectMembers.expression = valueExpression;
+                        const rightIndex = composite.rights.length;
+                        composite.rights.push(selectMembers);
+                        const assignmentLine = new nasl_concepts_1.AssignmentLine();
+                        assignmentLine.leftIndex = [0, propertyIndex];
+                        assignmentLine.rightIndex = [rightIndex];
+                        composite.assignmentLines.push(assignmentLine);
+                    }
+                };
+                // 按顺序处理每个属性
+                node.properties.forEach((property, index) => {
+                    syntaxKinds.push(ts.SyntaxKind[property.kind]);
+                    if (ts.isSpreadAssignment(property)) {
+                        // 如果有未完成的 composite，先添加它
+                        if (currentComposite && currentComposite.properties.length > 0) {
+                            args.push(new nasl_concepts_1.Argument({ expression: currentComposite }));
+                            currentComposite = null;
+                        }
+                        // 添加展开表达式
+                        const spreadExpression = interpret(property.expression);
+                        if (spreadExpression) {
+                            args.push(new nasl_concepts_1.Argument({ expression: spreadExpression }));
+                        }
+                    }
+                    else if (ts.isPropertyAssignment(property)) {
+                        // 如果还没有 composite，创建一个
+                        if (!currentComposite) {
+                            currentComposite = makeEmptyAnonymousStructure();
+                        }
+                        // 使用共享的属性处理逻辑
+                        processPropertyAssignment(property, index, currentComposite);
+                    }
+                    else {
+                        throw new Error(`ObjectLiteralExpression property type not implemented: ${ts.SyntaxKind[property.kind]}`);
+                    }
+                });
+                // 根据是否有展开操作决定返回类型
+                if (hasSpread) {
+                    // 如果最后还有未完成的 composite，添加它
+                    if (currentComposite && currentComposite.properties.length > 0) {
+                        args.push(new nasl_concepts_1.Argument({ expression: currentComposite }));
+                    }
+                    if (args.length === 0) {
+                        // 不应该接受，随便返回一个空的匿名数据结构即可
+                        return makeEmptyAnonymousStructure();
+                    }
+                    else if (args.length === 1) {
+                        const call = new nasl_concepts_1.CallLogic();
+                        call.calleeName = '$InternalMergeUnary';
+                        call.calleeNamespace = 'nasl.core';
+                        call.arguments = args;
+                        return call;
+                    }
+                    else if (args.length > 1) {
+                        // TODO wudengke 如果不支持多元重载，那么将他递归地翻译成二元$InternalMerge调用的嵌套
+                    }
+                    // 创建 $InternalMerge 调用
+                    const call = new nasl_concepts_1.CallLogic();
+                    call.calleeName = '$InternalMerge';
+                    call.calleeNamespace = 'nasl.core';
+                    call.arguments = args;
+                    return call;
+                }
+                else {
+                    // 没有展开操作，返回单个 composite
+                    return currentComposite || makeEmptyAnonymousStructure();
+                }
+            }
+            else if (ts.isParameter(node)) {
+                // Parameter - 参数
+                if (ts.isIdentifier(node.name)) {
+                    return new nasl_concepts_1.Param({ name: node.name.text });
+                }
+                return new nasl_concepts_1.Param({ name: 'param' });
+            }
+            else if (ts.isParenthesizedExpression(node)) {
+                // ParenthesizedExpression - 括号表达式
+                return interpret(node.expression);
+            }
+            else if (ts.isPropertyAccessExpression(node)) {
+                // PropertyAccessExpression - 属性访问表达式
+                const memberExpr = new nasl_concepts_1.MemberExpression();
+                memberExpr.object = interpret(node.expression);
+                memberExpr.property = new nasl_concepts_1.Identifier({ name: node.name.text });
+                return memberExpr;
+            }
+            else if (ts.isSpreadAssignment(node)) {
+                // SpreadAssignment - 展开赋值
+                throw new Error(`SpreadAssignment not implemented: ${ts.tokenToString(node.kind)}`);
+            }
+            else if (ts.isVariableStatement(node)) {
+            }
+            else if (ts.isVariableDeclarationList(node)) {
+                // VariableDeclarationList - 变量声明列表
+                node.declarations.forEach((decl) => {
+                    if (ts.isVariableDeclaration(decl)) {
+                        interpret(decl);
+                    }
+                });
+                return undefined;
+            }
+            else if (ts.isArrayLiteralExpression(node)) {
+                // 创建 $InternalTuple 调用
+                const call = new nasl_concepts_1.CallLogic();
+                const kind = ts.tokenToString(node.kind) || ts.SyntaxKind[node.kind];
+                const args = node?.elements?.map?.((element, index) => {
+                    const keyword = `$ArrayParams${index + 1}`;
+                    const expression = interpret(element);
+                    const argument = new nasl_concepts_1.Argument({ keyword, expression });
+                    argument.parentNode = call;
+                    expression && (expression.parentNode = argument);
+                    return argument;
+                }) || [];
+                call.calleeName = `$InternalTuple${args.length}`;
+                call.calleeNamespace = 'nasl.core';
+                call.arguments = args;
+                return call;
+            }
+            else if (ts.isParenthesizedExpression(node)) {
+                return interpret(node.expression);
+            }
+            else if (ts.isExpressionStatement(node)) {
+                return interpret(node.expression);
+            }
+            else if (ts.isBinaryExpression(node)) {
+                const result = new nasl_concepts_1.BinaryExpression();
+                result.left = interpret(node.left);
+                result.right = interpret(node.right);
+                result.operator = node.operatorToken.getText();
+                return result;
+            }
+            else if (ts.isElementAccessExpression(node)) {
+                const result = new nasl_concepts_1.CallFunction();
+                result.calleeName = 'Get';
+                result.calleeNamespace = 'nasl.util';
+                result.arguments = [
+                    interpret(node.expression),
+                    interpret(node.argumentExpression),
+                ];
+                return result;
+            }
+            else if (ts.SyntaxKind.NullKeyword === node.kind) {
+                const result = new nasl_concepts_1.NullLiteral();
+                return result;
+            }
+            else if (ts.isSourceFile(node)) {
+                // SourceFile 节点不需要处理
+            }
+            else {
+                // 收集未支持的表达式类型
+                const kind = ts.tokenToString(node.kind) || ts.SyntaxKind[node.kind];
+                this.unsupportedTypes.add(kind);
+                throw new Error(`未支持的表达式类型: ${kind}`);
+            }
+            ts.visitEachChild(node, visitor, undefined);
+            return undefined;
+        };
+        // 创建visitor函数来遍历AST节点
+        const visitor = (node) => {
+            interpret(node);
+            return node;
+        };
+        // 遍历source中的所有变量声明，将它收集到variables中
+        ts.visitNode(source, visitor);
+        fn.variables = variables;
+        fn.body = body;
+        fn.returns = returns;
+        // 打印统计的未支持表达式类型
+        this.printUnsupportedTypes();
+        // 输出收集到的所有SyntaxKind数组
+        // console.log('[TS-Parser] 去重后的SyntaxKind:', [...new Set(syntaxKinds)]);
+        // @ts-expect-error
+        fn.parentNode = { concept: 'App' };
+        return fn;
+    }
+    parseAndTransform(code) {
+        try {
+            return (0, chain_call_transformer_1.transformChainCalls)(code);
+        }
+        catch (error) {
+            console.error('Failed to parse TypeScript code:', error);
+            return null;
+        }
+    }
+    parse(code) {
+        try {
+            const sourceFile = ts.createSourceFile('temp.ts', code, ts.ScriptTarget.Latest, true);
+            return sourceFile;
+        }
+        catch (error) {
+            console.error('Failed to parse TypeScript code:', error);
+            return null;
+        }
+    }
+    /**
+     * 打印统计的未支持表达式类型
+     */
+    printUnsupportedTypes() {
+        if (this.unsupportedTypes.size > 0) {
+            console.log('\n=== 未支持的表达式类型统计 ===');
+            console.log(`总计: ${this.unsupportedTypes.size} 种类型`);
+            const sortedTypes = Array.from(this.unsupportedTypes).sort();
+            sortedTypes.forEach((type, index) => {
+                console.log(`${index + 1}. ${type}`);
+            });
+            console.log('================================\n');
+        }
+    }
+    /**
+     * 清空未支持类型统计
+     */
+    clearUnsupportedTypes() {
+        this.unsupportedTypes.clear();
+    }
+    /**
+     * 获取未支持类型列表
+     */
+    getUnsupportedTypes() {
+        return Array.from(this.unsupportedTypes);
+    }
+    /**
+     * 解析表达式，提取 namespace 和 name
+     * @param expression TypeScript 表达式节点
+     * @returns { namespace?: string, name: string }
+     *
+     * 示例：
+     * - a.b.c -> { namespace: "a.b", name: "c" }
+     * - c -> { name: "c" }
+     */
+    parseExpressionNamespace(expression) {
+        if (ts.isPropertyAccessExpression(expression)) {
+            // 处理 a.b.c 形式
+            const parts = [];
+            let current = expression;
+            // 从右到左收集所有部分
+            while (ts.isPropertyAccessExpression(current)) {
+                parts.unshift(current.name.text);
+                current = current.expression;
+            }
+            // 最左边应该是一个 Identifier
+            if (ts.isIdentifier(current)) {
+                parts.unshift(current.text);
+            }
+            else {
+                // 如果不是 Identifier，使用 getText() 作为备选
+                parts.unshift(current.getText());
+            }
+            if (parts.length === 1) {
+                // 只有一个部分，没有 namespace
+                return { name: parts[0] };
+            }
+            else {
+                // 多个部分，最后一个是 name，其余是 namespace
+                const name = parts.pop();
+                const namespace = parts.join('.');
+                return { namespace, name };
+            }
+        }
+        else if (ts.isIdentifier(expression)) {
+            // 处理单独的标识符 c
+            return { name: expression.text };
+        }
+        else {
+            // 其他类型的表达式，使用 getText() 作为 name
+            return { name: expression.getText() };
+        }
+    }
+    /**
+     * 解析TypeScript的TypeNode为NASL的TypeAnnotation
+     * @param typeNode TypeScript 类型节点
+     * @returns TypeAnnotation 或 undefined
+     */
+    interpretType(typeNode) {
+        const syntaxKind = ts.SyntaxKind[typeNode.kind];
+        if (ts.isTypeReferenceNode(typeNode)) {
+            // 处理类型引用节点，如 Array<T> 或 MyType
+            const typeName = typeNode.typeName;
+            let namespace;
+            let name;
+            if (ts.isQualifiedName(typeName)) {
+                // 处理限定名，如 A.B.C
+                const parts = [];
+                let current = typeName;
+                while (ts.isQualifiedName(current)) {
+                    parts.unshift(current.right.text);
+                    current = current.left;
+                }
+                if (ts.isIdentifier(current)) {
+                    parts.unshift(current.text);
+                }
+                if (parts.length === 1) {
+                    name = parts[0];
+                }
+                else {
+                    name = parts.pop();
+                    namespace = parts.join('.');
+                }
+            }
+            else if (ts.isIdentifier(typeName)) {
+                // 简单标识符
+                name = typeName.text;
+            }
+            else {
+                name = typeNode.getText();
+            }
+            const typeAnnotation = nasl_concepts_1.TypeAnnotation.createReference(name, {
+                typeNamespace: namespace,
+            });
+            // 处理泛型参数
+            if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+                const genericArgs = [];
+                typeNode.typeArguments.forEach((arg) => {
+                    const argType = this.interpretType(arg);
+                    if (argType) {
+                        genericArgs.push(argType);
+                    }
+                });
+                typeAnnotation.typeArguments = genericArgs;
+            }
+            return typeAnnotation;
+        }
+        else if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
+            // string 类型
+            return nasl_concepts_1.TypeAnnotation.createReference('String');
+        }
+        else if (typeNode.kind === ts.SyntaxKind.NumberKeyword) {
+            // number 类型
+            return nasl_concepts_1.TypeAnnotation.createReference('Double');
+        }
+        else if (typeNode.kind === ts.SyntaxKind.BooleanKeyword) {
+            // boolean 类型
+            return nasl_concepts_1.TypeAnnotation.createReference('Boolean');
+        }
+        else if (typeNode.kind === ts.SyntaxKind.VoidKeyword) {
+            // void 类型
+            return nasl_concepts_1.TypeAnnotation.createReference('Void');
+        }
+        else if (typeNode.kind === ts.SyntaxKind.AnyKeyword) {
+            // any 类型
+            return nasl_concepts_1.TypeAnnotation.createReference('Any');
+        }
+        else if (ts.isArrayTypeNode(typeNode)) {
+            // 数组类型，如 string[]
+            const elementType = this.interpretType(typeNode.elementType);
+            if (elementType) {
+                return nasl_concepts_1.TypeAnnotation.createReference('List', {
+                    typeArguments: [elementType],
+                });
+            }
+        }
+        else if (ts.isUnionTypeNode(typeNode)) {
+            // 联合类型，如 string | number
+            // 暂时取第一个类型作为主要类型
+            if (typeNode.types.length > 0) {
+                return this.interpretType(typeNode.types[0]);
+            }
+        }
+        else if (ts.isLiteralTypeNode(typeNode)) {
+            // 字面量类型，如 "hello" | 42
+            if (ts.isStringLiteral(typeNode.literal)) {
+                return nasl_concepts_1.TypeAnnotation.createReference('String');
+            }
+            else if (ts.isNumericLiteral(typeNode.literal)) {
+                return nasl_concepts_1.TypeAnnotation.createReference('Double');
+            }
+            else if (typeNode.literal.kind === ts.SyntaxKind.TrueKeyword ||
+                typeNode.literal.kind === ts.SyntaxKind.FalseKeyword) {
+                return nasl_concepts_1.TypeAnnotation.createReference('Boolean');
+            }
+        }
+        // 收集未支持的类型
+        this.unsupportedTypes.add(syntaxKind);
+        // 默认返回Any类型
+        return nasl_concepts_1.TypeAnnotation.createReference('Any');
+    }
+}
+exports.TypeScriptNASLParser = TypeScriptNASLParser;
+//# sourceMappingURL=ts-parser.js.map