cleanup locale

11 files changed, 181 insertions, 39 deletions

diff --git a/locale/en-us/meta.lua b/locale/en-us/meta.lua
index 839dc27a..09612d76 100644
--- a/locale/en-us/meta.lua
+++ b/locale/en-us/meta.lua
@@ -1,10 +1,11 @@
 ---@diagnostic disable: undefined-global, lowercase-global
 
--- basic
 arg                 =
 'Command-line arguments of Lua Standalone.'
+
 assert              =
 'Raises an error if the value of its argument v is false (i.e., `nil` or `false`); otherwise, returns all its arguments. In case of error, `message` is the error object; when absent, it defaults to `"assertion failed!"`'
+
 cgopt.collect       =
 'Performs a full garbage-collection cycle.'
 cgopt.stop          =
@@ -25,22 +26,29 @@ cgopt.generational  =
 'Change the collector mode to generational.'
 cgopt.isrunning     =
 'Returns whether the collector is running.'
+
 collectgarbage      =
 'This function is a generic interface to the garbage collector. It performs different functions according to its first argument, `opt`.'
+
 dofile              =
 'Opens the named file and executes its content as a Lua chunk. When called without arguments, `dofile` executes the content of the standard input (`stdin`). Returns all values returned by the chunk. In case of errors, `dofile` propagates the error to its caller. (That is, `dofile` does not run in protected mode.)'
+
 error               =
 [[
 Terminates the last protected function called and returns message as the error object.
 
 Usually, `error` adds some information about the error position at the beginning of the message, if the message is a string.
 ]]
+
 _G                  =
 'A global variable (not a function) that holds the global environment (see §2.2). Lua itself does not use this variable; changing its value does not affect any environment, nor vice versa.'
+
 getfenv             =
 'Returns the current environment in use by the function. `f` can be a Lua function or a number that specifies the function at that stack level.'
+
 getmetatable        =
 'If object does not have a metatable, returns nil. Otherwise, if the object\'s metatable has a __metatable field, returns the associated value. Otherwise, returns the metatable of the given object.'
+
 ipairs              =
 [[
 Returns three values (an iterator function, the table `t`, and `0`) so that the construction
@@ -49,12 +57,14 @@ Returns three values (an iterator function, the table `t`, and `0`) so that the
 ```
 will iterate over the key–value pairs `(1,t[1]), (2,t[2]), ...`, up to the first absent index.
 ]]
+
 loadmode.b          =
 'Only binary chunks.'
 loadmode.t          =
 'Only text chunks.'
 loadmode.bt         =
 'Both binary and text.'
+
 load['<5.1']        =
 'Loads a chunk using function `func` to get its pieces. Each call to `func` must return a string that concatenates with previous results.'
 load['>5.2']        =
@@ -63,12 +73,16 @@ Loads a chunk.
 
 If `chunk` is a string, the chunk is this string. If `chunk` is a function, `load` calls it repeatedly to get the chunk pieces. Each call to `chunk` must return a string that concatenates with previous results. A return of an empty string, `nil`, or no value signals the end of the chunk.
 ]]
+
 loadfile            =
 'Loads a chunk from file `filename` or from the standard input, if no file name is given.'
+
 loadstring          =
 'Loads a chunk from the given string.'
+
 module              =
 'Creates a module.'
+
 next                =
 [[
 Allows a program to traverse all fields of a table. Its first argument is a table and its second argument is an index in this table. A call to `next` returns the next index of the table and its associated value. When called with `nil` as its second argument, `next` returns an initial index and its associated value. When called with the last index, or with `nil` in an empty table, `next` returns `nil`. If the second argument is absent, then it is interpreted as `nil`. In particular, you can use `next(t)` to check whether a table is empty.
@@ -77,6 +91,7 @@ The order in which the indices are enumerated is not specified, *even for numeri
 
 The behavior of `next` is undefined if, during the traversal, you assign any value to a non-existent field in the table. You may however modify existing fields. In particular, you may set existing fields to nil.
 ]]
+
 pairs               =
 [[
 If `t` has a metamethod `__pairs`, calls it with t as argument and returns the first three results from the call.
@@ -89,30 +104,39 @@ will iterate over all key–value pairs of table `t`.
 
 See function $next for the caveats of modifying the table during its traversal.
 ]]
+
 pcall               =
 [[
 Calls the function `f` with the given arguments in *protected mode*. This means that any error inside `f` is not propagated; instead, `pcall` catches the error and returns a status code. Its first result is the status code (a boolean), which is true if the call succeeds without errors. In such case, `pcall` also returns all results from the call, after this first result. In case of any error, `pcall` returns `false` plus the error object.
 ]]
+
 print               =
 [[
 Receives any number of arguments and prints their values to `stdout`, converting each argument to a string following the same rules of $tostring.
 The function print is not intended for formatted output, but only as a quick way to show a value, for instance for debugging. For complete control over the output, use $string.format and $io.write.
 ]]
+
 rawequal            =
 'Checks whether v1 is equal to v2, without invoking the `__eq` metamethod.'
+
 rawget              =
 'Gets the real value of `table[index]`, without invoking the `__index` metamethod.'
+
 rawlen              =
 'Returns the length of the object `v`, without invoking the `__len` metamethod.'
+
 rawset              =
 [[
 Sets the real value of `table[index]` to `value`, without using the `__newindex` metavalue. `table` must be a table, `index` any value different from `nil` and `NaN`, and `value` any Lua value.
 This function returns `table`.
 ]]
+
 select              =
 'If `index` is a number, returns all arguments after argument number `index`; a negative number indexes from the end (`-1` is the last argument). Otherwise, `index` must be the string `"#"`, and `select` returns the total number of extra arguments it received.'
+
 setfenv             =
 'Sets the environment to be used by the given function. '
+
 setmetatable        =
 [[
 Sets the metatable for the given table. If `metatable` is `nil`, removes the metatable of the given table. If the original metatable has a `__metatable` field, raises an error.
@@ -121,12 +145,14 @@ This function returns `table`.
 
 To change the metatable of other types from Lua code, you must use the debug library (§6.10).
 ]]
+
 tonumber            =
 [[
 When called with no `base`, `tonumber` tries to convert its argument to a number. If the argument is already a number or a string convertible to a number, then `tonumber` returns this number; otherwise, it returns `fail`.
 
 The conversion of strings can result in integers or floats, according to the lexical conventions of Lua (see §3.1). The string may have leading and trailing spaces and a sign.
 ]]
+
 tostring            =
 [[
 Receives a value of any type and converts it to a string in a human-readable format.
@@ -135,18 +161,23 @@ If the metatable of `v` has a `__tostring` field, then `tostring` calls the corr
 
 For complete control of how numbers are converted, use $string.format.
 ]]
+
 type                =
 [[
 Returns the type of its only argument, coded as a string. The possible results of this function are `"nil"` (a string, not the value `nil`), `"number"`, `"string"`, `"boolean"`, `"table"`, `"function"`, `"thread"`, and `"userdata"`.
 ]]
+
 _VERSION            =
 'A global variable (not a function) that holds a string containing the running Lua version.'
+
 warn                =
 'Emits a warning with a message composed by the concatenation of all its arguments (which should be strings).'
+
 xpcall['=5.1']      =
 'Calls function `f` with the given arguments in protected mode with a new message handler.'
 xpcall['>5.2']      =
 'Calls function `f` with the given arguments in protected mode with a new message handler.'
+
 unpack              =
 [[
 Returns the elements from the given `list`. This function is equivalent to
@@ -227,6 +258,7 @@ coroutine.wrap              =
 'Creates a new coroutine, with body `f`; `f` must be a function. Returns a function that resumes the coroutine each time it is called.'
 coroutine.yield             =
 'Suspends the execution of the calling coroutine.'
+
 costatus.running            =
 'Is running.'
 costatus.suspended          =
@@ -296,6 +328,7 @@ debug.upvalueid             =
 'Returns a unique identifier (as a light userdata) for the upvalue numbered `n` from the given function.'
 debug.upvaluejoin           =
 'Make the `n1`-th upvalue of the Lua closure `f1` refer to the `n2`-th upvalue of the Lua closure `f2`.'
+
 infowhat.n                  =
 '`name` and `namewhat`'
 infowhat.S                  =
@@ -314,6 +347,7 @@ infowhat.r                  =
 '`ftransfer` and `ntransfer`'
 infowhat.L                  =
 '`activelines`'
+
 hookmask.c                  =
 'Calls hook when Lua calls a function.'
 hookmask.r                  =
@@ -344,6 +378,7 @@ file[':setvbuf']            =
 'Sets the buffering mode for an output file.'
 file[':write']              =
 'Writes the value of each of its arguments to `file`.'
+
 readmode.n                  =
 'Reads a numeral and returns it as number.'
 readmode.a                  =
@@ -352,12 +387,14 @@ readmode.l                  =
 'Reads the next line skipping the end of line.'
 readmode.L                  =
 'Reads the next line keeping the end of line.'
+
 seekwhence.set              =
 'Base is beginning of the file.'
 seekwhence.cur              =
 'Base is current position.'
 seekwhence['.end']          =
 'Base is end of file.'
+
 vbuf.no                     =
 'Output operation appears immediately.'
 vbuf.full                   =
@@ -402,6 +439,7 @@ io.type                     =
 'Checks whether `obj` is a valid file handle.'
 io.write                    =
 'Writes the value of each of its arguments to default output file.'
+
 openmode.r                  =
 'Read mode.'
 openmode.w                  =
@@ -426,10 +464,12 @@ openmode['.w+b']            =
 'Update mode, all previous data is erased. (in binary mode.)'
 openmode['.a+b']            =
 'Append update mode, previous data is preserved, writing is only allowed at the end of file. (in binary mode.)'
+
 popenmode.r                 =
 'Read data from this program by `file`.'
 popenmode.w                 =
 'Write data to this program by `file`.'
+
 filetype.file               =
 'Is an open file handle.'
 filetype['.closed file']    =
@@ -550,6 +590,7 @@ os.time                     =
 'Returns the current time when called without arguments, or a time representing the local date and time specified by the given table.'
 os.tmpname                  =
 'Returns a string with a file name that can be used for a temporary file.'
+
 osdate.year                 =
 'four digits'
 osdate.month                =
@@ -571,10 +612,12 @@ osdate.isdst                =
 
 package                     =
 ''
+
 require['<5.3']             =
 'Loads the given module, returns any value returned by the given module(`true` when `nil`).'
 require['>5.4']             =
 'Loads the given module, returns any value returned by the searcher(`true` when `nil`). Besides that value, also returns as a second result the loader data returned by the searcher, which indicates how `require` found the module. (For instance, if the module came from a file, this loader data is the file path.)'
+
 package.config              =
 'A string describing some compile-time configurations for packages.'
 package.cpath               =
diff --git a/locale/en-us/script.lua b/locale/en-us/script.lua
index f16235b4..3cbe0113 100644
--- a/locale/en-us/script.lua
+++ b/locale/en-us/script.lua
@@ -94,7 +94,6 @@ DIAG_NOT_YIELDABLE      =
 'The {}th parameter of this function was not marked as yieldable, but an async function was passed in. (Use `---@param name async fun()` to mark as yieldable)'
 DIAG_DISCARD_RETURNS    =
 'The return values of this function cannot be discarded.'
-
 DIAG_CIRCLE_DOC_CLASS                 =
 'Circularly inherited classes.'
 DIAG_DOC_FIELD_NO_CLASS               =
@@ -234,7 +233,6 @@ PARSER_INDEX_IN_FUNC_NAME =
 'The `[name]` form cannot be used in the name of a named function.'
 PARSER_UNKNOWN_ATTRIBUTE  =
 'Local attribute should be `const` or `close`'
-
 PARSER_LUADOC_MISS_CLASS_NAME           =
 '<class name> expected.'
 PARSER_LUADOC_MISS_EXTENDS_SYMBOL       =
@@ -279,7 +277,6 @@ SYMBOL_ANONYMOUS        =
 
 HOVER_VIEW_DOCUMENTS    =
 'View documents'
-
 HOVER_DOCUMENT_LUA51    =
 'http://www.lua.org/manual/5.1/manual.html#{}'
 HOVER_DOCUMENT_LUA52    =
@@ -290,8 +287,6 @@ 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     =
@@ -302,7 +297,6 @@ 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      =
 '({} prototypes)'
 HOVER_STRING_BYTES         =
@@ -313,7 +307,6 @@ HOVER_MULTI_DEF_PROTO      =
 '({} definitions, {} prototypes)'
 HOVER_MULTI_PROTO_NOT_FUNC =
 '({} non functional definition)'
-
 HOVER_USE_LUA_PATH      =
 '(Search path: `{}`)'
 HOVER_EXTENDS           =
@@ -537,4 +530,3 @@ CLI_CHECK_SUCCESS =
 'Diagnosis completed, no problems found'
 CLI_CHECK_RESULTS =
 'Diagnosis complete, {} problems found, see {}'
-
diff --git a/locale/pt-br/meta.lua b/locale/pt-br/meta.lua
index ce48e1c3..519bf41c 100644
--- a/locale/pt-br/meta.lua
+++ b/locale/pt-br/meta.lua
@@ -1,10 +1,11 @@
 ---@diagnostic disable: undefined-global, lowercase-global
 
--- basic
 arg                 =
 'Argumentos de inicialização para a versão standalone da linguagem Lua.'
+
 assert              =
 'Emite um erro se o valor de seu argumento v for falso (i.e., `nil` ou `false`); caso contrário, devolve todos os seus argumentos. Em caso de erro, `message` é o objeto de erro que, quando ausente, por padrão é `"assertion failed!"`'
+
 cgopt.collect       =
 'Realiza um ciclo completo de coleta de lixo (i.e., garbage-collection cycle).'
 cgopt.stop          =
@@ -25,22 +26,29 @@ cgopt.generational  =
 'Altera o modo do coletor para geracional.'
 cgopt.isrunning     =
 'Retorna um valor booleano indicando se o coletor de lixo (i.e., garbage-collection) está em execução.'
+
 collectgarbage      =
 'Esta função é uma interface genérica para o coletor de lixo (i.e., garbage-collection). Ela executa diferentes funções de acordo com seu primeiro argumento, `opt`.'
+
 dofile              =
 'Abre o arquivo fornecido por argumento e executa seu conteúdo como código Lua. Quando chamado sem argumentos, `dofile` executa o conteúdo da entrada padrão (`stdin`). Retorna todos os valores retornados pelo trecho de código contido no arquivo. Em caso de erros, o `dofile` propaga o erro para seu chamador. Ou seja, o `dofile` não funciona em modo protegido.'
+
 error               =
 [[
 Termina a última chamada de função protegida e retorna `message` como objeto de `erro`.
 
 Normalmente, o 'erro' adiciona algumas informações sobre a localização do erro no início da mensagem, quando a mensagem for uma string.
 ]]
+
 _G                  =
 'Uma variável global (não uma função) que detém o ambiente global (ver §2.2). Lua em si não usa esta variável; mudar seu valor não afeta nenhum ambiente e vice-versa.'
+
 getfenv             =
 'Retorna o ambiente atual em uso pela função. O `f` pode ser uma função Lua ou um número que especifica a função naquele nível de pilha.'
+
 getmetatable        =
 'Se o objeto não tiver uma metatable, o retorno é `nil`. Mas caso a metatable do objeto tenha um campo `__metatable`, é retornado o valor associado. Caso contrário, retorna a metatable do objeto dado.'
+
 ipairs              =
 [[
 Retorna três valores (uma função iteradora, a tabela `t`, e `0`) para que a seguinte construção
@@ -49,12 +57,14 @@ Retorna três valores (uma função iteradora, a tabela `t`, e `0`) para que a s
 ```
 possa iterar sobre os pares de valor-chave `(1,t[1]), (2,t[2]), ...`, até o primeiro índice ausente.
 ]]
+
 loadmode.b          =
 'Somente blocos binários.'
 loadmode.t          =
 'Somente blocos de texto.'
 loadmode.bt         =
 'Tanto binário quanto texto.'
+
 load['<5.1']        =
 'Carrega um bloco utilizando a função `func` para obter suas partes. Cada chamada para o `func` deve retornar uma string que é concatenada com os resultados anteriores.'
 load['>5.2']        =
@@ -63,12 +73,16 @@ Carrega um bloco.
 
 Se o bloco (i.e., `chunk`) é uma string, o bloco é essa string. Se o bloco é uma função, a função "load" é chamada repetidamente para obter suas partes. Cada chamada para o bloco deve retornar uma string que é concatenada com os resultados anteriores. O fim do bloco é sinalizado com o retorno de uma string vazia ou `nil`.
 ]]
+
 loadfile            =
 'Carrega um bloco de arquivo `filename` ou da entrada padrão, se nenhum nome de arquivo for dado.'
+
 loadstring          =
 'Carrega um bloco a partir de uma string dada.'
+
 module              =
 'Cria um módulo.'
+
 next                =
 [[
 Permite que um programa percorra todos os campos de uma tabela. Seu primeiro argumento é uma tabela e seu segundo argumento é um índice nesta tabela. Uma chamada `next` retorna o próximo índice da tabela e seu valor associado. Quando chamado usando `nil` como segundo argumento, `next` retorna um índice inicial e seu valor associado. Quando chamado com o último índice, ou com `nil` em uma tabela vazia, o `next` retorna o `nil`. Se o segundo argumento estiver ausente, então é interpretado como `nil`. Portanto, pode-se utilizar o `next(t)` para verificar se uma tabela está vazia.
@@ -77,6 +91,7 @@ A ordem na qual os índices são enumerados não é especificada, *mesmo para í
 
 O comportamento do `next` é indefinido se, durante a iteração/travessia, você atribuir qualquer valor a um campo inexistente na tabela. Você pode, entretanto, modificar os campos existentes e pode, inclusive, os definir como nulos.
 ]]
+
 pairs               =
 [[
 Se `t` tem um "meta" método (i.e., metamethod) `__pairs`, a chamada é feita usando t como argumento e retorna os três primeiros resultados.
@@ -89,30 +104,39 @@ possa iterar sobre todos os pares de valor-chave da tabela 't'.
 
 Veja a função $next para saber as ressalvas em modificar uma tabela durante sua iteração.
 ]]
+
 pcall               =
 [[
 Chama a função `f` com os argumentos dados em modo *protegido*. Isto significa que qualquer erro dentro de `f` não é propagado; em vez disso, o `pcall` captura o erro e retorna um código de status. Seu primeiro resultado é o código de status (booleano), que é verdadeiro se a chamada for bem sucedida sem erros. Neste caso, `pcall' também retorna todos os resultados da chamada, após este primeiro resultado. Em caso de qualquer erro, `pcall` retorna `false` mais o objeto de erro.
 ]]
+
 print               =
 [[
 Recebe qualquer número de argumentos e imprime seus valores na saída padrão `stdout`, convertendo cada argumento em uma string seguindo as mesmas regras do $tostring.
 A função `print` não é destinada à saída formatada, mas apenas como uma forma rápida de mostrar um valor, por exemplo, para debugging. Para controle completo sobre a saída, use $string.format e $io.write.
 ]]
+
 rawequal            =
 'Verifica se v1 é igual a v2, sem invocar a metatable `__eq`.'
+
 rawget              =
 'Obtém o valor real de `table[index]`, sem invocar a metatable `__index`.'
+
 rawlen              =
 'Retorna o comprimento do objeto `v`, sem invocar a metatable `__len`.'
+
 rawset              =
 [[
 Define o valor real de `table[index]` para `value`, sem utilizar o metavalue `__newindex`. `table` deve ser uma tabela, `index` qualquer valor diferente de `nil` e `NaN`, e `value` qualquer valor de tipos do Lua.
 Esta função retorna uma `table`.
 ]]
+
 select              =
 'Se `index` é um número, retorna todos os argumentos após o número do argumento `index`; um número negativo de índices do final (`-1` é o último argumento). Caso contrário, `index` deve ser a string `"#"`, e `select` retorna o número total de argumentos extras dados.'
+
 setfenv             =
 'Define o ambiente a ser utilizado pela função em questão.'
+
 setmetatable        =
 [[
 Define a metatable para a tabela dada. Se `metatabela` for `nil`, remove a metatable da tabela em questão. Se a metatable original tiver um campo `__metatable', um erro é lançado.
@@ -121,12 +145,14 @@ Esta função retorna uma `table`.
 
 Para alterar a metatable de outros tipos do código Lua, você deve utilizar a biblioteca de debugging (§6.10).
 ]]
+
 tonumber            =
 [[
 Quando chamado sem a base, `tonumber` tenta converter seu argumento para um número. Se o argumento já for um número ou uma string numérica, então `tonumber` retorna este número; caso contrário, retorna `fail`.
 
 A conversão de strings pode resultar em números inteiros ou de ponto flutuante, de acordo com as convenções lexicais de Lua (ver §3.1). A string pode ter espaços antes e depois e um sinal.
 ]]
+
 tostring            =
 [[
 Recebe um valor de qualquer tipo e o converte em uma string em formato legível por humanos.
@@ -135,18 +161,23 @@ Se a metatable de `v` tem um campo `__tostring', então `tostring' chama o valor
 
 Para controle completo de como os números são convertidos, utilize $string.format.
 ]]
+
 type                =
 [[
 Retorna o tipo de seu único argumento, codificado como uma string. Os resultados possíveis desta função são `"nil"` (uma string, não o valor `nil`), `"number"`, `"string"`, `"boolean"`, `"table"`, `"function"`, `"thread"`, e `"userdata"`.
 ]]
+
 _VERSION            =
 'Uma variável global (não uma função) que contém uma string contendo a versão Lua em execução.'
+
 warn                =
 'Emite um aviso com uma mensagem composta pela concatenação de todos os seus argumentos (que devem ser strings).'
+
 xpcall['=5.1']      =
 'Faz chamada a função `f` com os argumentos dados e em modo protegido, usando um manipulador de mensagens dado.'
 xpcall['>5.2']      =
 'Faz chamada a função `f` com os argumentos dados e em modo protegido, usando um manipulador de mensagens dado.'
+
 unpack              =
 [[
 Retorna os elementos da lista dada. Esta função é equivalente a
@@ -227,6 +258,7 @@ coroutine.wrap              =
 'Cria uma nova `coroutine`, a partir de uma função `f` e retorna uma função que retorna a coroutine cada vez que ele é chamado.'
 coroutine.yield             =
 'Suspende a execução da coroutine chamada.'
+
 costatus.running            =
 'Está em execução.'
 costatus.suspended          =
@@ -296,6 +328,7 @@ debug.upvalueid             =
 'Retorna um identificador único (como um dado de usuário leve) para o valor antecedente de numero `n` da função dada.'
 debug.upvaluejoin           =
 'Faz o `n1`-ésimo valor da função `f1` (i.e., closure Lua) referir-se ao `n2`-ésimo valor da função `f2`.'
+
 infowhat.n                  =
 '`name` e `namewhat`'
 infowhat.S                  =
@@ -314,6 +347,7 @@ infowhat.r                  =
 '`ftransfer` e `ntransfer`'
 infowhat.L                  =
 '`activelines`'
+
 hookmask.c                  =
 'Faz chamada a um `hook` quando o Lua chama uma função.'
 hookmask.r                  =
@@ -344,6 +378,7 @@ file[':setvbuf']            =
 'Define o modo de `buffer` para um arquivo de saída.'
 file[':write']              =
 'Escreve o valor de cada um de seus argumentos no arquivo.'
+
 readmode.n                  =
 'Lê um numeral e o devolve como número.'
 readmode.a                  =
@@ -352,12 +387,14 @@ readmode.l                  =
 'Lê a próxima linha pulando o final da linha.'
 readmode.L                  =
 'Lê a próxima linha mantendo o final da linha.'
+
 seekwhence.set              =
 'O cursor base é o início do arquivo.'
 seekwhence.cur              =
 'O cursor base é a posição atual.'
 seekwhence['.end']          =
 'O cursor base é o final do arquivo.'
+
 vbuf.no                     =
 'A saída da operação aparece imediatamente.'
 vbuf.full                   =
@@ -402,6 +439,7 @@ io.type                     =
 'Verifica se `obj` é um identificador de arquivo válido.'
 io.write                    =
 'Escreve o valor de cada um dos seus argumentos para o arquivo de saída padrão.'
+
 openmode.r                  =
 'Modo de leitura.'
 openmode.w                  =
@@ -426,10 +464,12 @@ openmode['.w+b']            =
 'Modo de atualização, todos os dados anteriores são apagados. (em modo binário)'
 openmode['.a+b']            =
 'Modo de anexação e atualização, todos os dados anteriores são preservados, a escrita só é permitida no final do arquivo. (em modo binário)'
+
 popenmode.r                 =
 'Leia dados deste programa pelo arquivo.'
 popenmode.w                 =
 'Escreva dados neste programa pelo arquivo.'
+
 filetype.file               =
 '`handler` para arquivo aberto.'
 filetype['.closed file']    =
@@ -550,6 +590,7 @@ os.time                     =
 'Retorna a hora atual quando chamada sem argumentos, ou um valor representando a data e a hora local especificados pela tabela fornecida.'
 os.tmpname                  =
 'Retorna uma string com um nome de arquivo que pode ser usado como arquivo temporário.'
+
 osdate.year                 =
 'Quatro dígitos.'
 osdate.month                =
@@ -571,10 +612,12 @@ osdate.isdst                =
 
 package                     =
 ''
+
 require['<5.3']             =
 'Carrega o módulo fornecido e retorna qualquer valor retornado pelo módulo (`true` quando `nil`).'
 require['>5.4']             =
 'Carrega o módulo fornecido e retorna qualquer valor retornado pelo pesquisador (`true` quando `nil`). Além desse valor, também retorna como segundo resultado um carregador de dados retornados pelo pesquisador, o que indica como `require` encontrou o módulo. (Por exemplo, se o módulo vier de um arquivo, este carregador de dados é o caminho do arquivo.)'
+
 package.config              =
 'string descrevendo configurações a serem utilizadas durante a compilação de pacotes.'
 package.cpath               =
@@ -699,6 +742,4 @@ utf8.codepoint              =
 utf8.len                    =
 'Retorna o número de caracteres UTF-8 na string `s` que começa entre as posições `i` e `j` (ambos inclusos).'
 utf8.offset                 =
-'Returns the position (in bytes) where the encoding of the `n`-th character of `s` (counting from position `i`) starts.'
-utf8.offset                 =
 'Retorna a posição (em bytes) onde a codificação do `n`-ésimo caractere de `s` inícia (contando a partir da posição `i`).'
diff --git a/locale/pt-br/script.lua b/locale/pt-br/script.lua
index f40dc0c6..3b539293 100644
--- a/locale/pt-br/script.lua
+++ b/locale/pt-br/script.lua
@@ -34,8 +34,6 @@ DIAG_PREFIELD_CALL      =
 'Será interpretado como `{}{}`. Pode ser necessário adicionar uma `,` ou `;`.'
 DIAG_OVER_MAX_ARGS      =
 'A função aceita apenas os parâmetros {:d}, mas você passou {:d}.'
-DIAG_OVER_MAX_ARGS      =
-'Recebe apenas {} variáveis, mas você definiu {}.'
 DIAG_AMBIGUITY_1        =
 'Calcule primeiro `{}`. Você pode precisar adicionar colchetes.'
 DIAG_LOWERCASE_GLOBAL   =
@@ -88,7 +86,6 @@ DIAG_DIFFERENT_REQUIRES =
 'O mesmo arquivo é necessário com nomes diferentes.'
 DIAG_REDUNDANT_RETURN   =
 'Retorno redundante.'
-
 DIAG_CIRCLE_DOC_CLASS                 =
 'Classes com herança cíclica.'
 DIAG_DOC_FIELD_NO_CLASS               =
@@ -228,7 +225,6 @@ PARSER_INDEX_IN_FUNC_NAME =
 'A forma `[name]` não pode ser usada em nome de uma função nomeada.'
 PARSER_UNKNOWN_ATTRIBUTE  =
 'Atributo local deve ser `const` ou `close`'
-
 PARSER_LUADOC_MISS_CLASS_NAME           =
 'Esperado <class name>.'
 PARSER_LUADOC_MISS_EXTENDS_SYMBOL       =
@@ -273,7 +269,6 @@ SYMBOL_ANONYMOUS        =
 
 HOVER_VIEW_DOCUMENTS    =
 'Visualizar documentos'
-
 HOVER_DOCUMENT_LUA51    =
 'http://www.lua.org/manual/5.1/manual.html#{}'
 HOVER_DOCUMENT_LUA52    =
@@ -284,8 +279,6 @@ 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     =
@@ -296,7 +289,6 @@ 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      =
 '({} protótipos)'
 HOVER_STRING_BYTES         =
@@ -307,7 +299,6 @@ HOVER_MULTI_DEF_PROTO      =
 '({} definições., {} protótipos)'
 HOVER_MULTI_PROTO_NOT_FUNC =
 '({} definição não funcional)'
-
 HOVER_USE_LUA_PATH      =
 '(Caminho de busca: `{}`)'
 HOVER_EXTENDS           =
@@ -503,3 +494,4 @@ PLUGIN_TRUST_NO                  =
 [[
 Não carregue este plugin
 ]]
+
diff --git a/locale/pt-br/setting.lua b/locale/pt-br/setting.lua
new file mode 100644
index 00000000..3b1c877d
--- /dev/null
+++ b/locale/pt-br/setting.lua
@@ -0,0 +1,2 @@
+---@diagnostic disable: undefined-global
+
diff --git a/locale/zh-cn/meta.lua b/locale/zh-cn/meta.lua
index 61ba6c9b..f9e39cb2 100644
--- a/locale/zh-cn/meta.lua
+++ b/locale/zh-cn/meta.lua
@@ -1,10 +1,11 @@
 ---@diagnostic disable: undefined-global, lowercase-global
 
--- basic
 arg                 =
 '独立版Lua的启动参数。'
+
 assert              =
 '如果其参数 `v` 的值为假（`nil` 或 `false`）， 它就调用 $error； 否则，返回所有的参数。 在错误情况时， `message` 指那个错误对象； 如果不提供这个参数，参数默认为 `"assertion failed!"` 。'
+
 cgopt.collect       =
 '做一次完整的垃圾收集循环。'
 cgopt.stop          =
@@ -25,22 +26,29 @@ 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              =
 [[
 返回三个值（迭代函数、表 `t` 以及 `0` ）， 如此，以下代码
@@ -49,12 +57,14 @@ ipairs              =
 ```
 将迭代键值对 `（1,t[1]) ，(2,t[2])， ...` ，直到第一个空值。
 ]]
+
 loadmode.b        =
 '只能是二进制代码块。'
 loadmode.t        =
 '只能是文本代码块。'
 loadmode.bt       =
 '可以是二进制也可以是文本。'
+
 load['<5.1']      =
 '使用 `func` 分段加载代码块。 每次调用 `func` 必须返回一个字符串用于连接前文。'
 load['>5.2']      =
@@ -63,12 +73,16 @@ load['>5.2']      =
 
 如果 `chunk` 是一个字符串，代码块指这个字符串。 如果 `chunk` 是一个函数， `load` 不断地调用它获取代码块的片断。 每次对 `chunk` 的调用都必须返回一个字符串紧紧连接在上次调用的返回串之后。 当返回空串、`nil`、或是不返回值时，都表示代码块结束。
 ]]
+
 loadfile            =
 '从文件 `filename` 或标准输入（如果文件名未提供）中获取代码块。'
+
 loadstring          =
 '使用给定字符串加载代码块。'
+
 module              =
 '创建一个模块。'
+
 next                =
 [[
 运行程序来遍历表中的所有域。 第一个参数是要遍历的表，第二个参数是表中的某个键。 `next` 返回该键的下一个键及其关联的值。 如果用 `nil` 作为第二个参数调用 `next` 将返回初始键及其关联值。 当以最后一个键去调用，或是以 `nil` 调用一张空表时， `next` 返回 `nil`。 如果不提供第二个参数，将认为它就是 `nil`。 特别指出，你可以用 `next(t)` 来判断一张表是否是空的。
@@ -77,6 +91,7 @@ next                =
 
 当在遍历过程中你给表中并不存在的域赋值， `next` 的行为是未定义的。 然而你可以去修改那些已存在的域。 特别指出，你可以清除一些已存在的域。
 ]]
+
 pairs               =
 [[
 如果 `t` 有元方法 `__pairs`， 以 `t` 为参数调用它，并返回其返回的前三个值。
@@ -89,52 +104,68 @@ 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              =
 [[
 在不触发任何元方法的情况下 将 `table[index]` 设为 `value。` `table` 必须是一张表， `index` 可以是 `nil` 与 `NaN` 之外的任何值。 `value` 可以是任何 Lua 值。
 这个函数返回 `table`。
 ]]
+
 select              =
 '如果 `index` 是个数字， 那么返回参数中第 `index` 个之后的部分； 负的数字会从后向前索引（`-1` 指最后一个参数）。 否则，`index` 必须是字符串 `"#"`， 此时 `select` 返回参数的个数。'
+
 setfenv             =
 '设置给定函数的环境。'
+
 setmetatable        =
 [[
 给指定表设置元表。 （你不能在 Lua 中改变其它类型值的元表，那些只能在 C 里做。） 如果 `metatable` 是 `nil`， 将指定表的元表移除。 如果原来那张元表有 `"__metatable"` 域，抛出一个错误。
 ]]
+
 tonumber            =
 [[
 如果调用的时候没有 `base`， `tonumber` 尝试把参数转换为一个数字。 如果参数已经是一个数字，或是一个可以转换为数字的字符串， `tonumber` 就返回这个数字； 否则返回 `nil`。
 
 字符串的转换结果可能是整数也可能是浮点数， 这取决于 Lua 的转换文法（参见 §3.1）。 （字符串可以有前置和后置的空格，可以带符号。）
 ]]
+
 tostring            =
 [[
 可以接收任何类型，它将其转换为人可阅读的字符串形式。 浮点数总被转换为浮点数的表现形式（小数点形式或是指数形式）。 （如果想完全控制数字如何被转换，可以使用 $string.format。）
 如果 `v` 有 `"__tostring"` 域的元表， `tostring` 会以 `v` 为参数调用它。 并用它的结果作为返回值。
 ]]
+
 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              =
 [[
 返回给定 `list` 中的所有元素。 改函数等价于
@@ -213,6 +244,7 @@ coroutine.wrap                =
 '创建一个主体函数为 `f` 的新协程。 f 必须是一个 Lua 的函数。 返回一个函数， 每次调用该函数都会延续该协程。'
 coroutine.yield               =
 '挂起正在调用的协程的执行。'
+
 costatus.running              =
 '正在运行。'
 costatus.suspended            =
@@ -274,6 +306,7 @@ debug.upvalueid           =
 '返回指定函数第 `n` 个上值的唯一标识符（一个轻量用户数据）。'
 debug.upvaluejoin         =
 '让 Lua 闭包 `f1` 的第 `n1` 个上值 引用 `Lua` 闭包 `f2` 的第 `n2` 个上值。'
+
 infowhat.n                =
 '`name` 和 `namewhat`'
 infowhat.S                =
@@ -292,6 +325,7 @@ infowhat.r                =
 '`ftransfer` 和 `ntransfer`'
 infowhat.L                =
 '`activelines`'
+
 hookmask.c                =
 '每当 Lua 调用一个函数时，调用钩子。'
 hookmask.r                =
@@ -322,6 +356,7 @@ file[':setvbuf']             =
 '设置输出文件的缓冲模式。'
 file[':write']               =
 '将参数的值逐个写入 `file`。'
+
 readmode.n                  =
 '读取一个数字，根据 Lua 的转换文法返回浮点数或整数。'
 readmode.a                  =
@@ -330,12 +365,14 @@ readmode.l                  =
 '读取一行并忽略行结束标记。'
 readmode.L                  =
 '读取一行并保留行结束标记。'
+
 seekwhence.set              =
 '基点为 0 （文件开头）。'
 seekwhence.cur              =
 '基点为当前位置。'
 seekwhence['.end']          =
 '基点为文件尾。'
+
 vbuf.no                     =
 '不缓冲；输出操作立刻生效。'
 vbuf.full                   =
@@ -380,6 +417,7 @@ io.type                    =
 '检查 `obj` 是否是合法的文件句柄。'
 io.write                   =
 '将参数的值逐个写入默认输出文件。'
+
 openmode.r                 =
 '读模式。'
 openmode.w                 =
@@ -404,10 +442,12 @@ openmode['.w+b']           =
 '更新模式，所有之前的数据都删除。（二进制方式）'
 openmode['.a+b']           =
 '追加更新模式，所有之前的数据都保留，只允许在文件尾部做写入。（二进制方式）'
+
 popenmode.r                =
 '从这个程序中读取数据。（二进制方式）'
 popenmode.w                =
 '向这个程序写入输入。（二进制方式）'
+
 filetype.file              =
 '是一个打开的文件句柄。'
 filetype['.closed file']   =
@@ -528,6 +568,7 @@ os.time                     =
 '当不传参数时，返回当前时刻。 如果传入一张表，就返回由这张表表示的时刻。'
 os.tmpname                  =
 '返回一个可用于临时文件的文件名字符串。'
+
 osdate.year                 =
 '四位数字'
 osdate.month                =
@@ -549,10 +590,12 @@ osdate.isdst                =
 
 package                     =
 ''
+
 require['<5.3']             =
 '加载一个模块，返回该模块的返回值（`nil`时为`true`）。'
 require['>5.4']             =
 '加载一个模块，返回该模块的返回值（`nil`时为`true`）与搜索器返回的加载数据。默认搜索器的加载数据指示了加载位置，对于文件来说就是文件路径。'
+
 package.config              =
 '一个描述有一些为包管理准备的编译期配置信息的串。'
 package.cpath               =
@@ -641,6 +684,7 @@ a1[f],···,a1[e]
 return a2
 ```
 ]]
+
 table.pack                  =
 '返回用所有参数以键 `1`,`2`, 等填充的新表， 并将 `"n"` 这个域设为参数的总数。'
 table.remove                =
diff --git a/locale/zh-cn/script.lua b/locale/zh-cn/script.lua
index 8cdb9ce3..79ae4c54 100644
--- a/locale/zh-cn/script.lua
+++ b/locale/zh-cn/script.lua
@@ -94,7 +94,6 @@ DIAG_NOT_YIELDABLE      =
 '此函数的第 {} 个参数没有被标记为可让出，但是传入了异步函数。（使用 `---@param name async fun()` 来标记为可让出）'
 DIAG_DISCARD_RETURNS    =
 '不能丢弃此函数的返回值。'
-
 DIAG_CIRCLE_DOC_CLASS                 =
 '循环继承的类。'
 DIAG_DOC_FIELD_NO_CLASS               =
@@ -234,7 +233,6 @@ PARSER_INDEX_IN_FUNC_NAME =
 '命名函数的名称中不能使用 `[name]` 形式。'
 PARSER_UNKNOWN_ATTRIBUTE  =
 '局部变量属性应该是 `const` 或 `close`'
-
 PARSER_LUADOC_MISS_CLASS_NAME           =
 '缺少类名称。'
 PARSER_LUADOC_MISS_EXTENDS_SYMBOL       =
@@ -279,7 +277,6 @@ SYMBOL_ANONYMOUS        =
 
 HOVER_VIEW_DOCUMENTS    =
 '查看文档'
-
 HOVER_DOCUMENT_LUA51    =
 'http://www.lua.org/manual/5.1/manual.html#{}'
 HOVER_DOCUMENT_LUA52    =
@@ -290,7 +287,6 @@ 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     =
@@ -301,7 +297,6 @@ 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         =
@@ -312,7 +307,6 @@ HOVER_MULTI_DEF_PROTO      =
 '({} 个定义，{} 个原型)'
 HOVER_MULTI_PROTO_NOT_FUNC =
 '({} 个非函数定义)'
-
 HOVER_USE_LUA_PATH      =
 '（搜索路径： `{}`）'
 HOVER_EXTENDS           =
diff --git a/locale/zh-cn/setting.lua b/locale/zh-cn/setting.lua
index 7323d68e..7592414a 100644
--- a/locale/zh-cn/setting.lua
+++ b/locale/zh-cn/setting.lua
@@ -211,8 +211,6 @@ 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']       =
diff --git a/locale/zh-tw/meta.lua b/locale/zh-tw/meta.lua
index bd02c566..9cb2f460 100644
--- a/locale/zh-tw/meta.lua
+++ b/locale/zh-tw/meta.lua
@@ -1,10 +1,11 @@
 ---@diagnostic disable: undefined-global, lowercase-global
 
--- basic
 arg =
 '獨立版Lua的啟動參數。 '
+
 assert =
 '如果其參數`v` 的值為假（`nil` 或`false`）， 它就呼叫$error； 否則，回傳所有的參數。在錯誤情況時， `message` 指那個錯誤對象； 如果不提供這個參數，參數預設為`"assertion failed!"` 。 '
+
 cgopt.collect =
 '做一次完整的垃圾回收循環。 '
 cgopt.stop =
@@ -25,22 +26,29 @@ 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 =
 [[
 回傳三個值（疊代函式、表`t` 以及`0` ）， 如此，以下程式碼
@@ -49,12 +57,14 @@ ipairs =
 ```
 將疊代鍵值對`（1,t[1]) ，(2,t[2])， ...` ，直到第一個空值。
 ]]
+
 loadmode.b =
 '只能是二進制程式碼區塊。 '
 loadmode.t =
 '只能是文字程式碼區塊。 '
 loadmode.bt =
 '可以是二進制也可以是文字。 '
+
 load['<5.1'] =
 '使用`func` 分段載入程式碼區塊。每次呼叫`func` 必須回傳一個字串用於連接前文。 '
 load['>5.2'] =
@@ -63,12 +73,16 @@ load['>5.2'] =
 
 如果`chunk` 是一個字串，程式碼區塊指這個字串。如果`chunk` 是一個函式， `load` 不斷地呼叫它獲取程式碼區塊的片段。每次對`chunk` 的呼叫都必須回傳一個字串緊緊連接在上次呼叫的回傳串之後。當回傳空串、`nil`、或是不回傳值時，都表示程式碼區塊結束。
 ]]
+
 loadfile =
 '從檔案`filename` 或標準輸入（如果檔名未提供）中獲取程式碼區塊。 '
+
 loadstring =
 '使用給定字串載入程式碼區塊。 '
+
 module =
 '創建一個模組。 '
+
 next =
 [[
 執行程式來走訪表中的所有域。第一個參數是要走訪的表，第二個參數是表中的某個鍵。 `next` 回傳該鍵的下一個鍵及其關聯的值。如果用`nil` 作為第二個參數呼叫`next` 將回傳初始鍵及其關聯值。當以最後一個鍵去呼叫，或是以`nil` 呼叫一張空表時， `next` 回傳`nil`。如果不提供第二個參數，將認為它就是`nil`。特別指出，你可以用`next(t)` 來判斷一張表是否是空的。
@@ -77,6 +91,7 @@ next =
 
 當在走訪過程中你給表中並不存在的域賦值， `next` 的行為是未定義的。然而你可以去修改那些已存在的域。特別指出，你可以清除一些已存在的域。
 ]]
+
 pairs =
 [[
 如果`t` 有元方法`__pairs`， 以`t` 為參數呼叫它，並回傳其回傳的前三個值。
@@ -89,52 +104,68 @@ 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 =
 [[
 在不觸發任何元方法的情況下將`table[index]` 設為`value。 ` `table` 必須是一張表， `index` 可以是`nil` 與`NaN` 之外的任何值。 `value` 可以是任何Lua 值。
 這個函式回傳`table`。
 ]]
+
 select =
 '如果`index` 是個數字， 那麼回傳參數中第`index` 個之後的部分； 負的數字會從後向前索引（`-1` 指最後一個參數）。否則，`index` 必須是字串`"#"`， 此時`select` 回傳參數的個數。 '
+
 setfenv =
 '設定給定函式的環境。 '
+
 setmetatable =
 [[
 給指定表設定元表。 （你不能在Lua 中改變其它類型值的元表，那些只能在C 裡做。） 如果`metatable` 是`nil`， 將指定表的元表移除。如果原來那張元表有`"__metatable"` 域，拋出一個錯誤。
 ]]
+
 tonumber =
 [[
 如果呼叫的時候沒有`base`， `tonumber` 嘗試把參數轉換為一個數字。如果參數已經是一個數字，或是一個可以轉換為數字的字串， `tonumber` 就回傳這個數字； 否則回傳`nil`。
 
 字串的轉換結果可能是整數也可能是浮點數， 這取決於Lua 的轉換文法（參見§3.1）。 （字串可以有前置和後置的空格，可以帶符號。）
 ]]
+
 tostring =
 [[
 可以接收任何類型，它將其轉換為人可閱讀的字串形式。浮點數總被轉換為浮點數的表現形式（小數點形式或是指數形式）。 （如果想完全控制數字如何被轉換，可以使用$string.format。）
 如果`v` 有`"__tostring"` 域的元表， `tostring` 會以`v` 為參數呼叫它。並用它的結果作為回傳值。
 ]]
+
 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 =
 [[
 回傳給定`list` 中的所有元素。改函式等價於
@@ -213,6 +244,7 @@ coroutine.wrap =
 '創建一個主體函式為`f` 的新共常式。 f 必須是一個Lua 的函式。回傳一個函式， 每次呼叫該函式都會延續該共常式。 '
 coroutine.yield =
 '掛起正在呼叫的共常式的執行。 '
+
 costatus.running =
 '正在執行。 '
 costatus.suspended =
@@ -274,6 +306,7 @@ debug.upvalueid =
 '回傳指定函式第`n` 個上值的唯一標識符（一個輕量使用者資料）。 '
 debug.upvaluejoin =
 '讓Lua 閉包`f1` 的第`n1` 個上值引用`Lua` 閉包`f2` 的第`n2` 個上值。 '
+
 infowhat.n =
 '`name` 和`namewhat`'
 infowhat.S =
@@ -292,6 +325,7 @@ infowhat.r =
 '`ftransfer` 和`ntransfer`'
 infowhat.L =
 '`activelines`'
+
 hookmask.c =
 '每當Lua 呼叫一個函式時，呼叫鉤子。 '
 hookmask.r =
@@ -322,6 +356,7 @@ file[':setvbuf'] =
 '設定輸出檔案的緩衝模式。 '
 file[':write'] =
 '將參數的值逐個寫入`file`。 '
+
 readmode.n =
 '讀取一個數字，根據Lua 的轉換文法回傳浮點數或整數。 '
 readmode.a =
@@ -330,12 +365,14 @@ readmode.l =
 '讀取一行並忽略行結束標記。 '
 readmode.L =
 '讀取一行並保留行結束標記。 '
+
 seekwhence.set =
 '基點為0 （檔案開頭）。 '
 seekwhence.cur =
 '基點為目前位置。 '
 seekwhence['.end'] =
 '基點為檔案尾。 '
+
 vbuf.no =
 '不緩衝；輸出操作立刻生效。 '
 vbuf.full =
@@ -380,6 +417,7 @@ io.type =
 '檢查`obj` 是否是合法的檔案控制代碼。 '
 io.write =
 '將參數的值逐個寫入預設輸出檔案。 '
+
 openmode.r =
 '讀模式。 '
 openmode.w =
@@ -404,10 +442,12 @@ openmode['.w+b'] =
 '更新模式，所有之前的資料都刪除。 （二進制方式）'
 openmode['.a+b'] =
 '追加更新模式，所有之前的資料都保留，只允許在檔案尾部做寫入。 （二進制方式）'
+
 popenmode.r =
 '從這個程式中讀取資料。 （二進制方式）'
 popenmode.w =
 '向這個程式寫入輸入。 （二進制方式）'
+
 filetype.file =
 '是一個打開的檔案控制代碼。 '
 filetype['.closed file'] =
@@ -528,6 +568,7 @@ os.time =
 '當不傳參數時，回傳目前時刻。如果傳入一張表，就回傳由這張表表示的時刻。 '
 os.tmpname =
 '回傳一個可用於臨時檔案的檔名字串。 '
+
 osdate.year =
 '四位數字'
 osdate.month =
@@ -549,10 +590,12 @@ osdate.isdst =
 
 package =
 ''
+
 require['<5.3'] =
 '載入一個模組，回傳該模組的回傳值（`nil`時為`true`）。 '
 require['>5.4'] =
 '載入一個模組，回傳該模組的回傳值（`nil`時為`true`）與搜尋器回傳的載入資料。預設搜尋器的載入資料指示了載入位置，對於檔案來說就是檔案路徑。 '
+
 package.config =
 '一個描述有一些為包管理準備的編譯期配置訊息的串。 '
 package.cpath =
@@ -641,6 +684,7 @@ a1[f],···,a1[e]
 return a2
 ```
 ]]
+
 table.pack =
 '回傳用所有參數以鍵`1`,`2`, 等填充的新表， 並將`"n"` 這個域設為參數的總數。 '
 table.remove =
diff --git a/locale/zh-tw/script.lua b/locale/zh-tw/script.lua
index de4e0abb..64858686 100644
--- a/locale/zh-tw/script.lua
+++ b/locale/zh-tw/script.lua
@@ -94,7 +94,6 @@ DIAG_NOT_YIELDABLE =
 '此函式的第{} 個參數沒有被標記為可讓出，但是傳入了異步函式。 （使用`---@param name async fun()` 來標記為可讓出）'
 DIAG_DISCARD_RETURNS =
 '不能丟棄此函式的回傳值。 '
-
 DIAG_CIRCLE_DOC_CLASS =
 '循環繼承的類。 '
 DIAG_DOC_FIELD_NO_CLASS =
@@ -234,7 +233,6 @@ PARSER_INDEX_IN_FUNC_NAME =
 '命名函式的名稱中不能使用`[name]` 形式。 '
 PARSER_UNKNOWN_ATTRIBUTE =
 '區域變數屬性應該是`const` 或`close`'
-
 PARSER_LUADOC_MISS_CLASS_NAME =
 '缺少類別名稱。 '
 PARSER_LUADOC_MISS_EXTENDS_SYMBOL =
@@ -279,7 +277,6 @@ SYMBOL_ANONYMOUS =
 
 HOVER_VIEW_DOCUMENTS =
 '查看文件'
-
 HOVER_DOCUMENT_LUA51 =
 'http://www.lua.org/manual/5.1/manual.html#{}'
 HOVER_DOCUMENT_LUA52 =
@@ -290,7 +287,6 @@ 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 =
@@ -301,7 +297,6 @@ 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 =
@@ -312,7 +307,6 @@ HOVER_MULTI_DEF_PROTO =
 '({} 個定義，{} 個原型)'
 HOVER_MULTI_PROTO_NOT_FUNC =
 '({} 個非函式定義)'
-
 HOVER_USE_LUA_PATH =
 '（搜尋路徑： `{}`）'
 HOVER_EXTENDS =
diff --git a/locale/zh-tw/setting.lua b/locale/zh-tw/setting.lua
index f2a6d0a8..e5ce01af 100644
--- a/locale/zh-tw/setting.lua
+++ b/locale/zh-tw/setting.lua
@@ -211,8 +211,6 @@ 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'] =