@mirascript/mirascript 0.1.64 → 0.1.65

package/src/vm/lib/global/math/unary.ts

@@ -10,136 +10,114 @@ function build(f: (x: number) => number): (x: VmAny) => number {
 
 export const sign = VmLib(build(Math.sign), {
     summary: '返回数值的符号（正数为 1，负数为 -1，零为 0）',
-    params: { x: '要判断符号的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要判断符号的数' } },
+    returns: { type: 'number' },
 });
 export const abs = VmLib(build(Math.abs), {
     summary: '返回数值的绝对值',
-    params: { x: '要取绝对值的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要取绝对值的数' } },
+    returns: { type: 'number' },
 });
 
 export const acos = VmLib(build(Math.acos), {
     summary: '返回数值的反余弦值（弧度）',
-    params: { x: '要计算反余弦的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算反余弦的数' } },
+    returns: { type: 'number' },
 });
 export const acosh = VmLib(build(Math.acosh), {
     summary: '返回数值的反双曲余弦值',
-    params: { x: '要计算反双曲余弦的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算反双曲余弦的数' } },
+    returns: { type: 'number' },
 });
 export const asin = VmLib(build(Math.asin), {
     summary: '返回数值的反正弦值（弧度）',
-    params: { x: '要计算反正弦的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算反正弦的数' } },
+    returns: { type: 'number' },
 });
 export const asinh = VmLib(build(Math.asinh), {
     summary: '返回数值的反双曲正弦值',
-    params: { x: '要计算反双曲正弦的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算反双曲正弦的数' } },
+    returns: { type: 'number' },
 });
 export const atan = VmLib(build(Math.atan), {
     summary: '返回数值的反正切值（弧度）',
-    params: { x: '要计算反正切的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算反正切的数' } },
+    returns: { type: 'number' },
 });
 export const atanh = VmLib(build(Math.atanh), {
     summary: '返回数值的反双曲正切值',
-    params: { x: '要计算反双曲正切的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算反双曲正切的数' } },
+    returns: { type: 'number' },
 });
 export const cos = VmLib(build(Math.cos), {
     summary: '返回数值的余弦值',
-    params: { x: '要计算余弦的数（弧度）' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算余弦的数（弧度）' } },
+    returns: { type: 'number' },
 });
 export const cosh = VmLib(build(Math.cosh), {
     summary: '返回数值的双曲余弦值',
-    params: { x: '要计算双曲余弦的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算双曲余弦的数' } },
+    returns: { type: 'number' },
 });
 export const sin = VmLib(build(Math.sin), {
     summary: '返回数值的正弦值',
-    params: { x: '要计算正弦的数（弧度）' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算正弦的数（弧度）' } },
+    returns: { type: 'number' },
 });
 export const sinh = VmLib(build(Math.sinh), {
     summary: '返回数值的双曲正弦值',
-    params: { x: '要计算双曲正弦的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算双曲正弦的数' } },
+    returns: { type: 'number' },
 });
 export const tan = VmLib(build(Math.tan), {
     summary: '返回数值的正切值',
-    params: { x: '要计算正切的数（弧度）' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算正切的数（弧度）' } },
+    returns: { type: 'number' },
 });
 export const tanh = VmLib(build(Math.tanh), {
     summary: '返回数值的双曲正切值',
-    params: { x: '要计算双曲正切的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算双曲正切的数' } },
+    returns: { type: 'number' },
 });
 
 export const exp = VmLib(build(Math.exp), {
     summary: '返回 e 的指定次幂',
-    params: { x: '指数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '指数' } },
+    returns: { type: 'number' },
 });
 export const expm1 = VmLib(build(Math.expm1), {
     summary: '返回 e 的 x 次幂减 1',
-    params: { x: '指数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '指数' } },
+    returns: { type: 'number' },
 });
 export const log = VmLib(build(Math.log), {
     summary: '返回数值的自然对数（以 e 为底）',
-    params: { x: '要取对数的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要取对数的数' } },
+    returns: { type: 'number' },
 });
 export const log10 = VmLib(build(Math.log10), {
     summary: '返回数值的以 10 为底的对数',
-    params: { x: '要取对数的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要取对数的数' } },
+    returns: { type: 'number' },
 });
 export const log1p = VmLib(build(Math.log1p), {
     summary: '返回 1 加上数值的自然对数',
-    params: { x: '要取对数的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要取对数的数' } },
+    returns: { type: 'number' },
 });
 export const log2 = VmLib(build(Math.log2), {
     summary: '返回数值的以 2 为底的对数',
-    params: { x: '要取对数的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要取对数的数' } },
+    returns: { type: 'number' },
 });
 
 export const sqrt = VmLib(build(Math.sqrt), {
     summary: '返回数值的平方根',
-    params: { x: '要开平方的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要开平方的数' } },
+    returns: { type: 'number' },
 });
 export const cbrt = VmLib(build(Math.cbrt), {
     summary: '返回数值的立方根',
-    params: { x: '要计算立方根的数' },
-    paramsType: { x: 'number' },
-    returnsType: 'number',
+    params: { x: { type: 'number', description: '要计算立方根的数' } },
+    returns: { type: 'number' },
 });

package/src/vm/lib/global/sequence/all-any.ts

@@ -31,12 +31,14 @@ export const all = VmLib(
     },
     {
         summary: '检查数组或记录中的所有键值对是否都满足条件',
-        params: { data: '要检查的数组或记录', predicate: '用于测试每个键值对的函数，返回 true 或 false' },
-        paramsType: {
-            data: 'array | record',
-            predicate: 'fn(value: any, key: number | string, input: type(data)) -> boolean',
+        params: {
+            data: { type: 'array | record', description: '要检查的数组或记录' },
+            predicate: {
+                type: 'fn(value: any, key: number | string, input: type(data)) -> boolean',
+                description: '用于测试每个键值对的函数',
+            },
         },
-        returnsType: 'boolean',
+        returns: { type: 'boolean' },
         examples: ['all([1, 2, 3], fn { it > 0 }) // true'],
     },
 );
@@ -67,12 +69,14 @@ export const any = VmLib(
     },
     {
         summary: '检查数组或记录中的是否存在满足条件的键值对',
-        params: { data: '要检查的数组或记录', predicate: '用于测试每个键值对的函数，返回 true 或 false' },
-        paramsType: {
-            data: 'array | record',
-            predicate: 'fn(value: any, key: number | string, input: type(data)) -> boolean',
+        params: {
+            data: { type: 'array | record', description: '要检查的数组或记录' },
+            predicate: {
+                type: 'fn(value: any, key: number | string, input: type(data)) -> boolean',
+                description: '用于测试每个键值对的函数',
+            },
         },
-        returnsType: 'boolean',
+        returns: { type: 'boolean' },
         examples: ['any([0, 1, 2], fn { it > 1 }) // true'],
     },
 );

package/src/vm/lib/global/sequence/entries.ts

@@ -20,9 +20,10 @@ export const keys = VmLib(
     },
     {
         summary: '返回数组、记录、外部对象或模块的键列表',
-        params: { data: '要获取键的数组、记录、外部对象或模块' },
-        paramsType: { data: 'array | record | extern | module' },
-        returnsType: 'number[] | string[]',
+        params: {
+            data: { type: 'array | record | extern | module', description: '要获取键的数组、记录、外部对象或模块' },
+        },
+        returns: { type: 'number[] | string[]' },
         examples: ['keys([10, 20]) // [0, 1]', 'keys((10, 20)) // ["0", "1"]'],
     },
 );
@@ -39,9 +40,8 @@ export const values = VmLib(
     },
     {
         summary: '返回数组或记录的值列表',
-        params: { data: '要获取值的数组或记录' },
-        paramsType: { data: 'array | record' },
-        returnsType: 'array',
+        params: { data: { type: 'array | record', description: '要获取值的数组或记录' } },
+        returns: { type: 'array' },
         examples: ['values((a: 1, b: 2)) // [1, 2]'],
     },
 );
@@ -61,9 +61,8 @@ export const entries = VmLib(
     },
     {
         summary: '返回数组或记录的键值对列表',
-        params: { data: '要获取键值对的数组或记录' },
-        paramsType: { data: 'array | record' },
-        returnsType: '(number, any)[] | (string, any)[]',
+        params: { data: { type: 'array | record', description: '要获取键值对的数组或记录' } },
+        returns: { type: '(number, any)[] | (string, any)[]' },
         examples: ['entries([1]) // [(0, 1)]', 'entries((a: 1)) // [("a", 1)]'],
     },
 );

package/src/vm/lib/global/sequence/find.ts

@@ -39,14 +39,13 @@ export const find = VmLib(
     {
         summary: '查找数组或记录中的键值对，返回第一个满足条件的键值对',
         params: {
-            data: '要查找的数组或记录',
-            predicate: '用于测试每个键值对的函数，或要查找的值',
+            data: { type: 'array | record', description: '要查找的数组或记录' },
+            predicate: {
+                type: '(fn(value: any, key: number | string, input: type(data)) -> boolean) | any',
+                description: '用于测试每个键值对的函数，或要查找的值',
+            },
         },
-        paramsType: {
-            data: 'array | record',
-            predicate: '(fn(value: any, key: number | string, input: type(data)) -> boolean) | any',
-        },
-        returnsType: '(number | string, any) | nil',
+        returns: { type: '(number | string, any) | nil' },
         examples: ['find([3, 5, 8], fn (v) { v % 2 == 0 }) // (2, 8)', `find((x: 1, y: 2, z: 3), 2) // ('y', 2)`],
     },
 );

package/src/vm/lib/global/sequence/flatten.ts

@@ -7,9 +7,11 @@ export const flatten = VmLib(
     },
     {
         summary: '将数组扁平化',
-        params: { data: '要扁平化的数组', depth: '扁平化的深度，默认为 1' },
-        paramsType: { data: 'array', depth: 'number' },
-        returnsType: 'array',
+        params: {
+            data: { type: 'array', description: '要扁平化的数组' },
+            depth: { type: 'number | nil', description: '扁平化的深度，默认为 1' },
+        },
+        returns: { type: 'array' },
         examples: ['flatten([[1, 2], [3, [4]]], 2) // [1, 2, 3, 4]'],
     },
 );

package/src/vm/lib/global/sequence/len.ts

@@ -15,9 +15,8 @@ export const len = VmLib(
     },
     {
         summary: '返回数组的长度',
-        params: { arr: '要求长度的数组' },
-        paramsType: { arr: 'array | extern' },
-        returnsType: 'number',
+        params: { arr: { type: 'array | extern', description: '要求长度的数组' } },
+        returns: { type: 'number' },
         examples: ['len([1, 2, 3]) // 3'],
     },
 );

package/src/vm/lib/global/sequence/map-filter.ts

@@ -28,14 +28,13 @@ export const map = VmLib(
     {
         summary: '对数组或记录中的每个元素应用函数，并返回结果',
         params: {
-            data: '要映射的数组或记录',
-            f: '应用于每个元素的函数',
+            data: { type: 'array | record', description: '要映射的数组或记录' },
+            f: {
+                type: 'fn(value: any, key: number | string, input: type(data)) -> any',
+                description: '应用于每个元素的函数',
+            },
         },
-        paramsType: {
-            data: 'array | record',
-            f: 'fn(value: any, key: number | string, input: type(data)) -> any',
-        },
-        returnsType: 'type(data)',
+        returns: { type: 'type(data)' },
         examples: ['map([1, 2, 3], fn { it * it }) // [1, 4, 9]'],
     },
 );
@@ -49,14 +48,13 @@ export const filter = VmLib(
     {
         summary: '过滤数组或记录中的元素，返回满足条件的元素',
         params: {
-            data: '要过滤的数组或记录',
-            predicate: '用于测试每个元素的函数',
-        },
-        paramsType: {
-            data: 'array | record',
-            predicate: 'fn(value: any, key: number | string, input: type(data)) -> boolean',
+            data: { type: 'array | record', description: '要过滤的数组或记录' },
+            predicate: {
+                type: 'fn(value: any, key: number | string, input: type(data)) -> boolean',
+                description: '用于测试每个元素的函数',
+            },
         },
-        returnsType: 'type(data)',
+        returns: { type: 'type(data)' },
         examples: ['filter([1, 2, 3, 4], fn { it % 2 == 0 }) // [2, 4]'],
     },
 );
@@ -70,14 +68,13 @@ export const filter_map = VmLib(
     {
         summary: '对数组或记录中的每个元素应用函数，并返回非 `nil` 的结果',
         params: {
-            data: '要映射的数组或记录',
-            f: '应用于每个元素的函数',
-        },
-        paramsType: {
-            data: 'array | record',
-            f: 'fn(value: any, key: number | string, input: type(data)) -> any | nil',
+            data: { type: 'array | record', description: '要映射的数组或记录' },
+            f: {
+                type: 'fn(value: any, key: number | string, input: type(data)) -> any | nil',
+                description: '应用于每个元素的函数',
+            },
         },
-        returnsType: 'type(data)',
+        returns: { type: 'type(data)' },
         examples: ['filter_map([1, 2, 3], fn {\n  if it % 2 == 0 { it * it } else { nil } \n}) // [4]'],
     },
 );

package/src/vm/lib/global/sequence/new.ts

@@ -21,9 +21,14 @@ export const new_record = VmLib(
     },
     {
         summary: '根据生成器函数创建一个记录',
-        params: { size: '记录的大小', generator: '生成器函数，返回键值对或 nil（表示跳过该条目）' },
-        paramsType: { size: 'number', generator: 'fn(index: number) -> (string, any) | nil' },
-        returnsType: 'record',
+        params: {
+            size: { type: 'number', description: '记录的大小' },
+            generator: {
+                type: 'fn(index: number) -> (string, any) | nil',
+                description: '生成器函数，返回键值对或 nil（表示跳过该条目）',
+            },
+        },
+        returns: { type: 'record' },
         examples: ['new_record(3, fn { (it, it * 2) }) // (0, 2, 4)'],
     },
 );
@@ -40,9 +45,11 @@ export const new_array = VmLib(
     },
     {
         summary: '根据生成器函数创建一个数组',
-        params: { length: '数组的长度', generator: '生成器函数，返回数组元素的值' },
-        paramsType: { length: 'number', generator: 'fn(index: number) -> any' },
-        returnsType: 'array',
+        params: {
+            length: { type: 'number', description: '数组的长度' },
+            generator: { type: 'fn(index: number) -> any', description: '生成器函数，返回数组元素的值' },
+        },
+        returns: { type: 'array' },
         examples: ['new_array(5, fn { it * it }) // [0, 1, 4, 9, 16]'],
     },
 );

package/src/vm/lib/global/sequence/repeat.ts

@@ -13,14 +13,10 @@ export const repeat = VmLib(
     {
         summary: '创建一个包含重复元素的数组',
         params: {
-            data: '要重复的元素',
-            times: '重复的次数，必须是非负整数',
+            data: { type: 'any', description: '要重复的元素' },
+            times: { type: 'number', description: '重复的次数，必须是非负整数' },
         },
-        paramsType: {
-            data: 'any',
-            times: 'number',
-        },
-        returnsType: 'type(data)[]',
+        returns: { type: 'type(data)[]' },
         examples: ['repeat(0, 5) // [0, 0, 0, 0, 0]', 'repeat("a", 3) // ["a", "a", "a"]'],
     },
 );

package/src/vm/lib/global/sequence/reverse.ts

@@ -9,9 +9,8 @@ export const reverse = VmLib(
     },
     {
         summary: '返回数组的反转副本',
-        params: { arr: '要反转的数组' },
-        paramsType: { arr: 'array' },
-        returnsType: 'array',
+        params: { arr: { type: 'array', description: '要反转的数组' } },
+        returns: { type: 'array' },
         examples: ['reverse([1, 2, 3]) // [3, 2, 1]'],
     },
 );

package/src/vm/lib/global/sequence/sort.ts

@@ -45,14 +45,13 @@ export const sort = VmLib(
     {
         summary: '对数组中的元素进行排序，并返回排序后的结果',
         params: {
-            data: '要排序的数组',
-            comparator: '用于比较两个元素的函数，返回一个数字，表示它们的相对顺序，默认按升序排列',
+            data: { type: 'array', description: '要排序的数组' },
+            comparator: {
+                type: 'fn(a: any, b: any) -> number',
+                description: '用于比较两个元素的函数，返回一个数字，表示它们的相对顺序，默认按升序排列',
+            },
         },
-        paramsType: {
-            data: 'array',
-            comparator: 'fn(a: any, b: any) -> number',
-        },
-        returnsType: 'array',
+        returns: { type: 'array' },
         examples: ['sort(["c", "a", "b"]) // ["a", "b", "c"]'],
     },
 );
@@ -77,16 +76,17 @@ export const sort_by = VmLib(
     {
         summary: '根据键函数对数组中的元素进行排序，并返回排序后的结果',
         params: {
-            data: '要排序的数组',
-            key: '用于提取排序键的函数，接受一个元素并返回其排序键',
-            comparator: '用于比较两个排序键的函数，返回一个数字，表示它们的相对顺序，默认按升序排列',
-        },
-        paramsType: {
-            data: 'array',
-            key: 'fn(value: any, index: number, arr: type(data)) -> any',
-            comparator: 'fn(a: any, b: any) -> number',
+            data: { type: 'array', description: '要排序的数组' },
+            key: {
+                type: 'fn(value: any, index: number, arr: type(data)) -> any',
+                description: '用于提取排序键的函数，接受一个元素并返回其排序键',
+            },
+            comparator: {
+                type: 'fn(a: any, b: any) -> number',
+                description: '用于比较两个排序键的函数，返回一个数字，表示它们的相对顺序，默认按升序排列',
+            },
         },
-        returnsType: 'array',
+        returns: { type: 'array' },
         examples: ['sort_by([(0, "x"), (2, "y"), (1, "z")], fn (item) { item[0] }) // [(0, "x"), (1, "z"), (2, "y")]'],
     },
 );

package/src/vm/lib/global/sequence/unique.ts

@@ -39,14 +39,13 @@ export const unique = VmLib(
     {
         summary: '对数组中的元素进行去重，并返回去重后的结果',
         params: {
-            data: '要去重的数组',
-            equal: '用于判等两个元素的函数，返回一个布尔值，默认使用严格相等比较',
+            data: { type: 'array', description: '要去重的数组' },
+            equal: {
+                type: 'fn(a: any, b: any) -> boolean',
+                description: '用于判等两个元素的函数，返回一个布尔值，默认使用严格相等比较',
+            },
         },
-        paramsType: {
-            data: 'array',
-            equal: 'fn(a: any, b: any) -> boolean',
-        },
-        returnsType: 'array',
+        returns: { type: 'array' },
         examples: ['unique([1, 2, 2, 3]) // [1, 2, 3]'],
     },
 );
@@ -80,16 +79,17 @@ export const unique_by = VmLib(
     {
         summary: '根据键函数对数组中的元素进行去重，并返回去重后的结果',
         params: {
-            data: '要去重的数组',
-            key: '用于提取去重键的函数，接受一个元素并返回其去重键',
-            equal: '用于判同两个元素的函数，返回一个布尔值，默认使用严格相等比较',
-        },
-        paramsType: {
-            data: 'array',
-            key: 'fn(value: any, index: number, arr: type(data)) -> any',
-            equal: 'fn(a: any, b: any) -> boolean',
+            data: { type: 'array', description: '要去重的数组' },
+            key: {
+                type: 'fn(value: any, index: number, arr: type(data)) -> any',
+                description: '用于提取去重键的函数，接受一个元素并返回其去重键',
+            },
+            equal: {
+                type: 'fn(a: any, b: any) -> boolean',
+                description: '用于判同两个元素的函数，返回一个布尔值，默认使用严格相等比较',
+            },
         },
-        returnsType: 'array',
+        returns: { type: 'array' },
         examples: ['unique_by(["apple", "banana", "apricot"], fn { chars(it)[0] }) // ["apple", "banana"]'],
     },
 );

package/src/vm/lib/global/sequence/with.ts

@@ -122,14 +122,13 @@ const _with = VmLib(
     {
         summary: '在数组或记录中设置多个键值对',
         params: {
-            data: '要设置的数组或记录',
-            '..entries': '要设置的键值对，成对出现；键可以是一个值或一个数组（表示嵌套路径）',
+            data: { type: 'array | record', description: '要设置的数组或记录' },
+            '..entries': {
+                type: '[..[number | string | (number | string)[], any][]]',
+                description: '要设置的键值对，成对出现；键可以是一个值或一个数组（表示嵌套路径）',
+            },
         },
-        paramsType: {
-            data: 'array | record',
-            '..entries': `[..[number | string | (number | string)[], any][]]`,
-        },
-        returnsType: 'type(data)',
+        returns: { type: 'type(data)' },
         examples: [
             `with([10, 20], 2, 99, 3 ,100) // [10, 20, 99, 100]`,
             `(a: 1)::with(["b", 1], 2) // (a: 1, b: [nil, 2])`,

package/src/vm/lib/global/sequence/zip.ts

@@ -29,9 +29,8 @@ export const zip = VmLib(
     },
     {
         summary: '将数组的数组/记录转换为数组/记录的数组',
-        params: { data: '要转换的数组/记录' },
-        paramsType: { data: 'array | record' },
-        returnsType: '(array | record)[]',
+        params: { data: { type: 'array | record', description: '要转换的数组/记录' } },
+        returns: { type: '(array | record)[]' },
         examples: [
             'zip((x: [1, 2], y: ["a", "b"])) // [(x: 1, y: "a"), (x: 2, y: "b")]',
             `zip([[1, 2], ["a", "b"]]) // [[1, "a"], [2, "b"]]`,

package/src/vm/lib/global/string/case.ts

@@ -6,9 +6,8 @@ export const to_uppercase = VmLib(
     },
     {
         summary: '将字符串转换为大写',
-        params: { str: '要转换的字符串' },
-        paramsType: { str: 'string' },
-        returnsType: 'string',
+        params: { str: { type: 'string', description: '要转换的字符串' } },
+        returns: { type: 'string' },
         examples: ['to_uppercase("mira") // "MIRA"'],
     },
 );
@@ -19,9 +18,8 @@ export const to_lowercase = VmLib(
     },
     {
         summary: '将字符串转换为小写',
-        params: { str: '要转换的字符串' },
-        paramsType: { str: 'string' },
-        returnsType: 'string',
+        params: { str: { type: 'string', description: '要转换的字符串' } },
+        returns: { type: 'string' },
         examples: ['to_lowercase("MIRA") // "mira"'],
     },
 );