@mirascript/mirascript 0.1.64 → 0.1.65

package/dist/{chunk-ITTCGBBX.js → chunk-MRA5WJ72.js}

@@ -46,10 +46,11 @@ import {
   kVmScript,
   kVmWrapper,
   keys,
+  keysLength,
   parseDiagnostics,
   toString,
   values
-} from "./chunk-QN3IOQRQ.js";
+} from "./chunk-X4FUFXO6.js";
 
 // src/compiler/load-module.ts
 import { loadModule } from "@mirascript/bindings";
@@ -494,9 +495,7 @@ function VmFunction(fn, option = {}) {
     isLib: opt.isLib ?? false,
     summary: opt.summary || void 0,
     params: opt.params,
-    paramsType: opt.paramsType,
-    returns: opt.returns || void 0,
-    returnsType: opt.returnsType || void 0,
+    returns: opt.returns ?? void 0,
     examples: opt.examples?.length ? opt.examples : void 0,
     deprecated: opt.deprecated ?? void 0
   };
@@ -563,21 +562,19 @@ var ValueVmContext = class {
   }
   /** @inheritdoc */
   get(key) {
-    if (hasOwn(this.env, key)) return this.env[key] ?? null;
-    {
-      const val = VM_SHARED_CONTEXT[key];
-      if (val !== void 0) return val;
-      return globalVarNotFound(key);
+    if (hasOwn(this.env, key)) {
+      return this.env[key] ?? null;
     }
+    return DefaultVmContext.get(key);
   }
   /** @inheritdoc */
   has(key) {
-    return hasOwn(this.env, key) || key in VM_SHARED_CONTEXT;
+    return hasOwn(this.env, key) || DefaultVmContext.has(key);
   }
   /** @inheritdoc */
   describe(key) {
     if (hasOwn(this.env, key)) return this.describer?.(key);
-    return VM_SHARED_CONTEXT_DESCRIPTIONS[key];
+    return DefaultVmContext.describe(key);
   }
 };
 defineProperty(ValueVmContext.prototype, kVmContext, { value: true });
@@ -595,32 +592,34 @@ var Value2VmContext = class {
   }
   /** @inheritdoc */
   get(key) {
-    if (this.env != null && hasOwn(this.env, key)) return this.env[key] ?? null;
+    if (this.env != null && hasOwn(this.env, key)) {
+      return this.env[key] ?? null;
+    }
     if (hasOwn(this.extern, key)) {
-      const val2 = this.extern[key];
-      if (val2 == null) return null;
-      if (typeof val2 != "object" && typeof val2 != "function") {
-        return wrapToVmValue(val2, null, null);
+      const val = this.extern[key];
+      if (val == null) return null;
+      if (typeof val != "object" && typeof val != "function") {
+        return wrapToVmValue(val, null, null);
       }
-      let cached = this.externCache.get(val2);
+      let cached = this.externCache.get(val);
       if (cached == null) {
-        cached = wrapToVmValue(val2, null, null);
-        this.externCache.set(val2, cached);
+        cached = wrapToVmValue(val, null, null);
+        this.externCache.set(val, cached);
       }
       return cached;
     }
-    const val = VM_SHARED_CONTEXT[key];
-    if (val !== void 0) return val;
-    return globalVarNotFound(key);
+    return DefaultVmContext.get(key);
   }
   /** @inheritdoc */
   has(key) {
-    return this.env != null && hasOwn(this.env, key) || hasOwn(this.extern, key) || key in VM_SHARED_CONTEXT;
+    return this.env != null && hasOwn(this.env, key) || hasOwn(this.extern, key) || DefaultVmContext.has(key);
   }
   /** @inheritdoc */
   describe(key) {
-    if (this.env != null && hasOwn(this.env, key) || hasOwn(this.extern, key)) return this.describer?.(key);
-    return VM_SHARED_CONTEXT_DESCRIPTIONS[key];
+    if (this.env != null && hasOwn(this.env, key) || hasOwn(this.extern, key)) {
+      return this.describer?.(key);
+    }
+    return DefaultVmContext.describe(key);
   }
 };
 defineProperty(Value2VmContext.prototype, kVmContext, { value: true });
@@ -640,18 +639,16 @@ var FactoryVmContext = class {
   get(key) {
     const value = this.getter(key);
     if (value !== void 0) return value;
-    const val = VM_SHARED_CONTEXT[key];
-    if (val !== void 0) return val;
-    return globalVarNotFound(key);
+    return DefaultVmContext.get(key);
   }
   /** @inheritdoc */
   has(key) {
-    return this.getter(key) !== void 0 || key in VM_SHARED_CONTEXT;
+    return this.getter(key) !== void 0 || DefaultVmContext.has(key);
   }
   /** @inheritdoc */
   describe(key) {
     if (this.getter(key) !== void 0) return this.describer?.(key);
-    return VM_SHARED_CONTEXT_DESCRIPTIONS[key];
+    return DefaultVmContext.describe(key);
   }
 };
 defineProperty(FactoryVmContext.prototype, kVmContext, { value: true });
@@ -1135,7 +1132,7 @@ var $In = (value, iterable) => {
 var $Length = (value) => {
   $AssertInit(value);
   if (isVmArray(value)) return value.length;
-  if (isVmRecord(value)) return keys(value).length;
+  if (isVmRecord(value)) return keysLength(value);
   if (isVmWrapper(value)) return value.keys().length;
   throw new VmError(`Value has no length: ${display(value)}`, 0);
 };
@@ -1608,9 +1605,7 @@ function VmLib(value, option, properties) {
   Object.defineProperties(ret, {
     summary: { enumerable: true, value: option.summary },
     params: { enumerable: true, value: option.params },
-    paramsType: { enumerable: true, value: option.paramsType },
     returns: { enumerable: true, value: option.returns },
-    returnsType: { enumerable: true, value: option.returnsType },
     examples: { enumerable: true, value: option.examples },
     deprecated: { enumerable: true, value: option.deprecated ?? void 0 }
   });
@@ -1627,23 +1622,20 @@ function build(f) {
 }
 var max = VmLib(build(Math.max), {
   summary: "返回一组数中的最大值",
-  params: { "..values": "要比较的数值" },
-  paramsType: { "..values": "number[]" },
-  returnsType: "number",
+  params: { "..values": { type: "number", description: "要比较的数值" } },
+  returns: { type: "number" },
   examples: ["max(3, 7, 2) // 7"]
 });
 var min2 = VmLib(build(Math.min), {
   summary: "返回一组数中的最小值",
-  params: { "..values": "要比较的数值" },
-  paramsType: { "..values": "number[]" },
-  returnsType: "number",
+  params: { "..values": { type: "number", description: "要比较的数值" } },
+  returns: { type: "number" },
   examples: ["min(3, 7, 2) // 2"]
 });
 var hypot = VmLib(build(Math.hypot), {
   summary: "返回所有参数平方和的平方根",
-  params: { "..values": "要计算的数值" },
-  paramsType: { "..values": "number[]" },
-  returnsType: "number",
+  params: { "..values": { type: "number", description: "要计算的数值" } },
+  returns: { type: "number" },
   examples: ["hypot(3, 4) // 5"]
 });
 var sum = VmLib(
@@ -1653,9 +1645,8 @@ var sum = VmLib(
   },
   {
     summary: "返回一组数的总和",
-    params: { "..values": "要计算的数值" },
-    paramsType: { "..values": "number[]" },
-    returnsType: "number",
+    params: { "..values": { type: "number", description: "要计算的数值" } },
+    returns: { type: "number" },
     examples: ["sum(1, 2, 3, 4) // 10"]
   }
 );
@@ -1666,9 +1657,8 @@ var product = VmLib(
   },
   {
     summary: "返回一组数的乘积",
-    params: { "..values": "要计算的数值" },
-    paramsType: { "..values": "number[]" },
-    returnsType: "number",
+    params: { "..values": { type: "number", description: "要计算的数值" } },
+    returns: { type: "number" },
     examples: ["product(2, 3, 4) // 24"]
   }
 );
@@ -1676,16 +1666,13 @@ var product = VmLib(
 // src/vm/lib/global/math/const.ts
 import { DiagnosticCode as DiagnosticCode2 } from "@mirascript/constants";
 var PI = VmLib(Math.PI, {
-  summary: "圆周率",
-  returnsType: "number"
+  summary: "圆周率"
 });
 var E = VmLib(Math.E, {
-  summary: "自然对数的底数",
-  returnsType: "number"
+  summary: "自然对数的底数"
 });
 var pi = VmLib(Math.PI, {
   summary: "圆周率",
-  returnsType: "number",
   deprecated: {
     use: "PI",
     message: DiagnosticCode2.PreferUppercaseConstant
@@ -1693,35 +1680,28 @@ var pi = VmLib(Math.PI, {
 });
 var e = VmLib(Math.E, {
   summary: "自然对数的底数",
-  returnsType: "number",
   deprecated: {
     use: "E",
     message: DiagnosticCode2.PreferUppercaseConstant
   }
 });
 var SQRT1_2 = VmLib(Math.SQRT1_2, {
-  summary: "½ 的平方根",
-  returnsType: "number"
+  summary: "½ 的平方根"
 });
 var SQRT2 = VmLib(Math.SQRT2, {
-  summary: "2 的平方根",
-  returnsType: "number"
+  summary: "2 的平方根"
 });
 var LN2 = VmLib(Math.LN2, {
-  summary: "2 的自然对数",
-  returnsType: "number"
+  summary: "2 的自然对数"
 });
 var LN10 = VmLib(Math.LN10, {
-  summary: "10 的自然对数",
-  returnsType: "number"
+  summary: "10 的自然对数"
 });
 var LOG2E = VmLib(Math.LOG2E, {
-  summary: "e 以 2 为底的对数",
-  returnsType: "number"
+  summary: "e 以 2 为底的对数"
 });
 var LOG10E = VmLib(Math.LOG10E, {
-  summary: "e 以 10 为底的对数",
-  returnsType: "number"
+  summary: "e 以 10 为底的对数"
 });
 
 // src/vm/lib/global/math/unary.ts
@@ -1732,135 +1712,113 @@ function build2(f) {
 }
 var sign = VmLib(build2(Math.sign), {
   summary: "返回数值的符号（正数为 1，负数为 -1，零为 0）",
-  params: { x: "要判断符号的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要判断符号的数" } },
+  returns: { type: "number" }
 });
 var abs2 = VmLib(build2(Math.abs), {
   summary: "返回数值的绝对值",
-  params: { x: "要取绝对值的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要取绝对值的数" } },
+  returns: { type: "number" }
 });
 var acos = VmLib(build2(Math.acos), {
   summary: "返回数值的反余弦值（弧度）",
-  params: { x: "要计算反余弦的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算反余弦的数" } },
+  returns: { type: "number" }
 });
 var acosh = VmLib(build2(Math.acosh), {
   summary: "返回数值的反双曲余弦值",
-  params: { x: "要计算反双曲余弦的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算反双曲余弦的数" } },
+  returns: { type: "number" }
 });
 var asin = VmLib(build2(Math.asin), {
   summary: "返回数值的反正弦值（弧度）",
-  params: { x: "要计算反正弦的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算反正弦的数" } },
+  returns: { type: "number" }
 });
 var asinh = VmLib(build2(Math.asinh), {
   summary: "返回数值的反双曲正弦值",
-  params: { x: "要计算反双曲正弦的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算反双曲正弦的数" } },
+  returns: { type: "number" }
 });
 var atan = VmLib(build2(Math.atan), {
   summary: "返回数值的反正切值（弧度）",
-  params: { x: "要计算反正切的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算反正切的数" } },
+  returns: { type: "number" }
 });
 var atanh = VmLib(build2(Math.atanh), {
   summary: "返回数值的反双曲正切值",
-  params: { x: "要计算反双曲正切的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算反双曲正切的数" } },
+  returns: { type: "number" }
 });
 var cos = VmLib(build2(Math.cos), {
   summary: "返回数值的余弦值",
-  params: { x: "要计算余弦的数（弧度）" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算余弦的数（弧度）" } },
+  returns: { type: "number" }
 });
 var cosh = VmLib(build2(Math.cosh), {
   summary: "返回数值的双曲余弦值",
-  params: { x: "要计算双曲余弦的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算双曲余弦的数" } },
+  returns: { type: "number" }
 });
 var sin = VmLib(build2(Math.sin), {
   summary: "返回数值的正弦值",
-  params: { x: "要计算正弦的数（弧度）" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算正弦的数（弧度）" } },
+  returns: { type: "number" }
 });
 var sinh = VmLib(build2(Math.sinh), {
   summary: "返回数值的双曲正弦值",
-  params: { x: "要计算双曲正弦的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算双曲正弦的数" } },
+  returns: { type: "number" }
 });
 var tan = VmLib(build2(Math.tan), {
   summary: "返回数值的正切值",
-  params: { x: "要计算正切的数（弧度）" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算正切的数（弧度）" } },
+  returns: { type: "number" }
 });
 var tanh = VmLib(build2(Math.tanh), {
   summary: "返回数值的双曲正切值",
-  params: { x: "要计算双曲正切的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算双曲正切的数" } },
+  returns: { type: "number" }
 });
 var exp = VmLib(build2(Math.exp), {
   summary: "返回 e 的指定次幂",
-  params: { x: "指数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "指数" } },
+  returns: { type: "number" }
 });
 var expm1 = VmLib(build2(Math.expm1), {
   summary: "返回 e 的 x 次幂减 1",
-  params: { x: "指数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "指数" } },
+  returns: { type: "number" }
 });
 var log = VmLib(build2(Math.log), {
   summary: "返回数值的自然对数（以 e 为底）",
-  params: { x: "要取对数的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要取对数的数" } },
+  returns: { type: "number" }
 });
 var log10 = VmLib(build2(Math.log10), {
   summary: "返回数值的以 10 为底的对数",
-  params: { x: "要取对数的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要取对数的数" } },
+  returns: { type: "number" }
 });
 var log1p = VmLib(build2(Math.log1p), {
   summary: "返回 1 加上数值的自然对数",
-  params: { x: "要取对数的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要取对数的数" } },
+  returns: { type: "number" }
 });
 var log2 = VmLib(build2(Math.log2), {
   summary: "返回数值的以 2 为底的对数",
-  params: { x: "要取对数的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要取对数的数" } },
+  returns: { type: "number" }
 });
 var sqrt = VmLib(build2(Math.sqrt), {
   summary: "返回数值的平方根",
-  params: { x: "要开平方的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要开平方的数" } },
+  returns: { type: "number" }
 });
 var cbrt = VmLib(build2(Math.cbrt), {
   summary: "返回数值的立方根",
-  params: { x: "要计算立方根的数" },
-  paramsType: { x: "number" },
-  returnsType: "number"
+  params: { x: { type: "number", description: "要计算立方根的数" } },
+  returns: { type: "number" }
 });
 
 // src/vm/lib/global/math/round.ts
@@ -1875,21 +1833,27 @@ function build3(f) {
 }
 var trunc2 = VmLib(build3(Math.trunc), {
   summary: "向零方向舍入数值",
-  params: { x: "要舍入的数", n: "小数位数，默认为 0" },
-  paramsType: { x: "number", n: "number | nil" },
-  returnsType: "number"
+  params: {
+    x: { type: "number", description: "要舍入的数" },
+    n: { type: "number | nil", description: "小数位数，默认为 0" }
+  },
+  returns: { type: "number" }
 });
 var floor = VmLib(build3(Math.floor), {
   summary: "向下舍入数值",
-  params: { x: "要舍入的数", n: "小数位数，默认为 0" },
-  paramsType: { x: "number", n: "number | nil" },
-  returnsType: "number"
+  params: {
+    x: { type: "number", description: "要舍入的数" },
+    n: { type: "number | nil", description: "小数位数，默认为 0" }
+  },
+  returns: { type: "number" }
 });
 var ceil2 = VmLib(build3(Math.ceil), {
   summary: "向上舍入数值",
-  params: { x: "要舍入的数", n: "小数位数，默认为 0" },
-  paramsType: { x: "number", n: "number | nil" },
-  returnsType: "number"
+  params: {
+    x: { type: "number", description: "要舍入的数" },
+    n: { type: "number | nil", description: "小数位数，默认为 0" }
+  },
+  returns: { type: "number" }
 });
 var _round = Math.round;
 var _abs = Math.abs;
@@ -1903,9 +1867,11 @@ var round = VmLib(
   }),
   {
     summary: "四舍五入数值",
-    params: { x: "要舍入的数", n: "小数位数，默认为 0" },
-    paramsType: { x: "number", n: "number" },
-    returnsType: "number"
+    params: {
+      x: { type: "number", description: "要舍入的数" },
+      n: { type: "number | nil", description: "小数位数，默认为 0" }
+    },
+    returns: { type: "number" }
   }
 );
 
@@ -2043,9 +2009,8 @@ var gamma = VmLib(
   },
   {
     summary: "返回 Gamma 函数的值",
-    params: { x: "要计算 Gamma 函数的数值" },
-    paramsType: { x: "number" },
-    returnsType: "number",
+    params: { x: { type: "number", description: "要计算 Gamma 函数的数值" } },
+    returns: { type: "number" },
     examples: ["gamma(5) // 24"]
   }
 );
@@ -2069,9 +2034,8 @@ var factorial = VmLib(
   },
   {
     summary: "返回一个数的阶乘",
-    params: { x: "要计算阶乘的数值" },
-    paramsType: { x: "number" },
-    returnsType: "number",
+    params: { x: { type: "number", description: "要计算阶乘的数值" } },
+    returns: { type: "number" },
     examples: ["factorial(5) // 120"]
   }
 );
@@ -2080,21 +2044,24 @@ var factorial = VmLib(
 var { atan2: _atan2, pow: _pow, random: _random } = Math;
 var atan2 = VmLib((x, y) => _atan2(expectNumber(0, x), expectNumber(1, y)), {
   summary: "返回从原点到点 (x, y) 的角度（弧度）",
-  params: { x: "x 坐标", y: "y 坐标" },
-  paramsType: { x: "number", y: "number" },
-  returnsType: "number"
+  params: {
+    x: { type: "number", description: "x 坐标" },
+    y: { type: "number", description: "y 坐标" }
+  },
+  returns: { type: "number" }
 });
 var pow3 = VmLib((x, y) => _pow(expectNumber(0, x), expectNumber(1, y)), {
   summary: "返回 x 的 y 次幂",
-  params: { x: "底数", y: "指数" },
-  paramsType: { x: "number", y: "number" },
-  returnsType: "number"
+  params: {
+    x: { type: "number", description: "底数" },
+    y: { type: "number", description: "指数" }
+  },
+  returns: { type: "number" }
 });
 var random = VmLib(() => _random(), {
   summary: "返回 [0, 1) 之间的伪随机数",
   params: {},
-  paramsType: {},
-  returnsType: "number"
+  returns: { type: "number" }
 });
 
 // src/vm/lib/global/bit.ts
@@ -2104,9 +2071,11 @@ var b_and = VmLib(
   },
   {
     summary: "返回两个数的按位与",
-    params: { x: "第一个操作数", y: "第二个操作数" },
-    paramsType: { x: "number", y: "number" },
-    returnsType: "number",
+    params: {
+      x: { type: "number", description: "第一个操作数" },
+      y: { type: "number", description: "第二个操作数" }
+    },
+    returns: { type: "number" },
     examples: ["b_and(6, 3) // 2"]
   }
 );
@@ -2116,9 +2085,11 @@ var b_or = VmLib(
   },
   {
     summary: "返回两个数的按位或",
-    params: { x: "第一个操作数", y: "第二个操作数" },
-    paramsType: { x: "number", y: "number" },
-    returnsType: "number",
+    params: {
+      x: { type: "number", description: "第一个操作数" },
+      y: { type: "number", description: "第二个操作数" }
+    },
+    returns: { type: "number" },
     examples: ["b_or(5, 2) // 7"]
   }
 );
@@ -2128,9 +2099,8 @@ var b_not = VmLib(
   },
   {
     summary: "返回一个数的按位取反",
-    params: { x: "操作数" },
-    paramsType: { x: "number" },
-    returnsType: "number",
+    params: { x: { type: "number", description: "操作数" } },
+    returns: { type: "number" },
     examples: ["b_not(0) // -1"]
   }
 );
@@ -2140,9 +2110,11 @@ var b_xor = VmLib(
   },
   {
     summary: "返回两个数的按位异或",
-    params: { x: "第一个操作数", y: "第二个操作数" },
-    paramsType: { x: "number", y: "number" },
-    returnsType: "number",
+    params: {
+      x: { type: "number", description: "第一个操作数" },
+      y: { type: "number", description: "第二个操作数" }
+    },
+    returns: { type: "number" },
     examples: ["b_xor(5, 3) // 6"]
   }
 );
@@ -2152,9 +2124,8 @@ var shl = VmLib(
   },
   {
     summary: "返回第一个操作数左移指定的位数",
-    params: { x: "第一个操作数", y: "位数" },
-    paramsType: { x: "number", y: "number" },
-    returnsType: "number",
+    params: { x: { type: "number", description: "第一个操作数" }, y: { type: "number", description: "位数" } },
+    returns: { type: "number" },
     examples: ["shl(3, 2) // 12"]
   }
 );
@@ -2164,9 +2135,8 @@ var sar = VmLib(
   },
   {
     summary: "返回第一个操作数右移指定的位数",
-    params: { x: "第一个操作数", y: "位数" },
-    paramsType: { x: "number", y: "number" },
-    returnsType: "number",
+    params: { x: { type: "number", description: "第一个操作数" }, y: { type: "number", description: "位数" } },
+    returns: { type: "number" },
     examples: ["sar(-8, 1) // -4"]
   }
 );
@@ -2176,9 +2146,8 @@ var shr = VmLib(
   },
   {
     summary: "返回第一个操作数无符号右移指定的位数",
-    params: { x: "第一个操作数", y: "位数" },
-    paramsType: { x: "number", y: "number" },
-    returnsType: "number",
+    params: { x: { type: "number", description: "第一个操作数" }, y: { type: "number", description: "位数" } },
+    returns: { type: "number" },
     examples: ["shr(8, 1) // 4"]
   }
 );
@@ -2295,14 +2264,13 @@ var _with = VmLib(
   {
     summary: "在数组或记录中设置多个键值对",
     params: {
-      data: "要设置的数组或记录",
-      "..entries": "要设置的键值对，成对出现；键可以是一个值或一个数组（表示嵌套路径）"
-    },
-    paramsType: {
-      data: "array | record",
-      "..entries": `[..[number | string | (number | string)[], any][]]`
+      data: { type: "array | record", description: "要设置的数组或记录" },
+      "..entries": {
+        type: "[..[number | string | (number | string)[], any][]]",
+        description: "要设置的键值对，成对出现；键可以是一个值或一个数组（表示嵌套路径）"
+      }
     },
-    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])`
@@ -2329,9 +2297,10 @@ var keys3 = 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"]']
   }
 );
@@ -2345,9 +2314,8 @@ var values3 = 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]"]
   }
 );
@@ -2366,9 +2334,8 @@ var entries2 = 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)]']
   }
 );
@@ -2387,9 +2354,8 @@ var 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"]
   }
 );
@@ -2409,14 +2375,13 @@ var map2 = VmLib(
   {
     summary: "对数组或记录中的每个元素应用函数，并返回结果",
     params: {
-      data: "要映射的数组或记录",
-      f: "应用于每个元素的函数"
-    },
-    paramsType: {
-      data: "array | record",
-      f: "fn(value: any, key: number | string, input: type(data)) -> any"
+      data: { type: "array | record", description: "要映射的数组或记录" },
+      f: {
+        type: "fn(value: any, key: number | string, input: type(data)) -> any",
+        description: "应用于每个元素的函数"
+      }
     },
-    returnsType: "type(data)",
+    returns: { type: "type(data)" },
     examples: ["map([1, 2, 3], fn { it * it }) // [1, 4, 9]"]
   }
 );
@@ -2428,14 +2393,13 @@ var 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]"]
   }
 );
@@ -2447,14 +2411,13 @@ var 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]"]
   }
 );
@@ -2492,14 +2455,13 @@ var find = VmLib(
   {
     summary: "查找数组或记录中的键值对，返回第一个满足条件的键值对",
     params: {
-      data: "要查找的数组或记录",
-      predicate: "用于测试每个键值对的函数，或要查找的值"
-    },
-    paramsType: {
-      data: "array | record",
-      predicate: "(fn(value: any, key: number | string, input: type(data)) -> boolean) | any"
+      data: { type: "array | record", description: "要查找的数组或记录" },
+      predicate: {
+        type: "(fn(value: any, key: number | string, input: type(data)) -> boolean) | any",
+        description: "用于测试每个键值对的函数，或要查找的值"
+      }
     },
-    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)`]
   }
 );
@@ -2512,9 +2474,11 @@ var 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]"]
   }
 );
@@ -2529,9 +2493,8 @@ var 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]"]
   }
 );
@@ -2562,9 +2525,8 @@ var 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"]]`
@@ -2597,12 +2559,14 @@ var 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"]
   }
 );
@@ -2630,12 +2594,14 @@ var 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"]
   }
 );
@@ -2678,14 +2644,13 @@ var sort = VmLib(
   {
     summary: "对数组中的元素进行排序，并返回排序后的结果",
     params: {
-      data: "要排序的数组",
-      comparator: "用于比较两个元素的函数，返回一个数字，表示它们的相对顺序，默认按升序排列"
-    },
-    paramsType: {
-      data: "array",
-      comparator: "fn(a: any, b: any) -> number"
+      data: { type: "array", description: "要排序的数组" },
+      comparator: {
+        type: "fn(a: any, b: any) -> number",
+        description: "用于比较两个元素的函数，返回一个数字，表示它们的相对顺序，默认按升序排列"
+      }
     },
-    returnsType: "array",
+    returns: { type: "array" },
     examples: ['sort(["c", "a", "b"]) // ["a", "b", "c"]']
   }
 );
@@ -2709,16 +2674,17 @@ var 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")]']
   }
 );
@@ -2755,14 +2721,13 @@ var unique = VmLib(
   {
     summary: "对数组中的元素进行去重，并返回去重后的结果",
     params: {
-      data: "要去重的数组",
-      equal: "用于判等两个元素的函数，返回一个布尔值，默认使用严格相等比较"
-    },
-    paramsType: {
-      data: "array",
-      equal: "fn(a: any, b: any) -> boolean"
+      data: { type: "array", description: "要去重的数组" },
+      equal: {
+        type: "fn(a: any, b: any) -> boolean",
+        description: "用于判等两个元素的函数，返回一个布尔值，默认使用严格相等比较"
+      }
     },
-    returnsType: "array",
+    returns: { type: "array" },
     examples: ["unique([1, 2, 2, 3]) // [1, 2, 3]"]
   }
 );
@@ -2795,16 +2760,17 @@ var 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"]']
   }
 );
@@ -2822,14 +2788,10 @@ var repeat = VmLib(
   {
     summary: "创建一个包含重复元素的数组",
     params: {
-      data: "要重复的元素",
-      times: "重复的次数，必须是非负整数"
-    },
-    paramsType: {
-      data: "any",
-      times: "number"
+      data: { type: "any", description: "要重复的元素" },
+      times: { type: "number", description: "重复的次数，必须是非负整数" }
     },
-    returnsType: "type(data)[]",
+    returns: { type: "type(data)[]" },
     examples: ["repeat(0, 5) // [0, 0, 0, 0, 0]", 'repeat("a", 3) // ["a", "a", "a"]']
   }
 );
@@ -2851,9 +2813,14 @@ var 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)"]
   }
 );
@@ -2869,9 +2836,11 @@ var 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]"]
   }
 );
@@ -3013,9 +2982,10 @@ var debug_print = VmLib(
   },
   {
     summary: "打印调试信息到控制台",
-    params: { "..args": "要打印的调试信息，可以是任意类型" },
-    paramsType: { "..args": "any[]" },
-    returnsType: "nil",
+    params: {
+      "..args": { type: "any[]", description: "要打印的值，可以是任意类型" }
+    },
+    returns: { type: "nil" },
     examples: ['debug_print("value:", 42);']
   },
   // eslint-disable-next-line no-console
@@ -3030,9 +3000,8 @@ var panic = VmLib(
   },
   {
     summary: "产生错误，并打印错误信息到控制台",
-    params: { message: "要打印的错误信息" },
-    paramsType: { message: "string" },
-    returnsType: "never",
+    params: { message: { type: "string", description: "要打印的错误信息" } },
+    returns: { type: "never" },
     examples: ['panic("boom");']
   },
   // eslint-disable-next-line no-console
@@ -3070,9 +3039,8 @@ var to_json = VmLib(
   },
   {
     summary: "将数据转换为 JSON 字符串",
-    params: { data: "要转换为 JSON 的数据" },
-    paramsType: { data: "any" },
-    returnsType: "string",
+    params: { data: { type: "any", description: "要转换为 JSON 的数据" } },
+    returns: { type: "string" },
     examples: ['to_json([1, 2, 3]) // "[1,2,3]"']
   }
 );
@@ -3088,9 +3056,11 @@ var from_json = VmLib(
   },
   {
     summary: "将 JSON 字符串转换为数据",
-    params: { json: "要转换的 JSON 字符串", fallback: "如果转换失败，返回的默认值" },
-    paramsType: { json: "string", fallback: "any" },
-    returnsType: "any",
+    params: {
+      json: { type: "string", description: "要转换的 JSON 字符串" },
+      fallback: { type: "any", description: "如果转换失败，返回的默认值" }
+    },
+    returns: { type: "any" },
     examples: [`from_json('{"a":1}') // (a: 1)`]
   }
 );
@@ -3104,11 +3074,10 @@ var to_string = VmLib(
   {
     summary: "将数据转换为字符串",
     params: {
-      data: "要转换的数据",
-      fallback: "转换失败时的返回值"
+      data: { type: "any", description: "要转换的数据" },
+      fallback: { type: "any", description: "转换失败时的返回值" }
     },
-    paramsType: { data: "any", fallback: "any" },
-    returnsType: "string | type(fallback)",
+    returns: { type: "string | type(fallback)" },
     examples: ['to_string([1, 2]) // "1, 2"']
   }
 );
@@ -3120,11 +3089,10 @@ var to_number = VmLib(
   {
     summary: "将数据转换为数字",
     params: {
-      data: "要转换的数据",
-      fallback: "转换失败时的返回值"
+      data: { type: "string | number | boolean", description: "要转换的数据" },
+      fallback: { type: "any", description: "转换失败时的返回值" }
     },
-    paramsType: { data: "string | number | boolean", fallback: "any" },
-    returnsType: "number | type(fallback)",
+    returns: { type: "number | type(fallback)" },
     examples: ['to_number("1.5") // 1.5']
   }
 );
@@ -3135,9 +3103,11 @@ var format = VmLib(
   },
   {
     summary: "将数据格式化为指定格式的字符串",
-    params: { data: "要格式化的数据", format: "格式字符串" },
-    paramsType: { data: "any", format: "string" },
-    returnsType: "string",
+    params: {
+      data: { type: "any", description: "要格式化的数据" },
+      format: { type: "string", description: "格式字符串" }
+    },
+    returns: { type: "string" },
     examples: ['format(12, ".3") // "12.000"']
   }
 );
@@ -3149,9 +3119,8 @@ var trim_start = VmLib(
   },
   {
     summary: "去除字符串开头的空白字符",
-    params: { str: "要处理的字符串" },
-    paramsType: { str: "string" },
-    returnsType: "string",
+    params: { str: { type: "string", description: "要处理的字符串" } },
+    returns: { type: "string" },
     examples: ['trim_start("  mira") // "mira"']
   }
 );
@@ -3161,9 +3130,8 @@ var trim_end = VmLib(
   },
   {
     summary: "去除字符串结尾的空白字符",
-    params: { str: "要处理的字符串" },
-    paramsType: { str: "string" },
-    returnsType: "string",
+    params: { str: { type: "string", description: "要处理的字符串" } },
+    returns: { type: "string" },
     examples: ['trim_end("mira  ") // "mira"']
   }
 );
@@ -3173,9 +3141,8 @@ var trim = VmLib(
   },
   {
     summary: "去除字符串两端的空白字符",
-    params: { str: "要处理的字符串" },
-    paramsType: { str: "string" },
-    returnsType: "string",
+    params: { str: { type: "string", description: "要处理的字符串" } },
+    returns: { type: "string" },
     examples: ['trim("  mira  ") // "mira"']
   }
 );
@@ -3187,9 +3154,8 @@ var to_uppercase = VmLib(
   },
   {
     summary: "将字符串转换为大写",
-    params: { str: "要转换的字符串" },
-    paramsType: { str: "string" },
-    returnsType: "string",
+    params: { str: { type: "string", description: "要转换的字符串" } },
+    returns: { type: "string" },
     examples: ['to_uppercase("mira") // "MIRA"']
   }
 );
@@ -3199,9 +3165,8 @@ var to_lowercase = VmLib(
   },
   {
     summary: "将字符串转换为小写",
-    params: { str: "要转换的字符串" },
-    paramsType: { str: "string" },
-    returnsType: "string",
+    params: { str: { type: "string", description: "要转换的字符串" } },
+    returns: { type: "string" },
     examples: ['to_lowercase("MIRA") // "mira"']
   }
 );
@@ -3213,9 +3178,11 @@ var starts_with = VmLib(
   },
   {
     summary: "检查字符串是否以指定子串开头",
-    params: { str: "要检查的字符串", search: "要匹配的子串" },
-    paramsType: { str: "string", search: "string" },
-    returnsType: "boolean",
+    params: {
+      str: { type: "string", description: "要检查的字符串" },
+      search: { type: "string", description: "要匹配的子串" }
+    },
+    returns: { type: "boolean" },
     examples: ['starts_with("mira", "mi") // true']
   }
 );
@@ -3225,9 +3192,11 @@ var ends_with = VmLib(
   },
   {
     summary: "检查字符串是否以指定子串结尾",
-    params: { str: "要检查的字符串", search: "要匹配的子串" },
-    paramsType: { str: "string", search: "string" },
-    returnsType: "boolean",
+    params: {
+      str: { type: "string", description: "要检查的字符串" },
+      search: { type: "string", description: "要匹配的子串" }
+    },
+    returns: { type: "boolean" },
     examples: ['ends_with("mira", "ra") // true']
   }
 );
@@ -3237,9 +3206,11 @@ var contains = VmLib(
   },
   {
     summary: "检查字符串是否包含指定子串",
-    params: { str: "要检查的字符串", search: "要匹配的子串" },
-    paramsType: { str: "string", search: "string" },
-    returnsType: "boolean",
+    params: {
+      str: { type: "string", description: "要检查的字符串" },
+      search: { type: "string", description: "要匹配的子串" }
+    },
+    returns: { type: "boolean" },
     examples: ['contains("hello", "ll") // true']
   }
 );
@@ -3251,9 +3222,8 @@ var chars = VmLib(
   },
   {
     summary: "将字符串转换为字符数组",
-    params: { str: "要转换的字符串" },
-    paramsType: { str: "string" },
-    returnsType: "string[]",
+    params: { str: { type: "string", description: "要转换的字符串" } },
+    returns: { type: "string[]" },
     examples: ['chars("Mira") // ["M", "i", "r", "a"]']
   }
 );
@@ -3266,9 +3236,12 @@ var replace = VmLib(
   },
   {
     summary: "替换字符串中的指定子串",
-    params: { str: "要处理的字符串", search: "要替换的子串", replacement: "替换后的字符串" },
-    paramsType: { str: "string", search: "string", replacement: "string" },
-    returnsType: "string",
+    params: {
+      str: { type: "string", description: "要处理的字符串" },
+      search: { type: "string", description: "要替换的子串" },
+      replacement: { type: "string", description: "替换后的字符串" }
+    },
+    returns: { type: "string" },
     examples: ['replace("foo bar foo", "foo", "baz") // "baz bar baz"']
   }
 );
@@ -3281,9 +3254,11 @@ var split = VmLib(
   },
   {
     summary: "将字符串拆分为子串数组",
-    params: { str: "要拆分的字符串", separator: "分隔符" },
-    paramsType: { str: "string", separator: "string" },
-    returnsType: "string[]",
+    params: {
+      str: { type: "string", description: "要拆分的字符串" },
+      separator: { type: "string", description: "分隔符" }
+    },
+    returns: { type: "string[]" },
     examples: ['split("a,b,c", ",") // ["a", "b", "c"]']
   }
 );
@@ -3295,9 +3270,11 @@ var join = VmLib(
   },
   {
     summary: "将字符串数组连接为单个字符串",
-    params: { arr: "要连接的字符串数组", separator: "分隔符" },
-    paramsType: { arr: "string[]", separator: "string" },
-    returnsType: "string",
+    params: {
+      arr: { type: "string[]", description: "要连接的字符串数组" },
+      separator: { type: "string", description: "分隔符" }
+    },
+    returns: { type: "string" },
     examples: ['join(["a", "b", "c"], "-") // "a-b-c"']
   }
 );
@@ -3338,11 +3315,10 @@ var to_timestamp = VmLib(
   {
     summary: "将数据转换为 Unix 毫秒时间戳",
     params: {
-      datetime: "要转换的数据，默认为当前时间",
-      fallback: "转换失败时的返回值"
+      datetime: { type: "number | string | nil", description: "要转换的数据，默认为当前时间" },
+      fallback: { type: "any", description: "转换失败时的返回值" }
     },
-    paramsType: { datetime: "number | string | nil", fallback: "any" },
-    returnsType: "number | type(fallback)",
+    returns: { type: "number | type(fallback)" },
     examples: ['to_timestamp("1970-01-01T00:00:00Z") // 0']
   }
 );
@@ -3367,12 +3343,11 @@ var to_datetime = VmLib(
   {
     summary: "将数据转换为 DateTime 记录",
     params: {
-      datetime: "要转换的数据，默认为当前时间",
-      offset: "时区偏移量（单位：小时），默认为 0",
-      fallback: "转换失败时的返回值"
+      datetime: { type: "number | string | nil", description: "要转换的数据，默认为当前时间" },
+      offset: { type: "number | nil", description: "时区偏移量（单位：小时），默认为 0" },
+      fallback: { type: "any", description: "转换失败时的返回值" }
     },
-    paramsType: { datetime: "number | string | nil", offset: "number | nil", fallback: "any" },
-    returnsType: "DateTime | type(fallback)",
+    returns: { type: "DateTime | type(fallback)" },
     examples: [
       `
 to_datetime(0)
@@ -3395,11 +3370,10 @@ var to_iso8601 = VmLib(
   {
     summary: "将数据转换为 ISO 8601 格式的字符串",
     params: {
-      datetime: "要转换的数据，默认为当前时间",
-      fallback: "转换失败时的返回值"
+      datetime: { type: "number | string | nil", description: "要转换的数据，默认为当前时间" },
+      fallback: { type: "any", description: "转换失败时的返回值" }
     },
-    paramsType: { datetime: "number | string | nil", fallback: "any" },
-    returnsType: "string | type(fallback)",
+    returns: { type: "string | type(fallback)" },
     examples: ['to_iso8601(0) // "1970-01-01T00:00:00.000Z"']
   }
 );
@@ -3451,9 +3425,8 @@ var size = VmLib(
   },
   {
     summary: "获取矩阵尺寸",
-    params: { matrix: "要获取尺寸的矩阵" },
-    paramsType: { matrix: "any[][]" },
-    returnsType: "[number, number]",
+    params: { matrix: { type: "any[][]", description: "要获取尺寸的矩阵" } },
+    returns: { type: "[number, number]" },
     examples: ["matrix.size([[1, 2], [3, 4]]) // [2, 2]"]
   }
 );
@@ -3477,9 +3450,8 @@ var transpose = VmLib(
   },
   {
     summary: "转置矩阵",
-    params: { matrix: "要转置的矩阵" },
-    paramsType: { matrix: "any[][]" },
-    returnsType: "any[][]",
+    params: { matrix: { type: "any[][]", description: "要转置的矩阵" } },
+    returns: { type: "any[][]" },
     examples: ["matrix.transpose([[1, 2], [3, 4]]) // [[1, 3], [2, 4]]"]
   }
 );
@@ -3592,9 +3564,12 @@ var entrywise = VmLib(
   },
   {
     summary: "逐项操作",
-    params: { a: "第一个操作数", b: "第二个操作数", f: "操作函数" },
-    paramsType: { a: "any | any[] | any[][]", b: "any | any[] | any[][]", f: "fn(a: any, b: any) -> any" },
-    returnsType: "any | any[] | any[][]",
+    params: {
+      a: { type: "any | any[] | any[][]", description: "第一个操作数" },
+      b: { type: "any | any[] | any[][]", description: "第二个操作数" },
+      f: { type: "fn(a: any, b: any) -> any", description: "操作函数" }
+    },
+    returns: { type: "any | any[] | any[][]" },
     examples: [`matrix.entrywise([1, 2], [3, 4], fn (x, y) { x + y }) // [4, 6]`]
   }
 );
@@ -3606,9 +3581,11 @@ var add2 = VmLib(
   },
   {
     summary: "逐项相加",
-    params: { a: "第一个操作数", b: "第二个操作数" },
-    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
-    returnsType: "number | number[] | number[][]",
+    params: {
+      a: { type: "number | number[] | number[][]", description: "第一个操作数" },
+      b: { type: "number | number[] | number[][]", description: "第二个操作数" }
+    },
+    returns: { type: "number | number[] | number[][]" },
     examples: ["matrix.add([1, 2], [3, 4]) // [4, 6]"]
   }
 );
@@ -3620,9 +3597,11 @@ var subtract = VmLib(
   },
   {
     summary: "逐项相减",
-    params: { a: "第一个操作数", b: "第二个操作数" },
-    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
-    returnsType: "number | number[] | number[][]",
+    params: {
+      a: { type: "number | number[] | number[][]", description: "第一个操作数" },
+      b: { type: "number | number[] | number[][]", description: "第二个操作数" }
+    },
+    returns: { type: "number | number[] | number[][]" },
     examples: ["matrix.subtract([3, 4], [1, 2]) // [2, 2]"]
   }
 );
@@ -3634,9 +3613,11 @@ var entrywise_multiply = VmLib(
   },
   {
     summary: "逐项相乘",
-    params: { a: "第一个操作数", b: "第二个操作数" },
-    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
-    returnsType: "number | number[] | number[][]",
+    params: {
+      a: { type: "number | number[] | number[][]", description: "第一个操作数" },
+      b: { type: "number | number[] | number[][]", description: "第二个操作数" }
+    },
+    returns: { type: "number | number[] | number[][]" },
     examples: ["matrix.entrywise_multiply([1, 2], [3, 4]) // [3, 8]"]
   }
 );
@@ -3648,9 +3629,11 @@ var entrywise_divide = VmLib(
   },
   {
     summary: "逐项相除",
-    params: { a: "第一个操作数", b: "第二个操作数" },
-    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
-    returnsType: "number | number[] | number[][]",
+    params: {
+      a: { type: "number | number[] | number[][]", description: "第一个操作数" },
+      b: { type: "number | number[] | number[][]", description: "第二个操作数" }
+    },
+    returns: { type: "number | number[] | number[][]" },
     examples: ["matrix.entrywise_divide([4, 6], [2, 3]) // [2, 2]"]
   }
 );
@@ -3714,9 +3697,11 @@ var multiply = VmLib(
   },
   {
     summary: "矩阵相乘",
-    params: { a: "第一个操作数", b: "第二个操作数" },
-    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
-    returnsType: "number | number[] | number[][]",
+    params: {
+      a: { type: "number | number[] | number[][]", description: "第一个操作数" },
+      b: { type: "number | number[] | number[][]", description: "第二个操作数" }
+    },
+    returns: { type: "number | number[] | number[][]" },
     examples: ["matrix.multiply([[1, 2], [3, 4]], [5, 6]) // [17, 39]"]
   }
 );
@@ -3805,9 +3790,8 @@ var invert = VmLib(
   },
   {
     summary: "矩阵求逆",
-    params: { a: "待求逆的矩阵" },
-    paramsType: { a: "number | number[][]" },
-    returnsType: "number | number[][]",
+    params: { a: { type: "number | number[][]", description: "待求逆的矩阵" } },
+    returns: { type: "number | number[][]" },
     examples: ["matrix.invert([[1, 2], [3, 4]]) // [[-2, 1], [1.5, -0.5]]"]
   }
 );
@@ -3826,16 +3810,14 @@ function filled(size2, value) {
 }
 var zeros = VmLib((...size2) => filled(size2, 0), {
   summary: "创建一个全零的矩阵",
-  params: { "..size": "矩阵的维度" },
-  paramsType: { "..size": "number[]" },
-  returnsType: "number[][]",
+  params: { "..size": { type: "number[]", description: "矩阵的维度" } },
+  returns: { type: "number[][]" },
   examples: ["matrix.zeros(2, 3) // [[0, 0, 0], [0, 0, 0]]"]
 });
 var ones = VmLib((...size2) => filled(size2, 1), {
   summary: "创建一个全一的矩阵",
-  params: { "..size": "矩阵的维度" },
-  paramsType: { "..size": "number[]" },
-  returnsType: "number[][]",
+  params: { "..size": { type: "number[]", description: "矩阵的维度" } },
+  returns: { type: "number[][]" },
   examples: ["matrix.ones(2, 2) // [[1, 1], [1, 1]]"]
 });
 var identity = VmLib(
@@ -3858,9 +3840,8 @@ var identity = VmLib(
   },
   {
     summary: "创建一个单位矩阵",
-    params: { "..size": "矩阵的维度" },
-    paramsType: { "..size": "[number] | [number, number]" },
-    returnsType: "number[][]",
+    params: { "..size": { type: "[number] | [number, number]", description: "矩阵的维度" } },
+    returns: { type: "number[][]" },
     examples: ["matrix.identity(3) // [[1, 0, 0], [0, 1, 0], [0, 0, 1]]"]
   }
 );
@@ -3898,9 +3879,11 @@ var diagonal = VmLib(
   },
   {
     summary: "创建一个对角矩阵或获取矩阵的对角线",
-    params: { x: "对角线元素或要获取对角线的矩阵", k: "对角线偏移量，默认为 0" },
-    paramsType: { x: "number[] | number[][]", k: "number" },
-    returnsType: "number[][] | number[]",
+    params: {
+      x: { type: "number[] | number[][]", description: "对角线元素或要获取对角线的矩阵" },
+      k: { type: "number", description: "对角线偏移量，默认为 0" }
+    },
+    returns: { type: "number[][] | number[]" },
     examples: [
       "matrix.diagonal([1, 2, 3]) // [[1, 0, 0], [0, 2, 0], [0, 0, 3]]",
       "matrix.diagonal([[1, 2], [3, 4]]) // [1, 4]"
@@ -3979,4 +3962,4 @@ export {
   emitScript,
   lib
 };
-//# sourceMappingURL=chunk-ITTCGBBX.js.map
+//# sourceMappingURL=chunk-MRA5WJ72.js.map