@lcap/nasl 3.8.3-beta.1 → 3.8.3-beta.2

package/coverage/src/concepts/basics/stdlib/nasl.util.ts.html

@@ -23,30 +23,30 @@
         <div class='clearfix'>
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">90.32% </span>
+                <span class="strong">94.73% </span>
                 <span class="quiet">Statements</span>
-                <span class='fraction'>28/31</span>
+                <span class='fraction'>18/19</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
                 <span class="strong">100% </span>
                 <span class="quiet">Branches</span>
-                <span class='fraction'>5/5</span>
+                <span class='fraction'>0/0</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">80% </span>
+                <span class="strong">0% </span>
                 <span class="quiet">Functions</span>
-                <span class='fraction'>4/5</span>
+                <span class='fraction'>0/1</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">89.28% </span>
+                <span class="strong">100% </span>
                 <span class="quiet">Lines</span>
-                <span class='fraction'>25/28</span>
+                <span class='fraction'>17/17</span>
             </div>
         
             
@@ -2316,72 +2316,7 @@
 <a name='L2251'></a><a href='#L2251'>2251</a>
 <a name='L2252'></a><a href='#L2252'>2252</a>
 <a name='L2253'></a><a href='#L2253'>2253</a>
-<a name='L2254'></a><a href='#L2254'>2254</a>
-<a name='L2255'></a><a href='#L2255'>2255</a>
-<a name='L2256'></a><a href='#L2256'>2256</a>
-<a name='L2257'></a><a href='#L2257'>2257</a>
-<a name='L2258'></a><a href='#L2258'>2258</a>
-<a name='L2259'></a><a href='#L2259'>2259</a>
-<a name='L2260'></a><a href='#L2260'>2260</a>
-<a name='L2261'></a><a href='#L2261'>2261</a>
-<a name='L2262'></a><a href='#L2262'>2262</a>
-<a name='L2263'></a><a href='#L2263'>2263</a>
-<a name='L2264'></a><a href='#L2264'>2264</a>
-<a name='L2265'></a><a href='#L2265'>2265</a>
-<a name='L2266'></a><a href='#L2266'>2266</a>
-<a name='L2267'></a><a href='#L2267'>2267</a>
-<a name='L2268'></a><a href='#L2268'>2268</a>
-<a name='L2269'></a><a href='#L2269'>2269</a>
-<a name='L2270'></a><a href='#L2270'>2270</a>
-<a name='L2271'></a><a href='#L2271'>2271</a>
-<a name='L2272'></a><a href='#L2272'>2272</a>
-<a name='L2273'></a><a href='#L2273'>2273</a>
-<a name='L2274'></a><a href='#L2274'>2274</a>
-<a name='L2275'></a><a href='#L2275'>2275</a>
-<a name='L2276'></a><a href='#L2276'>2276</a>
-<a name='L2277'></a><a href='#L2277'>2277</a>
-<a name='L2278'></a><a href='#L2278'>2278</a>
-<a name='L2279'></a><a href='#L2279'>2279</a>
-<a name='L2280'></a><a href='#L2280'>2280</a>
-<a name='L2281'></a><a href='#L2281'>2281</a>
-<a name='L2282'></a><a href='#L2282'>2282</a>
-<a name='L2283'></a><a href='#L2283'>2283</a>
-<a name='L2284'></a><a href='#L2284'>2284</a>
-<a name='L2285'></a><a href='#L2285'>2285</a>
-<a name='L2286'></a><a href='#L2286'>2286</a>
-<a name='L2287'></a><a href='#L2287'>2287</a>
-<a name='L2288'></a><a href='#L2288'>2288</a>
-<a name='L2289'></a><a href='#L2289'>2289</a></td><td class="line-coverage quiet"><span class="cline-any cline-yes">45x</span>
-<span class="cline-any cline-yes">1x</span>
-<span class="cline-any cline-yes">1x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">1x</span>
-<span class="cline-any cline-no">&nbsp;</span>
-<span class="cline-any cline-no">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-no">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">1x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">1x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">1x</span>
+<a name='L2254'></a><a href='#L2254'>2254</a></td><td class="line-coverage quiet"><span class="cline-any cline-yes">1x</span>
 <span class="cline-any cline-yes">1x</span>
 <span class="cline-any cline-yes">1x</span>
 <span class="cline-any cline-yes">1x</span>
@@ -2409,6 +2344,7 @@
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1x</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
@@ -2445,10 +2381,6 @@
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">1x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
@@ -4636,2297 +4568,2260 @@
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">3x</span>
-<span class="cline-any cline-yes">82x</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span></td><td class="text"><pre class="prettyprint lang-js">import Namespace from '../../Namespace__';
+import Param from '../../Param__';
+import Return from '../../Return__';
+import Logic from '../../Logic__';
+import Function from '../../Function__';
+import TypeAnnotation from '../../TypeAnnotation__';
+import TypeParam from '../../TypeParam__';
+import NumericLiteral from '../../NumericLiteral__';
+import Identifier from '../../Identifier__';
+import BooleanLiteral from '../../BooleanLiteral__';
+import StringLiteral from '../../StringLiteral__';
+import AnonymousFunction from '../../AnonymousFunction__';
+import StringInterpolation from '../../StringInterpolation__';
+import NewList from '../../NewList__';
 import { TIMEZONES } from './timeZone';
-import { getConceptConstructor } from '../../../decorators';
 &nbsp;
-export const createTimezoneParam = (<span class="fstat-no" title="function not covered" >fnName: string) =&gt; {</span>
-  const <span class="cstat-no" title="statement not covered" >Param = getConceptConstructor('Param');</span>
-  const <span class="cstat-no" title="statement not covered" >StringLiteral = getConceptConstructor('StringLiteral');</span>
-&nbsp;
-<span class="cstat-no" title="statement not covered" >  return new Param({</span>
+export const createTimezoneParam = <span class="fstat-no" title="function not covered" >(f</span>nName : string) =&gt; <span class="cstat-no" title="statement not covered" >new Param({</span>
     name: '时区',
     description: '以此时区为基准',
     useComponent: { type: 's-bidirectional-bind-switch' },
     defaultExpression: new StringLiteral({
-      name: `${fnName}TimeZoneDefaultExpression`,
-      value: 'global'
+        name: `${fnName}TimeZoneDefaultExpression`,
+        value: 'global'
     }),
     options: TIMEZONES,
     hidden: true,
-  });
-}
-&nbsp;
-const utilNamespace = new Namespace({
-  name: 'util',
-  logics: [],
-  functions: [],
-});
-&nbsp;
-export default utilNamespace;
+})
 &nbsp;
-/** @internal */
-export function initialize() {
-  const TypeAnnotation = getConceptConstructor('TypeAnnotation');
-  const Logic = getConceptConstructor('Logic');
-  const Param = getConceptConstructor('Param');
-  const Return = getConceptConstructor('Return');
-  const Function = getConceptConstructor('Function');
-  const AnonymousFunction = getConceptConstructor('AnonymousFunction');
-  const StringInterpolation = getConceptConstructor('StringInterpolation');
-  const TypeParam = getConceptConstructor('TypeParam');
-  const Identifier = getConceptConstructor('Identifier');
-  const BooleanLiteral = getConceptConstructor('BooleanLiteral');
-  const NumericLiteral = getConceptConstructor('NumericLiteral');
-  const StringLiteral = getConceptConstructor('StringLiteral');
-  const NewList = getConceptConstructor('NewList');
-  const DefaultValue = getConceptConstructor('DefaultValue');
-&nbsp;
-  const logics = [
-    new Logic({
-      name: 'consoleLog',
-      params: [
-        new Param({
-          name: 'arg',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-          defaultExpression: new StringInterpolation(),
+export default new Namespace({
+    name: 'util',
+    logics: [
+        new Logic({
+            name: 'consoleLog',
+            params: [
+                new Param({
+                    name: 'arg',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultExpression: new StringInterpolation(),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Logic({
-      name: 'jsonSerialize',
-      params: [
-        new Param({
-          name: 'arg',
+        new Logic({
+            name: 'jsonSerialize',
+            params: [
+                new Param({
+                    name: 'arg',
+                }),
+            ],
+            returns: [
+                new Return({
+                    name: 'result',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          name: 'result',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        new Logic({
+            name: 'jsonDeserialize',
+            typeParams: [
+                new TypeParam({
+                    name: 'T',
+                }),
+            ],
+            params: [
+                new Param({
+                    name: 'arg',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    name: 'result',
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                    useComponent: { type: 's-datatype-select' },
+                }),
+            ],
         }),
-      ],
-    }),
-    new Logic({
-      name: 'jsonDeserialize',
-      typeParams: [
-        new TypeParam({
-          name: 'T',
+    ],
+    functions: [
+        new Function({
+            name: 'Convert',
+            description: '各基础数据类型之间转换',
+            typeParams: [
+                new TypeParam({
+                    name: 'T',
+                }),
+            ],
+            params: [
+                new Param({
+                    name: 'value',
+                    description: '选择变量或常量',
+                    defaultExpression: new Identifier(),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-      params: [
-        new Param({
-          name: 'arg',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        new Function({
+            name: 'ToString',
+            description: '各类型转换成字符串',
+            params: [
+                new Param({
+                    name: 'value',
+                    description: '待转成字符串的表达式',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Any'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          name: 'result',
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-          useComponent: { type: 's-datatype-select' },
+        new Function({
+            name: 'FromString',
+            description: '字符串转换成其他类型',
+            typeParams: [
+                new TypeParam({
+                    name: 'T',
+                }),
+            ],
+            params: [
+                new Param({
+                    name: 'value',
+                    defaultExpression: new Identifier(),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-    }),
-  ];
 &nbsp;
-  const functions = [
-&nbsp;
-    new Function({
-      name: 'Convert',
-      description: '各基础数据类型之间转换',
-      typeParams: [
-        new TypeParam({
-          name: 'T',
-        }),
-      ],
-      params: [
-        new Param({
-          name: 'value',
-          description: '选择变量或常量',
-          defaultExpression: new Identifier(),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ToString',
-      description: '各类型转换成字符串',
-      params: [
-        new Param({
-          name: 'value',
-          description: '待转成字符串的表达式',
-          typeAnnotation: TypeAnnotation.createPrimitive('Any'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'FromString',
-      description: '字符串转换成其他类型',
-      typeParams: [
-        new TypeParam({
-          name: 'T',
-        }),
-      ],
-      params: [
-        new Param({
-          name: 'value',
-          defaultExpression: new Identifier(),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'IndexOf',
-      description: '搜索字符串位置',
-      params: [
-        new Param({
-          name: 'str',
-          description: '指定字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'search',
-          description: '指定需要搜索的字段，String类型',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'fromIndex',
-          description: '开始搜索的索引值，Integer类型，用数字表示第几项，项数索引从0开始',
-          defaultExpression: new NumericLiteral({ value: '0' }),
-        }),
+        new Function({
+            name: 'IndexOf',
+            description: '搜索字符串位置',
+            params: [
+                new Param({
+                    name: 'str',
+                    description: '指定字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'search',
+                    description: '指定需要搜索的字段，String类型',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'fromIndex',
+                    description: '开始搜索的索引值，Integer类型，用数字表示第几项，项数索引从0开始',
+                    defaultExpression: new NumericLiteral({ value: '0' }),
+                }),
 &nbsp;
-        new Param({
-          name: 'ignoreCase',
-          description: '是否忽略大小写，true为忽略，false为不忽略',
-          defaultExpression: new BooleanLiteral({ value: 'true' }),
-          options: [
-            {
-              text: 'true',
-              value: 'true',
-              description: '忽略大小写',
-            },
-            {
-              text: 'false',
-              value: 'false',
-              description: '对大小写敏感',
-            },
-          ],
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'LastIndexOf',
-      description: '从末尾搜索字符串位置',
-      params: [
-        new Param({
-          name: 'str',
-          description: '指定字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'search',
-          description: '指定需要搜索的字段，String类型',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'ignoreCase',
-          description: '是否忽略大小写，true为忽略，false为不忽略',
-          defaultExpression: new BooleanLiteral({ value: 'true' }),
-          options: [
-            {
-              text: 'true',
-              value: 'true',
-              description: '忽略大小写',
-            },
-            {
-              text: 'false',
-              value: 'false',
-              description: '对大小写敏感',
-            },
-          ],
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Replace',
-      description: '字符串替换。返回替换后的新字符串。',
-      params: [
-        new Param({
-          name: 'str',
-          description: '指定原始字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'search',
-          description: '指定原始字符串中需要被替换的字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'replace',
-          description: '指定进行替换操作的字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'SubString',
-      description: '字符串截取。返回截取的字符串。',
-      params: [
-        new Param({
-          name: 'str',
-          description: '指定需要截取的字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'start',
-          description: 'int类型，输入数字指定开始截取的位置',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'length',
-          description: '指定截取的字符串长度',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'EnumToList',
-      description: '返回枚举value和text的List集合',
-      typeParams: [
-        new TypeParam({
-          name: 'enum',
-          useComponent: { type: 's-enum-select' },
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createPrimitive('String')],
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'EnumValueToText',
-      description: '返回枚举指定value的标题字符串',
-      typeParams: [
-        new TypeParam({
-          name: 'enum',
-          useComponent: { type: 's-enum-select' },
-        }),
-      ],
-      params: [
-        new Param({
-          name: 'value',
-          description: '指定需要将枚举值转换为标题的字段',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'StringToEnumValue',
-      description: '在指定enum中找到与参数str相同的枚举值并返回。',
-      typeParams: [
-        new TypeParam({
-          name: 'enum',
-          useComponent: { type: 's-enum-select' },
-        }),
-      ],
-      params: [
-        new Param({
-          name: 'value',
-          description: '指定一个字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Split',
-      description: '将字符串参数，用分割符分割成字符串列表，并返回',
-      params: [
-        new Param({
-          name: 'str',
-          description: '指定字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-        new Param({
-          name: 'separator',
-          description: '指定字符串中作为分隔符的参数',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createPrimitive('String')],
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Join',
-      description: '将列表的项，用连接符连接成一个字符串，并返回',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createPrimitive('String')],
-          }),
-        }),
-        new Param({
-          name: 'separator',
-          description: '连接符，用于连接列表中的项',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Length',
-      description: '返回String或Map或List的长度',
-      params: [
-        new Param({
-          name: 'param',
-          description: '指定字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ToLower',
-      description: '返回全部小写的字符串',
-      params: [
-        new Param({
-          name: 'str1',
-          description: '指定字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ToUpper',
-      description: '返回全部大写的字符串',
-      params: [
-        new Param({
-          name: 'str1',
-          description: '指定字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Trim',
-      description: '删除字符串的前后空格。返回裁剪后的新字符串。',
-      params: [
-        new Param({
-          name: 'str1',
-          description: '指定字符串',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Get',
-      description: '获得列表位于指定索引处的项',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-        new Param({
-          name: 'index',
-          description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Set',
-      description: '（修改原数据）为列表的指定索引项赋值（覆盖原索引项）',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-        new Param({
-          name: 'index',
-          description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-        new Param({
-          name: 'item',
-          description: '列表指定索引下的新项',
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Contains',
-      description: '测试列表是否包含某一项，返回测试结果',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-        new Param({
-          name: 'item',
-          description: '指定项',
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('Boolean'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Add',
-      description: '（修改原数据）在列表末尾追加项。',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-        new Param({
-          name: 'item',
-          description: '指定需要在列表末尾增加的项',
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'AddAll',
-      description: '（修改原数据）为一个列表添加另一列表中的多项内容。返回新列表的长度',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表1',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-        new Param({
-          name: 'addList',
-          description: '指定列表2',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Insert',
-      description: '（修改原数据）在列表的指定索引处插入新项（原索引项依次后推）',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-        new Param({
-          name: 'index',
-          description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-        new Param({
-          name: 'item',
-          description: '待插入项',
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Remove',
-      description: '（修改原数据）删除列表的某项',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-        new Param({
-          name: 'item',
-          description: '指定项',
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'RemoveAt',
-      description: '（修改原数据）在列表中删除位于指定索引的项。返回被删除的项',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-        new Param({
-          name: 'index',
-          description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListHead',
-      description: '返回列表的首项',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListLast',
-      description: '返回列表的末项',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListFlatten',
-      description: '将嵌套列表摊平一层并返回（List&lt;List&lt;T&gt;&gt; 变为 List&lt;T&gt;）',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListToMap',
-      description: '选取列表项的某些属性，根据这些属性将列表变为 Map 并返回',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+                new Param({
+                    name: 'ignoreCase',
+                    description: '是否忽略大小写，true为忽略，false为不忽略',
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
+                    options: [
+                        {
+                            text: 'true',
+                            value: 'true',
+                            description: '忽略大小写',
+                        },
+                        {
+                            text: 'false',
+                            value: 'false',
+                            description: '对大小写敏感',
+                        },
+                    ],
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: `根据项的属性及其本身进行key和value的定义`,
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'LastIndexOf',
+            description: '从末尾搜索字符串位置',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'str',
+                    description: '指定字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'search',
+                    description: '指定需要搜索的字段，String类型',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'ignoreCase',
+                    description: '是否忽略大小写，true为忽略，false为不忽略',
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
+                    options: [
+                        {
+                            text: 'true',
+                            value: 'true',
+                            description: '忽略大小写',
+                        },
+                        {
+                            text: 'false',
+                            value: 'false',
+                            description: '对大小写敏感',
+                        },
+                    ],
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
             ],
-            body: new Identifier(),
-          }),
         }),
-        new Param({
-          name: 'byVal',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'Replace',
+            description: '字符串替换。返回替换后的新字符串。',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'str',
+                    description: '指定原始字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'search',
+                    description: '指定原始字符串中需要被替换的字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'replace',
+                    description: '指定进行替换操作的字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
             ],
-            body: new Identifier(),
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListTransform',
-      description: '对列表的每一项调用函数 by，得到新项；返回新项构成的列表',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
         }),
-        new Param({
-          name: 'by',
-          description: '指定对列表中项的某个属性或项本身的处理方式，支持算数运算和比较运算',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'SubString',
+            description: '字符串截取。返回截取的字符串。',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'str',
+                    description: '指定需要截取的字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'start',
+                    description: 'int类型，输入数字指定开始截取的位置',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'length',
+                    description: '指定截取的字符串长度',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
             ],
-          }),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListSum',
-      description: '返回数值列表中所有项的和',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListProduct',
-      description: '返回数值列表中所有项的积',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定数值类型列表',
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListAverage',
-      description: '返回数值列表中所有项的平均值',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定数值类型列表',
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListMax',
-      description: '返回数值列表中所有项的最大值',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定数值类型列表',
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ListMin',
-      description: '返回数值列表中所有项的最小值',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定数值类型列表',
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'MapGet',
-      description: '查询出Map中key为指定值的value值列表',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
-          typeAnnotation: TypeAnnotation.createGeneric('map', {
-            typeArguments: [
-              TypeAnnotation.createTypeParam('K'),
-              TypeAnnotation.createTypeParam('V'),
-            ],
-          }),
-        }),
-        new Param({
-          name: 'key',
-          description: '指定参数key',
-          typeAnnotation: TypeAnnotation.createTypeParam('K'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('V'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'MapPut',
-      description: '（修改原数据）为Map中添加键值对',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
-          typeAnnotation: TypeAnnotation.createGeneric('map', {
-            typeArguments: [
-              TypeAnnotation.createTypeParam('K'),
-              TypeAnnotation.createTypeParam('V'),
-            ],
-          }),
-        }),
-        new Param({
-          name: 'key',
-          description: '指定参数key',
-          typeAnnotation: TypeAnnotation.createTypeParam('K'),
-        }),
-        new Param({
-          name: 'value',
-          description: '指定参数value',
-          typeAnnotation: TypeAnnotation.createTypeParam('V'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'MapRemove',
-      description: '（修改原数据）删除Map中的键值对',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('map', {
-            typeArguments: [
-              TypeAnnotation.createTypeParam('K'),
-              TypeAnnotation.createTypeParam('V'),
-            ],
-          }),
-        }),
-        new Param({
-          name: 'key',
-          description: '指定参数key',
-          typeAnnotation: TypeAnnotation.createTypeParam('K'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'MapContains',
-      description: '判断Map中是否存在参数指定的键值对',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
-          typeAnnotation: TypeAnnotation.createGeneric('map', {
-            typeArguments: [
-              TypeAnnotation.createTypeParam('K'),
-              TypeAnnotation.createTypeParam('V'),
-            ],
-          }),
-        }),
-        new Param({
-          name: 'key',
-          description: '指定参数key',
-          typeAnnotation: TypeAnnotation.createTypeParam('K'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('Boolean'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'MapKeys',
-      description: '输出Map中key集合',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
-          typeAnnotation: TypeAnnotation.createGeneric('map', {
-            typeArguments: [
-              TypeAnnotation.createTypeParam('K'),
-              TypeAnnotation.createTypeParam('V'),
-            ],
-          }),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('K')],
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'MapValues',
-      description: '输出Map中value集合',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
-          typeAnnotation: TypeAnnotation.createGeneric('map', {
-            typeArguments: [
-              TypeAnnotation.createTypeParam('K'),
-              TypeAnnotation.createTypeParam('V'),
-            ],
-          }),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('V')],
-          }),
         }),
-      ],
-    }),
-    new Function({
-      name: 'MapFilter',
-      description: '在指定Map中过滤出符合条件参数的Map列表',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
+        new Function({
+            name: 'EnumToList',
+            description: '返回枚举value和text的List集合',
+            typeParams: [
+                new TypeParam({
+                    name: 'enum',
+                    useComponent: { type: 's-enum-select' },
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createPrimitive('String')],
+                    }),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '针对键值对的参数key和value设置过滤条件，支持算数运算、比较运算和逻辑运算',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'EnumValueToText',
+            description: '返回枚举指定value的标题字符串',
+            typeParams: [
+                new TypeParam({
+                    name: 'enum',
+                    useComponent: { type: 's-enum-select' },
+                }),
+            ],
             params: [
-              new Param({
-                name: 'key',
-                typeAnnotation: null,
-              }),
-              new Param({
-                name: 'value',
-                typeAnnotation: null,
-              }),
-            ],
-          }),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('map', {
-            typeArguments: [
-              TypeAnnotation.createTypeParam('K'),
-              TypeAnnotation.createTypeParam('V'),
-            ],
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'MapTransform',
-      description: '对 Map 的每一项调用函数 by，得到新项，并返回新项构成的 Map。（Map 的每一项从 (K0, V0) 变为 (K, V)。）',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
+                new Param({
+                    name: 'value',
+                    description: '指定需要将枚举值转换为标题的字段',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: `指定映射中键值对的参数处理方式，支持算数运算和比较运算`,
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'StringToEnumValue',
+            description: '在指定enum中找到与参数str相同的枚举值并返回。',
+            typeParams: [
+                new TypeParam({
+                    name: 'enum',
+                    useComponent: { type: 's-enum-select' },
+                }),
+            ],
             params: [
-              new Param({
-                name: 'key',
-                typeAnnotation: null,
-              }),
-              new Param({
-                name: 'value',
-                typeAnnotation: null,
-              }),
-            ],
-            body: new Identifier({
-              name: 'key',
-            }),
-          }),
+                new Param({
+                    name: 'value',
+                    description: '指定一个字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'byVal',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'Split',
+            description: '将字符串参数，用分割符分割成字符串列表，并返回',
             params: [
-              new Param({
-                name: 'key',
-                typeAnnotation: null,
-              }),
-              new Param({
-                name: 'value',
-                typeAnnotation: null,
-              }),
-            ],
-          }),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('Map', {
-            typeArguments: [TypeAnnotation.createTypeParam('K'), TypeAnnotation.createTypeParam('V')],
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'CurrDate',
-      description: '返回指定时区的当前日期',
-      params: [],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Date'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'CurrTime',
-      description: '返回指定时区的当前时间',
-      params: [],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('Time'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'CurrDateTime',
-      description: '返回指定时区的当前日期时间',
-      params: [],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'FormatDate',
-      description: '返回格式化日期字符串',
-      params: [
-        new Param({
-          name: 'date',
-          description: '指定需要格式化日期的字段',
-          typeAnnotation: TypeAnnotation.createPrimitive('Date'),
-        }),
-        new Param({
-          name: 'formatter',
-          description: '格式化规则，默认为yyyy-MM-dd，即年月日格式',
-          defaultValue: new DefaultValue({
-            expression: new StringLiteral({ value: 'yyyy-MM-dd' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd' }),
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        })
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'FormatDateTime',
-      description: '返回格式化日期时间字符串。当输入为 DateTime 类型时，会把数据转到目标时区的当地时间进行格式化。',
-      params: [
-        new Param({
-          name: 'date',
-          description: '指定需要格式化日期时间的字段',
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-        new Param({
-          name: 'formatter',
-          description: '格式化规则，默认为yyyy-MM-dd',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-          defaultValue: new DefaultValue({
-            expression: new StringLiteral({ value: 'yyyy-MM-dd HH:mm:ss' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd HH:mm:ss' }),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'FormatNumber',
-      description: '返回格式化的数字字符串',
-      params: [
-        new Param({
-          name: 'value',
-          description: '指定需要格式化小数位数的字段',
-          typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
-          defaultExpression: new Identifier(),
-        }),
-        new Param({
-          name: 'digits',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-          description: '保留小数位数',
-          defaultValue: new DefaultValue({
-            expression: new NumericLiteral({ value: '2' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new NumericLiteral({ value: '2' }),
-        }),
-        new Param({
-          name: 'showGroups',
-          description: '是否显示千分位：true显示，false不显示',
-          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
-          defaultValue: new DefaultValue({
-            expression: new BooleanLiteral({ value: 'false' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new BooleanLiteral({ value: 'false' }),
-          options: [
-            {
-              text: 'true',
-              value: 'true',
-              description: '显示千分位',
-            },
-            {
-              text: 'false',
-              value: 'false',
-              description: '不显示千分位',
-            },
-          ],
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'AddDays',
-      description: '返回日期天数加法计算结果',
-      params: [
-        new Param({
-          name: 'dateTime',
-          description: '指定日期时间',
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-        new Param({
-          name: 'amount',
-          description: '增加的天数',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'AddMonths',
-      description: '返回月份加法计算结果',
-      params: [
-        new Param({
-          name: 'dateTime',
-          description: '指定日期时间',
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-        new Param({
-          name: 'amount',
-          description: '增加的月数',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'DateDiff',
-      description: '返回日期比较结果',
-      params: [
-        new Param({
-          name: 'dateTime1',
-          description: '指定日期时间1',
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-          defaultExpression: new Identifier(),
-        }),
-        new Param({
-          name: 'dateTime2',
-          description: '指定日期时间2',
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-          defaultExpression: new Identifier(),
-        }),
-        new Param({
-          name: 'calcType',
-          description: '计算类型。计算两个日期时间之间的差值，支持年数、季度数、月数、星期数、天数、小时数、分钟数、秒数',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-          defaultValue: new DefaultValue({
-            expression: new StringLiteral({ value: 'd' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new StringLiteral({ value: 'd' }),
-          options: [
-            {
-              text: 'Year',
-              value: 'y',
-              description: '年数',
-            },
-            {
-              text: 'Season',
-              value: 'q',
-              description: '季度数',
-            },
-            {
-              text: 'Month',
-              value: 'M',
-              description: '月数',
-            },
-            {
-              text: 'Week',
-              value: 'w',
-              description: '星期数',
-            },
-            {
-              text: 'Day',
-              value: 'd',
-              description: '天数',
-            },
-            {
-              text: 'Hour',
-              value: 'h',
-              description: '小时数',
-            },
-            {
-              text: 'Minute',
-              value: 'm',
-              description: '分钟数',
-            },
-            {
-              text: 'Second',
-              value: 's',
-              description: '秒数',
-            },
-          ],
-        }),
-        new Param({
-          name: '结果处理',
-          description: '结果是否绝对值处理',
-          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
-          defaultValue: new DefaultValue({
-            expression: new BooleanLiteral({ value: 'true' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new BooleanLiteral({ value: 'true' }),
-          options: [
-            {
-              text: '绝对值',
-              value: 'true',
-              description: '结果绝对值处理',
-            },
-            {
-              text: '不处理',
-              value: 'false',
-              description: '结果不做绝对值处理',
-            },
-          ],
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'ConvertTimezone',
-      description: '为指定日期时间转换时区',
-      params: [
-        new Param({
-          name: '指定日期',
-          description: '指定日期',
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-        new Param({
-          name: '转换时区至',
-          description: '转换时区至',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-          defaultValue: new DefaultValue({
-            expression: new StringLiteral({ value: 'Asia/Shanghai' }),
-            concept: 'DefaultValue',
-          }),
-          useComponent: { type: 's-bidirectional-bind-switch' },
-          defaultExpression: new StringLiteral({
-            value: 'Asia/Shanghai',
-            name: 'ConvertTimezoneDefaultExpression',
-          }),
-          options: [
-            {
-              text: '中国标准时间（UTC +8）',
-              value: 'Asia/Shanghai',
-              description: '中国标准时间',
-            },
-            {
-              text: '格林威治标准时间（UTC +0）',
-              value: 'Europe/London',
-              description: '格林威治标准时间',
-            },
-            {
-              text: '北美东部标准时间（UTC -5）',
-              value: 'America/New_York',
-              description: '北美东部标准时间',
-            },
-            {
-              text: '日本标准时间（UTC +9）',
-              value: 'Asia/Tokyo',
-              description: '日本标准时间',
-            },
-            {
-              text: '欧洲中部标准时间（UTC +1）',
-              value: 'Europe/Paris',
-              description: '欧洲中部标准时间',
-            },
-          ],
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'GetDateCount',
-      description: '按指定维度计算日期，如“所在年-第几周”。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。',
-      params: [
-        new Param({
-          name: '指定日期',
-          description: '将被计算的日期',
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-        new Param({
-          name: '根据指定日期计算',
-          description: '获取指定日期的特定信息，如是其所在年的第几天',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-          defaultValue: new DefaultValue({
-            expression: new StringLiteral({ value: 'week-year' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new StringLiteral({ value: 'week-year' }),
-          cascader: true,
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'AlterDateTime',
-      description: '为指定日期时间调整增加（减少）时间',
-      params: [
-        new Param({
-          name: '指定日期时间',
-          description: '将被更改的日期时间或日期',
-          typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
-        }),
-        new Param({
-          name: '调整',
-          description: '为指定的日期时间增加或减少指定的数量，只能填整数',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-          defaultValue: new DefaultValue({
-            expression: new StringLiteral({ value: 'Increase' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new StringLiteral({ value: 'Increase' }),
-          options: [
-            { text: '增加', value: 'Increase' },
-            { text: '减少', value: 'Decrease' },
-          ],
-        }),
-        new Param({
-          name: 'amount',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-          defaultExpression: new NumericLiteral({ value: '0' }),
-        }),
-        new Param({
-          name: '计算数',
-          typeAnnotation: TypeAnnotation.createPrimitive('String'),
-          defaultValue: new DefaultValue({
-            expression: new StringLiteral({ value: 'day' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new StringLiteral({ value: 'day' }),
-          options: [
-            { text: '天', value: 'day' },
-            { text: '周', value: 'week' },
-            { text: '月', value: 'month' },
-            { text: '季度', value: 'quarter' },
-            { text: '年', value: 'year' },
-          ],
-        }),
-      ],
-    }),
-    new Function({
-      name: 'GetSpecificDaysOfWeek',
-      description: '按“星期几”获取指定日期范围内的日子。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。',
-      params: [
-        new Param({
-          name: '起始',
-          description: '起始日期（包含）',
-          typeAnnotation: TypeAnnotation.createPrimitive('Date'),
-        }),
-        new Param({
-          name: '结束',
-          description: '结束日期（包含）',
-          typeAnnotation: TypeAnnotation.createPrimitive('Date'),
-        }),
-        new Param({
-          name: '指定',
-          description: '指定的星期几，可多选',
-          useComponent: { type: 's-bidirectional-bind-switch' },
-          defaultExpression: new NewList({
-            name: 'GetSpecificDaysOfWeekTargetDefaultExpression',
-            typeAnnotation: TypeAnnotation.createGeneric('List', {
-              typeArguments: [TypeAnnotation.createPrimitive('Long')],
-            }),
-          }),
-          options: [
-            { text: '星期一', value: '1' },
-            { text: '星期二', value: '2' },
-            { text: '星期三', value: '3' },
-            { text: '星期四', value: '4' },
-            { text: '星期五', value: '5' },
-            { text: '星期六', value: '6' },
-            { text: '星期日', value: '7' },
-          ],
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Clone',
-      description: '复制一个所选参数的实例',
-      params: [
-        new Param({
-          name: 'struct',
-          description: '指定对象',
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'Clear',
-      description: '（修改原数据）清除复杂对象中每个属性的数据（若输入是单个基础类型如 Integer 的值，则不做处理）',
-      params: [
-        new Param({
-          name: 'struct',
-          description: '指定对象',
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'RandomInt',
-      description: '产生随机整数',
-      params: [
-        new Param({
-          name: 'start',
-          description: '起始数字，Integer类型',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-        new Param({
-          name: 'end',
-          description: '截至数字，Integer类型',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-        }),
-      ],
-    }),
-    new Function({
-      name: 'CreateListPage',
-      description: '将List&lt;T&gt;列表转换为列表分页',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+                new Param({
+                    name: 'str',
+                    description: '指定字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'separator',
+                    description: '指定字符串中作为分隔符的参数',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createPrimitive('String')],
+                    }),
+                }),
+            ],
         }),
-        new Param({
-          name: 'total',
-          description: '指定数据条数',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        new Function({
+            name: 'Join',
+            description: '将列表的项，用连接符连接成一个字符串，并返回',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createPrimitive('String')],
+                    }),
+                }),
+                new Param({
+                    name: 'separator',
+                    description: '连接符，用于连接列表中的项',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'Concat',
+            description: '将所有字符串参数连接并返回',
+            params: [
+                new Param({
+                    name: 'str1',
+                    description: '指定字符串1',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'str2',
+                    description: '指定字符串2',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListSort',
-      description: '（修改原数据）为列表按指定规则排序',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'Length',
+            description: '返回String或Map或List的长度',
+            params: [
+                new Param({
+                    name: 'param',
+                    description: '指定字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性或项本身，支持算数运算和比较运算',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'ToLower',
+            description: '返回全部小写的字符串',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'str1',
+                    description: '指定字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
             ],
-          }),
         }),
-        new Param({
-          name: 'sort',
-          description: '支持升序或降序设置，asc为升序，desc为降序。',
-          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
-          defaultValue: new DefaultValue({
-            expression: new BooleanLiteral({ value: 'true' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new BooleanLiteral({ value: 'true' }),
-          options: [
-            {
-              text: 'asc',
-              value: 'true',
-              description: '升序',
-            },
-            {
-              text: 'desc',
-              value: 'false',
-              description: '降序',
-            },
-          ],
+        new Function({
+            name: 'ToUpper',
+            description: '返回全部大写的字符串',
+            params: [
+                new Param({
+                    name: 'str1',
+                    description: '指定字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-      ],
-      returns: [],
-    }),
-    new Function({
-      name: 'ListFind',
-      description: '返回列表中第一个符合条件的项',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'Trim',
+            description: '删除字符串的前后空格。返回裁剪后的新字符串。',
+            params: [
+                new Param({
+                    name: 'str1',
+                    description: '指定字符串',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'Get',
+            description: '获得列表位于指定索引处的项',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'index',
+                    description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
             ],
-          }),
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
+        new Function({
+            name: 'Set',
+            description: '（修改原数据）为列表的指定索引项赋值（覆盖原索引项）',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'index',
+                    description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+                new Param({
+                    name: 'item',
+                    description: '列表指定索引下的新项',
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListFindIndex',
-      description: '返回列表中第一个符合条件的项的索引值',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'Contains',
+            description: '测试列表是否包含某一项，返回测试结果',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'item',
+                    description: '指定项',
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('Boolean'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'Add',
+            description: '（修改原数据）在列表末尾追加项。',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'item',
+                    description: '指定需要在列表末尾增加的项',
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
             ],
-          }),
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        new Function({
+            name: 'AddAll',
+            description: '（修改原数据）为一个列表添加另一列表中的多项内容。返回新列表的长度',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表1',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'addList',
+                    description: '指定列表2',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListFilter',
-      description: '筛选列表中符合条件的所有项，返回这些项构成的新的列表',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+        new Function({
+            name: 'Insert',
+            description: '（修改原数据）在列表的指定索引处插入新项（原索引项依次后推）',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'index',
+                    description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+                new Param({
+                    name: 'item',
+                    description: '待插入项',
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'Remove',
+            description: '（修改原数据）删除列表的某项',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'item',
+                    description: '指定项',
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
             ],
-          }),
         }),
-      ],
-      returns: [
-        new Return({
-          name: 'list',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'RemoveAt',
+            description: '（修改原数据）在列表中删除位于指定索引的项。返回被删除的项',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'index',
+                    description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListReverse',
-      description: '（修改原数据）将列表的所有项反向排列（例如第一项变为最后一项）',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'ListHead',
+            description: '返回列表的首项',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-      returns: [],
-    }),
-    new Function({
-      name: 'ListDistinct',
-      description: '（修改原数据）为列表去除重复项',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'ListLast',
+            description: '返回列表的末项',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-      returns: [],
-    }),
-    new Function({
-      name: 'ListDistinctBy',
-      description: '按某几个属性为列表去除重复项。返回去除重复项后的列表',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+        new Function({
+            name: 'ListFlatten',
+            description: '将嵌套列表摊平一层并返回（List&lt;List&lt;T&gt;&gt; 变为 List&lt;T&gt;）',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某几个属性，若项无属性，则该函数不生效',
-          defaultExpression: new NewList({
-            name: 'ListDistinctByTargetDefaultExpression',
-            typeAnnotation: TypeAnnotation.createGeneric('List', {
-              typeArguments: [TypeAnnotation.createTypeParam('T')],
-            }),
-            items: [
-              new AnonymousFunction({
-                params: [
-                  new Param({
-                    name: 'item',
-                    description: '是否忽略大小写',
-                    typeAnnotation: null,
-                  }),
-                ],
-                body: new Identifier(),
-              }),
-            ],
-          }),
+        new Function({
+            name: 'ListToMap',
+            description: '选取列表项的某些属性，根据这些属性将列表变为 Map 并返回',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: `根据项的属性及其本身进行key和value的定义`,
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+                new Param({
+                    name: 'byVal',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+            ],
         }),
-      ],
-      returns: [new Return({
-        typeAnnotation: TypeAnnotation.createGeneric('List', {
-          typeArguments: [
-            TypeAnnotation.createTypeParam('T'),
-          ],
+        new Function({
+            name: 'ListTransform',
+            description: '对列表的每一项调用函数 by，得到新项；返回新项构成的列表',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定对列表中项的某个属性或项本身的处理方式，支持算数运算和比较运算',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
         }),
-      })],
-    }),
-    new Function({
-      name: 'ListGroupBy',
-      description: '按某个属性为列表分组。以选中的属性为 key 建立 Map 并返回。',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+        new Function({
+            name: 'ListSum',
+            description: '返回数值列表中所有项的和',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'ListProduct',
+            description: '返回数值列表中所有项的积',
             params: [
-              new Param({
-                name: 'item',
-                description: '是否忽略大小写',
-                typeAnnotation: null,
-              }),
-            ],
-            body: new Identifier(),
-          }),
+                new Param({
+                    name: 'list',
+                    description: '指定数值类型列表',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-      returns: [new Return({
-        typeAnnotation: TypeAnnotation.createGeneric('map', {
-          typeArguments: [
-            TypeAnnotation.createTypeParam('K'),
-            TypeAnnotation.createGeneric('List', {
-              typeArguments: [TypeAnnotation.createTypeParam('A')],
-            }),
-          ],
+        new Function({
+            name: 'ListAverage',
+            description: '返回数值列表中所有项的平均值',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定数值类型列表',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      })],
-    }),
-    new Function({
-      name: 'ListSlice',
-      description: '将列表按照规则切片，返回切片后的子列表',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'ListMax',
+            description: '返回数值列表中所有项的最大值',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定数值类型列表',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'start',
-          description: '切片起始的索引，integer类型，项数索引从0开始',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        new Function({
+            name: 'ListMin',
+            description: '返回数值列表中所有项的最小值',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定数值类型列表',
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'end',
-          description: '切片结束的索引，integer类型，用数字表示第几项，项数索引从0开始',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        new Function({
+            name: 'MapGet',
+            description: '查询出Map中key为指定值的value值列表',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    description: '指定参数key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('V'),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'MapPut',
+            description: '（修改原数据）为Map中添加键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    description: '指定参数key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+                new Param({
+                    name: 'value',
+                    description: '指定参数value',
+                    typeAnnotation: TypeAnnotation.createTypeParam('V'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'SliceToListPage',
-      description: '将列表按照规则切片，返回切片后的列表分页',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'MapRemove',
+            description: '（修改原数据）删除Map中的键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    description: '指定参数key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'page',
-          description: '页数，integer类型，从1开始',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        new Function({
+            name: 'MapContains',
+            description: '判断Map中是否存在参数指定的键值对',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'key',
+                    description: '指定参数key',
+                    typeAnnotation: TypeAnnotation.createTypeParam('K'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('Boolean'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'size',
-          description: '每页的大小，integer类型',
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        new Function({
+            name: 'MapKeys',
+            description: '输出Map中key集合',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K')],
+                    }),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('PageOf', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'MapValues',
+            description: '输出Map中value集合',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('V')],
+                    }),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'New',
-      description: '根据参数选择的类型，返回该参数的实例化对象',
-      typeParams: [
-        new TypeParam({
-          name: 'T',
+        new Function({
+            name: 'MapFilter',
+            description: '在指定Map中过滤出符合条件参数的Map列表',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '针对键值对的参数key和value设置过滤条件，支持算数运算、比较运算和逻辑运算',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+            ],
         }),
-      ],
-      params: [
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
+        new Function({
+            name: 'MapTransform',
+            description: '对 Map 的每一项调用函数 by，得到新项，并返回新项构成的 Map。（Map 的每一项从 (K0, V0) 变为 (K, V)。）',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                }),
+                new Param({
+                    name: 'by',
+                    description: `指定映射中键值对的参数处理方式，支持算数运算和比较运算`,
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier({
+                            name: 'key',
+                        }),
+                    }),
+                }),
+                new Param({
+                    name: 'byVal',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('Map', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K'), TypeAnnotation.createTypeParam('V')],
+                    }),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'Round',
-      description: '对指定的小数按指定的舍入模式进行舍入，返回舍入后的整数',
-      params: [
-        new Param({
-          name: 'value',
-          description: '被取整小数',
-          typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
+        new Function({
+            name: 'CurrDate',
+            description: '返回指定时区的当前日期',
+            params: [ ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Date'),
+                }),
+            ],
         }),
-        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.createPrimitive('String'),
-          defaultExpression: new StringLiteral({ value: 'HalfUp' }),
-          options: [
-            { text: 'HalfUp', value: 'HalfUp', description: '四舍五入' },
-            { text: 'TowardsZero', value: 'TowardsZero', description: '截断、向零取整，如 -2.6 取整为 -2' },
-            { text: 'Towardslnfinity', value: 'TowardsInfinity', description: '进位、向正负无穷取整，如 -1.1 取整为 -2' },
-          ],
-&nbsp;
+        new Function({
+            name: 'CurrTime',
+            description: '返回指定时区的当前时间',
+            params: [ ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('Time'),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        new Function({
+            name: 'CurrDateTime',
+            description: '返回指定时区的当前日期时间',
+            params: [ ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'HasValue',
-      description: '判断参数是否为有效值，null、空字符串、纯空格、长度为0的集合均不被视为有效值，传入多个参数时，判断是否全部都是有效值',
-      params: [
-        new Param({
-          name: 'param1',
-          description: '指定参数1',
-          typeAnnotation: TypeAnnotation.createPrimitive('Any'),
+        new Function({
+            name: 'FormatDate',
+            description: '返回格式化日期字符串',
+            params: [
+                new Param({
+                    name: 'date',
+                    description: '指定需要格式化日期的字段',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Date'),
+                }),
+                new Param({
+                    name: 'formatter',
+                    description: '格式化规则，默认为yyyy-MM-dd，即年月日格式',
+                    defaultValue: 'yyyy-MM-dd',
+                    defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd' }),
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                })
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+        new Function({
+            name: 'FormatDateTime',
+            description: '返回格式化日期时间字符串。当输入为 DateTime 类型时，会把数据转到目标时区的当地时间进行格式化。',
+            params: [
+                new Param({
+                    name: 'date',
+                    description: '指定需要格式化日期时间的字段',
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
+                new Param({
+                    name: 'formatter',
+                    description: '格式化规则，默认为yyyy-MM-dd',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: 'yyyy-MM-dd HH:mm:ss',
+                    defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd HH:mm:ss' }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListFindAsync',
-      description: '返回列表中第一个符合条件的项',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'FormatNumber',
+            description: '返回格式化的数字字符串',
+            params: [
+                new Param({
+                    name: 'value',
+                    description: '指定需要格式化小数位数的字段',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
+                    defaultExpression: new Identifier(),
+                }),
+                new Param({
+                    name: 'digits',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                    description: '保留小数位数',
+                    defaultValue: '2',
+                    defaultExpression: new NumericLiteral({ value: '2' }),
+                }),
+                new Param({
+                    name: 'showGroups',
+                    description: '是否显示千分位：true显示，false不显示',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: 'false',
+                    defaultExpression: new BooleanLiteral({ value: 'false' }),
+                    options: [
+                        {
+                            text: 'true',
+                            value: 'true',
+                            description: '显示千分位',
+                        },
+                        {
+                            text: 'false',
+                            value: 'false',
+                            description: '不显示千分位',
+                        },
+                    ],
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'AddDays',
+            description: '返回日期天数加法计算结果',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'dateTime',
+                    description: '指定日期时间',
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
+                new Param({
+                    name: 'amount',
+                    description: '增加的天数',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
             ],
-          }),
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createTypeParam('T'),
+        new Function({
+            name: 'AddMonths',
+            description: '返回月份加法计算结果',
+            params: [
+                new Param({
+                    name: 'dateTime',
+                    description: '指定日期时间',
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
+                new Param({
+                    name: 'amount',
+                    description: '增加的月数',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListSortAsync',
-      description: '（修改原数据）为列表按指定规则排序',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'DateDiff',
+            description: '返回日期比较结果',
+            params: [
+                new Param({
+                    name: 'dateTime1',
+                    description: '指定日期时间1',
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                    defaultExpression: new Identifier(),
+                }),
+                new Param({
+                    name: 'dateTime2',
+                    description: '指定日期时间2',
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                    defaultExpression: new Identifier(),
+                }),
+                new Param({
+                    name: 'calcType',
+                    description: '计算类型。计算两个日期时间之间的差值，支持年数、季度数、月数、星期数、天数、小时数、分钟数、秒数',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: 'd',
+                    defaultExpression: new StringLiteral({ value: 'd' }),
+                    options: [
+                        {
+                            text: 'Year',
+                            value: 'y',
+                            description: '年数',
+                        },
+                        {
+                            text: 'Season',
+                            value: 'q',
+                            description: '季度数',
+                        },
+                        {
+                            text: 'Month',
+                            value: 'M',
+                            description: '月数',
+                        },
+                        {
+                            text: 'Week',
+                            value: 'w',
+                            description: '星期数',
+                        },
+                        {
+                            text: 'Day',
+                            value: 'd',
+                            description: '天数',
+                        },
+                        {
+                            text: 'Hour',
+                            value: 'h',
+                            description: '小时数',
+                        },
+                        {
+                            text: 'Minute',
+                            value: 'm',
+                            description: '分钟数',
+                        },
+                        {
+                            text: 'Second',
+                            value: 's',
+                            description: '秒数',
+                        },
+                    ],
+                }),
+                new Param({
+                    name: '结果处理',
+                    description: '结果是否绝对值处理',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: 'true',
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
+                    options: [
+                        {
+                            text: '绝对值',
+                            value: 'true',
+                            description: '结果绝对值处理',
+                        },
+                        {
+                            text: '不处理',
+                            value: 'false',
+                            description: '结果不做绝对值处理',
+                        },
+                    ],
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性或项本身，支持算数运算和比较运算',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'ConvertTimezone',
+            description: '为指定日期时间转换时区',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: '指定日期',
+                    description: '指定日期',
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
+                new Param({
+                    name: '转换时区至',
+                    description: '转换时区至',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: 'Asia/Shanghai',
+                    useComponent: { type: 's-bidirectional-bind-switch' },
+                    defaultExpression: new StringLiteral({
+                        value: 'Asia/Shanghai',
+                        name: 'ConvertTimezoneDefaultExpression',
+                    }),
+                    options: [
+                        {
+                            text: '中国标准时间（UTC +8）',
+                            value: 'Asia/Shanghai',
+                            description: '中国标准时间',
+                        },
+                        {
+                            text: '格林威治标准时间（UTC +0）',
+                            value: 'Europe/London',
+                            description: '格林威治标准时间',
+                        },
+                        {
+                            text: '北美东部标准时间（UTC -5）',
+                            value: 'America/New_York',
+                            description: '北美东部标准时间',
+                        },
+                        {
+                            text: '日本标准时间（UTC +9）',
+                            value: 'Asia/Tokyo',
+                            description: '日本标准时间',
+                        },
+                        {
+                            text: '欧洲中部标准时间（UTC +1）',
+                            value: 'Europe/Paris',
+                            description: '欧洲中部标准时间',
+                        },
+                    ],
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
             ],
-          }),
         }),
-        new Param({
-          name: 'sort',
-          description: '支持升序或降序设置，asc为升序，desc为降序。',
-          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
-          defaultValue: new DefaultValue({
-            expression: new BooleanLiteral({ value: 'true' }),
-            concept: 'DefaultValue',
-          }),
-          defaultExpression: new BooleanLiteral({ value: 'true' }),
-          options: [
-            { text: 'asc(升序)', value: 'true' },
-            { text: 'desc(降序)', value: 'false' },
-          ],
+        new Function({
+            name: 'GetDateCount',
+            description: '按指定维度计算日期，如“所在年-第几周”。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。',
+            params: [
+                new Param({
+                    name: '指定日期',
+                    description: '将被计算的日期',
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
+                new Param({
+                    name: '根据指定日期计算',
+                    description: '获取指定日期的特定信息，如是其所在年的第几天',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: 'week-year',
+                    defaultExpression: new StringLiteral({ value: 'week-year' }),
+                    cascader: true,
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
         }),
-      ],
-      returns: [],
-    }),
-    new Function({
-      name: 'ListFilterAsync',
-      description: '筛选列表中符合条件的所有项，返回这些项构成的新的列表',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+        new Function({
+            name: 'AlterDateTime',
+            description: '为指定日期时间调整增加（减少）时间',
+            params: [
+                new Param({
+                    name: '指定日期时间',
+                    description: '将被更改的日期时间或日期',
+                    typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
+                }),
+                new Param({
+                    name: '调整',
+                    description: '为指定的日期时间增加或减少指定的数量，只能填整数',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: 'Increase',
+                    defaultExpression: new StringLiteral({ value: 'Increase' }),
+                    options: [
+                        { text: '增加', value: 'Increase' },
+                        { text: '减少', value: 'Decrease' },
+                    ],
+                }),
+                new Param({
+                    name: 'amount',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                    defaultExpression: new NumericLiteral({ value: '0' }),
+                }),
+                new Param({
+                    name: '计算数',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultValue: 'day',
+                    defaultExpression: new StringLiteral({ value: 'day' }),
+                    options: [
+                        { text: '天', value: 'day' },
+                        { text: '周', value: 'week' },
+                        { text: '月', value: 'month' },
+                        { text: '季度', value: 'quarter' },
+                        { text: '年', value: 'year' },
+                    ],
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'GetSpecificDaysOfWeek',
+            description: '按“星期几”获取指定日期范围内的日子。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: '起始',
+                    description: '起始日期（包含）',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Date'),
+                }),
+                new Param({
+                    name: '结束',
+                    description: '结束日期（包含）',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Date'),
+                }),
+                new Param({
+                    name: '指定',
+                    description: '指定的星期几，可多选',
+                    useComponent: { type: 's-bidirectional-bind-switch' },
+                    defaultExpression: new NewList({
+                        name: 'GetSpecificDaysOfWeekTargetDefaultExpression',
+                        typeAnnotation: TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createPrimitive('Long')],
+                        }),
+                    }),
+                    options: [
+                        { text: '星期一', value: '1' },
+                        { text: '星期二', value: '2' },
+                        { text: '星期三', value: '3' },
+                        { text: '星期四', value: '4' },
+                        { text: '星期五', value: '5' },
+                        { text: '星期六', value: '6' },
+                        { text: '星期日', value: '7' },
+                    ],
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
             ],
-          }),
         }),
-      ],
-      returns: [
-        new Return({
-          name: 'list',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'Clone',
+            description: '复制一个所选参数的实例',
+            params: [
+                new Param({
+                    name: 'struct',
+                    description: '指定对象',
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListFindIndexAsync',
-      description: '返回列表中第一个符合条件的项的索引值',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'Clear',
+            description: '（修改原数据）清除复杂对象数据（不支持清除 Integer 等基础类型的值）',
+            params: [
+                new Param({
+                    name: 'struct',
+                    description: '指定对象',
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'RandomInt',
+            description: '产生随机整数',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'start',
+                    description: '起始数字，Integer类型',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+                new Param({
+                    name: 'end',
+                    description: '截至数字，Integer类型',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
             ],
-          }),
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        new Function({
+            name: 'CreateListPage',
+            description: '将List&lt;T&gt;列表转换为列表分页',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'total',
+                    description: '指定数据条数',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListDistinctByAsync',
-      description: '按某个属性为列表去除重复项。返回去除重复项后的列表',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+        new Function({
+            name: 'ListSort',
+            description: '（修改原数据）为列表按指定规则排序',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性或项本身，支持算数运算和比较运算',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'sort',
+                    description: '支持升序或降序设置，asc为升序，desc为降序。',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: 'asc',
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
+                    options: [
+                        {
+                            text: 'asc',
+                            value: 'true',
+                            description: '升序',
+                        },
+                        {
+                            text: 'desc',
+                            value: 'false',
+                            description: '降序',
+                        },
+                    ],
+                }),
+            ],
+            returns: [],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'ListFind',
+            description: '返回列表中第一个符合条件的项',
             params: [
-              new Param({
-                name: 'item',
-                description: '是否忽略大小写',
-                typeAnnotation: null,
-              }),
-            ],
-            body: new Identifier(),
-          }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-      returns: [new Return({
-        typeAnnotation: TypeAnnotation.createGeneric('List', {
-          typeArguments: [
-            TypeAnnotation.createTypeParam('T'),
-          ],
+        new Function({
+            name: 'ListFindIndex',
+            description: '返回列表中第一个符合条件的项的索引值',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
         }),
-      })],
-    }),
-    new Function({
-      name: 'ListGroupByAsync',
-      description: '按某个属性为列表分组。以选中的属性为 key 建立 Map 并返回。',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+        new Function({
+            name: 'ListFilter',
+            description: '筛选列表中符合条件的所有项，返回这些项构成的新的列表',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'ListReverse',
+            description: '（修改原数据）将列表的所有项反向排列（例如第一项变为最后一项）',
             params: [
-              new Param({
-                name: 'item',
-                description: '是否忽略大小写',
-                typeAnnotation: null,
-              }),
-            ],
-            body: new Identifier(),
-          }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+            returns: [],
         }),
-      ],
-      returns: [new Return({
-        typeAnnotation: TypeAnnotation.createGeneric('map', {
-          typeArguments: [
-            TypeAnnotation.createTypeParam('K'),
-            TypeAnnotation.createGeneric('List', {
-              typeArguments: [TypeAnnotation.createTypeParam('A')],
-            }),
-          ],
+        new Function({
+            name: 'ListDistinct',
+            description: '（修改原数据）为列表去除重复项',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
+            returns: [],
         }),
-      })],
-    }),
-    new Function({
-      name: 'ListTransformAsync',
-      description: '对列表的每一项调用函数 by，得到新项；返回新项构成的列表',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+        new Function({
+            name: 'ListDistinctBy',
+            description: '按某几个属性为列表去除重复项。返回去除重复项后的列表',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某几个属性，若项无属性，则该函数不生效',
+                    defaultExpression: new NewList({
+                        name: 'ListDistinctByTargetDefaultExpression',
+                        typeAnnotation: TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createTypeParam('T')],
+                        }),
+                        items: [
+                            new AnonymousFunction({
+                                params: [
+                                    new Param({
+                                        name: 'item',
+                                        description: '是否忽略大小写',
+                                        typeAnnotation: null,
+                                    }),
+                                ],
+                                body: new Identifier(),
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [new Return({
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [
+                        TypeAnnotation.createTypeParam('T'),
+                    ],
+                }),
+            })],
+        }),
+        new Function({
+            name: 'ListGroupBy',
+            description: '按某个属性为列表分组。以选中的属性为 key 建立 Map 并返回。',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                description: '是否忽略大小写',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+            ],
+            returns: [new Return({
+                typeAnnotation: TypeAnnotation.createGeneric('map', {
+                    typeArguments: [
+                        TypeAnnotation.createTypeParam('K'),
+                        TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createTypeParam('A')],
+                        }),
+                    ],
+                }),
+            })],
+        }),
+        new Function({
+            name: 'ListSlice',
+            description: '将列表按照规则切片，返回切片后的子列表',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'start',
+                    description: '切片起始的索引，integer类型，项数索引从0开始',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+                new Param({
+                    name: 'end',
+                    description: '切片结束的索引，integer类型，用数字表示第几项，项数索引从0开始',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '指定对列表中项的某个属性或项本身的处理方式，支持算数运算和比较运算',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'SliceToListPage',
+            description: '将列表按照规则切片，返回切片后的列表分页',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'page',
+                    description: '页数，integer类型，从1开始',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+                new Param({
+                    name: 'size',
+                    description: '每页的大小，integer类型',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('PageOf', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
             ],
-          }),
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('List', {
-            typeArguments: [TypeAnnotation.createTypeParam('T')],
-          }),
+        new Function({
+            name: 'New',
+            description: '根据参数选择的类型，返回该参数的实例化对象',
+            typeParams: [
+                new TypeParam({
+                    name: 'T',
+                }),
+            ],
+            params: [
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'MapFilterAsync',
-      description: '在指定Map中过滤出符合条件参数的Map列表',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
+        new Function({
+            name: 'Round',
+            description: '对指定的小数按指定的舍入模式进行舍入，返回舍入后的整数',
+            params: [
+                new Param({
+                    name: 'value',
+                    description: '被取整小数',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
+                }),
+                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.createPrimitive('String'),
+                    defaultExpression: new StringLiteral({ value: 'HalfUp' }),
+                    options: [
+                        { text: 'HalfUp', value: 'HalfUp', description: '四舍五入' },
+                        { text: 'TowardsZero', value: 'TowardsZero', description: '截断、向零取整，如 -2.6 取整为 -2' },
+                        { text: 'Towardslnfinity', value: 'TowardsInfinity', description: '进位、向正负无穷取整，如 -1.1 取整为 -2' },
+                    ],
+&nbsp;
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: '针对键值对的参数key和value设置过滤条件，支持算数运算、比较运算和逻辑运算',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'HasValue',
+            description: '判断参数是否为有效值，null、空字符串、纯空格、长度为0的集合均不被视为有效值，传入多个参数时，判断是否全部都是有效值',
             params: [
-              new Param({
-                name: 'key',
-                typeAnnotation: null,
-              }),
-              new Param({
-                name: 'value',
-                typeAnnotation: null,
-              }),
-            ],
-          }),
+                new Param({
+                    name: 'param1',
+                    description: '指定参数1',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Any'),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('map', {
-            typeArguments: [
-              TypeAnnotation.createTypeParam('K'),
-              TypeAnnotation.createTypeParam('V'),
-            ],
-          }),
+        new Function({
+            name: 'ListFindAsync',
+            description: '返回列表中第一个符合条件的项',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'MapTransformAsync',
-      description: '对 Map 的每一项调用函数 by，得到新项，并返回新项构成的 Map。（Map 的每一项从 (K0, V0) 变为 (K, V)。）',
-      params: [
-        new Param({
-          name: 'map',
-          description: '指定映射',
+        new Function({
+            name: 'ListSortAsync',
+            description: '（修改原数据）为列表按指定规则排序',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性或项本身，支持算数运算和比较运算',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+                new Param({
+                    name: 'sort',
+                    description: '支持升序或降序设置，asc为升序，desc为降序。',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                    defaultValue: 'asc',
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
+                    options: [
+                        { text: 'asc(升序)', value: 'true' },
+                        { text: 'desc(降序)', value: 'false' },
+                    ],
+                }),
+            ],
+            returns: [],
         }),
-        new Param({
-          name: 'by',
-          description: `指定映射中键值对的参数处理方式，支持算数运算和比较运算`,
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'ListFilterAsync',
+            description: '筛选列表中符合条件的所有项，返回这些项构成的新的列表',
             params: [
-              new Param({
-                name: 'key',
-                typeAnnotation: null,
-              }),
-              new Param({
-                name: 'value',
-                typeAnnotation: null,
-              }),
-            ],
-            body: new Identifier({
-              name: 'key',
-            }),
-          }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
         }),
-        new Param({
-          name: 'byVal',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'ListFindIndexAsync',
+            description: '返回列表中第一个符合条件的项的索引值',
             params: [
-              new Param({
-                name: 'key',
-                typeAnnotation: null,
-              }),
-              new Param({
-                name: 'value',
-                typeAnnotation: null,
-              }),
-            ],
-          }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+                }),
+            ],
         }),
-      ],
-      returns: [
-        new Return({
-          typeAnnotation: TypeAnnotation.createGeneric('Map', {
-            typeArguments: [TypeAnnotation.createTypeParam('K'), TypeAnnotation.createTypeParam('V')],
-          }),
+        new Function({
+            name: 'ListDistinctByAsync',
+            description: '按某个属性为列表去除重复项。返回去除重复项后的列表',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                description: '是否忽略大小写',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+            ],
+            returns: [new Return({
+                typeAnnotation: TypeAnnotation.createGeneric('List', {
+                    typeArguments: [
+                        TypeAnnotation.createTypeParam('T'),
+                    ],
+                }),
+            })],
+        }),
+        new Function({
+            name: 'ListGroupByAsync',
+            description: '按某个属性为列表分组。以选中的属性为 key 建立 Map 并返回。',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                description: '是否忽略大小写',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+            ],
+            returns: [new Return({
+                typeAnnotation: TypeAnnotation.createGeneric('map', {
+                    typeArguments: [
+                        TypeAnnotation.createTypeParam('K'),
+                        TypeAnnotation.createGeneric('List', {
+                            typeArguments: [TypeAnnotation.createTypeParam('A')],
+                        }),
+                    ],
+                }),
+            })],
+        }),
+        new Function({
+            name: 'ListTransformAsync',
+            description: '对列表的每一项调用函数 by，得到新项；返回新项构成的列表',
+            params: [
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '指定对列表中项的某个属性或项本身的处理方式，支持算数运算和比较运算',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+            ],
         }),
-      ],
-    }),
-    new Function({
-      name: 'ListToMapAsync',
-      description: '选取列表项的某些属性，根据这些属性将列表变为 Map 并返回',
-      params: [
-        new Param({
-          name: 'list',
-          description: '指定列表',
+        new Function({
+            name: 'MapFilterAsync',
+            description: '在指定Map中过滤出符合条件参数的Map列表',
+            params: [
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                }),
+                new Param({
+                    name: 'by',
+                    description: '针对键值对的参数key和value设置过滤条件，支持算数运算、比较运算和逻辑运算',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('map', {
+                        typeArguments: [
+                            TypeAnnotation.createTypeParam('K'),
+                            TypeAnnotation.createTypeParam('V'),
+                        ],
+                    }),
+                }),
+            ],
         }),
-        new Param({
-          name: 'by',
-          description: `根据项的属性及其本身进行key和value的定义`,
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'MapTransformAsync',
+            description: '对 Map 的每一项调用函数 by，得到新项，并返回新项构成的 Map。（Map 的每一项从 (K0, V0) 变为 (K, V)。）',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'map',
+                    description: '指定映射',
+                }),
+                new Param({
+                    name: 'by',
+                    description: `指定映射中键值对的参数处理方式，支持算数运算和比较运算`,
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier({
+                            name: 'key',
+                        }),
+                    }),
+                }),
+                new Param({
+                    name: 'byVal',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'key',
+                                typeAnnotation: null,
+                            }),
+                            new Param({
+                                name: 'value',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                    }),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createGeneric('Map', {
+                        typeArguments: [TypeAnnotation.createTypeParam('K'), TypeAnnotation.createTypeParam('V')],
+                    }),
+                }),
             ],
-            body: new Identifier(),
-          }),
         }),
-        new Param({
-          name: 'byVal',
-          defaultExpression: new AnonymousFunction({
+        new Function({
+            name: 'ListToMapAsync',
+            description: '选取列表项的某些属性，根据这些属性将列表变为 Map 并返回',
             params: [
-              new Param({
-                name: 'item',
-                typeAnnotation: null,
-              }),
+                new Param({
+                    name: 'list',
+                    description: '指定列表',
+                }),
+                new Param({
+                    name: 'by',
+                    description: `根据项的属性及其本身进行key和value的定义`,
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
+                new Param({
+                    name: 'byVal',
+                    defaultExpression: new AnonymousFunction({
+                        params: [
+                            new Param({
+                                name: 'item',
+                                typeAnnotation: null,
+                            }),
+                        ],
+                        body: new Identifier(),
+                    }),
+                }),
             ],
-            body: new Identifier(),
-          }),
         }),
-      ],
-    }),
-  ];
-&nbsp;
-  logics.forEach((logic) =&gt; utilNamespace.addLogic(logic));
-  functions.forEach((func) =&gt; utilNamespace.addFunction(func));
-}
+    ],
+});
 &nbsp;</pre></td></tr></table></pre>
 
                 <div class='push'></div><!-- for sticky footer -->
@@ -6934,7 +6829,7 @@ export function initialize() {
             <div class='footer quiet pad2 space-top1 center small'>
                 Code coverage generated by
                 <a href="https://istanbul.js.org/" target="_blank" rel="noopener noreferrer">istanbul</a>
-                at 2023-12-07T14:08:08.581Z
+                at 2023-10-18T11:36:07.885Z
             </div>
         <script src="../../../../prettify.js"></script>
         <script>