modify the layout of the locale files

separate titles and localized contents on separate lines for easy viewing with comparison tools

3 files changed, 1236 insertions, 618 deletions

diff --git a/locale/zh-cn/meta.lua b/locale/zh-cn/meta.lua
index d2fd3c7b..8e7c37e8 100644
--- a/locale/zh-cn/meta.lua
+++ b/locale/zh-cn/meta.lua
@@ -1,55 +1,84 @@
 ---@diagnostic disable: undefined-global, lowercase-global
 
 -- basic
-arg                 = '独立版Lua的启动参数。'
-assert              = '如果其参数 `v` 的值为假（`nil` 或 `false`）， 它就调用 $error； 否则，返回所有的参数。 在错误情况时， `message` 指那个错误对象； 如果不提供这个参数，参数默认为 `"assertion failed!"` 。'
-cgopt.collect       = '做一次完整的垃圾收集循环。'
-cgopt.stop          = '停止垃圾收集器的运行。'
-cgopt.restart       = '重启垃圾收集器的自动运行。'
-cgopt.count         = '以 K 字节数为单位返回 Lua 使用的总内存数。'
-cgopt.step          = '单步运行垃圾收集器。 步长“大小”由 `arg` 控制。'
-cgopt.setpause      = '将 `arg` 设为收集器的 *间歇率* 。'
-cgopt.setstepmul    = '将 `arg` 设为收集器的 *步进倍率* 。'
-cgopt.incremental   = '改变收集器模式为增量模式。'
-cgopt.generational  = '改变收集器模式为分代模式。'
-cgopt.isrunning     = '返回表示收集器是否在工作的布尔值。'
-collectgarbage      = '这个函数是垃圾收集器的通用接口。 通过参数 opt 它提供了一组不同的功能。'
-dofile              = '打开该名字的文件，并执行文件中的 Lua 代码块。 不带参数调用时， `dofile` 执行标准输入的内容（`stdin`）。 返回该代码块的所有返回值。 对于有错误的情况，`dofile` 将错误反馈给调用者 （即，`dofile` 没有运行在保护模式下）。'
-error               = [[
+arg                 =
+'独立版Lua的启动参数。'
+assert              =
+'如果其参数 `v` 的值为假（`nil` 或 `false`）， 它就调用 $error； 否则，返回所有的参数。 在错误情况时， `message` 指那个错误对象； 如果不提供这个参数，参数默认为 `"assertion failed!"` 。'
+cgopt.collect       =
+'做一次完整的垃圾收集循环。'
+cgopt.stop          =
+'停止垃圾收集器的运行。'
+cgopt.restart       =
+'重启垃圾收集器的自动运行。'
+cgopt.count         =
+'以 K 字节数为单位返回 Lua 使用的总内存数。'
+cgopt.step          =
+'单步运行垃圾收集器。 步长“大小”由 `arg` 控制。'
+cgopt.setpause      =
+'将 `arg` 设为收集器的 *间歇率* 。'
+cgopt.setstepmul    =
+'将 `arg` 设为收集器的 *步进倍率* 。'
+cgopt.incremental   =
+'改变收集器模式为增量模式。'
+cgopt.generational  =
+'改变收集器模式为分代模式。'
+cgopt.isrunning     =
+'返回表示收集器是否在工作的布尔值。'
+collectgarbage      =
+'这个函数是垃圾收集器的通用接口。 通过参数 opt 它提供了一组不同的功能。'
+dofile              =
+'打开该名字的文件，并执行文件中的 Lua 代码块。 不带参数调用时， `dofile` 执行标准输入的内容（`stdin`）。 返回该代码块的所有返回值。 对于有错误的情况，`dofile` 将错误反馈给调用者 （即，`dofile` 没有运行在保护模式下）。'
+error               =
+[[
 中止上一次保护函数调用， 将错误对象 `message` 返回。 函数 `error` 永远不会返回。
 
 当 `message` 是一个字符串时，通常 `error` 会把一些有关出错位置的信息附加在消息的前头。 level 参数指明了怎样获得出错位置。
 ]]
-_G                  = '一个全局变量（非函数）， 内部储存有全局环境（参见 §2.2）。 Lua 自己不使用这个变量； 改变这个变量的值不会对任何环境造成影响，反之亦然。'
-getfenv             = '返回给定函数的环境。`f` 可以是一个Lua函数，也可是一个表示调用栈层级的数字。'
-getmetatable        = '如果 `object` 不包含元表，返回 `nil` 。 否则，如果在该对象的元表中有 `"__metatable"` 域时返回其关联值， 没有时返回该对象的元表。'
-ipairs              = [[
+_G                  =
+'一个全局变量（非函数）， 内部储存有全局环境（参见 §2.2）。 Lua 自己不使用这个变量； 改变这个变量的值不会对任何环境造成影响，反之亦然。'
+getfenv             =
+'返回给定函数的环境。`f` 可以是一个Lua函数，也可是一个表示调用栈层级的数字。'
+getmetatable        =
+'如果 `object` 不包含元表，返回 `nil` 。 否则，如果在该对象的元表中有 `"__metatable"` 域时返回其关联值， 没有时返回该对象的元表。'
+ipairs              =
+[[
 返回三个值（迭代函数、表 `t` 以及 `0` ）， 如此，以下代码
 ```lua
     for i,v in ipairs(t) do body end
 ```
 将迭代键值对 `（1,t[1]) ，(2,t[2])， ...` ，直到第一个空值。
 ]]
-loadmode.b        = '只能是二进制代码块。'
-loadmode.t        = '只能是文本代码块。'
-loadmode.bt       = '可以是二进制也可以是文本。'
-load['<5.1']      = '使用 `func` 分段加载代码块。 每次调用 `func` 必须返回一个字符串用于连接前文。'
-load['>5.2']      = [[
+loadmode.b        =
+'只能是二进制代码块。'
+loadmode.t        =
+'只能是文本代码块。'
+loadmode.bt       =
+'可以是二进制也可以是文本。'
+load['<5.1']      =
+'使用 `func` 分段加载代码块。 每次调用 `func` 必须返回一个字符串用于连接前文。'
+load['>5.2']      =
+[[
 加载一个代码块。
 
 如果 `chunk` 是一个字符串，代码块指这个字符串。 如果 `chunk` 是一个函数， `load` 不断地调用它获取代码块的片断。 每次对 `chunk` 的调用都必须返回一个字符串紧紧连接在上次调用的返回串之后。 当返回空串、`nil`、或是不返回值时，都表示代码块结束。
 ]]
-loadfile            = '从文件 `filename` 或标准输入（如果文件名未提供）中获取代码块。'
-loadstring          = '使用给定字符串加载代码块。'
-module              = '创建一个模块。'
-next                = [[
+loadfile            =
+'从文件 `filename` 或标准输入（如果文件名未提供）中获取代码块。'
+loadstring          =
+'使用给定字符串加载代码块。'
+module              =
+'创建一个模块。'
+next                =
+[[
 运行程序来遍历表中的所有域。 第一个参数是要遍历的表，第二个参数是表中的某个键。 `next` 返回该键的下一个键及其关联的值。 如果用 `nil` 作为第二个参数调用 `next` 将返回初始键及其关联值。 当以最后一个键去调用，或是以 `nil` 调用一张空表时， `next` 返回 `nil`。 如果不提供第二个参数，将认为它就是 `nil`。 特别指出，你可以用 `next(t)` 来判断一张表是否是空的。
 
 索引在遍历过程中的次序无定义， 即使是数字索引也是这样。 （如果想按数字次序遍历表，可以使用数字形式的 `for` 。）
 
 当在遍历过程中你给表中并不存在的域赋值， `next` 的行为是未定义的。 然而你可以去修改那些已存在的域。 特别指出，你可以清除一些已存在的域。
 ]]
-pairs               = [[
+pairs               =
+[[
 如果 `t` 有元方法 `__pairs`， 以 `t` 为参数调用它，并返回其返回的前三个值。
 
 否则，返回三个值：`next` 函数， 表 `t`，以及 `nil`。 因此以下代码
@@ -60,138 +89,224 @@ pairs               = [[
 
 参见函数 $next 中关于迭代过程中修改表的风险。
 ]]
-pcall               = '传入参数，以 *保护模式* 调用函数 `f` 。 这意味着 `f` 中的任何错误不会抛出； 取而代之的是，`pcall` 会将错误捕获到，并返回一个状态码。 第一个返回值是状态码（一个布尔量）， 当没有错误时，其为真。 此时，`pcall` 同样会在状态码后返回所有调用的结果。 在有错误时，`pcall` 返回 `false` 加错误消息。'
-print               = '接收任意数量的参数，并将它们的值打印到 `stdout`。 它用 `tostring` 函数将每个参数都转换为字符串。 `print` 不用于做格式化输出。仅作为看一下某个值的快捷方式。 多用于调试。 完整的对输出的控制，请使用 $string.format 以及 $io.write。'
-rawequal            = '在不触发任何元方法的情况下 检查 `v1` 是否和 `v2` 相等。 返回一个布尔量。'
-rawget              = '在不触发任何元方法的情况下 获取 `table[index]` 的值。 `table` 必须是一张表； `index` 可以是任何值。'
-rawlen              = '在不触发任何元方法的情况下 返回对象 `v` 的长度。 `v` 可以是表或字符串。 它返回一个整数。'
-rawset              = [[
+pcall               =
+'传入参数，以 *保护模式* 调用函数 `f` 。 这意味着 `f` 中的任何错误不会抛出； 取而代之的是，`pcall` 会将错误捕获到，并返回一个状态码。 第一个返回值是状态码（一个布尔量）， 当没有错误时，其为真。 此时，`pcall` 同样会在状态码后返回所有调用的结果。 在有错误时，`pcall` 返回 `false` 加错误消息。'
+print               =
+'接收任意数量的参数，并将它们的值打印到 `stdout`。 它用 `tostring` 函数将每个参数都转换为字符串。 `print` 不用于做格式化输出。仅作为看一下某个值的快捷方式。 多用于调试。 完整的对输出的控制，请使用 $string.format 以及 $io.write。'
+rawequal            =
+'在不触发任何元方法的情况下 检查 `v1` 是否和 `v2` 相等。 返回一个布尔量。'
+rawget              =
+'在不触发任何元方法的情况下 获取 `table[index]` 的值。 `table` 必须是一张表； `index` 可以是任何值。'
+rawlen              =
+'在不触发任何元方法的情况下 返回对象 `v` 的长度。 `v` 可以是表或字符串。 它返回一个整数。'
+rawset              =
+[[
 在不触发任何元方法的情况下 将 `table[index]` 设为 `value。` `table` 必须是一张表， `index` 可以是 `nil` 与 `NaN` 之外的任何值。 `value` 可以是任何 Lua 值。
 这个函数返回 `table`。
 ]]
-select              = '如果 `index` 是个数字， 那么返回参数中第 `index` 个之后的部分； 负的数字会从后向前索引（`-1` 指最后一个参数）。 否则，`index` 必须是字符串 `"#"`， 此时 `select` 返回参数的个数。'
-setfenv             = '设置给定函数的环境。'
-setmetatable        = [[
+select              =
+'如果 `index` 是个数字， 那么返回参数中第 `index` 个之后的部分； 负的数字会从后向前索引（`-1` 指最后一个参数）。 否则，`index` 必须是字符串 `"#"`， 此时 `select` 返回参数的个数。'
+setfenv             =
+'设置给定函数的环境。'
+setmetatable        =
+[[
 给指定表设置元表。 （你不能在 Lua 中改变其它类型值的元表，那些只能在 C 里做。） 如果 `metatable` 是 `nil`， 将指定表的元表移除。 如果原来那张元表有 `"__metatable"` 域，抛出一个错误。
 ]]
-tonumber            = [[
+tonumber            =
+[[
 如果调用的时候没有 `base`， `tonumber` 尝试把参数转换为一个数字。 如果参数已经是一个数字，或是一个可以转换为数字的字符串， `tonumber` 就返回这个数字； 否则返回 `nil`。
 
 字符串的转换结果可能是整数也可能是浮点数， 这取决于 Lua 的转换文法（参见 §3.1）。 （字符串可以有前置和后置的空格，可以带符号。）
 ]]
-tostring            = [[
+tostring            =
+[[
 可以接收任何类型，它将其转换为人可阅读的字符串形式。 浮点数总被转换为浮点数的表现形式（小数点形式或是指数形式）。 （如果想完全控制数字如何被转换，可以使用 $string.format。）
 如果 `v` 有 `"__tostring"` 域的元表， `tostring` 会以 `v` 为参数调用它。 并用它的结果作为返回值。
 ]]
-type                = [[
+type                =
+[[
 将参数的类型编码为一个字符串返回。 函数可能的返回值有 `"nil"` （一个字符串，而不是 `nil` 值）， `"number"`， `"string"`， `"boolean"`， `"table"`， `"function"`， `"thread"`， `"userdata"`。
 ]]
-_VERSION            = '一个包含有当前解释器版本号的全局变量（并非函数）。'
-warn                = '使用所有参数组成的字符串消息来发送警告。'
-xpcall['=5.1']      = '传入参数，以 *保护模式* 调用函数 `f` 。这个函数和 `pcall` 类似。 不过它可以额外设置一个消息处理器 `err`。'
-xpcall['>5.2']      = '传入参数，以 *保护模式* 调用函数 `f` 。这个函数和 `pcall` 类似。 不过它可以额外设置一个消息处理器 `msgh`。'
-unpack              = [[
+_VERSION            =
+'一个包含有当前解释器版本号的全局变量（并非函数）。'
+warn                =
+'使用所有参数组成的字符串消息来发送警告。'
+xpcall['=5.1']      =
+'传入参数，以 *保护模式* 调用函数 `f` 。这个函数和 `pcall` 类似。 不过它可以额外设置一个消息处理器 `err`。'
+xpcall['>5.2']      =
+'传入参数，以 *保护模式* 调用函数 `f` 。这个函数和 `pcall` 类似。 不过它可以额外设置一个消息处理器 `msgh`。'
+unpack              =
+[[
 返回给定 `list` 中的所有元素。 改函数等价于
 ```lua
 return list[i], list[i+1], ···, list[j]
 ```
 ]]
 
-bit32               = ''
-bit32.arshift       = [[
+bit32               =
+''
+bit32.arshift       =
+[[
 返回 `x` 向右位移 `disp` 位的结果。`disp` 为负时向左位移。这是算数位移操作，左侧的空位使用 `x` 的高位填充，右侧空位使用 `0` 填充。
 ]]
-bit32.band          = '返回参数按位与的结果。'
-bit32.bnot          = [[
+bit32.band          =
+'返回参数按位与的结果。'
+bit32.bnot          =
+[[
 返回 `x` 按位取反的结果。
 
 ```lua
-assert(bit32.bnot(x) == (-1 - x) % 2^32)
+assert(bit32.bnot(x) ==
+(-1 - x) % 2^32)
 ```
 ]]
-bit32.bor           = '返回参数按位或的结果。'
-bit32.btest         = '参数按位与的结果不为0时，返回 `true` 。'
-bit32.bxor          = '返回参数按位异或的结果。'
-bit32.extract       = '返回 `n` 中第 `field` 到第 `field + width - 1` 位组成的结果。'
-bit32.replace       = '返回 `v` 的第 `field` 到第 `field + width - 1` 位替换 `n` 的对应位后的结果。'
-bit32.lrotate       = '返回 `x` 向左旋转 `disp` 位的结果。`disp` 为负时向右旋转。'
-bit32.lshift        = [[
+bit32.bor           =
+'返回参数按位或的结果。'
+bit32.btest         =
+'参数按位与的结果不为0时，返回 `true` 。'
+bit32.bxor          =
+'返回参数按位异或的结果。'
+bit32.extract       =
+'返回 `n` 中第 `field` 到第 `field + width - 1` 位组成的结果。'
+bit32.replace       =
+'返回 `v` 的第 `field` 到第 `field + width - 1` 位替换 `n` 的对应位后的结果。'
+bit32.lrotate       =
+'返回 `x` 向左旋转 `disp` 位的结果。`disp` 为负时向右旋转。'
+bit32.lshift        =
+[[
 返回 `x` 向左位移 `disp` 位的结果。`disp` 为负时向右位移。空位总是使用 `0` 填充。
 
 ```lua
-assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
+assert(bit32.lshift(b, disp) ==
+(b * 2^disp) % 2^32)
 ```
 ]]
-bit32.rrotate       = '返回 `x` 向右旋转 `disp` 位的结果。`disp` 为负时向左旋转。'
-bit32.rshift        = [[
+bit32.rrotate       =
+'返回 `x` 向右旋转 `disp` 位的结果。`disp` 为负时向左旋转。'
+bit32.rshift        =
+[[
 返回 `x` 向右位移 `disp` 位的结果。`disp` 为负时向左位移。空位总是使用 `0` 填充。
 
 ```lua
-assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
+assert(bit32.lshift(b, disp) ==
+(b * 2^disp) % 2^32)
 ```
 ]]
 
-coroutine                     = ''
-coroutine.create              = '创建一个主体函数为 `f` 的新协程。 f 必须是一个 Lua 的函数。 返回这个新协程，它是一个类型为 `"thread"` 的对象。'
-coroutine.isyieldable         = '如果正在运行的协程可以让出，则返回真。'
-coroutine.isyieldable['>5.4'] = '如果协程 `co` 可以让出，则返回真。`co` 默认为正在运行的协程。'
-coroutine.close               = '关闭协程 `co`，并关闭它所有等待 *to-be-closed* 的变量，并将协程状态设为 `dead` 。'
-coroutine.resume              = '开始或继续协程 `co` 的运行。'
-coroutine.running             = '返回当前正在运行的协程加一个布尔量。 如果当前运行的协程是主线程，其为真。'
-coroutine.status              = '以字符串形式返回协程 `co` 的状态。'
-coroutine.wrap                = '创建一个主体函数为 `f` 的新协程。 f 必须是一个 Lua 的函数。 返回一个函数， 每次调用该函数都会延续该协程。'
-coroutine.yield               = '挂起正在调用的协程的执行。'
-costatus.running              = '正在运行。'
-costatus.suspended            = '挂起或是还没有开始运行。'
-costatus.normal               = '是活动的，但并不在运行。'
-costatus.dead                 = '运行完主体函数或因错误停止。'
+coroutine                     =
+''
+coroutine.create              =
+'创建一个主体函数为 `f` 的新协程。 f 必须是一个 Lua 的函数。 返回这个新协程，它是一个类型为 `"thread"` 的对象。'
+coroutine.isyieldable         =
+'如果正在运行的协程可以让出，则返回真。'
+coroutine.isyieldable['>5.4'] =
+'如果协程 `co` 可以让出，则返回真。`co` 默认为正在运行的协程。'
+coroutine.close               =
+'关闭协程 `co`，并关闭它所有等待 *to-be-closed* 的变量，并将协程状态设为 `dead` 。'
+coroutine.resume              =
+'开始或继续协程 `co` 的运行。'
+coroutine.running             =
+'返回当前正在运行的协程加一个布尔量。 如果当前运行的协程是主线程，其为真。'
+coroutine.status              =
+'以字符串形式返回协程 `co` 的状态。'
+coroutine.wrap                =
+'创建一个主体函数为 `f` 的新协程。 f 必须是一个 Lua 的函数。 返回一个函数， 每次调用该函数都会延续该协程。'
+coroutine.yield               =
+'挂起正在调用的协程的执行。'
+costatus.running              =
+'正在运行。'
+costatus.suspended            =
+'挂起或是还没有开始运行。'
+costatus.normal               =
+'是活动的，但并不在运行。'
+costatus.dead                 =
+'运行完主体函数或因错误停止。'
 
-debug                       = ''
-debug.debug               = '进入一个用户交互模式，运行用户输入的每个字符串。'
-debug.getfenv             = '返回对象 `o` 的环境。'
-debug.gethook             = '返回三个表示线程钩子设置的值： 当前钩子函数，当前钩子掩码，当前钩子计数 。'
-debug.getinfo             = '返回关于一个函数信息的表。'
-debug.getlocal['<5.1']    = '返回在栈的 `level` 层处函数的索引为 `index` 的局部变量的名字和值。'
-debug.getlocal['>5.2']    = '返回在栈的 `f` 层处函数的索引为 `index` 的局部变量的名字和值。'
-debug.getmetatable        = '返回给定 `value` 的元表。'
-debug.getregistry         = '返回注册表。'
-debug.getupvalue          = '返回函数 `f` 的第 `up` 个上值的名字和值。'
-debug.getuservalue['<5.3']= '返回关联在 `u` 上的 `Lua` 值。'
-debug.getuservalue['>5.4']= '返回关联在 `u` 上的第 `n` 个 `Lua` 值，以及一个布尔，`false`表示值不存在。'
-debug.setcstacklimit      = [[
+debug                       =
+''
+debug.debug               =
+'进入一个用户交互模式，运行用户输入的每个字符串。'
+debug.getfenv             =
+'返回对象 `o` 的环境。'
+debug.gethook             =
+'返回三个表示线程钩子设置的值： 当前钩子函数，当前钩子掩码，当前钩子计数 。'
+debug.getinfo             =
+'返回关于一个函数信息的表。'
+debug.getlocal['<5.1']    =
+'返回在栈的 `level` 层处函数的索引为 `index` 的局部变量的名字和值。'
+debug.getlocal['>5.2']    =
+'返回在栈的 `f` 层处函数的索引为 `index` 的局部变量的名字和值。'
+debug.getmetatable        =
+'返回给定 `value` 的元表。'
+debug.getregistry         =
+'返回注册表。'
+debug.getupvalue          =
+'返回函数 `f` 的第 `up` 个上值的名字和值。'
+debug.getuservalue['<5.3']=
+'返回关联在 `u` 上的 `Lua` 值。'
+debug.getuservalue['>5.4']=
+'返回关联在 `u` 上的第 `n` 个 `Lua` 值，以及一个布尔，`false`表示值不存在。'
+debug.setcstacklimit      =
+[[
 ### **已在 `Lua 5.4.2` 中废弃**
 
 设置新的C栈限制。该限制控制Lua中嵌套调用的深度，以避免堆栈溢出。
 
 如果设置成功，该函数返回之前的限制；否则返回`false`。
 ]]
-debug.setfenv             = '将 `table` 设置为 `object` 的环境。'
-debug.sethook             = '将一个函数作为钩子函数设入。'
-debug.setlocal            = '将 `value` 赋给 栈上第 `level` 层函数的第 `local` 个局部变量。'
-debug.setmetatable        = '将 `value` 的元表设为 `table` （可以是 `nil`）。'
-debug.setupvalue          = '将 `value` 设为函数 `f` 的第 `up` 个上值。'
-debug.setuservalue['<5.3']= '将 `value` 设为 `udata` 的关联值。'
-debug.setuservalue['>5.4']= '将 `value` 设为 `udata` 的第 `n` 个关联值。'
-debug.traceback           = '返回调用栈的栈回溯信息。 字符串可选项 `message` 被添加在栈回溯信息的开头。'
-debug.upvalueid           = '返回指定函数第 `n` 个上值的唯一标识符（一个轻量用户数据）。'
-debug.upvaluejoin         = '让 Lua 闭包 `f1` 的第 `n1` 个上值 引用 `Lua` 闭包 `f2` 的第 `n2` 个上值。'
-infowhat.n                = '`name` 和 `namewhat`'
-infowhat.S                = '`source`，`short_src`，`linedefined`，`lalinedefined`，和 `what`'
-infowhat.l                = '`currentline`'
-infowhat.t                = '`istailcall`'
-infowhat.u['<5.1']        = '`nups`'
-infowhat.u['>5.2']        = '`nups`、`nparams` 和 `isvararg`'
-infowhat.f                = '`func`'
-infowhat.r                = '`ftransfer` 和 `ntransfer`'
-infowhat.L                = '`activelines`'
-hookmask.c                = '每当 Lua 调用一个函数时，调用钩子。'
-hookmask.r                = '每当 Lua 从一个函数内返回时，调用钩子。'
-hookmask.l                = '每当 Lua 进入新的一行时，调用钩子。'
+debug.setfenv             =
+'将 `table` 设置为 `object` 的环境。'
+debug.sethook             =
+'将一个函数作为钩子函数设入。'
+debug.setlocal            =
+'将 `value` 赋给 栈上第 `level` 层函数的第 `local` 个局部变量。'
+debug.setmetatable        =
+'将 `value` 的元表设为 `table` （可以是 `nil`）。'
+debug.setupvalue          =
+'将 `value` 设为函数 `f` 的第 `up` 个上值。'
+debug.setuservalue['<5.3']=
+'将 `value` 设为 `udata` 的关联值。'
+debug.setuservalue['>5.4']=
+'将 `value` 设为 `udata` 的第 `n` 个关联值。'
+debug.traceback           =
+'返回调用栈的栈回溯信息。 字符串可选项 `message` 被添加在栈回溯信息的开头。'
+debug.upvalueid           =
+'返回指定函数第 `n` 个上值的唯一标识符（一个轻量用户数据）。'
+debug.upvaluejoin         =
+'让 Lua 闭包 `f1` 的第 `n1` 个上值 引用 `Lua` 闭包 `f2` 的第 `n2` 个上值。'
+infowhat.n                =
+'`name` 和 `namewhat`'
+infowhat.S                =
+'`source`，`short_src`，`linedefined`，`lalinedefined`，和 `what`'
+infowhat.l                =
+'`currentline`'
+infowhat.t                =
+'`istailcall`'
+infowhat.u['<5.1']        =
+'`nups`'
+infowhat.u['>5.2']        =
+'`nups`、`nparams` 和 `isvararg`'
+infowhat.f                =
+'`func`'
+infowhat.r                =
+'`ftransfer` 和 `ntransfer`'
+infowhat.L                =
+'`activelines`'
+hookmask.c                =
+'每当 Lua 调用一个函数时，调用钩子。'
+hookmask.r                =
+'每当 Lua 从一个函数内返回时，调用钩子。'
+hookmask.l                =
+'每当 Lua 进入新的一行时，调用钩子。'
 
-file                        = ''
-file[':close']              = '关闭 `file`。'
-file[':flush']              = '将写入的数据保存到 `file` 中。'
-file[':lines']              = [[
+file                        =
+''
+file[':close']              =
+'关闭 `file`。'
+file[':flush']              =
+'将写入的数据保存到 `file` 中。'
+file[':lines']              =
+[[
 ------
 ```lua
 for c in file:lines(...) do
@@ -199,29 +314,51 @@ for c in file:lines(...) do
 end
 ```
 ]]
-file[':read']                = '读文件 `file`， 指定的格式决定了要读什么。'
-file[':seek']                = '设置及获取基于文件开头处计算出的位置。'
-file[':setvbuf']             = '设置输出文件的缓冲模式。'
-file[':write']               = '将参数的值逐个写入 `file`。'
-readmode.n                  = '读取一个数字，根据 Lua 的转换文法返回浮点数或整数。'
-readmode.a                  = '从当前位置开始读取整个文件。'
-readmode.l                  = '读取一行并忽略行结束标记。'
-readmode.L                  = '读取一行并保留行结束标记。'
-seekwhence.set              = '基点为 0 （文件开头）。'
-seekwhence.cur              = '基点为当前位置。'
-seekwhence['.end']          = '基点为文件尾。'
-vbuf.no                     = '不缓冲；输出操作立刻生效。'
-vbuf.full                   = '完全缓冲；只有在缓存满或调用 flush 时才做输出操作。'
-vbuf.line                   = '行缓冲；输出将缓冲到每次换行前。'
+file[':read']                =
+'读文件 `file`， 指定的格式决定了要读什么。'
+file[':seek']                =
+'设置及获取基于文件开头处计算出的位置。'
+file[':setvbuf']             =
+'设置输出文件的缓冲模式。'
+file[':write']               =
+'将参数的值逐个写入 `file`。'
+readmode.n                  =
+'读取一个数字，根据 Lua 的转换文法返回浮点数或整数。'
+readmode.a                  =
+'从当前位置开始读取整个文件。'
+readmode.l                  =
+'读取一行并忽略行结束标记。'
+readmode.L                  =
+'读取一行并保留行结束标记。'
+seekwhence.set              =
+'基点为 0 （文件开头）。'
+seekwhence.cur              =
+'基点为当前位置。'
+seekwhence['.end']          =
+'基点为文件尾。'
+vbuf.no                     =
+'不缓冲；输出操作立刻生效。'
+vbuf.full                   =
+'完全缓冲；只有在缓存满或调用 flush 时才做输出操作。'
+vbuf.line                   =
+'行缓冲；输出将缓冲到每次换行前。'
 
-io                          = ''
-io.stdin                    = '标准输入。'
-io.stdout                   = '标准输出。'
-io.stderr                   = '标准错误。'
-io.close                    = '关闭 `file` 或默认输出文件。'
-io.flush                    = '将写入的数据保存到默认输出文件中。'
-io.input                    = '设置 `file` 为默认输入文件。'
-io.lines                    = [[
+io                          =
+''
+io.stdin                    =
+'标准输入。'
+io.stdout                   =
+'标准输出。'
+io.stderr                   =
+'标准错误。'
+io.close                    =
+'关闭 `file` 或默认输出文件。'
+io.flush                    =
+'将写入的数据保存到默认输出文件中。'
+io.input                    =
+'设置 `file` 为默认输入文件。'
+io.lines                    =
+[[
 ------
 ```lua
 for c in io.lines(filename, ...) do
@@ -229,161 +366,289 @@ for c in io.lines(filename, ...) do
 end
 ```
 ]]
-io.open                    = '用字符串 `mode` 指定的模式打开一个文件。'
-io.output                  = '设置 `file` 为默认输出文件。'
-io.popen                   = '用一个分离进程开启程序 `prog` 。'
-io.read                    = '读文件 `file`， 指定的格式决定了要读什么。'
-io.tmpfile                 = '如果成功，返回一个临时文件的句柄。'
-io.type                    = '检查 `obj` 是否是合法的文件句柄。'
-io.write                   = '将参数的值逐个写入默认输出文件。'
-openmode.r                 = '读模式。'
-openmode.w                 = '写模式。'
-openmode.a                 = '追加模式。'
-openmode['.r+']            = '更新模式，所有之前的数据都保留。'
-openmode['.w+']            = '更新模式，所有之前的数据都删除。'
-openmode['.a+']            = '追加更新模式，所有之前的数据都保留，只允许在文件尾部做写入。'
-openmode.rb                = '读模式。（二进制方式）'
-openmode.wb                = '写模式。（二进制方式）'
-openmode.ab                = '追加模式。（二进制方式）'
-openmode['.r+b']           = '更新模式，所有之前的数据都保留。（二进制方式）'
-openmode['.w+b']           = '更新模式，所有之前的数据都删除。（二进制方式）'
-openmode['.a+b']           = '追加更新模式，所有之前的数据都保留，只允许在文件尾部做写入。（二进制方式）'
-popenmode.r                = '从这个程序中读取数据。（二进制方式）'
-popenmode.w                = '向这个程序写入输入。（二进制方式）'
-filetype.file              = '是一个打开的文件句柄。'
-filetype['.closed file']   = '是一个关闭的文件句柄。'
-filetype['.nil']           = '不是文件句柄。'
+io.open                    =
+'用字符串 `mode` 指定的模式打开一个文件。'
+io.output                  =
+'设置 `file` 为默认输出文件。'
+io.popen                   =
+'用一个分离进程开启程序 `prog` 。'
+io.read                    =
+'读文件 `file`， 指定的格式决定了要读什么。'
+io.tmpfile                 =
+'如果成功，返回一个临时文件的句柄。'
+io.type                    =
+'检查 `obj` 是否是合法的文件句柄。'
+io.write                   =
+'将参数的值逐个写入默认输出文件。'
+openmode.r                 =
+'读模式。'
+openmode.w                 =
+'写模式。'
+openmode.a                 =
+'追加模式。'
+openmode['.r+']            =
+'更新模式，所有之前的数据都保留。'
+openmode['.w+']            =
+'更新模式，所有之前的数据都删除。'
+openmode['.a+']            =
+'追加更新模式，所有之前的数据都保留，只允许在文件尾部做写入。'
+openmode.rb                =
+'读模式。（二进制方式）'
+openmode.wb                =
+'写模式。（二进制方式）'
+openmode.ab                =
+'追加模式。（二进制方式）'
+openmode['.r+b']           =
+'更新模式，所有之前的数据都保留。（二进制方式）'
+openmode['.w+b']           =
+'更新模式，所有之前的数据都删除。（二进制方式）'
+openmode['.a+b']           =
+'追加更新模式，所有之前的数据都保留，只允许在文件尾部做写入。（二进制方式）'
+popenmode.r                =
+'从这个程序中读取数据。（二进制方式）'
+popenmode.w                =
+'向这个程序写入输入。（二进制方式）'
+filetype.file              =
+'是一个打开的文件句柄。'
+filetype['.closed file']   =
+'是一个关闭的文件句柄。'
+filetype['.nil']           =
+'不是文件句柄。'
 
-math                        = ''
-math.abs                    = '返回 `x` 的绝对值。'
-math.acos                   = '返回 `x` 的反余弦值（用弧度表示）。'
-math.asin                   = '返回 `x` 的反正弦值（用弧度表示）。'
-math.atan['<5.2']           = '返回 `x` 的反正切值（用弧度表示）。'
-math.atan['>5.3']           = '返回 `y/x` 的反正切值（用弧度表示）。'
-math.atan2                  = '返回 `y/x` 的反正切值（用弧度表示）。'
-math.ceil                   = '返回不小于 `x` 的最小整数值。'
-math.cos                    = '返回 `x` 的余弦（假定参数是弧度）。'
-math.cosh                   = '返回 `x` 的双曲余弦（假定参数是弧度）。'
-math.deg                    = '将角 `x` 从弧度转换为角度。'
-math.exp                    = '返回 `e^x` 的值 （e 为自然对数的底）。'
-math.floor                  = '返回不大于 `x` 的最大整数值。'
-math.fmod                   = '返回 `x` 除以 `y`，将商向零圆整后的余数。'
-math.frexp                  = '将 `x` 分解为尾数与指数，返回值符合 `x = m * (2 ^ e)` 。`e` 是一个整数，`m` 是 [0.5, 1) 之间的规格化小数 (`x` 为0时 `m` 为0)。'
-math.huge                   = '一个比任何数字值都大的浮点数。'
-math.ldexp                  = '返回 `m * (2 ^ e)` 。'
-math.log['<5.1']            = '返回 `x` 的自然对数。'
-math.log['>5.2']            = '回以指定底的 `x` 的对数。'
-math.log10                  = '返回 `x` 的以10为底的对数。'
-math.max                    = '返回参数中最大的值， 大小由 Lua 操作 `<` 决定。'
-math.maxinteger             = '最大值的整数。'
-math.min                    = '返回参数中最小的值， 大小由 Lua 操作 `<` 决定。'
-math.mininteger             = '最小值的整数。'
-math.modf                   = '返回 `x` 的整数部分和小数部分。'
-math.pi                     = '*π* 的值。'
-math.pow                    = '返回 `x ^ y` 。'
-math.rad                    = '将角 `x` 从角度转换为弧度。'
-math.random                 = [[
+math                        =
+''
+math.abs                    =
+'返回 `x` 的绝对值。'
+math.acos                   =
+'返回 `x` 的反余弦值（用弧度表示）。'
+math.asin                   =
+'返回 `x` 的反正弦值（用弧度表示）。'
+math.atan['<5.2']           =
+'返回 `x` 的反正切值（用弧度表示）。'
+math.atan['>5.3']           =
+'返回 `y/x` 的反正切值（用弧度表示）。'
+math.atan2                  =
+'返回 `y/x` 的反正切值（用弧度表示）。'
+math.ceil                   =
+'返回不小于 `x` 的最小整数值。'
+math.cos                    =
+'返回 `x` 的余弦（假定参数是弧度）。'
+math.cosh                   =
+'返回 `x` 的双曲余弦（假定参数是弧度）。'
+math.deg                    =
+'将角 `x` 从弧度转换为角度。'
+math.exp                    =
+'返回 `e^x` 的值 （e 为自然对数的底）。'
+math.floor                  =
+'返回不大于 `x` 的最大整数值。'
+math.fmod                   =
+'返回 `x` 除以 `y`，将商向零圆整后的余数。'
+math.frexp                  =
+'将 `x` 分解为尾数与指数，返回值符合 `x = m * (2 ^ e)` 。`e` 是一个整数，`m` 是 [0.5, 1) 之间的规格化小数 (`x` 为0时 `m` 为0)。'
+math.huge                   =
+'一个比任何数字值都大的浮点数。'
+math.ldexp                  =
+'返回 `m * (2 ^ e)` 。'
+math.log['<5.1']            =
+'返回 `x` 的自然对数。'
+math.log['>5.2']            =
+'回以指定底的 `x` 的对数。'
+math.log10                  =
+'返回 `x` 的以10为底的对数。'
+math.max                    =
+'返回参数中最大的值， 大小由 Lua 操作 `<` 决定。'
+math.maxinteger             =
+'最大值的整数。'
+math.min                    =
+'返回参数中最小的值， 大小由 Lua 操作 `<` 决定。'
+math.mininteger             =
+'最小值的整数。'
+math.modf                   =
+'返回 `x` 的整数部分和小数部分。'
+math.pi                     =
+'*π* 的值。'
+math.pow                    =
+'返回 `x ^ y` 。'
+math.rad                    =
+'将角 `x` 从角度转换为弧度。'
+math.random                 =
+[[
 * `math.random()`: 返回 [0,1) 区间内一致分布的浮点伪随机数。
 * `math.random(n)`: 返回 [1, n] 区间内一致分布的整数伪随机数。
 * `math.random(m, n)`: 返回 [m, n] 区间内一致分布的整数伪随机数。
 ]]
-math.randomseed['<5.3']     = '把 `x` 设为伪随机数发生器的“种子”： 相同的种子产生相同的随机数列。'
-math.randomseed['>5.4']     = [[
+math.randomseed['<5.3']     =
+'把 `x` 设为伪随机数发生器的“种子”： 相同的种子产生相同的随机数列。'
+math.randomseed['>5.4']     =
+[[
 * `math.randomseed(x, y)`: 将 `x` 与 `y` 连接为128位的种子来重新初始化伪随机生成器。
 * `math.randomseed(x)`: 等同于 `math.randomseed(x, 0)` 。
 * `math.randomseed()`: Generates a seed with a weak attempt for randomness.（不会翻）
 ]]
-math.sin                    = '返回 `x` 的正弦值（假定参数是弧度）。'
-math.sinh                   = '返回 `x` 的双曲正弦值（假定参数是弧度）。'
-math.sqrt                   = '返回 `x` 的平方根。'
-math.tan                    = '返回 `x` 的正切值（假定参数是弧度）。'
-math.tanh                   = '返回 `x` 的双曲正切值（假定参数是弧度）。'
-math.tointeger              = '如果 `x` 可以转换为一个整数， 返回该整数。'
-math.type                   = '如果 `x` 是整数，返回 `"integer"`， 如果它是浮点数，返回 `"float"`， 如果 `x` 不是数字，返回 `nil`。'
-math.ult                    = '如果整数 `m` 和 `n` 以无符号整数形式比较， `m` 在 `n` 之下，返回布尔真否则返回假。'
+math.sin                    =
+'返回 `x` 的正弦值（假定参数是弧度）。'
+math.sinh                   =
+'返回 `x` 的双曲正弦值（假定参数是弧度）。'
+math.sqrt                   =
+'返回 `x` 的平方根。'
+math.tan                    =
+'返回 `x` 的正切值（假定参数是弧度）。'
+math.tanh                   =
+'返回 `x` 的双曲正切值（假定参数是弧度）。'
+math.tointeger              =
+'如果 `x` 可以转换为一个整数， 返回该整数。'
+math.type                   =
+'如果 `x` 是整数，返回 `"integer"`， 如果它是浮点数，返回 `"float"`， 如果 `x` 不是数字，返回 `nil`。'
+math.ult                    =
+'如果整数 `m` 和 `n` 以无符号整数形式比较， `m` 在 `n` 之下，返回布尔真否则返回假。'
 
-os                          = ''
-os.clock                    = '返回程序使用的按秒计 CPU 时间的近似值。'
-os.date                     = '返回一个包含日期及时刻的字符串或表。 格式化方法取决于所给字符串 `format`。'
-os.difftime                 = '返回以秒计算的时刻 `t1` 到 `t2` 的差值。'
-os.execute                  = '调用系统解释器执行 `command`。'
-os.exit['<5.1']             = '调用 C 函数 `exit` 终止宿主程序。'
-os.exit['>5.2']             = '调用 ISO C 函数 `exit` 终止宿主程序。'
-os.getenv                   = '返回进程环境变量 `varname` 的值。'
-os.remove                   = '删除指定名字的文件。'
-os.rename                   = '将名字为 `oldname` 的文件或目录更名为 `newname`。'
-os.setlocale                = '设置程序的当前区域。'
-os.time                     = '当不传参数时，返回当前时刻。 如果传入一张表，就返回由这张表表示的时刻。'
-os.tmpname                  = '返回一个可用于临时文件的文件名字符串。'
-osdate.year                 = '四位数字'
-osdate.month                = '1-12'
-osdate.day                  = '1-31'
-osdate.hour                 = '0-23'
-osdate.min                  = '0-59'
-osdate.sec                  = '0-61'
-osdate.wday                 = '星期几，1-7，星期天为 1'
-osdate.yday                 = '当年的第几天，1-366'
-osdate.isdst                = '夏令时标记，一个布尔量'
+os                          =
+''
+os.clock                    =
+'返回程序使用的按秒计 CPU 时间的近似值。'
+os.date                     =
+'返回一个包含日期及时刻的字符串或表。 格式化方法取决于所给字符串 `format`。'
+os.difftime                 =
+'返回以秒计算的时刻 `t1` 到 `t2` 的差值。'
+os.execute                  =
+'调用系统解释器执行 `command`。'
+os.exit['<5.1']             =
+'调用 C 函数 `exit` 终止宿主程序。'
+os.exit['>5.2']             =
+'调用 ISO C 函数 `exit` 终止宿主程序。'
+os.getenv                   =
+'返回进程环境变量 `varname` 的值。'
+os.remove                   =
+'删除指定名字的文件。'
+os.rename                   =
+'将名字为 `oldname` 的文件或目录更名为 `newname`。'
+os.setlocale                =
+'设置程序的当前区域。'
+os.time                     =
+'当不传参数时，返回当前时刻。 如果传入一张表，就返回由这张表表示的时刻。'
+os.tmpname                  =
+'返回一个可用于临时文件的文件名字符串。'
+osdate.year                 =
+'四位数字'
+osdate.month                =
+'1-12'
+osdate.day                  =
+'1-31'
+osdate.hour                 =
+'0-23'
+osdate.min                  =
+'0-59'
+osdate.sec                  =
+'0-61'
+osdate.wday                 =
+'星期几，1-7，星期天为 1'
+osdate.yday                 =
+'当年的第几天，1-366'
+osdate.isdst                =
+'夏令时标记，一个布尔量'
 
-package                     = ''
-require['<5.3']             = '加载一个模块，返回该模块的返回值（`nil`时为`true`）。'
-require['>5.4']             = '加载一个模块，返回该模块的返回值（`nil`时为`true`）与搜索器返回的加载数据。默认搜索器的加载数据指示了加载位置，对于文件来说就是文件路径。'
-package.config              = '一个描述有一些为包管理准备的编译期配置信息的串。'
-package.cpath               = '这个路径被 `require` 在 C 加载器中做搜索时用到。'
-package.loaded              = '用于 `require` 控制哪些模块已经被加载的表。'
-package.loaders             = '用于 `require` 控制如何加载模块的表。'
-package.loadlib             = '让宿主程序动态链接 C 库 `libname` 。'
-package.path                = '这个路径被 `require` 在 Lua 加载器中做搜索时用到。'
-package.preload             = '保存有一些特殊模块的加载器。'
-package.searchers           = '用于 `require` 控制如何加载模块的表。'
-package.searchpath          = '在指定 `path` 中搜索指定的 `name` 。'
-package.seeall              = '给 `module` 设置一个元表，该元表的 `__index` 域为全局环境，这样模块便会继承全局环境的值。可作为 `module` 函数的选项。'
+package                     =
+''
+require['<5.3']             =
+'加载一个模块，返回该模块的返回值（`nil`时为`true`）。'
+require['>5.4']             =
+'加载一个模块，返回该模块的返回值（`nil`时为`true`）与搜索器返回的加载数据。默认搜索器的加载数据指示了加载位置，对于文件来说就是文件路径。'
+package.config              =
+'一个描述有一些为包管理准备的编译期配置信息的串。'
+package.cpath               =
+'这个路径被 `require` 在 C 加载器中做搜索时用到。'
+package.loaded              =
+'用于 `require` 控制哪些模块已经被加载的表。'
+package.loaders             =
+'用于 `require` 控制如何加载模块的表。'
+package.loadlib             =
+'让宿主程序动态链接 C 库 `libname` 。'
+package.path                =
+'这个路径被 `require` 在 Lua 加载器中做搜索时用到。'
+package.preload             =
+'保存有一些特殊模块的加载器。'
+package.searchers           =
+'用于 `require` 控制如何加载模块的表。'
+package.searchpath          =
+'在指定 `path` 中搜索指定的 `name` 。'
+package.seeall              =
+'给 `module` 设置一个元表，该元表的 `__index` 域为全局环境，这样模块便会继承全局环境的值。可作为 `module` 函数的选项。'
 
-string                      = ''
-string.byte                 = '返回字符 `s[i]`， `s[i+1]`， ...　，`s[j]` 的内部数字编码。'
-string.char                 = '接收零或更多的整数。 返回和参数数量相同长度的字符串。 其中每个字符的内部编码值等于对应的参数值。'
-string.dump                 = '返回包含有以二进制方式表示的（一个 *二进制代码块* ）指定函数的字符串。'
-string.find                 = '查找第一个字符串中匹配到的 `pattern`（参见 §6.4.1）。'
-string.format               = '返回不定数量参数的格式化版本，格式化串为第一个参数。'
-string.gmatch               = [[
+string                      =
+''
+string.byte                 =
+'返回字符 `s[i]`， `s[i+1]`， ...　，`s[j]` 的内部数字编码。'
+string.char                 =
+'接收零或更多的整数。 返回和参数数量相同长度的字符串。 其中每个字符的内部编码值等于对应的参数值。'
+string.dump                 =
+'返回包含有以二进制方式表示的（一个 *二进制代码块* ）指定函数的字符串。'
+string.find                 =
+'查找第一个字符串中匹配到的 `pattern`（参见 §6.4.1）。'
+string.format               =
+'返回不定数量参数的格式化版本，格式化串为第一个参数。'
+string.gmatch               =
+[[
 返回一个迭代器函数。 每次调用这个函数都会继续以 `pattern` （参见　§6.4.1） 对 s 做匹配，并返回所有捕获到的值。
 
 下面这个例子会循环迭代字符串 s 中所有的单词， 并逐行打印：
 ```lua
-    s = "hello world from Lua"
+    s =
+"hello world from Lua"
     for w in string.gmatch(s, "%a+") do
         print(w)
     end
 ```
 ]]
-string.gsub                 = '将字符串 s 中，所有的（或是在 n 给出时的前 n 个） pattern （参见 §6.4.1）都替换成 repl ，并返回其副本。'
-string.len                  = '返回其长度。'
-string.lower                = '将其中的大写字符都转为小写后返回其副本。'
-string.match                = '在字符串 s 中找到第一个能用 pattern （参见 §6.4.1）匹配到的部分。 如果能找到，match 返回其中的捕获物； 否则返回 nil 。'
-string.pack                 = '返回一个打包了（即以二进制形式序列化） v1, v2 等值的二进制字符串。 字符串 fmt 为打包格式（参见 §6.4.2）。'
-string.packsize             = [[返回以指定格式用 $string.pack 打包的字符串的长度。 格式化字符串中不可以有变长选项 's' 或 'z' （参见 §6.4.2）。]]
-string.rep['<5.1']          = '返回 `n` 个字符串 `s` 连在一起的字符串。 如果 `n` 不是正数则返回空串。'
-string.rep['>5.2']          = '返回 `n` 个字符串 `s` 以字符串 `sep` 为分割符连在一起的字符串。 默认的 `sep` 值为空字符串（即没有分割符）。 如果 `n` 不是正数则返回空串。'
-string.reverse              = '返回字符串 s 的翻转串。'
-string.sub                  = '返回字符串的子串， 该子串从 `i` 开始到 `j` 为止。'
-string.unpack               = '返回以格式 fmt （参见 §6.4.2） 打包在字符串 s （参见 string.pack） 中的值。'
-string.upper                = '接收一个字符串，将其中的小写字符都转为大写后返回其副本。'
+string.gsub                 =
+'将字符串 s 中，所有的（或是在 n 给出时的前 n 个） pattern （参见 §6.4.1）都替换成 repl ，并返回其副本。'
+string.len                  =
+'返回其长度。'
+string.lower                =
+'将其中的大写字符都转为小写后返回其副本。'
+string.match                =
+'在字符串 s 中找到第一个能用 pattern （参见 §6.4.1）匹配到的部分。 如果能找到，match 返回其中的捕获物； 否则返回 nil 。'
+string.pack                 =
+'返回一个打包了（即以二进制形式序列化） v1, v2 等值的二进制字符串。 字符串 fmt 为打包格式（参见 §6.4.2）。'
+string.packsize             =
+[[返回以指定格式用 $string.pack 打包的字符串的长度。 格式化字符串中不可以有变长选项 's' 或 'z' （参见 §6.4.2）。]]
+string.rep['<5.1']          =
+'返回 `n` 个字符串 `s` 连在一起的字符串。 如果 `n` 不是正数则返回空串。'
+string.rep['>5.2']          =
+'返回 `n` 个字符串 `s` 以字符串 `sep` 为分割符连在一起的字符串。 默认的 `sep` 值为空字符串（即没有分割符）。 如果 `n` 不是正数则返回空串。'
+string.reverse              =
+'返回字符串 s 的翻转串。'
+string.sub                  =
+'返回字符串的子串， 该子串从 `i` 开始到 `j` 为止。'
+string.unpack               =
+'返回以格式 fmt （参见 §6.4.2） 打包在字符串 s （参见 string.pack） 中的值。'
+string.upper                =
+'接收一个字符串，将其中的小写字符都转为大写后返回其副本。'
 
-table                       = ''
-table.concat                = '提供一个列表，其所有元素都是字符串或数字，返回字符串 `list[i]..sep..list[i+1] ··· sep..list[j]`。'
-table.insert                = '在 `list` 的位置 `pos` 处插入元素 `value`。'
-table.maxn                  = '返回给定表的最大正数索引，如果表没有正数索引，则返回零。'
-table.move                  = [[
+table                       =
+''
+table.concat                =
+'提供一个列表，其所有元素都是字符串或数字，返回字符串 `list[i]..sep..list[i+1] ··· sep..list[j]`。'
+table.insert                =
+'在 `list` 的位置 `pos` 处插入元素 `value`。'
+table.maxn                  =
+'返回给定表的最大正数索引，如果表没有正数索引，则返回零。'
+table.move                  =
+[[
 将元素从表 `a1` 移到表 `a2`。
 ```lua
-a2[t],··· = a1[f],···,a1[e]
+a2[t],··· =
+a1[f],···,a1[e]
 return a2
 ```
 ]]
-table.pack                  = '返回用所有参数以键 `1`,`2`, 等填充的新表， 并将 `"n"` 这个域设为参数的总数。'
-table.remove                = '移除 `list` 中 `pos` 位置上的元素，并返回这个被移除的值。'
-table.sort                  = '在表内从 `list[1]` 到 `list[#list]` *原地* 对其间元素按指定次序排序。'
-table.unpack                = [[
+table.pack                  =
+'返回用所有参数以键 `1`,`2`, 等填充的新表， 并将 `"n"` 这个域设为参数的总数。'
+table.remove                =
+'移除 `list` 中 `pos` 位置上的元素，并返回这个被移除的值。'
+table.sort                  =
+'在表内从 `list[1]` 到 `list[#list]` *原地* 对其间元素按指定次序排序。'
+table.unpack                =
+[[
 返回列表中的元素。 这个函数等价于
 ```lua
     return list[i], list[i+1], ···, list[j]
@@ -391,10 +656,14 @@ table.unpack                = [[
 i 默认为 1 ，j 默认为 #list。
 ]]
 
-utf8                        = ''
-utf8.char                   = '接收零或多个整数， 将每个整数转换成对应的 UTF-8 字节序列，并返回这些序列连接到一起的字符串。'
-utf8.charpattern            = '用于精确匹配到一个 UTF-8 字节序列的模式，它假定处理的对象是一个合法的 UTF-8 字符串。'
-utf8.codes                  = [[
+utf8                        =
+''
+utf8.char                   =
+'接收零或多个整数， 将每个整数转换成对应的 UTF-8 字节序列，并返回这些序列连接到一起的字符串。'
+utf8.charpattern            =
+'用于精确匹配到一个 UTF-8 字节序列的模式，它假定处理的对象是一个合法的 UTF-8 字符串。'
+utf8.codes                  =
+[[
 返回一系列的值，可以让
 ```lua
 for p, c in utf8.codes(s) do
@@ -403,6 +672,9 @@ end
 ```
 迭代出字符串 s 中所有的字符。 这里的 p 是位置（按字节数）而 c 是每个字符的编号。 如果处理到一个不合法的字节序列，将抛出一个错误。
 ]]
-utf8.codepoint              = '以整数形式返回 `s` 中 从位置 `i` 到 `j` 间（包括两端） 所有字符的编号。'
-utf8.len                    = '返回字符串 `s` 中 从位置 `i` 到 `j` 间 （包括两端） UTF-8 字符的个数。'
-utf8.offset                 = '返回编码在 `s` 中的第 `n` 个字符的开始位置（按字节数） （从位置 `i` 处开始统计）。'
+utf8.codepoint              =
+'以整数形式返回 `s` 中 从位置 `i` 到 `j` 间（包括两端） 所有字符的编号。'
+utf8.len                    =
+'返回字符串 `s` 中 从位置 `i` 到 `j` 间 （包括两端） UTF-8 字符的个数。'
+utf8.offset                 =
+'返回编码在 `s` 中的第 `n` 个字符的开始位置（按字节数） （从位置 `i` 处开始统计）。'
diff --git a/locale/zh-cn/script.lua b/locale/zh-cn/script.lua
index 7b2f8852..8c944e99 100644
--- a/locale/zh-cn/script.lua
+++ b/locale/zh-cn/script.lua
@@ -1,271 +1,512 @@
-DIAG_LINE_ONLY_SPACE    = '只有空格的空行。'
-DIAG_LINE_POST_SPACE    = '后置空格。'
-DIAG_UNUSED_LOCAL       = '未使用的局部变量 `{}`。'
-DIAG_UNDEF_GLOBAL       = '未定义的全局变量 `{}`。'
-DIAG_UNDEF_FIELD        = '未定义的属性/字段 `{}`。'
-DIAG_UNDEF_ENV_CHILD    = '未定义的变量 `{}`（重载了 `_ENV` ）。'
-DIAG_UNDEF_FENV_CHILD   = '未定义的变量 `{}`（处于模块中）。'
-DIAG_GLOBAL_IN_NIL_ENV  = '不能使用全局变量（`_ENV`被置为了`nil`）。'
-DIAG_GLOBAL_IN_NIL_FENV = '不能使用全局变量（模块被置为了`nil`）。'
-DIAG_UNUSED_LABEL       = '未使用的标签 `{}`。'
-DIAG_UNUSED_FUNCTION    = '未使用的函数。'
-DIAG_UNUSED_VARARG      = '未使用的不定参数。'
-DIAG_REDEFINED_LOCAL    = '重定义局部变量 `{}`。'
-DIAG_DUPLICATE_INDEX    = '重复的索引 `{}`。'
-DIAG_DUPLICATE_METHOD   = '重复的方法 `{}`。'
-DIAG_PREVIOUS_CALL      = '会被解释为 `{}{}`。你可能需要加一个 `;`。'
-DIAG_PREFIELD_CALL      = '会被解释为 `{}{}`。你可能需要加一个`,`或`;`。'
-DIAG_OVER_MAX_ARGS      = '函数只接收 {:d} 个参数，但你传了 {:d} 个。'
-DIAG_OVER_MAX_VALUES    = '只有 {} 个变量，但你设置了 {} 个值。'
-DIAG_AMBIGUITY_1        = '会优先运算 `{}`，你可能需要加个括号。'
-DIAG_LOWERCASE_GLOBAL   = '首字母小写的全局变量，你是否漏了 `local` 或是有拼写错误？'
-DIAG_EMPTY_BLOCK        = '空代码块'
-DIAG_DIAGNOSTICS        = 'Lua 诊断'
-DIAG_SYNTAX_CHECK       = 'Lua 语法检查'
-DIAG_NEED_VERSION       = '在 {} 中是合法的，当前为 {}'
-DIAG_DEFINED_VERSION    = '在 {} 中有定义，当前为 {}'
-DIAG_DEFINED_CUSTOM     = '在 {} 中有定义'
-DIAG_DUPLICATE_CLASS    = '重复定义的 Class `{}`。'
-DIAG_UNDEFINED_CLASS    = '未定义的 Class `{}`。'
-DIAG_CYCLIC_EXTENDS     = '循环继承。'
-DIAG_INEXISTENT_PARAM   = '不存在的参数。'
-DIAG_DUPLICATE_PARAM    = '重复的参数。'
-DIAG_NEED_CLASS         = '需要先定义 Class 。'
-DIAG_DUPLICATE_SET_FIELD= '重复定义的字段 `{}`。'
-DIAG_SET_CONST          = '不能对常量赋值。'
-DIAG_SET_FOR_STATE      = '修改了循环变量。'
-DIAG_CODE_AFTER_BREAK   = '无法执行到 `break` 后的代码。'
-DIAG_UNBALANCED_ASSIGNMENTS = '由于值的数量不够而被赋值为了 `nil` 。在Lua中, `x, y = 1` 等价于 `x, y = 1, nil` 。'
-DIAG_REQUIRE_LIKE       = '你可以在设置中将 `{}` 视为 `require`。'
-DIAG_COSE_NON_OBJECT    = '无法 close 此类型的值。（除非给此类型设置 `__close` 元方法）'
-DIAG_COUNT_DOWN_LOOP    = '你的意思是 `{}` 吗？'
-DIAG_IMPLICIT_ANY       = '无法推测出类型。'
-DIAG_DEPRECATED         = '已废弃。'
-DIAG_DIFFERENT_REQUIRES = '使用了不同的名字 require 了同一个文件。'
-DIAG_REDUNDANT_RETURN   = '冗余返回。'
-DIAG_AWAIT_IN_SYNC      = '只能在标记为异步的函数中调用异步函数。'
-DIAG_NOT_YIELDABLE      = '此函数的第 {} 个参数没有被标记为可让出，但是传入了异步函数。（使用 `---@param name async fun()` 来标记为可让出）'
-DIAG_DISCARD_RETURNS    = '不能丢弃此函数的返回值。'
+DIAG_LINE_ONLY_SPACE    =
+'只有空格的空行。'
+DIAG_LINE_POST_SPACE    =
+'后置空格。'
+DIAG_UNUSED_LOCAL       =
+'未使用的局部变量 `{}`。'
+DIAG_UNDEF_GLOBAL       =
+'未定义的全局变量 `{}`。'
+DIAG_UNDEF_FIELD        =
+'未定义的属性/字段 `{}`。'
+DIAG_UNDEF_ENV_CHILD    =
+'未定义的变量 `{}`（重载了 `_ENV` ）。'
+DIAG_UNDEF_FENV_CHILD   =
+'未定义的变量 `{}`（处于模块中）。'
+DIAG_GLOBAL_IN_NIL_ENV  =
+'不能使用全局变量（`_ENV`被置为了`nil`）。'
+DIAG_GLOBAL_IN_NIL_FENV =
+'不能使用全局变量（模块被置为了`nil`）。'
+DIAG_UNUSED_LABEL       =
+'未使用的标签 `{}`。'
+DIAG_UNUSED_FUNCTION    =
+'未使用的函数。'
+DIAG_UNUSED_VARARG      =
+'未使用的不定参数。'
+DIAG_REDEFINED_LOCAL    =
+'重定义局部变量 `{}`。'
+DIAG_DUPLICATE_INDEX    =
+'重复的索引 `{}`。'
+DIAG_DUPLICATE_METHOD   =
+'重复的方法 `{}`。'
+DIAG_PREVIOUS_CALL      =
+'会被解释为 `{}{}`。你可能需要加一个 `;`。'
+DIAG_PREFIELD_CALL      =
+'会被解释为 `{}{}`。你可能需要加一个`,`或`;`。'
+DIAG_OVER_MAX_ARGS      =
+'函数只接收 {:d} 个参数，但你传了 {:d} 个。'
+DIAG_OVER_MAX_VALUES    =
+'只有 {} 个变量，但你设置了 {} 个值。'
+DIAG_AMBIGUITY_1        =
+'会优先运算 `{}`，你可能需要加个括号。'
+DIAG_LOWERCASE_GLOBAL   =
+'首字母小写的全局变量，你是否漏了 `local` 或是有拼写错误？'
+DIAG_EMPTY_BLOCK        =
+'空代码块'
+DIAG_DIAGNOSTICS        =
+'Lua 诊断'
+DIAG_SYNTAX_CHECK       =
+'Lua 语法检查'
+DIAG_NEED_VERSION       =
+'在 {} 中是合法的，当前为 {}'
+DIAG_DEFINED_VERSION    =
+'在 {} 中有定义，当前为 {}'
+DIAG_DEFINED_CUSTOM     =
+'在 {} 中有定义'
+DIAG_DUPLICATE_CLASS    =
+'重复定义的 Class `{}`。'
+DIAG_UNDEFINED_CLASS    =
+'未定义的 Class `{}`。'
+DIAG_CYCLIC_EXTENDS     =
+'循环继承。'
+DIAG_INEXISTENT_PARAM   =
+'不存在的参数。'
+DIAG_DUPLICATE_PARAM    =
+'重复的参数。'
+DIAG_NEED_CLASS         =
+'需要先定义 Class 。'
+DIAG_DUPLICATE_SET_FIELD=
+'重复定义的字段 `{}`。'
+DIAG_SET_CONST          =
+'不能对常量赋值。'
+DIAG_SET_FOR_STATE      =
+'修改了循环变量。'
+DIAG_CODE_AFTER_BREAK   =
+'无法执行到 `break` 后的代码。'
+DIAG_UNBALANCED_ASSIGNMENTS =
+'由于值的数量不够而被赋值为了 `nil` 。在Lua中, `x, y = 1` 等价于 `x, y = 1, nil` 。'
+DIAG_REQUIRE_LIKE       =
+'你可以在设置中将 `{}` 视为 `require`。'
+DIAG_COSE_NON_OBJECT    =
+'无法 close 此类型的值。（除非给此类型设置 `__close` 元方法）'
+DIAG_COUNT_DOWN_LOOP    =
+'你的意思是 `{}` 吗？'
+DIAG_IMPLICIT_ANY       =
+'无法推测出类型。'
+DIAG_DEPRECATED         =
+'已废弃。'
+DIAG_DIFFERENT_REQUIRES =
+'使用了不同的名字 require 了同一个文件。'
+DIAG_REDUNDANT_RETURN   =
+'冗余返回。'
+DIAG_AWAIT_IN_SYNC      =
+'只能在标记为异步的函数中调用异步函数。'
+DIAG_NOT_YIELDABLE      =
+'此函数的第 {} 个参数没有被标记为可让出，但是传入了异步函数。（使用 `---@param name async fun()` 来标记为可让出）'
+DIAG_DISCARD_RETURNS    =
+'不能丢弃此函数的返回值。'
 
-DIAG_CIRCLE_DOC_CLASS                 = '循环继承的类。'
-DIAG_DOC_FIELD_NO_CLASS               = '字段必须定义在类之后。'
-DIAG_DUPLICATE_DOC_CLASS              = '重复定义的类 `{}`。'
-DIAG_DUPLICATE_DOC_FIELD              = '重复定义的字段 `{}`。'
-DIAG_DUPLICATE_DOC_PARAM              = '重复指向的参数 `{}`。'
-DIAG_UNDEFINED_DOC_CLASS              = '未定义的类 `{}`。'
-DIAG_UNDEFINED_DOC_NAME               = '未定义的类型或别名 `{}`。'
-DIAG_UNDEFINED_DOC_PARAM              = '指向了未定义的参数 `{}`。'
-DIAG_UNKNOWN_DIAG_CODE                = '未知的诊断代号 `{}`。'
+DIAG_CIRCLE_DOC_CLASS                 =
+'循环继承的类。'
+DIAG_DOC_FIELD_NO_CLASS               =
+'字段必须定义在类之后。'
+DIAG_DUPLICATE_DOC_CLASS              =
+'重复定义的类 `{}`。'
+DIAG_DUPLICATE_DOC_FIELD              =
+'重复定义的字段 `{}`。'
+DIAG_DUPLICATE_DOC_PARAM              =
+'重复指向的参数 `{}`。'
+DIAG_UNDEFINED_DOC_CLASS              =
+'未定义的类 `{}`。'
+DIAG_UNDEFINED_DOC_NAME               =
+'未定义的类型或别名 `{}`。'
+DIAG_UNDEFINED_DOC_PARAM              =
+'指向了未定义的参数 `{}`。'
+DIAG_UNKNOWN_DIAG_CODE                =
+'未知的诊断代号 `{}`。'
 
-MWS_NOT_SUPPORT         = '{} 目前还不支持多工作目录，我可能需要重启才能支持新的工作目录...'
-MWS_RESTART             = '重启'
-MWS_NOT_COMPLETE        = '工作目录还没有准备好，你可以稍后再试一下...'
-MWS_COMPLETE            = '工作目录准备好了，你可以再试一下了...'
-MWS_MAX_PRELOAD         = '预加载文件数已达上限（{}），你需要手动打开需要加载的文件。'
-MWS_UCONFIG_FAILED      = '用户配置保存失败。'
-MWS_UCONFIG_UPDATED     = '用户配置已更新。'
-MWS_WCONFIG_UPDATED     = '工作区配置已更新。'
+MWS_NOT_SUPPORT         =
+'{} 目前还不支持多工作目录，我可能需要重启才能支持新的工作目录...'
+MWS_RESTART             =
+'重启'
+MWS_NOT_COMPLETE        =
+'工作目录还没有准备好，你可以稍后再试一下...'
+MWS_COMPLETE            =
+'工作目录准备好了，你可以再试一下了...'
+MWS_MAX_PRELOAD         =
+'预加载文件数已达上限（{}），你需要手动打开需要加载的文件。'
+MWS_UCONFIG_FAILED      =
+'用户配置保存失败。'
+MWS_UCONFIG_UPDATED     =
+'用户配置已更新。'
+MWS_WCONFIG_UPDATED     =
+'工作区配置已更新。'
 
-WORKSPACE_SKIP_LARGE_FILE = '已跳过过大的文件：{}。当前设置的大小限制为：{} KB，该文件大小为：{} KB'
-WORKSPACE_LOADING         = '正在加载工作目录'
-WORKSPACE_DIAGNOSTIC      = '正在对工作目录进行诊断'
-WORKSPACE_SKIP_HUGE_FILE  = '出于性能考虑，已停止对此文件解析：{}'
+WORKSPACE_SKIP_LARGE_FILE =
+'已跳过过大的文件：{}。当前设置的大小限制为：{} KB，该文件大小为：{} KB'
+WORKSPACE_LOADING         =
+'正在加载工作目录'
+WORKSPACE_DIAGNOSTIC      =
+'正在对工作目录进行诊断'
+WORKSPACE_SKIP_HUGE_FILE  =
+'出于性能考虑，已停止对此文件解析：{}'
 
-PARSER_CRASH            = '语法解析崩溃了！遗言：{}'
-PARSER_UNKNOWN          = '未知语法错误...'
-PARSER_MISS_NAME        = '缺少名称。'
-PARSER_UNKNOWN_SYMBOL   = '未知符号`{symbol}`。'
-PARSER_MISS_SYMBOL      = '缺少符号`{symbol}`。'
-PARSER_MISS_ESC_X       = '必须是2个16进制字符。'
-PARSER_UTF8_SMALL       = '至少有1个字符。'
-PARSER_UTF8_MAX         = '必须在 {min} 与 {max} 之间。'
-PARSER_ERR_ESC          = '错误的转义符。'
-PARSER_MUST_X16         = '必须是16进制字符。'
-PARSER_MISS_EXPONENT    = '缺少指数部分。'
-PARSER_MISS_EXP         = '缺少表达式。'
-PARSER_MISS_FIELD       = '缺少字段/属性名。'
-PARSER_MISS_METHOD      = '缺少方法名。'
-PARSER_ARGS_AFTER_DOTS  = '`...`必须是最后一个参数。'
-PARSER_KEYWORD          = '关键字无法作为名称。'
-PARSER_EXP_IN_ACTION    = '该表达式不能作为语句。'
-PARSER_BREAK_OUTSIDE    = '`break`必须在循环内部。'
-PARSER_MALFORMED_NUMBER = '无法构成有效数字。'
-PARSER_ACTION_AFTER_RETURN = '`return`之后不能再执行代码。'
-PARSER_ACTION_AFTER_BREAK = '`break`之后不能再执行代码。'
-PARSER_NO_VISIBLE_LABEL = '标签`{label}`不可见。'
-PARSER_REDEFINE_LABEL   = '标签`{label}`重复定义。'
-PARSER_UNSUPPORT_SYMBOL = '{version} 不支持该符号。'
-PARSER_UNEXPECT_DOTS    = '`...`只能在不定参函数中使用。'
-PARSER_UNEXPECT_SYMBOL  = '未知的符号 `{symbol}` 。'
-PARSER_UNKNOWN_TAG      = '不支持的属性。'
-PARSER_MULTI_TAG        = '只能设置一个属性。'
-PARSER_UNEXPECT_LFUNC_NAME = '局部函数只能使用标识符作为名称。'
-PARSER_UNEXPECT_EFUNC_NAME = '函数作为表达式时不能命名。'
-PARSER_ERR_LCOMMENT_END = '应使用`{symbol}`来关闭多行注释。'
-PARSER_ERR_C_LONG_COMMENT = 'Lua应使用`--[[ ]]`来进行多行注释。'
-PARSER_ERR_LSTRING_END  = '应使用`{symbol}`来关闭长字符串。'
-PARSER_ERR_ASSIGN_AS_EQ = '应使用`=`来进行赋值操作。'
-PARSER_ERR_EQ_AS_ASSIGN = '应使用`==`来进行等于判断。'
-PARSER_ERR_UEQ          = '应使用`~=`来进行不等于判断。'
-PARSER_ERR_THEN_AS_DO   = '应使用`then`。'
-PARSER_ERR_DO_AS_THEN   = '应使用`do`。'
-PARSER_MISS_END         = '缺少对应的`end`。'
-PARSER_ERR_COMMENT_PREFIX = 'Lua应使用`--`来进行注释。'
-PARSER_MISS_SEP_IN_TABLE = '需要用`,`或`;`进行分割。'
-PARSER_SET_CONST         = '不能对常量赋值。'
-PARSER_UNICODE_NAME      = '包含了 Unicode 字符。'
-PARSER_ERR_NONSTANDARD_SYMBOL = 'Lua中应使用符号 `{symbol}`。'
-PARSER_MISS_SPACE_BETWEEN = '符号之间必须保留空格'
-PARSER_INDEX_IN_FUNC_NAME = '命名函数的名称中不能使用 `[name]` 形式。'
-PARSER_UNKNOWN_ATTRIBUTE  = '局部变量属性应该是 `const` 或 `close`'
+PARSER_CRASH            =
+'语法解析崩溃了！遗言：{}'
+PARSER_UNKNOWN          =
+'未知语法错误...'
+PARSER_MISS_NAME        =
+'缺少名称。'
+PARSER_UNKNOWN_SYMBOL   =
+'未知符号`{symbol}`。'
+PARSER_MISS_SYMBOL      =
+'缺少符号`{symbol}`。'
+PARSER_MISS_ESC_X       =
+'必须是2个16进制字符。'
+PARSER_UTF8_SMALL       =
+'至少有1个字符。'
+PARSER_UTF8_MAX         =
+'必须在 {min} 与 {max} 之间。'
+PARSER_ERR_ESC          =
+'错误的转义符。'
+PARSER_MUST_X16         =
+'必须是16进制字符。'
+PARSER_MISS_EXPONENT    =
+'缺少指数部分。'
+PARSER_MISS_EXP         =
+'缺少表达式。'
+PARSER_MISS_FIELD       =
+'缺少字段/属性名。'
+PARSER_MISS_METHOD      =
+'缺少方法名。'
+PARSER_ARGS_AFTER_DOTS  =
+'`...`必须是最后一个参数。'
+PARSER_KEYWORD          =
+'关键字无法作为名称。'
+PARSER_EXP_IN_ACTION    =
+'该表达式不能作为语句。'
+PARSER_BREAK_OUTSIDE    =
+'`break`必须在循环内部。'
+PARSER_MALFORMED_NUMBER =
+'无法构成有效数字。'
+PARSER_ACTION_AFTER_RETURN =
+'`return`之后不能再执行代码。'
+PARSER_ACTION_AFTER_BREAK =
+'`break`之后不能再执行代码。'
+PARSER_NO_VISIBLE_LABEL =
+'标签`{label}`不可见。'
+PARSER_REDEFINE_LABEL   =
+'标签`{label}`重复定义。'
+PARSER_UNSUPPORT_SYMBOL =
+'{version} 不支持该符号。'
+PARSER_UNEXPECT_DOTS    =
+'`...`只能在不定参函数中使用。'
+PARSER_UNEXPECT_SYMBOL  =
+'未知的符号 `{symbol}` 。'
+PARSER_UNKNOWN_TAG      =
+'不支持的属性。'
+PARSER_MULTI_TAG        =
+'只能设置一个属性。'
+PARSER_UNEXPECT_LFUNC_NAME =
+'局部函数只能使用标识符作为名称。'
+PARSER_UNEXPECT_EFUNC_NAME =
+'函数作为表达式时不能命名。'
+PARSER_ERR_LCOMMENT_END =
+'应使用`{symbol}`来关闭多行注释。'
+PARSER_ERR_C_LONG_COMMENT =
+'Lua应使用`--[[ ]]`来进行多行注释。'
+PARSER_ERR_LSTRING_END  =
+'应使用`{symbol}`来关闭长字符串。'
+PARSER_ERR_ASSIGN_AS_EQ =
+'应使用`=`来进行赋值操作。'
+PARSER_ERR_EQ_AS_ASSIGN =
+'应使用`==`来进行等于判断。'
+PARSER_ERR_UEQ          =
+'应使用`~=`来进行不等于判断。'
+PARSER_ERR_THEN_AS_DO   =
+'应使用`then`。'
+PARSER_ERR_DO_AS_THEN   =
+'应使用`do`。'
+PARSER_MISS_END         =
+'缺少对应的`end`。'
+PARSER_ERR_COMMENT_PREFIX =
+'Lua应使用`--`来进行注释。'
+PARSER_MISS_SEP_IN_TABLE =
+'需要用`,`或`;`进行分割。'
+PARSER_SET_CONST         =
+'不能对常量赋值。'
+PARSER_UNICODE_NAME      =
+'包含了 Unicode 字符。'
+PARSER_ERR_NONSTANDARD_SYMBOL =
+'Lua中应使用符号 `{symbol}`。'
+PARSER_MISS_SPACE_BETWEEN =
+'符号之间必须保留空格'
+PARSER_INDEX_IN_FUNC_NAME =
+'命名函数的名称中不能使用 `[name]` 形式。'
+PARSER_UNKNOWN_ATTRIBUTE  =
+'局部变量属性应该是 `const` 或 `close`'
 
-PARSER_LUADOC_MISS_CLASS_NAME           = '缺少类名称。'
-PARSER_LUADOC_MISS_EXTENDS_SYMBOL       = '缺少符号 `:`。'
-PARSER_LUADOC_MISS_CLASS_EXTENDS_NAME   = '缺少要继承的类名称。'
-PARSER_LUADOC_MISS_SYMBOL               = '缺少符号 `{symbol}`。'
-PARSER_LUADOC_MISS_ARG_NAME             = '缺少参数名称。'
-PARSER_LUADOC_MISS_TYPE_NAME            = '缺少类型名。'
-PARSER_LUADOC_MISS_ALIAS_NAME           = '缺少别名。'
-PARSER_LUADOC_MISS_ALIAS_EXTENDS        = '缺少别名定义。'
-PARSER_LUADOC_MISS_PARAM_NAME           = '缺少要指向的参数名称。'
-PARSER_LUADOC_MISS_PARAM_EXTENDS        = '缺少参数的类型定义。'
-PARSER_LUADOC_MISS_FIELD_NAME           = '缺少字段名称。'
-PARSER_LUADOC_MISS_FIELD_EXTENDS        = '缺少字段的类型定义。'
-PARSER_LUADOC_MISS_GENERIC_NAME         = '缺少泛型名称。'
-PARSER_LUADOC_MISS_GENERIC_EXTENDS_NAME = '缺少泛型要继承的类名称。'
-PARSER_LUADOC_MISS_VARARG_TYPE          = '缺少不定参的类型定义。'
-PARSER_LUADOC_MISS_FUN_AFTER_OVERLOAD   = '缺少关键字 `fun`。'
-PARSER_LUADOC_MISS_CATE_NAME            = '缺少文档类型名称。'
-PARSER_LUADOC_MISS_DIAG_MODE            = '缺少诊断模式'
-PARSER_LUADOC_ERROR_DIAG_MODE           = '诊断模式不正确'
+PARSER_LUADOC_MISS_CLASS_NAME           =
+'缺少类名称。'
+PARSER_LUADOC_MISS_EXTENDS_SYMBOL       =
+'缺少符号 `:`。'
+PARSER_LUADOC_MISS_CLASS_EXTENDS_NAME   =
+'缺少要继承的类名称。'
+PARSER_LUADOC_MISS_SYMBOL               =
+'缺少符号 `{symbol}`。'
+PARSER_LUADOC_MISS_ARG_NAME             =
+'缺少参数名称。'
+PARSER_LUADOC_MISS_TYPE_NAME            =
+'缺少类型名。'
+PARSER_LUADOC_MISS_ALIAS_NAME           =
+'缺少别名。'
+PARSER_LUADOC_MISS_ALIAS_EXTENDS        =
+'缺少别名定义。'
+PARSER_LUADOC_MISS_PARAM_NAME           =
+'缺少要指向的参数名称。'
+PARSER_LUADOC_MISS_PARAM_EXTENDS        =
+'缺少参数的类型定义。'
+PARSER_LUADOC_MISS_FIELD_NAME           =
+'缺少字段名称。'
+PARSER_LUADOC_MISS_FIELD_EXTENDS        =
+'缺少字段的类型定义。'
+PARSER_LUADOC_MISS_GENERIC_NAME         =
+'缺少泛型名称。'
+PARSER_LUADOC_MISS_GENERIC_EXTENDS_NAME =
+'缺少泛型要继承的类名称。'
+PARSER_LUADOC_MISS_VARARG_TYPE          =
+'缺少不定参的类型定义。'
+PARSER_LUADOC_MISS_FUN_AFTER_OVERLOAD   =
+'缺少关键字 `fun`。'
+PARSER_LUADOC_MISS_CATE_NAME            =
+'缺少文档类型名称。'
+PARSER_LUADOC_MISS_DIAG_MODE            =
+'缺少诊断模式'
+PARSER_LUADOC_ERROR_DIAG_MODE           =
+'诊断模式不正确'
 
-SYMBOL_ANONYMOUS        = '<匿名函数>'
+SYMBOL_ANONYMOUS        =
+'<匿名函数>'
 
-HOVER_VIEW_DOCUMENTS    = '查看文档'
+HOVER_VIEW_DOCUMENTS    =
+'查看文档'
 
-HOVER_DOCUMENT_LUA51    = 'http://www.lua.org/manual/5.1/manual.html#{}'
-HOVER_DOCUMENT_LUA52    = 'http://www.lua.org/manual/5.2/manual.html#{}'
-HOVER_DOCUMENT_LUA53    = 'http://cloudwu.github.io/lua53doc/manual.html#{}'
-HOVER_DOCUMENT_LUA54    = 'http://www.lua.org/manual/5.4/manual.html#{}'
-HOVER_DOCUMENT_LUAJIT   = 'http://www.lua.org/manual/5.1/manual.html#{}'
+HOVER_DOCUMENT_LUA51    =
+'http://www.lua.org/manual/5.1/manual.html#{}'
+HOVER_DOCUMENT_LUA52    =
+'http://www.lua.org/manual/5.2/manual.html#{}'
+HOVER_DOCUMENT_LUA53    =
+'http://cloudwu.github.io/lua53doc/manual.html#{}'
+HOVER_DOCUMENT_LUA54    =
+'http://www.lua.org/manual/5.4/manual.html#{}'
+HOVER_DOCUMENT_LUAJIT   =
+'http://www.lua.org/manual/5.1/manual.html#{}'
 
-HOVER_NATIVE_DOCUMENT_LUA51     = 'command:extension.lua.doc?["en-us/51/manual.html/{}"]'
-HOVER_NATIVE_DOCUMENT_LUA52     = 'command:extension.lua.doc?["en-us/52/manual.html/{}"]'
-HOVER_NATIVE_DOCUMENT_LUA53     = 'command:extension.lua.doc?["zh-cn/53/manual.html/{}"]'
-HOVER_NATIVE_DOCUMENT_LUA54     = 'command:extension.lua.doc?["en-us/54/manual.html/{}"]'
-HOVER_NATIVE_DOCUMENT_LUAJIT    = 'command:extension.lua.doc?["en-us/51/manual.html/{}"]'
+HOVER_NATIVE_DOCUMENT_LUA51     =
+'command:extension.lua.doc?["en-us/51/manual.html/{}"]'
+HOVER_NATIVE_DOCUMENT_LUA52     =
+'command:extension.lua.doc?["en-us/52/manual.html/{}"]'
+HOVER_NATIVE_DOCUMENT_LUA53     =
+'command:extension.lua.doc?["zh-cn/53/manual.html/{}"]'
+HOVER_NATIVE_DOCUMENT_LUA54     =
+'command:extension.lua.doc?["en-us/54/manual.html/{}"]'
+HOVER_NATIVE_DOCUMENT_LUAJIT    =
+'command:extension.lua.doc?["en-us/51/manual.html/{}"]'
 
-HOVER_MULTI_PROTOTYPE      = '({} 个原型)'
-HOVER_STRING_BYTES         = '{} 个字节'
-HOVER_STRING_CHARACTERS    = '{} 个字节，{} 个字符'
-HOVER_MULTI_DEF_PROTO      = '({} 个定义，{} 个原型)'
-HOVER_MULTI_PROTO_NOT_FUNC = '({} 个非函数定义)'
+HOVER_MULTI_PROTOTYPE      =
+'({} 个原型)'
+HOVER_STRING_BYTES         =
+'{} 个字节'
+HOVER_STRING_CHARACTERS    =
+'{} 个字节，{} 个字符'
+HOVER_MULTI_DEF_PROTO      =
+'({} 个定义，{} 个原型)'
+HOVER_MULTI_PROTO_NOT_FUNC =
+'({} 个非函数定义)'
 
-HOVER_USE_LUA_PATH      = '（搜索路径： `{}`）'
-HOVER_EXTENDS           = '展开为 {}'
-HOVER_TABLE_TIME_UP     = '出于性能考虑，已禁用了部分类型推断。'
-HOVER_WS_LOADING        = '正在加载工作目录：{} / {}'
+HOVER_USE_LUA_PATH      =
+'（搜索路径： `{}`）'
+HOVER_EXTENDS           =
+'展开为 {}'
+HOVER_TABLE_TIME_UP     =
+'出于性能考虑，已禁用了部分类型推断。'
+HOVER_WS_LOADING        =
+'正在加载工作目录：{} / {}'
 
-ACTION_DISABLE_DIAG     = '在工作区禁用诊断 ({})。'
-ACTION_MARK_GLOBAL      = '标记 `{}` 为已定义的全局变量。'
-ACTION_REMOVE_SPACE     = '清除所有后置空格。'
-ACTION_ADD_SEMICOLON    = '添加 `;` 。'
-ACTION_ADD_BRACKETS     = '添加括号。'
-ACTION_RUNTIME_VERSION  = '修改运行版本为 {} 。'
-ACTION_OPEN_LIBRARY     = '加载 {} 中的全局变量。'
-ACTION_ADD_DO_END       = '添加 `do ... end` 。'
-ACTION_FIX_LCOMMENT_END = '改用正确的多行注释关闭符号。'
-ACTION_ADD_LCOMMENT_END = '关闭多行注释。'
-ACTION_FIX_C_LONG_COMMENT = '修改为 Lua 的多行注释格式。'
-ACTION_FIX_LSTRING_END  = '改用正确的长字符串关闭符号。'
-ACTION_ADD_LSTRING_END  = '关闭长字符串。'
-ACTION_FIX_ASSIGN_AS_EQ = '改为 `=` 。'
-ACTION_FIX_EQ_AS_ASSIGN = '改为 `==` 。'
-ACTION_FIX_UEQ          = '改为 `~=` 。'
-ACTION_FIX_THEN_AS_DO   = '改为 `then` 。'
-ACTION_FIX_DO_AS_THEN   = '改为 `do` 。'
-ACTION_ADD_END          = '添加 `end` （根据缩进推测添加位置）。'
-ACTION_FIX_COMMENT_PREFIX = '改为 `--` 。'
-ACTION_FIX_NONSTANDARD_SYMBOL = '改为 `{symbol}`'
-ACTION_RUNTIME_UNICODE_NAME = '允许使用 Unicode 字符。'
-ACTION_SWAP_PARAMS      = '将其改为 `{node}` 的第 {index} 个参数'
-ACTION_FIX_INSERT_SPACE = '插入空格'
-ACTION_JSON_TO_LUA      = '把 JSON 转成 Lua'
-ACTION_DISABLE_DIAG_LINE= '在此行禁用诊断 ({})。'
-ACTION_DISABLE_DIAG_FILE= '在此文件禁用诊断 ({})。'
-ACTION_MARK_ASYNC       = '将当前函数标记为异步。'
+ACTION_DISABLE_DIAG     =
+'在工作区禁用诊断 ({})。'
+ACTION_MARK_GLOBAL      =
+'标记 `{}` 为已定义的全局变量。'
+ACTION_REMOVE_SPACE     =
+'清除所有后置空格。'
+ACTION_ADD_SEMICOLON    =
+'添加 `;` 。'
+ACTION_ADD_BRACKETS     =
+'添加括号。'
+ACTION_RUNTIME_VERSION  =
+'修改运行版本为 {} 。'
+ACTION_OPEN_LIBRARY     =
+'加载 {} 中的全局变量。'
+ACTION_ADD_DO_END       =
+'添加 `do ... end` 。'
+ACTION_FIX_LCOMMENT_END =
+'改用正确的多行注释关闭符号。'
+ACTION_ADD_LCOMMENT_END =
+'关闭多行注释。'
+ACTION_FIX_C_LONG_COMMENT =
+'修改为 Lua 的多行注释格式。'
+ACTION_FIX_LSTRING_END  =
+'改用正确的长字符串关闭符号。'
+ACTION_ADD_LSTRING_END  =
+'关闭长字符串。'
+ACTION_FIX_ASSIGN_AS_EQ =
+'改为 `=` 。'
+ACTION_FIX_EQ_AS_ASSIGN =
+'改为 `==` 。'
+ACTION_FIX_UEQ          =
+'改为 `~=` 。'
+ACTION_FIX_THEN_AS_DO   =
+'改为 `then` 。'
+ACTION_FIX_DO_AS_THEN   =
+'改为 `do` 。'
+ACTION_ADD_END          =
+'添加 `end` （根据缩进推测添加位置）。'
+ACTION_FIX_COMMENT_PREFIX =
+'改为 `--` 。'
+ACTION_FIX_NONSTANDARD_SYMBOL =
+'改为 `{symbol}`'
+ACTION_RUNTIME_UNICODE_NAME =
+'允许使用 Unicode 字符。'
+ACTION_SWAP_PARAMS      =
+'将其改为 `{node}` 的第 {index} 个参数'
+ACTION_FIX_INSERT_SPACE =
+'插入空格'
+ACTION_JSON_TO_LUA      =
+'把 JSON 转成 Lua'
+ACTION_DISABLE_DIAG_LINE=
+'在此行禁用诊断 ({})。'
+ACTION_DISABLE_DIAG_FILE=
+'在此文件禁用诊断 ({})。'
+ACTION_MARK_ASYNC       =
+'将当前函数标记为异步。'
 
-COMMAND_DISABLE_DIAG       = '禁用诊断'
-COMMAND_MARK_GLOBAL        = '标记全局变量'
-COMMAND_REMOVE_SPACE       = '清除所有后置空格'
-COMMAND_ADD_BRACKETS       = '添加括号'
-COMMAND_RUNTIME_VERSION    = '修改运行版本'
-COMMAND_OPEN_LIBRARY       = '加载第三方库中的全局变量'
-COMMAND_UNICODE_NAME       = '允许使用 Unicode 字符'
-COMMAND_JSON_TO_LUA        = 'JSON 转 Lua'
-COMMAND_JSON_TO_LUA_FAILED = 'JSON 转 Lua 失败：{}'
+COMMAND_DISABLE_DIAG       =
+'禁用诊断'
+COMMAND_MARK_GLOBAL        =
+'标记全局变量'
+COMMAND_REMOVE_SPACE       =
+'清除所有后置空格'
+COMMAND_ADD_BRACKETS       =
+'添加括号'
+COMMAND_RUNTIME_VERSION    =
+'修改运行版本'
+COMMAND_OPEN_LIBRARY       =
+'加载第三方库中的全局变量'
+COMMAND_UNICODE_NAME       =
+'允许使用 Unicode 字符'
+COMMAND_JSON_TO_LUA        =
+'JSON 转 Lua'
+COMMAND_JSON_TO_LUA_FAILED =
+'JSON 转 Lua 失败：{}'
 
-COMPLETION_IMPORT_FROM           = '从 {} 中导入'
-COMPLETION_DISABLE_AUTO_REQUIRE  = '禁用自动require'
-COMPLETION_ASK_AUTO_REQUIRE      = '在文件顶部添加代码 require 此文件？'
+COMPLETION_IMPORT_FROM           =
+'从 {} 中导入'
+COMPLETION_DISABLE_AUTO_REQUIRE  =
+'禁用自动require'
+COMPLETION_ASK_AUTO_REQUIRE      =
+'在文件顶部添加代码 require 此文件？'
 
-DEBUG_MEMORY_LEAK       = '{} 很抱歉发生了严重的内存泄漏，语言服务即将重启。'
-DEBUG_RESTART_NOW       = '立即重启'
+DEBUG_MEMORY_LEAK       =
+'{} 很抱歉发生了严重的内存泄漏，语言服务即将重启。'
+DEBUG_RESTART_NOW       =
+'立即重启'
 
-WINDOW_COMPILING                 = '正在编译'
-WINDOW_DIAGNOSING                = '正在诊断'
-WINDOW_INITIALIZING              = '正在初始化...'
-WINDOW_PROCESSING_HOVER          = '正在处理悬浮提示...'
-WINDOW_PROCESSING_DEFINITION     = '正在处理转到定义...'
-WINDOW_PROCESSING_REFERENCE      = '正在处理转到引用...'
-WINDOW_PROCESSING_RENAME         = '正在处理重命名...'
-WINDOW_PROCESSING_COMPLETION     = '正在处理自动完成...'
-WINDOW_PROCESSING_SIGNATURE      = '正在处理参数提示...'
-WINDOW_PROCESSING_SYMBOL         = '正在处理文件符号...'
-WINDOW_PROCESSING_WS_SYMBOL      = '正在处理工作区符号...'
-WINDOW_PROCESSING_SEMANTIC_FULL  = '正在处理全量语义着色...'
-WINDOW_PROCESSING_SEMANTIC_RANGE = '正在处理差量语义着色...'
-WINDOW_PROCESSING_HINT           = '正在处理内联提示...'
-WINDOW_INCREASE_UPPER_LIMIT      = '增加上限'
-WINDOW_CLOSE                     = '关闭'
-WINDOW_SETTING_WS_DIAGNOSTIC     = '你可以在设置中延迟或禁用工作目录诊断'
-WINDOW_DONT_SHOW_AGAIN           = '不再提示'
-WINDOW_DELAY_WS_DIAGNOSTIC       = '空闲时诊断（延迟{}秒）'
-WINDOW_DISABLE_DIAGNOSTIC        = '禁用工作区诊断'
-WINDOW_LUA_STATUS_WORKSPACE      = '工作区：{}'
-WINDOW_LUA_STATUS_CACHED_FILES   = '已缓存文件：{ast}/{max}'
-WINDOW_LUA_STATUS_MEMORY_COUNT   = '内存占用：{mem:.f}M'
-WINDOW_APPLY_SETTING             = '应用设置'
-WINDOW_CHECK_SEMANTIC            = '如果你正在使用市场中的颜色主题，你可能需要同时修改 `editor.semanticHighlighting.enabled` 选项为 `true` 才会使语义着色生效。'
-WINDOW_TELEMETRY_HINT            = '请允许发送匿名的使用数据与错误报告，帮助我们进一步完善此插件。在[此处](https://github.com/sumneko/lua-language-server/wiki/%E9%9A%90%E7%A7%81%E5%A3%B0%E6%98%8E)阅读我们的隐私声明。'
-WINDOW_TELEMETRY_ENABLE          = '允许'
-WINDOW_TELEMETRY_DISABLE         = '禁止'
-WINDOW_CLIENT_NOT_SUPPORT_CONFIG = '你的客户端不支持从服务侧修改设置，请手动修改如下设置：'
-WINDOW_LCONFIG_NOT_SUPPORT_CONFIG= '暂不支持自动修改本地设置，请手动修改如下设置：'
-WINDOW_MANUAL_CONFIG_ADD         = '为 `{key}` 添加值 `{value:q}`;'
-WINDOW_MANUAL_CONFIG_SET         = '将 `{key}` 的值设置为 `{value:q}`;'
-WINDOW_MANUAL_CONFIG_PROP        = '将 `{key}` 的属性 `{prop}` 设置为 `{value:q}`;'
-WINDOW_APPLY_WHIT_SETTING        = '应用并修改设置'
-WINDOW_APPLY_WHITOUT_SETTING     = '应用但不修改设置'
-WINDOW_ASK_APPLY_LIBRARY         = '是否需要将你的工作环境配置为 `{}` ？'
+WINDOW_COMPILING                 =
+'正在编译'
+WINDOW_DIAGNOSING                =
+'正在诊断'
+WINDOW_INITIALIZING              =
+'正在初始化...'
+WINDOW_PROCESSING_HOVER          =
+'正在处理悬浮提示...'
+WINDOW_PROCESSING_DEFINITION     =
+'正在处理转到定义...'
+WINDOW_PROCESSING_REFERENCE      =
+'正在处理转到引用...'
+WINDOW_PROCESSING_RENAME         =
+'正在处理重命名...'
+WINDOW_PROCESSING_COMPLETION     =
+'正在处理自动完成...'
+WINDOW_PROCESSING_SIGNATURE      =
+'正在处理参数提示...'
+WINDOW_PROCESSING_SYMBOL         =
+'正在处理文件符号...'
+WINDOW_PROCESSING_WS_SYMBOL      =
+'正在处理工作区符号...'
+WINDOW_PROCESSING_SEMANTIC_FULL  =
+'正在处理全量语义着色...'
+WINDOW_PROCESSING_SEMANTIC_RANGE =
+'正在处理差量语义着色...'
+WINDOW_PROCESSING_HINT           =
+'正在处理内联提示...'
+WINDOW_INCREASE_UPPER_LIMIT      =
+'增加上限'
+WINDOW_CLOSE                     =
+'关闭'
+WINDOW_SETTING_WS_DIAGNOSTIC     =
+'你可以在设置中延迟或禁用工作目录诊断'
+WINDOW_DONT_SHOW_AGAIN           =
+'不再提示'
+WINDOW_DELAY_WS_DIAGNOSTIC       =
+'空闲时诊断（延迟{}秒）'
+WINDOW_DISABLE_DIAGNOSTIC        =
+'禁用工作区诊断'
+WINDOW_LUA_STATUS_WORKSPACE      =
+'工作区：{}'
+WINDOW_LUA_STATUS_CACHED_FILES   =
+'已缓存文件：{ast}/{max}'
+WINDOW_LUA_STATUS_MEMORY_COUNT   =
+'内存占用：{mem:.f}M'
+WINDOW_APPLY_SETTING             =
+'应用设置'
+WINDOW_CHECK_SEMANTIC            =
+'如果你正在使用市场中的颜色主题，你可能需要同时修改 `editor.semanticHighlighting.enabled` 选项为 `true` 才会使语义着色生效。'
+WINDOW_TELEMETRY_HINT            =
+'请允许发送匿名的使用数据与错误报告，帮助我们进一步完善此插件。在[此处](https://github.com/sumneko/lua-language-server/wiki/%E9%9A%90%E7%A7%81%E5%A3%B0%E6%98%8E)阅读我们的隐私声明。'
+WINDOW_TELEMETRY_ENABLE          =
+'允许'
+WINDOW_TELEMETRY_DISABLE         =
+'禁止'
+WINDOW_CLIENT_NOT_SUPPORT_CONFIG =
+'你的客户端不支持从服务侧修改设置，请手动修改如下设置：'
+WINDOW_LCONFIG_NOT_SUPPORT_CONFIG=
+'暂不支持自动修改本地设置，请手动修改如下设置：'
+WINDOW_MANUAL_CONFIG_ADD         =
+'为 `{key}` 添加值 `{value:q}`;'
+WINDOW_MANUAL_CONFIG_SET         =
+'将 `{key}` 的值设置为 `{value:q}`;'
+WINDOW_MANUAL_CONFIG_PROP        =
+'将 `{key}` 的属性 `{prop}` 设置为 `{value:q}`;'
+WINDOW_APPLY_WHIT_SETTING        =
+'应用并修改设置'
+WINDOW_APPLY_WHITOUT_SETTING     =
+'应用但不修改设置'
+WINDOW_ASK_APPLY_LIBRARY         =
+'是否需要将你的工作环境配置为 `{}` ？'
 
-CONFIG_LOAD_FAILED               = '无法读取设置文件：{}'
-CONFIG_LOAD_ERROR                = '设置文件加载错误：{}'
-CONFIG_TYPE_ERROR                = '设置文件必须是lua或json格式：{}'
+CONFIG_LOAD_FAILED               =
+'无法读取设置文件：{}'
+CONFIG_LOAD_ERROR                =
+'设置文件加载错误：{}'
+CONFIG_TYPE_ERROR                =
+'设置文件必须是lua或json格式：{}'
 
-PLUGIN_RUNTIME_ERROR             = [[
+PLUGIN_RUNTIME_ERROR             =
+[[
 插件发生错误，请汇报给插件作者。
 请在输出或日志中查看详细信息。
 插件路径：{}
 ]]
-PLUGIN_TRUST_LOAD                = [[
+PLUGIN_TRUST_LOAD                =
+[[
 当前设置试图加载位于此位置的插件：{}
 
 注意，恶意的插件可能会危害您的电脑
 ]]
-PLUGIN_TRUST_YES                 = [[
+PLUGIN_TRUST_YES                 =
+[[
 信任并加载插件
 ]]
-PLUGIN_TRUST_NO                  = [[
+PLUGIN_TRUST_NO                  =
+[[
 不要加载此插件
 ]]
diff --git a/locale/zh-cn/setting.lua b/locale/zh-cn/setting.lua
index 2a56d287..df3e1a87 100644
--- a/locale/zh-cn/setting.lua
+++ b/locale/zh-cn/setting.lua
@@ -1,14 +1,18 @@
 ---@diagnostic disable: undefined-global
 
-config.runtime.version            = "Lua运行版本。"
-config.runtime.path               = [[
+config.runtime.version            =
+"Lua运行版本。"
+config.runtime.path               =
+[[
 当使用 `require` 时，如何根据输入的名字来查找文件。
 此选项设置为 `?/init.lua` 意味着当你输入 `require 'myfile'` 时，会从已加载的文件中搜索 `{workspace}/myfile/init.lua`。
 当 `runtime.pathStrict` 设置为 `false` 时，还会尝试搜索 `${workspace}/**/myfile/init.lua`。
 如果你想要加载工作区以外的文件，你需要先设置 `Lua.workspace.library`。
 ]]
-config.runtime.pathStrict         = '启用后 `runtime.path` 将只搜索第一层目录，见 `runtime.path` 的说明。'
-config.runtime.special            = [[将自定义全局变量视为一些特殊的内置变量，语言服务将提供特殊的支持。
+config.runtime.pathStrict         =
+'启用后 `runtime.path` 将只搜索第一层目录，见 `runtime.path` 的说明。'
+config.runtime.special            =
+[[将自定义全局变量视为一些特殊的内置变量，语言服务将提供特殊的支持。
 下面这个例子表示将 `include` 视为 `require` 。
 ```json
 "Lua.runtime.special" : {
@@ -16,40 +20,64 @@ config.runtime.special            = [[将自定义全局变量视为一些特殊
 }
 ```
 ]]
-config.runtime.unicodeName        = "允许在名字中使用 Unicode 字符。"
-config.runtime.nonstandardSymbol  = "支持非标准的符号。请务必确认你的运行环境支持这些符号。"
-config.runtime.plugin             = "插件路径，请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/Plugin)了解用法。"
-config.runtime.fileEncoding       = "文件编码，`ansi` 选项只在 `Windows` 平台下有效。"
-config.runtime.builtin            = [[
+config.runtime.unicodeName        =
+"允许在名字中使用 Unicode 字符。"
+config.runtime.nonstandardSymbol  =
+"支持非标准的符号。请务必确认你的运行环境支持这些符号。"
+config.runtime.plugin             =
+"插件路径，请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/Plugin)了解用法。"
+config.runtime.fileEncoding       =
+"文件编码，`ansi` 选项只在 `Windows` 平台下有效。"
+config.runtime.builtin            =
+[[
 调整内置库的启用状态，你可以根据实际运行环境禁用掉不存在的库（或重新定义）。
 
 * `default`: 表示库会根据运行版本启用或禁用
 * `enable`: 总是启用
 * `disable`: 总是禁用
 ]]
-config.diagnostics.enable         = "启用诊断。"
-config.diagnostics.disable        = "禁用的诊断（使用浮框括号内的代码）。"
-config.diagnostics.globals        = "已定义的全局变量。"
-config.diagnostics.severity       = "修改诊断等级。"
-config.diagnostics.neededFileStatus = [[
+config.diagnostics.enable         =
+"启用诊断。"
+config.diagnostics.disable        =
+"禁用的诊断（使用浮框括号内的代码）。"
+config.diagnostics.globals        =
+"已定义的全局变量。"
+config.diagnostics.severity       =
+"修改诊断等级。"
+config.diagnostics.neededFileStatus =
+[[
 * Opened:  只诊断打开的文件
 * Any:     诊断任何文件
 * Disable: 禁用此诊断
 ]]
-config.diagnostics.workspaceDelay = "进行工作区诊断的延迟（毫秒）。当你启动工作区，或编辑了任意文件后，将会在后台对整个工作区进行重新诊断。设置为负数可以禁用工作区诊断。"
-config.diagnostics.workspaceRate  = "工作区诊断的运行速率（百分比）。降低该值会减少CPU占用，但是也会降低工作区诊断的速度。你当前正在编辑的文件的诊断总是全速完成，不受该选项影响。"
-config.diagnostics.libraryFiles   = "如何诊断通过 `Lua.workspace.library` 加载的文件。"
-config.diagnostics.ignoredFiles   = "如何诊断被忽略的文件。"
-config.diagnostics.files.Enable   = "总是诊断这些文件。"
-config.diagnostics.files.Opened   = "只有打开这些文件时才会诊断。"
-config.diagnostics.files.Disable  = "不诊断这些文件。"
-config.workspace.ignoreDir        = "忽略的文件与目录（使用 `.gitignore` 语法）。"
-config.workspace.ignoreSubmodules = "忽略子模块。"
-config.workspace.useGitIgnore     = "忽略 `.gitignore` 中列举的文件。"
-config.workspace.maxPreload       = "最大预加载文件数。"
-config.workspace.preloadFileSize  = "预加载时跳过大小大于该值（KB）的文件。"
-config.workspace.library          = "除了当前工作区以外，还会从哪些目录中加载文件。这些目录中的文件将被视作外部提供的代码库，部分操作（如重命名字段）不会修改这些文件。"
-config.workspace.checkThirdParty  = [[
+config.diagnostics.workspaceDelay =
+"进行工作区诊断的延迟（毫秒）。当你启动工作区，或编辑了任意文件后，将会在后台对整个工作区进行重新诊断。设置为负数可以禁用工作区诊断。"
+config.diagnostics.workspaceRate  =
+"工作区诊断的运行速率（百分比）。降低该值会减少CPU占用，但是也会降低工作区诊断的速度。你当前正在编辑的文件的诊断总是全速完成，不受该选项影响。"
+config.diagnostics.libraryFiles   =
+"如何诊断通过 `Lua.workspace.library` 加载的文件。"
+config.diagnostics.ignoredFiles   =
+"如何诊断被忽略的文件。"
+config.diagnostics.files.Enable   =
+"总是诊断这些文件。"
+config.diagnostics.files.Opened   =
+"只有打开这些文件时才会诊断。"
+config.diagnostics.files.Disable  =
+"不诊断这些文件。"
+config.workspace.ignoreDir        =
+"忽略的文件与目录（使用 `.gitignore` 语法）。"
+config.workspace.ignoreSubmodules =
+"忽略子模块。"
+config.workspace.useGitIgnore     =
+"忽略 `.gitignore` 中列举的文件。"
+config.workspace.maxPreload       =
+"最大预加载文件数。"
+config.workspace.preloadFileSize  =
+"预加载时跳过大小大于该值（KB）的文件。"
+config.workspace.library          =
+"除了当前工作区以外，还会从哪些目录中加载文件。这些目录中的文件将被视作外部提供的代码库，部分操作（如重命名字段）不会修改这些文件。"
+config.workspace.checkThirdParty  =
+[[
 自动检测与适配第三方库，目前支持的库为：
 
 * OpenResty
@@ -59,84 +87,161 @@ config.workspace.checkThirdParty  = [[
 * skynet
 * Jass
 ]]
-config.workspace.userThirdParty          = '在这里添加私有的第三方库适配文件路径，请参考内置的[配置文件路径](https://github.com/sumneko/lua-language-server/tree/master/meta/3rd)'
-config.completion.enable                 = '启用自动完成。'
-config.completion.callSnippet            = '显示函数调用片段。'
-config.completion.callSnippet.Disable    = "只显示 `函数名`。"
-config.completion.callSnippet.Both       = "显示 `函数名` 与 `调用片段`。"
-config.completion.callSnippet.Replace    = "只显示 `调用片段`。"
-config.completion.keywordSnippet         = '显示关键字语法片段'
-config.completion.keywordSnippet.Disable = "只显示 `关键字`。"
-config.completion.keywordSnippet.Both    = "显示 `关键字` 与 `语法片段`。"
-config.completion.keywordSnippet.Replace = "只显示 `语法片段`。"
-config.completion.displayContext         = "预览建议的相关代码片段，可能可以帮助你了解这项建议的用法。设置的数字表示代码片段的截取行数，设置为`0`可以禁用此功能。"
-config.completion.workspaceWord          = "显示的上下文单词是否包含工作区中其他文件的内容。"
-config.completion.showWord               = "在建议中显示上下文单词。"
-config.completion.showWord.Enable        = "总是在建议中显示上下文单词。"
-config.completion.showWord.Fallback      = "无法根据语义提供建议时才显示上下文单词。"
-config.completion.showWord.Disable       = "不显示上下文单词。"
-config.completion.autoRequire            = "输入内容看起来是个文件名时，自动 `require` 此文件。"
-config.completion.showParams             = "在建议列表中显示函数的参数信息，函数拥有多个定义时会分开显示。"
-config.completion.requireSeparator       = "`require` 时使用的分隔符。"
-config.completion.postfix                = "用于触发后缀建议的符号。"
-config.color.mode                        = "着色模式。"
-config.color.mode.Semantic               = "语义着色。你可能需要同时将 `editor.semanticHighlighting.enabled` 设置为 `true` 才能生效。"
-config.color.mode.SemanticEnhanced       = "增强的语义颜色。 类似于`Semantic`，但会进行额外的分析（也会带来额外的开销）。"
-config.color.mode.Grammar                = "语法着色。"
-config.semantic.enable                   = "启用语义着色。你可能需要同时将 `editor.semanticHighlighting.enabled` 设置为 `true` 才能生效。"
-config.semantic.variable                 = "对变量/字段/参数进行语义着色。"
-config.semantic.annotation               = "对类型注解进行语义着色。"
-config.semantic.keyword                  = "对关键字/字面量/运算符进行语义着色。只有当你的编辑器无法进行语法着色时才需要启用此功能。"
-config.signatureHelp.enable              = "启用参数提示。"
-config.hover.enable                      = "启用悬停提示。"
-config.hover.viewString                  = "悬停提示查看字符串内容（仅当字面量包含转义符时）。"
-config.hover.viewStringMax               = "悬停提示查看字符串内容时的最大长度。"
-config.hover.viewNumber                  = "悬停提示查看数字内容（仅当字面量不是十进制时）。"
-config.hover.fieldInfer                  = "悬停提示查看表时，会对表的每个字段进行类型推测，当类型推测的用时累计达到该设定值（毫秒）时，将跳过后续字段的类型推测。"
-config.hover.previewFields               = "悬停提示查看表时，限制表内字段的最大预览数量。"
-config.hover.enumsLimit                  = "当值对应多个类型时，限制类型的显示数量。"
-config.develop.enable                    = '开发者模式。请勿开启，会影响性能。'
-config.develop.debuggerPort              = '调试器监听端口。'
-config.develop.debuggerWait              = '调试器连接之前挂起。'
-config.intelliSense.searchDepth          = '设置智能感知的搜索深度。增大该值可以增加准确度，但会降低性能。不同的项目对该设置的容忍度差异较大，请自己调整为合适的值。'
-config.intelliSense.fastGlobal           = '在对全局变量进行补全，及查看 `_G` 的悬浮提示时进行优化。这会略微降低类型推测的准确度，但是对于大量使用全局变量的项目会有大幅的性能提升。'
-config.window.statusBar                  = '在状态栏显示插件状态。'
-config.window.progressBar                = '在状态栏显示进度条。'
-config.hint.enable                       = '启用内联提示。'
-config.hint.paramType                    = '在函数的参数位置提示类型。'
-config.hint.setType                      = '在赋值操作位置提示类型。'
-config.hint.paramName                    = '在函数调用处提示参数名。'
-config.hint.paramName.All                = '所有类型的参数均进行提示。'
-config.hint.paramName.Literal            = '只有字面量类型的参数进行提示。'
-config.hint.paramName.Disable            = '禁用参数提示。'
-config.hint.arrayIndex                   = '在构造表时提示数组索引。'
-config.hint.arrayIndex.Enable            = '所有的表中都提示数组索引。'
-config.hint.arrayIndex.Auto              = '只有表大于3项，或者表是混合类型时才进行提示。'
-config.hint.arrayIndex.Disable           = '禁用数组索引提示。'
-config.telemetry.enable                  = [[
+config.workspace.userThirdParty          =
+'在这里添加私有的第三方库适配文件路径，请参考内置的[配置文件路径](https://github.com/sumneko/lua-language-server/tree/master/meta/3rd)'
+config.completion.enable                 =
+'启用自动完成。'
+config.completion.callSnippet            =
+'显示函数调用片段。'
+config.completion.callSnippet.Disable    =
+"只显示 `函数名`。"
+config.completion.callSnippet.Both       =
+"显示 `函数名` 与 `调用片段`。"
+config.completion.callSnippet.Replace    =
+"只显示 `调用片段`。"
+config.completion.keywordSnippet         =
+'显示关键字语法片段'
+config.completion.keywordSnippet.Disable =
+"只显示 `关键字`。"
+config.completion.keywordSnippet.Both    =
+"显示 `关键字` 与 `语法片段`。"
+config.completion.keywordSnippet.Replace =
+"只显示 `语法片段`。"
+config.completion.displayContext         =
+"预览建议的相关代码片段，可能可以帮助你了解这项建议的用法。设置的数字表示代码片段的截取行数，设置为`0`可以禁用此功能。"
+config.completion.workspaceWord          =
+"显示的上下文单词是否包含工作区中其他文件的内容。"
+config.completion.showWord               =
+"在建议中显示上下文单词。"
+config.completion.showWord.Enable        =
+"总是在建议中显示上下文单词。"
+config.completion.showWord.Fallback      =
+"无法根据语义提供建议时才显示上下文单词。"
+config.completion.showWord.Disable       =
+"不显示上下文单词。"
+config.completion.autoRequire            =
+"输入内容看起来是个文件名时，自动 `require` 此文件。"
+config.completion.showParams             =
+"在建议列表中显示函数的参数信息，函数拥有多个定义时会分开显示。"
+config.completion.requireSeparator       =
+"`require` 时使用的分隔符。"
+config.completion.postfix                =
+"用于触发后缀建议的符号。"
+config.color.mode                        =
+"着色模式。"
+config.color.mode.Semantic               =
+"语义着色。你可能需要同时将 `editor.semanticHighlighting.enabled` 设置为 `true` 才能生效。"
+config.color.mode.SemanticEnhanced       =
+"增强的语义颜色。 类似于`Semantic`，但会进行额外的分析（也会带来额外的开销）。"
+config.color.mode.Grammar                =
+"语法着色。"
+config.semantic.enable                   =
+"启用语义着色。你可能需要同时将 `editor.semanticHighlighting.enabled` 设置为 `true` 才能生效。"
+config.semantic.variable                 =
+"对变量/字段/参数进行语义着色。"
+config.semantic.annotation               =
+"对类型注解进行语义着色。"
+config.semantic.keyword                  =
+"对关键字/字面量/运算符进行语义着色。只有当你的编辑器无法进行语法着色时才需要启用此功能。"
+config.signatureHelp.enable              =
+"启用参数提示。"
+config.hover.enable                      =
+"启用悬停提示。"
+config.hover.viewString                  =
+"悬停提示查看字符串内容（仅当字面量包含转义符时）。"
+config.hover.viewStringMax               =
+"悬停提示查看字符串内容时的最大长度。"
+config.hover.viewNumber                  =
+"悬停提示查看数字内容（仅当字面量不是十进制时）。"
+config.hover.fieldInfer                  =
+"悬停提示查看表时，会对表的每个字段进行类型推测，当类型推测的用时累计达到该设定值（毫秒）时，将跳过后续字段的类型推测。"
+config.hover.previewFields               =
+"悬停提示查看表时，限制表内字段的最大预览数量。"
+config.hover.enumsLimit                  =
+"当值对应多个类型时，限制类型的显示数量。"
+config.develop.enable                    =
+'开发者模式。请勿开启，会影响性能。'
+config.develop.debuggerPort              =
+'调试器监听端口。'
+config.develop.debuggerWait              =
+'调试器连接之前挂起。'
+config.intelliSense.searchDepth          =
+'设置智能感知的搜索深度。增大该值可以增加准确度，但会降低性能。不同的项目对该设置的容忍度差异较大，请自己调整为合适的值。'
+config.intelliSense.fastGlobal           =
+'在对全局变量进行补全，及查看 `_G` 的悬浮提示时进行优化。这会略微降低类型推测的准确度，但是对于大量使用全局变量的项目会有大幅的性能提升。'
+config.window.statusBar                  =
+'在状态栏显示插件状态。'
+config.window.progressBar                =
+'在状态栏显示进度条。'
+config.hint.enable                       =
+'启用内联提示。'
+config.hint.paramType                    =
+'在函数的参数位置提示类型。'
+config.hint.setType                      =
+'在赋值操作位置提示类型。'
+config.hint.paramName                    =
+'在函数调用处提示参数名。'
+config.hint.paramName.All                =
+'所有类型的参数均进行提示。'
+config.hint.paramName.Literal            =
+'只有字面量类型的参数进行提示。'
+config.hint.paramName.Disable            =
+'禁用参数提示。'
+config.hint.arrayIndex                   =
+'在构造表时提示数组索引。'
+config.hint.arrayIndex.Enable            =
+'所有的表中都提示数组索引。'
+config.hint.arrayIndex.Auto              =
+'只有表大于3项，或者表是混合类型时才进行提示。'
+config.hint.arrayIndex.Disable           =
+'禁用数组索引提示。'
+config.telemetry.enable                  =
+[[
 启用遥测，通过网络发送你的编辑器信息与错误日志。在[此处](https://github.com/sumneko/lua-language-server/wiki/%E9%9A%90%E7%A7%81%E5%A3%B0%E6%98%8E)阅读我们的隐私声明。
 ]]
-config.misc.parameters                   = 'VSCode中启动语言服务时的[命令行参数](https://github.com/sumneko/lua-language-server/wiki/Command-line)。'
-config.IntelliSense.traceLocalSet        = '请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/IntelliSense-optional-features)了解用法。'
-config.IntelliSense.traceReturn          = '请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/IntelliSense-optional-features)了解用法。'
-config.IntelliSense.traceBeSetted        = '请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/IntelliSense-optional-features)了解用法。'
-config.IntelliSense.traceFieldInject     = '请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/IntelliSense-optional-features)了解用法。'
+config.misc.parameters                   =
+'VSCode中启动语言服务时的[命令行参数](https://github.com/sumneko/lua-language-server/wiki/Command-line)。'
+config.IntelliSense.traceLocalSet        =
+'请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/IntelliSense-optional-features)了解用法。'
+config.IntelliSense.traceReturn          =
+'请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/IntelliSense-optional-features)了解用法。'
+config.IntelliSense.traceBeSetted        =
+'请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/IntelliSense-optional-features)了解用法。'
+config.IntelliSense.traceFieldInject     =
+'请查阅[文档](https://github.com/sumneko/lua-language-server/wiki/IntelliSense-optional-features)了解用法。'
 
 
-config.diagnostics['unused-local']          = '未使用的局部变量'
-config.diagnostics['unused-function']       = '未使用的函数'
-config.diagnostics['undefined-global']      = '未定义的全局变量'
-config.diagnostics['global-in-nil-env']     = '不能使用全局变量（ `_ENV` 被设置为了 `nil`）'
-config.diagnostics['unused-label']          = '未使用的标签'
-config.diagnostics['unused-vararg']         = '未使用的不定参数'
-config.diagnostics['trailing-space']        = '后置空格'
-config.diagnostics['redefined-local']       = '重复定义的局部变量'
-config.diagnostics['newline-call']          = '以 `(` 开始的新行，在语法上被解析为了上一行的函数调用'
-config.diagnostics['newfield-call']         = '在字面量表中，2行代码之间缺少分隔符，在语法上被解析为了一次索引操作'
-config.diagnostics['redundant-parameter']   = '函数调用时，传入了多余的参数'
-config.diagnostics['ambiguity-1']           = '优先级歧义，如：`num or 0 + 1`，推测用户的实际期望为 `(num or 0) + 1` '
-config.diagnostics['lowercase-global']      = '首字母小写的全局变量定义'
-config.diagnostics['undefined-env-child']   = '`_ENV` 被设置为了新的字面量表，但是试图获取的全局变量不再这张表中'
-config.diagnostics['duplicate-index']       = '在字面量表中重复定义了索引'
-config.diagnostics['empty-block']           = '空代码块'
-config.diagnostics['redundant-value']       = '赋值操作时，值的数量比被赋值的对象多'
+config.diagnostics['unused-local']          =
+'未使用的局部变量'
+config.diagnostics['unused-function']       =
+'未使用的函数'
+config.diagnostics['undefined-global']      =
+'未定义的全局变量'
+config.diagnostics['global-in-nil-env']     =
+'不能使用全局变量（ `_ENV` 被设置为了 `nil`）'
+config.diagnostics['unused-label']          =
+'未使用的标签'
+config.diagnostics['unused-vararg']         =
+'未使用的不定参数'
+config.diagnostics['trailing-space']        =
+'后置空格'
+config.diagnostics['redefined-local']       =
+'重复定义的局部变量'
+config.diagnostics['newline-call']          =
+'以 `(` 开始的新行，在语法上被解析为了上一行的函数调用'
+config.diagnostics['newfield-call']         =
+'在字面量表中，2行代码之间缺少分隔符，在语法上被解析为了一次索引操作'
+config.diagnostics['redundant-parameter']   =
+'函数调用时，传入了多余的参数'
+config.diagnostics['ambiguity-1']           =
+'优先级歧义，如：`num or 0 + 1`，推测用户的实际期望为 `(num or 0) + 1` '
+config.diagnostics['lowercase-global']      =
+'首字母小写的全局变量定义'
+config.diagnostics['undefined-env-child']   =
+'`_ENV` 被设置为了新的字面量表，但是试图获取的全局变量不再这张表中'
+config.diagnostics['duplicate-index']       =
+'在字面量表中重复定义了索引'
+config.diagnostics['empty-block']           =
+'空代码块'
+config.diagnostics['redundant-value']       =
+'赋值操作时，值的数量比被赋值的对象多'