@lcap/nasl 3.4.0-beta.6 → 3.5.0-alpha.1

package/out/concepts/basics/stdlib/nasl.util.js

@@ -3,165 +3,176 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTimezoneParam = void 0;
+exports.initialize = exports.createTimezoneParam = void 0;
 const Namespace__1 = __importDefault(require("../../Namespace__"));
-const Param__1 = __importDefault(require("../../Param__"));
-const Return__1 = __importDefault(require("../../Return__"));
-const Logic__1 = __importDefault(require("../../Logic__"));
-const Function__1 = __importDefault(require("../../Function__"));
-const TypeAnnotation__1 = __importDefault(require("../../TypeAnnotation__"));
-const TypeParam__1 = __importDefault(require("../../TypeParam__"));
-const NumericLiteral__1 = __importDefault(require("../../NumericLiteral__"));
-const Identifier__1 = __importDefault(require("../../Identifier__"));
-const BooleanLiteral__1 = __importDefault(require("../../BooleanLiteral__"));
-const StringLiteral__1 = __importDefault(require("../../StringLiteral__"));
-const AnonymousFunction__1 = __importDefault(require("../../AnonymousFunction__"));
-const StringInterpolation__1 = __importDefault(require("../../StringInterpolation__"));
-const NewList__1 = __importDefault(require("../../NewList__"));
-const DefaultValue__1 = __importDefault(require("../../DefaultValue__"));
 const timeZone_1 = require("./timeZone");
-const createTimezoneParam = (fnName) => new Param__1.default({
-    name: '时区',
-    description: '以此时区为基准',
-    useComponent: { type: 's-bidirectional-bind-switch' },
-    defaultExpression: new StringLiteral__1.default({
-        name: `${fnName}TimeZoneDefaultExpression`,
-        value: 'global'
-    }),
-    options: timeZone_1.TIMEZONES,
-    hidden: true,
-});
+const decorators_1 = require("../../../decorators");
+const createTimezoneParam = (fnName) => {
+    const Param = (0, decorators_1.getConceptConstructor)('Param');
+    const StringLiteral = (0, decorators_1.getConceptConstructor)('StringLiteral');
+    return new Param({
+        name: '时区',
+        description: '以此时区为基准',
+        useComponent: { type: 's-bidirectional-bind-switch' },
+        defaultExpression: new StringLiteral({
+            name: `${fnName}TimeZoneDefaultExpression`,
+            value: 'global'
+        }),
+        options: timeZone_1.TIMEZONES,
+        hidden: true,
+    });
+};
 exports.createTimezoneParam = createTimezoneParam;
-exports.default = new Namespace__1.default({
+const utilNamespace = new Namespace__1.default({
     name: 'util',
-    logics: [
-        new Logic__1.default({
+    logics: [],
+    functions: [],
+});
+exports.default = utilNamespace;
+/** @internal */
+function initialize() {
+    const TypeAnnotation = (0, decorators_1.getConceptConstructor)('TypeAnnotation');
+    const Logic = (0, decorators_1.getConceptConstructor)('Logic');
+    const Param = (0, decorators_1.getConceptConstructor)('Param');
+    const Return = (0, decorators_1.getConceptConstructor)('Return');
+    const Function = (0, decorators_1.getConceptConstructor)('Function');
+    const AnonymousFunction = (0, decorators_1.getConceptConstructor)('AnonymousFunction');
+    const StringInterpolation = (0, decorators_1.getConceptConstructor)('StringInterpolation');
+    const TypeParam = (0, decorators_1.getConceptConstructor)('TypeParam');
+    const Identifier = (0, decorators_1.getConceptConstructor)('Identifier');
+    const BooleanLiteral = (0, decorators_1.getConceptConstructor)('BooleanLiteral');
+    const NumericLiteral = (0, decorators_1.getConceptConstructor)('NumericLiteral');
+    const StringLiteral = (0, decorators_1.getConceptConstructor)('StringLiteral');
+    const NewList = (0, decorators_1.getConceptConstructor)('NewList');
+    const DefaultValue = (0, decorators_1.getConceptConstructor)('DefaultValue');
+    const logics = [
+        new Logic({
             name: 'consoleLog',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'arg',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
-                    defaultExpression: new StringInterpolation__1.default(),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultExpression: new StringInterpolation(),
                 }),
             ],
         }),
-        new Logic__1.default({
+        new Logic({
             name: 'jsonSerialize',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'arg',
                 }),
             ],
             returns: [
-                new Return__1.default({
+                new Return({
                     name: 'result',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Logic__1.default({
+        new Logic({
             name: 'jsonDeserialize',
             typeParams: [
-                new TypeParam__1.default({
+                new TypeParam({
                     name: 'T',
                 }),
             ],
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'arg',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
+                new Return({
                     name: 'result',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                     useComponent: { type: 's-datatype-select' },
                 }),
             ],
         }),
-    ],
-    functions: [
-        new Function__1.default({
+    ];
+    const functions = [
+        new Function({
             name: 'Convert',
             description: '各基础数据类型之间转换',
             typeParams: [
-                new TypeParam__1.default({
+                new TypeParam({
                     name: 'T',
                 }),
             ],
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'value',
                     description: '选择变量或常量',
-                    defaultExpression: new Identifier__1.default(),
+                    defaultExpression: new Identifier(),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ToString',
             description: '各类型转换成字符串',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'value',
                     description: '待转成字符串的表达式',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Any'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Any'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'FromString',
             description: '字符串转换成其他类型',
             typeParams: [
-                new TypeParam__1.default({
+                new TypeParam({
                     name: 'T',
                 }),
             ],
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'value',
-                    defaultExpression: new Identifier__1.default(),
+                    defaultExpression: new Identifier(),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'IndexOf',
             description: '搜索字符串位置',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'str',
                     description: '指定字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'search',
                     description: '指定需要搜索的字段，String类型',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'fromIndex',
                     description: '开始搜索的索引值，Integer类型，用数字表示第几项，项数索引从0开始',
-                    defaultExpression: new NumericLiteral__1.default({ value: '0' }),
+                    defaultExpression: new NumericLiteral({ value: '0' }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'ignoreCase',
                     description: '是否忽略大小写，true为忽略，false为不忽略',
-                    defaultExpression: new BooleanLiteral__1.default({ value: 'true' }),
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
                         {
                             text: 'true',
@@ -177,29 +188,29 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'LastIndexOf',
             description: '从末尾搜索字符串位置',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'str',
                     description: '指定字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'search',
                     description: '指定需要搜索的字段，String类型',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'ignoreCase',
                     description: '是否忽略大小写，true为忽略，false为不忽略',
-                    defaultExpression: new BooleanLiteral__1.default({ value: 'true' }),
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
                         {
                             text: 'true',
@@ -215,511 +226,511 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Replace',
             description: '字符串替换。返回替换后的新字符串。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'str',
                     description: '指定原始字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'search',
                     description: '指定原始字符串中需要被替换的字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'replace',
                     description: '指定进行替换操作的字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'SubString',
             description: '字符串截取。返回截取的字符串。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'str',
                     description: '指定需要截取的字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'start',
                     description: 'int类型，输入数字指定开始截取的位置',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'length',
                     description: '指定截取的字符串长度',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'EnumToList',
             description: '返回枚举value和text的List集合',
             typeParams: [
-                new TypeParam__1.default({
+                new TypeParam({
                     name: 'enum',
                     useComponent: { type: 's-enum-select' },
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createPrimitive('String')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createPrimitive('String')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'EnumValueToText',
             description: '返回枚举指定value的标题字符串',
             typeParams: [
-                new TypeParam__1.default({
+                new TypeParam({
                     name: 'enum',
                     useComponent: { type: 's-enum-select' },
                 }),
             ],
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'value',
                     description: '指定需要将枚举值转换为标题的字段',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'StringToEnumValue',
             description: '在指定enum中找到与参数str相同的枚举值并返回。',
             typeParams: [
-                new TypeParam__1.default({
+                new TypeParam({
                     name: 'enum',
                     useComponent: { type: 's-enum-select' },
                 }),
             ],
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'value',
                     description: '指定一个字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Split',
             description: '将字符串参数，用分割符分割成字符串列表，并返回',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'str',
                     description: '指定字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'separator',
                     description: '指定字符串中作为分隔符的参数',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createPrimitive('String')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createPrimitive('String')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Join',
             description: '将列表的项，用连接符连接成一个字符串，并返回',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createPrimitive('String')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createPrimitive('String')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'separator',
                     description: '连接符，用于连接列表中的项',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Length',
             description: '返回String或Map或List的长度',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'param',
                     description: '指定字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ToLower',
             description: '返回全部小写的字符串',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'str1',
                     description: '指定字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ToUpper',
             description: '返回全部大写的字符串',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'str1',
                     description: '指定字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Trim',
             description: '删除字符串的前后空格。返回裁剪后的新字符串。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'str1',
                     description: '指定字符串',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Get',
             description: '获得列表位于指定索引处的项',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'index',
                     description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Set',
             description: '（修改原数据）为列表的指定索引项赋值（覆盖原索引项）',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'index',
                     description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'item',
                     description: '列表指定索引下的新项',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Contains',
             description: '测试列表是否包含某一项，返回测试结果',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'item',
                     description: '指定项',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('Boolean'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('Boolean'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Add',
             description: '（修改原数据）在列表末尾追加项。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'item',
                     description: '指定需要在列表末尾增加的项',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'AddAll',
             description: '（修改原数据）为一个列表添加另一列表中的多项内容。返回新列表的长度',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表1',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'addList',
                     description: '指定列表2',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Insert',
             description: '（修改原数据）在列表的指定索引处插入新项（原索引项依次后推）',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'index',
                     description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'item',
                     description: '待插入项',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Remove',
             description: '（修改原数据）删除列表的某项',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'item',
                     description: '指定项',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'RemoveAt',
             description: '（修改原数据）在列表中删除位于指定索引的项。返回被删除的项',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'index',
                     description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListHead',
             description: '返回列表的首项',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListLast',
             description: '返回列表的末项',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListFlatten',
             description: '将嵌套列表摊平一层并返回（List<List<T>> 变为 List<T>）',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListToMap',
             description: '选取列表项的某些属性，根据这些属性将列表变为 Map 并返回',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: `根据项的属性及其本身进行key和value的定义`,
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default(),
+                        body: new Identifier(),
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'byVal',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default(),
+                        body: new Identifier(),
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListTransform',
             description: '对列表的每一项调用函数 by，得到新项；返回新项构成的列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定对列表中项的某个属性或项本身的处理方式，支持算数运算和比较运算',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
@@ -728,251 +739,251 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListSum',
             description: '返回数值列表中所有项的和',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListProduct',
             description: '返回数值列表中所有项的积',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定数值类型列表',
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListAverage',
             description: '返回数值列表中所有项的平均值',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定数值类型列表',
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListMax',
             description: '返回数值列表中所有项的最大值',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定数值类型列表',
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListMin',
             description: '返回数值列表中所有项的最小值',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定数值类型列表',
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapGet',
             description: '查询出Map中key为指定值的value值列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createTypeParam('V'),
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
                         ],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'key',
                     description: '指定参数key',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('K'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('V'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('V'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapPut',
             description: '（修改原数据）为Map中添加键值对',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createTypeParam('V'),
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
                         ],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'key',
                     description: '指定参数key',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('K'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'value',
                     description: '指定参数value',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('V'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('V'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapRemove',
             description: '（修改原数据）删除Map中的键值对',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createTypeParam('V'),
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
                         ],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'key',
                     description: '指定参数key',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('K'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapContains',
             description: '判断Map中是否存在参数指定的键值对',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createTypeParam('V'),
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
                         ],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'key',
                     description: '指定参数key',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('K'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('Boolean'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('Boolean'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapKeys',
             description: '输出Map中key集合',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createTypeParam('V'),
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
                         ],
                     }),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('K')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapValues',
             description: '输出Map中value集合',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createTypeParam('V'),
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
                         ],
                     }),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('V')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('V')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapFilter',
             description: '在指定Map中过滤出符合条件参数的Map列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '针对键值对的参数key和value设置过滤条件，支持算数运算、比较运算和逻辑运算',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'key',
                                 typeAnnotation: null,
                             }),
-                            new Param__1.default({
+                            new Param({
                                 name: 'value',
                                 typeAnnotation: null,
                             }),
@@ -981,52 +992,52 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createTypeParam('V'),
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
                         ],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapTransform',
             description: '对 Map 的每一项调用函数 by，得到新项，并返回新项构成的 Map。（Map 的每一项从 (K0, V0) 变为 (K, V)。）',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: `指定映射中键值对的参数处理方式，支持算数运算和比较运算`,
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'key',
                                 typeAnnotation: null,
                             }),
-                            new Param__1.default({
+                            new Param({
                                 name: 'value',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default({
+                        body: new Identifier({
                             name: 'key',
                         }),
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'byVal',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'key',
                                 typeAnnotation: null,
                             }),
-                            new Param__1.default({
+                            new Param({
                                 name: 'value',
                                 typeAnnotation: null,
                             }),
@@ -1035,124 +1046,124 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('Map', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('K'), TypeAnnotation__1.default.createTypeParam('V')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('Map', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K'), TypeAnnotation.createTypeParam('V')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'CurrDate',
             description: '返回指定时区的当前日期',
             params: [],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Date'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Date'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'CurrTime',
             description: '返回指定时区的当前时间',
             params: [],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('Time'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('Time'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'CurrDateTime',
             description: '返回指定时区的当前日期时间',
             params: [],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'FormatDate',
             description: '返回格式化日期字符串',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'date',
                     description: '指定需要格式化日期的字段',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Date'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Date'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'formatter',
                     description: '格式化规则，默认为yyyy-MM-dd，即年月日格式',
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new StringLiteral__1.default({ value: 'yyyy-MM-dd' }),
+                    defaultValue: new DefaultValue({
+                        expression: new StringLiteral({ value: 'yyyy-MM-dd' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new StringLiteral__1.default({ value: 'yyyy-MM-dd' }),
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                    defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 })
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'FormatDateTime',
             description: '返回格式化日期时间字符串。当输入为 DateTime 类型时，会把数据转到目标时区的当地时间进行格式化。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'date',
                     description: '指定需要格式化日期时间的字段',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'formatter',
                     description: '格式化规则，默认为yyyy-MM-dd',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new StringLiteral__1.default({ value: 'yyyy-MM-dd HH:mm:ss' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: new DefaultValue({
+                        expression: new StringLiteral({ value: 'yyyy-MM-dd HH:mm:ss' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new StringLiteral__1.default({ value: 'yyyy-MM-dd HH:mm:ss' }),
+                    defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd HH:mm:ss' }),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'FormatNumber',
             description: '返回格式化的数字字符串',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'value',
                     description: '指定需要格式化小数位数的字段',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Decimal'),
-                    defaultExpression: new Identifier__1.default(),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
+                    defaultExpression: new Identifier(),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'digits',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                     description: '保留小数位数',
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new NumericLiteral__1.default({ value: '2' }),
+                    defaultValue: new DefaultValue({
+                        expression: new NumericLiteral({ value: '2' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new NumericLiteral__1.default({ value: '2' }),
+                    defaultExpression: new NumericLiteral({ value: '2' }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'showGroups',
                     description: '是否显示千分位：true显示，false不显示',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Boolean'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new BooleanLiteral__1.default({ value: 'false' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: new DefaultValue({
+                        expression: new BooleanLiteral({ value: 'false' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new BooleanLiteral__1.default({ value: 'false' }),
+                    defaultExpression: new BooleanLiteral({ value: 'false' }),
                     options: [
                         {
                             text: 'true',
@@ -1168,78 +1179,78 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'AddDays',
             description: '返回日期天数加法计算结果',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'dateTime',
                     description: '指定日期时间',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'amount',
                     description: '增加的天数',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'AddMonths',
             description: '返回月份加法计算结果',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'dateTime',
                     description: '指定日期时间',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'amount',
                     description: '增加的月数',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'DateDiff',
             description: '返回日期比较结果',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'dateTime1',
                     description: '指定日期时间1',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
-                    defaultExpression: new Identifier__1.default(),
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                    defaultExpression: new Identifier(),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'dateTime2',
                     description: '指定日期时间2',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
-                    defaultExpression: new Identifier__1.default(),
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                    defaultExpression: new Identifier(),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'calcType',
                     description: '计算类型。计算两个日期时间之间的差值，支持年数、季度数、月数、星期数、天数、小时数、分钟数、秒数',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new StringLiteral__1.default({ value: 'd' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: new DefaultValue({
+                        expression: new StringLiteral({ value: 'd' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new StringLiteral__1.default({ value: 'd' }),
+                    defaultExpression: new StringLiteral({ value: 'd' }),
                     options: [
                         {
                             text: 'Year',
@@ -1283,15 +1294,15 @@ exports.default = new Namespace__1.default({
                         },
                     ],
                 }),
-                new Param__1.default({
+                new Param({
                     name: '结果处理',
                     description: '结果是否绝对值处理',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Boolean'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new BooleanLiteral__1.default({ value: 'true' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: new DefaultValue({
+                        expression: new BooleanLiteral({ value: 'true' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new BooleanLiteral__1.default({ value: 'true' }),
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
                         {
                             text: '绝对值',
@@ -1307,30 +1318,30 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ConvertTimezone',
             description: '为指定日期时间转换时区',
             params: [
-                new Param__1.default({
+                new Param({
                     name: '指定日期',
                     description: '指定日期',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: '转换时区至',
                     description: '转换时区至',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new StringLiteral__1.default({ value: 'Asia/Shanghai' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: new DefaultValue({
+                        expression: new StringLiteral({ value: 'Asia/Shanghai' }),
                         concept: 'DefaultValue',
                     }),
                     useComponent: { type: 's-bidirectional-bind-switch' },
-                    defaultExpression: new StringLiteral__1.default({
+                    defaultExpression: new StringLiteral({
                         value: 'Asia/Shanghai',
                         name: 'ConvertTimezoneDefaultExpression',
                     }),
@@ -1364,74 +1375,74 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'GetDateCount',
             description: '按指定维度计算日期，如“所在年-第几周”。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: '指定日期',
                     description: '将被计算的日期',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: '根据指定日期计算',
                     description: '获取指定日期的特定信息，如是其所在年的第几天',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new StringLiteral__1.default({ value: 'week-year' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: new DefaultValue({
+                        expression: new StringLiteral({ value: 'week-year' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new StringLiteral__1.default({ value: 'week-year' }),
+                    defaultExpression: new StringLiteral({ value: 'week-year' }),
                     cascader: true,
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'AlterDateTime',
             description: '为指定日期时间调整增加（减少）时间',
             params: [
-                new Param__1.default({
+                new Param({
                     name: '指定日期时间',
                     description: '将被更改的日期时间或日期',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('DateTime'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: '调整',
                     description: '为指定的日期时间增加或减少指定的数量，只能填整数',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new StringLiteral__1.default({ value: 'Increase' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: new DefaultValue({
+                        expression: new StringLiteral({ value: 'Increase' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new StringLiteral__1.default({ value: 'Increase' }),
+                    defaultExpression: new StringLiteral({ value: 'Increase' }),
                     options: [
                         { text: '增加', value: 'Increase' },
                         { text: '减少', value: 'Decrease' },
                     ],
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'amount',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
-                    defaultExpression: new NumericLiteral__1.default({ value: '0' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                    defaultExpression: new NumericLiteral({ value: '0' }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: '计算数',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new StringLiteral__1.default({ value: 'day' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: new DefaultValue({
+                        expression: new StringLiteral({ value: 'day' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new StringLiteral__1.default({ value: 'day' }),
+                    defaultExpression: new StringLiteral({ value: 'day' }),
                     options: [
                         { text: '天', value: 'day' },
                         { text: '周', value: 'week' },
@@ -1442,28 +1453,28 @@ exports.default = new Namespace__1.default({
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'GetSpecificDaysOfWeek',
             description: '按“星期几”获取指定日期范围内的日子。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: '起始',
                     description: '起始日期（包含）',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Date'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Date'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: '结束',
                     description: '结束日期（包含）',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Date'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Date'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: '指定',
                     description: '指定的星期几，可多选',
                     useComponent: { type: 's-bidirectional-bind-switch' },
-                    defaultExpression: new NewList__1.default({
+                    defaultExpression: new NewList({
                         name: 'GetSpecificDaysOfWeekTargetDefaultExpression',
-                        typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                            typeArguments: [TypeAnnotation__1.default.createPrimitive('Long')],
+                        typeAnnotation: TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createPrimitive('Long')],
                         }),
                     }),
                     options: [
@@ -1478,123 +1489,123 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Clone',
             description: '复制一个所选参数的实例',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'struct',
                     description: '指定对象',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Clear',
             description: '（修改原数据）清除复杂对象中每个属性的数据（若输入是单个基础类型如 Integer 的值，则不做处理）',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'struct',
                     description: '指定对象',
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'RandomInt',
             description: '产生随机整数',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'start',
                     description: '起始数字，Integer类型',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'end',
                     description: '截至数字，Integer类型',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'CreateListPage',
             description: '将List<T>列表转换为列表分页',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'total',
                     description: '指定数据条数',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('PageOf', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListSort',
             description: '（修改原数据）为列表按指定规则排序',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性或项本身，支持算数运算和比较运算',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
                         ],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'sort',
                     description: '支持升序或降序设置，asc为升序，desc为降序。',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Boolean'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new BooleanLiteral__1.default({ value: 'true' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: new DefaultValue({
+                        expression: new BooleanLiteral({ value: 'true' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new BooleanLiteral__1.default({ value: 'true' }),
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
                         {
                             text: 'asc',
@@ -1611,23 +1622,23 @@ exports.default = new Namespace__1.default({
             ],
             returns: [],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListFind',
             description: '返回列表中第一个符合条件的项',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
@@ -1636,28 +1647,28 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListFindIndex',
             description: '返回列表中第一个符合条件的项的索引值',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
@@ -1666,25 +1677,25 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListFilter',
             description: '筛选列表中符合条件的所有项，返回这些项构成的新的列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
@@ -1693,204 +1704,204 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
+                new Return({
                     name: 'list',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListReverse',
             description: '（修改原数据）将列表的所有项反向排列（例如第一项变为最后一项）',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
             returns: [],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListDistinct',
             description: '（修改原数据）为列表去除重复项',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
             returns: [],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListDistinctBy',
             description: '按某几个属性为列表去除重复项。返回去除重复项后的列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某几个属性，若项无属性，则该函数不生效',
-                    defaultExpression: new NewList__1.default({
+                    defaultExpression: new NewList({
                         name: 'ListDistinctByTargetDefaultExpression',
-                        typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                            typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                        typeAnnotation: TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createTypeParam('T')],
                         }),
                         items: [
-                            new AnonymousFunction__1.default({
+                            new AnonymousFunction({
                                 params: [
-                                    new Param__1.default({
+                                    new Param({
                                         name: 'item',
                                         description: '是否忽略大小写',
                                         typeAnnotation: null,
                                     }),
                                 ],
-                                body: new Identifier__1.default(),
+                                body: new Identifier(),
                             }),
                         ],
                     }),
                 }),
             ],
-            returns: [new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
+            returns: [new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('T'),
+                            TypeAnnotation.createTypeParam('T'),
                         ],
                     }),
                 })],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListGroupBy',
             description: '按某个属性为列表分组。以选中的属性为 key 建立 Map 并返回。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 description: '是否忽略大小写',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default(),
+                        body: new Identifier(),
                     }),
                 }),
             ],
-            returns: [new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+            returns: [new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createGeneric('List', {
-                                typeArguments: [TypeAnnotation__1.default.createTypeParam('A')],
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createGeneric('List', {
+                                typeArguments: [TypeAnnotation.createTypeParam('A')],
                             }),
                         ],
                     }),
                 })],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListSlice',
             description: '将列表按照规则切片，返回切片后的子列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'start',
                     description: '切片起始的索引，integer类型，项数索引从0开始',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'end',
                     description: '切片结束的索引，integer类型，用数字表示第几项，项数索引从0开始',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'SliceToListPage',
             description: '将列表按照规则切片，返回切片后的列表分页',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'page',
                     description: '页数，integer类型，从1开始',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'size',
                     description: '每页的大小，integer类型',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('PageOf', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('PageOf', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'New',
             description: '根据参数选择的类型，返回该参数的实例化对象',
             typeParams: [
-                new TypeParam__1.default({
+                new TypeParam({
                     name: 'T',
                 }),
             ],
             params: [],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'Round',
             description: '对指定的小数按指定的舍入模式进行舍入，返回舍入后的整数',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'value',
                     description: '被取整小数',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Decimal'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'mode',
                     description: '取整模式：HalfUp 四舍五入，如 -2.5 取整为 -3，2.5 取整为 3。TowardsZero 截断、向零取整：如 -2.6 取整为 -2，2.6 取整为 2。TowardsInfinity 进位、向正负无穷取整，如 -1.1 取整为 -2，1.1 取整为 2',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('String'),
-                    defaultExpression: new StringLiteral__1.default({ value: 'HalfUp' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultExpression: new StringLiteral({ value: 'HalfUp' }),
                     options: [
                         { text: 'HalfUp', value: 'HalfUp', description: '四舍五入' },
                         { text: 'TowardsZero', value: 'TowardsZero', description: '截断、向零取整，如 -2.6 取整为 -2' },
@@ -1899,44 +1910,44 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'HasValue',
             description: '判断参数是否为有效值，null、空字符串、纯空格、长度为0的集合均不被视为有效值，传入多个参数时，判断是否全部都是有效值',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'param1',
                     description: '指定参数1',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Any'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Any'),
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Boolean'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListFindAsync',
             description: '返回列表中第一个符合条件的项',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
@@ -1945,43 +1956,43 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createTypeParam('T'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListSortAsync',
             description: '（修改原数据）为列表按指定规则排序',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性或项本身，支持算数运算和比较运算',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
                         ],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'sort',
                     description: '支持升序或降序设置，asc为升序，desc为降序。',
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Boolean'),
-                    defaultValue: new DefaultValue__1.default({
-                        expression: new BooleanLiteral__1.default({ value: 'true' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: new DefaultValue({
+                        expression: new BooleanLiteral({ value: 'true' }),
                         concept: 'DefaultValue',
                     }),
-                    defaultExpression: new BooleanLiteral__1.default({ value: 'true' }),
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
                         { text: 'asc(升序)', value: 'true' },
                         { text: 'desc(降序)', value: 'false' },
@@ -1990,20 +2001,20 @@ exports.default = new Namespace__1.default({
             ],
             returns: [],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListFilterAsync',
             description: '筛选列表中符合条件的所有项，返回这些项构成的新的列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
@@ -2012,31 +2023,31 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
+                new Return({
                     name: 'list',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListFindIndexAsync',
             description: '返回列表中第一个符合条件的项的索引值',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
@@ -2045,90 +2056,90 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createPrimitive('Long'),
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListDistinctByAsync',
             description: '按某个属性为列表去除重复项。返回去除重复项后的列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 description: '是否忽略大小写',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default(),
+                        body: new Identifier(),
                     }),
                 }),
             ],
-            returns: [new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
+            returns: [new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('T'),
+                            TypeAnnotation.createTypeParam('T'),
                         ],
                     }),
                 })],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListGroupByAsync',
             description: '按某个属性为列表分组。以选中的属性为 key 建立 Map 并返回。',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 description: '是否忽略大小写',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default(),
+                        body: new Identifier(),
                     }),
                 }),
             ],
-            returns: [new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+            returns: [new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createGeneric('List', {
-                                typeArguments: [TypeAnnotation__1.default.createTypeParam('A')],
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createGeneric('List', {
+                                typeArguments: [TypeAnnotation.createTypeParam('A')],
                             }),
                         ],
                     }),
                 })],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListTransformAsync',
             description: '对列表的每一项调用函数 by，得到新项；返回新项构成的列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '指定对列表中项的某个属性或项本身的处理方式，支持算数运算和比较运算',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
@@ -2137,31 +2148,31 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('List', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('T')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapFilterAsync',
             description: '在指定Map中过滤出符合条件参数的Map列表',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: '针对键值对的参数key和value设置过滤条件，支持算数运算、比较运算和逻辑运算',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'key',
                                 typeAnnotation: null,
                             }),
-                            new Param__1.default({
+                            new Param({
                                 name: 'value',
                                 typeAnnotation: null,
                             }),
@@ -2170,52 +2181,52 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('map', {
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
-                            TypeAnnotation__1.default.createTypeParam('K'),
-                            TypeAnnotation__1.default.createTypeParam('V'),
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
                         ],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'MapTransformAsync',
             description: '对 Map 的每一项调用函数 by，得到新项，并返回新项构成的 Map。（Map 的每一项从 (K0, V0) 变为 (K, V)。）',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'map',
                     description: '指定映射',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: `指定映射中键值对的参数处理方式，支持算数运算和比较运算`,
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'key',
                                 typeAnnotation: null,
                             }),
-                            new Param__1.default({
+                            new Param({
                                 name: 'value',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default({
+                        body: new Identifier({
                             name: 'key',
                         }),
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'byVal',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'key',
                                 typeAnnotation: null,
                             }),
-                            new Param__1.default({
+                            new Param({
                                 name: 'value',
                                 typeAnnotation: null,
                             }),
@@ -2224,48 +2235,51 @@ exports.default = new Namespace__1.default({
                 }),
             ],
             returns: [
-                new Return__1.default({
-                    typeAnnotation: TypeAnnotation__1.default.createGeneric('Map', {
-                        typeArguments: [TypeAnnotation__1.default.createTypeParam('K'), TypeAnnotation__1.default.createTypeParam('V')],
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('Map', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K'), TypeAnnotation.createTypeParam('V')],
                     }),
                 }),
             ],
         }),
-        new Function__1.default({
+        new Function({
             name: 'ListToMapAsync',
             description: '选取列表项的某些属性，根据这些属性将列表变为 Map 并返回',
             params: [
-                new Param__1.default({
+                new Param({
                     name: 'list',
                     description: '指定列表',
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'by',
                     description: `根据项的属性及其本身进行key和value的定义`,
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default(),
+                        body: new Identifier(),
                     }),
                 }),
-                new Param__1.default({
+                new Param({
                     name: 'byVal',
-                    defaultExpression: new AnonymousFunction__1.default({
+                    defaultExpression: new AnonymousFunction({
                         params: [
-                            new Param__1.default({
+                            new Param({
                                 name: 'item',
                                 typeAnnotation: null,
                             }),
                         ],
-                        body: new Identifier__1.default(),
+                        body: new Identifier(),
                     }),
                 }),
             ],
         }),
-    ],
-});
+    ];
+    logics.forEach((logic) => utilNamespace.addLogic(logic));
+    functions.forEach((func) => utilNamespace.addFunction(func));
+}
+exports.initialize = initialize;
 //# sourceMappingURL=nasl.util.js.map