finish meta locale in en-US

1 files changed, 417 insertions, 0 deletions

diff --git a/locale/en-US/meta.lni b/locale/en-US/meta.lni
new file mode 100644
index 00000000..fafbff92
--- /dev/null
+++ b/locale/en-US/meta.lni
@@ -0,0 +1,417 @@
+-- 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  "      = Stops automatic execution.
+"cgopt.restart"     = Restarts automatic execution.
+"cgopt.count "      = Returns the total memory in Kbytes.
+"cgopt.step"        = Performs a garbage-collection step.
+"cgopt.setpause"    = Set `pause`.
+"cgopt.setstepmul"  = Set `step multiplier`.
+"cgopt.incremental" = Change the collector mode to incremental.
+"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
+```lua
+    for i,v in ipairs(t) do body end
+```
+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"          = [[
+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.
+
+The order in which the indices are enumerated is not specified, *even for numeric indices*. (To traverse a table in numerical order, use a numerical `for`.)
+
+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.
+]]
+paris               = [[
+If `t` has a metamethod `__pairs`, calls it with t as argument and returns the first three results from the call.
+
+Otherwise, returns three values: the $next function, the table `t`, and `nil`, so that the construction
+```lua
+    for k,v in pairs(t) do body end
+```
+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             = ''
+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.
+
+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.
+
+If the metatable of `v` has a `__tostring` field, then `tostring` calls the corresponding value with `v` as argument, and uses the result of the call as its result. Otherwise, if the metatable of `v` has a `__name` field with a string value, `tostring` may use that string in its final result.
+
+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
+```lua
+    return list[i], list[i+1], ···, list[j]
+```
+]]
+
+bit32               = ''
+"bit32.arshift"     = [[
+Returns the number `x` shifted `disp` bits to the right. Negative displacements shift to the left.
+
+This shift operation is what is called arithmetic shift. Vacant bits on the left are filled with copies of the higher bit of `x`; vacant bits on the right are filled with zeros.
+]]
+"bit32.band"        = Returns the bitwise *and* of its operands.
+"bit32.bnot"        = [[
+Returns the bitwise negation of `x`.
+
+```lua
+assert(bit32.bnot(x) == (-1 - x) % 2^32)
+```
+]]
+"bit32.bor"         = Returns the bitwise *or* of its operands.
+"bit32.btest"       = Returns a boolean signaling whether the bitwise *and* of its operands is different from zero.
+"bit32.bxor"        = Returns the bitwise *exclusive or* of its operands.
+"bit32.extract"     = Returns the unsigned number formed by the bits `field` to `field + width - 1` from `n`.
+"bit32.replace"     = Returns a copy of `n` with the bits `field` to `field + width - 1` replaced by the value `v` .
+"bit32.lrotate"     = Returns the number `x` rotated `disp` bits to the left. Negative displacements rotate to the right.
+"bit32.lshift"      = [[
+Returns the number `x` shifted `disp` bits to the left. Negative displacements shift to the right. In any direction, vacant bits are filled with zeros.
+
+```lua
+assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
+```
+]]
+"bit32.rrotate"     = Returns the number `x` rotated `disp` bits to the right. Negative displacements rotate to the left.
+"bit32.rshift"      = [[
+Returns the number `x` shifted `disp` bits to the right. Negative displacements shift to the left. In any direction, vacant bits are filled with zeros.
+
+```lua
+assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))
+```
+]]
+
+coroutine                   = ''
+"coroutine.create"          = Creates a new coroutine, with body `f`. `f` must be a function. Returns this new coroutine, an object with type `"thread"`.
+"coroutine.isyieldable"     = Returns true when the running coroutine can yield.
+"coroutine.isyieldable>5.4" = Returns true when the coroutine `co` can yield. The default for `co` is the running coroutine.
+"coroutine.close"           = Closes coroutine `co` , closing all its pending to-be-closed variables and putting the coroutine in a dead state.
+"coroutine.resume"          = Starts or continues the execution of coroutine `co`.
+"coroutine.running"         = Returns the running coroutine plus a boolean, true when the running coroutine is the main one.
+"coroutine.status"          = Returns the status of coroutine `co`.
+"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"        = Is suspended or not started.
+"costatus.normal"           = Is active but not running.
+"costatus.dead"             = Has finished or stopped with an error.
+
+debug                       = ''
+"debug.debug"               = Enters an interactive mode with the user, running each string that the user enters.
+"debug.getfenv"             = Returns the environment of object `o` .
+"debug.gethook"             = Returns the current hook settings of the thread.
+"debug.getinfo"             = Returns a table with information about a function.
+"debug.getlocal<5.1"        = Returns the name and the value of the local variable with index `local` of the function at level `level` of the stack.
+"debug.getlocal>5.2"        = Returns the name and the value of the local variable with index `local` of the function at level `f` of the stack.
+"debug.getmetatable"        = Returns the metatable of the given value.
+"debug.getregistry"         = Returns the registry table.
+"debug.getupvalue"          = Returns the name and the value of the upvalue with index `up` of the function.
+"debug.getuservalue<5.3"    = Returns the Lua value associated to u.
+"debug.getuservalue>5.4"    = [[
+Returns the `n`-th user value associated
+to the userdata `u` plus a boolean,
+`false` if the userdata does not have that value.
+]]
+"debug.setcstacklimit"      = [[
+### **Deprecated in `Lua 5.4.2`**
+
+Sets a new limit for the C stack. This limit controls how deeply nested calls can go in Lua, with the intent of avoiding a stack overflow.
+
+In case of success, this function returns the old limit. In case of error, it returns `false`.
+]]
+"debug.setfenv"             = Sets the environment of the given `object` to the given `table` .
+"debug.sethook"             = Sets the given function as a hook.
+"debug.setlocal"            = Assigns the `value` to the local variable with index `local` of the function at `level` of the stack.
+"debug.setmetatable"        = Sets the metatable for the given value to the given table (which can be `nil`).
+"debug.setupvalue"          = Assigns the `value` to the upvalue with index `up` of the function.
+"debug.setuservalue<5.3"    = Sets the given value as the Lua value associated to the given udata.
+"debug.setuservalue>5.4"    = [[
+Sets the given `value` as
+the `n`-th user value associated to the given `udata`.
+`udata` must be a full userdata.
+]]
+"debug.traceback"           = Returns a string with a traceback of the call stack. The optional message string is appended at the beginning of the traceback.
+"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"                = `source`, `short_src`, `linedefined`, `lastlinedefined`, and `what`'
+"infowhat.l"                = `currentline`
+"infowhat.t"                = `istailcall`
+"infowhat.u<5.1"            = `nups`
+"infowhat.u>5.2"            = `nups`, `nparams`, and `isvararg`
+"infowhat.f"                = `func`
+"infowhat.r"                = `ftransfer` and `ntransfer`
+"infowhat.L"                = `activelines`
+"hookmask.c"                = Calls hook when Lua calls a function.
+"hookmask.r"                = Calls hook when Lua returns from a function.
+"hookmask.l"                = Calls hook when Lua enters a new line of code.
+
+file                        = ''
+"file:close"                = Close `file`.
+"file:flush"                = Saves any written data to `file`.
+"file:lines"                = [[
+------
+```lua
+for c in file:lines(...) do
+    body
+end
+```
+]]
+"file:read"                 = Reads the `file`, according to the given formats, which specify what to read.
+"file:seek"                 = Sets and gets the file position, measured from the beginning of the file.
+"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"                = Reads the whole file.
+"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"                 = Performed only when the buffer is full.
+"vbuf.line"                 = Buffered until a newline is output.
+
+io                          = ''
+"io.stdin"                  = standard input.
+"io.stdout"                 = standard output.
+"io.stderr"                 = standard error.
+"io.close"                  = Close `file` or default output file.
+"io.flush"                  = Saves any written data to default output file.
+"io.input"                  = Sets `file` as the default input file.
+"io.lines"                  = [[
+------
+```lua
+for c in io.lines(filename, ...) do
+    body
+end
+```
+]]
+"io.open"                   = Opens a file, in the mode specified in the string `mode`.
+"io.output"                 = Sets `file` as the default output file.
+"io.popen"                  = Starts program prog in a separated process.
+"io.read"                   = Reads the `file`, according to the given formats, which specify what to read.
+"io.tempfile"               = In case of success, returns a handle for a temporary file.
+"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"                = Write mode.
+"openmode.a"                = Append mode.
+"openmode.r+"               = Update mode, all previous data is preserved.
+"openmode.w+"               = Update mode, all previous data is erased.
+"openmode.a+"               = Append update mode, previous data is preserved, writing is only allowed at the end of file.
+"openmode.rb"                = Read mode. (in binary mode.)
+"openmode.wb"                = Write mode. (in binary mode.)
+"openmode.ab"                = Append mode. (in binary mode.)
+"openmode.r+b"               = Update mode, all previous data is preserved. (in binary mode.)
+"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"      = Is a closed file handle.
+"filetype.nil"              = Is not a file handle.
+
+math                        = ''
+"math.abs"                  = Returns the absolute value of `x`.
+"math.acos"                 = Returns the arc cosine of `x` (in radians).
+"math.asin"                 = Returns the arc sine of `x` (in radians).
+"math.atan<5.2"             = Returns the arc tangent of `x` (in radians).
+"math.atan>5.3"             = Returns the arc tangent of `y/x` (in radians).
+"math.atan2"                = Returns the arc tangent of `y/x` (in radians).
+"math.ceil"                 = Returns the smallest integral value larger than or equal to `x`.
+"math.cos"                  = Returns the cosine of `x` (assumed to be in radians).
+"math.cosh"                 = Returns the hyperbolic cosine of `x` (assumed to be in radians).
+"math.deg"                  = Converts the angle `x` from radians to degrees.
+"math.exp"                  = Returns the value `e^x` (where `e` is the base of natural logarithms).
+"math.floor"                = Returns the largest integral value smaller than or equal to `x`.
+"math.fmod"                 = Returns the remainder of the division of `x` by `y` that rounds the quotient towards zero.
+"math.frexp"                = Decompose `x` into tails and exponents. Returns `m` and `e` such that `x = m * (2 ^ e)`, `e` is an integer and the absolute value of `m` is in the range [0.5, 1) (or zero when `x` is zero).
+"math.huge"                 = A value larger than any other numeric value.
+"math.ldexp"                = Returns `m * (2 ^ e)` .
+"math.log<5.1"              = Returns the natural logarithm of `x` .
+"math.log>5.2"              = Returns the logarithm of `x` in the given base.
+"math.log10"                = Returns the base-10 logarithm of x.
+"math.max"                  = Returns the argument with the maximum value, according to the Lua operator `<`.
+"math.maxinteger"           = An integer with the maximum value for an integer.
+"math.min"                  = Returns the argument with the minimum value, according to the Lua operator `<`.
+"math.mininteger"           = An integer with the minimum value for an integer.
+"math.modf"                 = Returns the integral part of `x` and the fractional part of `x`.
+"math.pi"                   = The value of *π*.
+"math.pow"                  = Returns `x ^ y` .
+"math.rad"                  = Converts the angle `x` from degrees to radians.
+"math.random"               = [[
+* `math.random()`: Returns a float in the range [0,1).
+* `math.random(n)`: Returns a integer in the range [1, n].
+* `math.random(m, n)`: Returns a integer in the range [m, n].
+]]
+"math.randomseed<5.3"       = Sets `x` as the "seed" for the pseudo-random generator.
+"math.randomseed>5.4"       = [[
+* `math.randomseed(x, y)`: Concatenate `x` and `y` into a 128-bit `seed` to reinitialize the pseudo-random generator.
+* `math.randomseed(x)`: Equate to `math.randomseed(x, 0)` .
+* `math.randomseed()`: Generates a seed with a weak attempt for randomness.
+]]
+"math.sin"                  = Returns the sine of `x` (assumed to be in radians).
+"math.sinh"                 = Returns the hyperbolic sine of `x` (assumed to be in radians).
+"math.sqrt"                 = Returns the square root of `x`.
+"math.tan"                  = Returns the tangent of `x` (assumed to be in radians).
+"math.tanh"                 = Returns the hyperbolic tangent of `x` (assumed to be in radians).
+"math.tointeger"            = If the value `x` is convertible to an integer, returns that integer.
+"math.type"                 = Returns `"integer"` if `x` is an integer, `"float"` if it is a float, or `nil` if `x` is not a number.
+"math.ult"                  = Returns `true` if and only if `m` is below `n` when they are compared as unsigned integers.
+
+os                          = ''
+"os.clock"                  = Returns an approximation of the amount in seconds of CPU time used by the program.
+"os.date"                   = Returns a string or a table containing date and time, formatted according to the given string `format`.
+"os.difftime"               = Returns the difference, in seconds, from time `t1` to time `t2`.
+"os.execute"                = Passes `command` to be executed by an operating system shell.'
+"os.exit<5.1"               = Calls the C function `exit` to terminate the host program.
+"os.exit>5.2"               = Calls the ISO C function `exit` to terminate the host program.
+"os.getenv"                 = Returns the value of the process environment variable `varname`.
+"os.remove"                 = Deletes the file with the given name.
+"os.rename"                 = Renames the file or directory named `oldname` to `newname`.
+"os.setlocale"              = Sets the current locale of the program.
+"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.
+
+package                     = ''
+"package.config"            = A string describing some compile-time configurations for packages.
+"package.cpath"             = The path used by `require` to search for a C loader.
+"package.loaded"            = A table used by `require` to control which modules are already loaded.
+"package.loaders"           = A table used by `require` to control how to load modules.
+"package.loadlib"           = Dynamically links the host program with the C library `libname`.
+"package.path"              = The path used by `require` to search for a Lua loader.
+"package.preload"           = A table to store loaders for specific modules.
+"package.searchers"         = A table used by `require` to control how to load modules.
+"package.searchpath"        = Searches for the given `name` in the given `path`.
+"package.seeall"            = Sets a metatable for `module` with its `__index` field referring to the global environment, so that this module inherits values from the global environment. To be used as an option to function `module` .
+
+string                      = ''
+"string.byte"               = Returns the internal numeric codes of the characters `s[i], s[i+1], ..., s[j]`.
+"string.char"               = Returns a string with length equal to the number of arguments, in which each character has the internal numeric code equal to its corresponding argument.
+"string.dump"               = Returns a string containing a binary representation (a *binary chunk*) of the given function.
+"string.find"               = Looks for the first match of `pattern` (see §6.4.1) in the string.
+"string.format"             = Returns a formatted version of its variable number of arguments following the description given in its first argument.
+"string.gmatch"             = [[
+Returns an iterator function that, each time it is called, returns the next captures from `pattern` (see §6.4.1) over the string s. 
+
+As an example, the following loop will iterate over all the words from string s, printing one per line:
+```lua
+    s = "hello world from Lua"
+    for w in string.gmatch(s, "%a+") do
+        print(w)
+    end
+```
+]]
+"string.gsub"               = Returns a copy of s in which all (or the first `n`, if given) occurrences of the `pattern` (see §6.4.1) have been replaced by a replacement string specified by `repl`.
+"string.len"                = Returns its length.
+"string.lower"              = Returns a copy of this string with all uppercase letters changed to lowercase.
+"string.match"              = Looks for the first match of `pattern` (see §6.4.1) in the string.
+"string.pack"               = Returns a binary string containing the values `v1`, `v2`, etc. packed (that is, serialized in binary form) according to the format string `fmt` (see §6.4.2) .
+"string.packsize"           = Returns the size of a string resulting from `string.pack` with the given format string `fmt` (see §6.4.2) .
+"string.rep>5.2"            = Returns a string that is the concatenation of `n` copies of the string `s` separated by the string `sep`.
+"string.rep<5.1"            = Returns a string that is the concatenation of `n` copies of the string `s` .
+"string.reverse"            = Returns a string that is the string `s` reversed.
+"string.sub"                = Returns the substring of the string that starts at `i` and continues until `j`.
+"string.unpack"             = Returns the values packed in string according to the format string `fmt` (see §6.4.2) .
+"string.upper"              = Returns a copy of this string with all lowercase letters changed to uppercase.
+
+table                       = ''
+"table.concat"              = Given a list where all elements are strings or numbers, returns the string `list[i]..sep..list[i+1] ··· sep..list[j]`.
+"table.insert"              = Inserts element `value` at position `pos` in `list`.
+"table.maxn"                = Returns the largest positive numerical index of the given table, or zero if the table has no positive numerical indices.
+"table.move"                = [[
+Moves elements from table `a1` to table `a2`.
+```lua
+a2[t],··· = a1[f],···,a1[e]
+return a2
+```
+]]
+"table.pack"                = Returns a new table with all arguments stored into keys `1`, `2`, etc. and with a field `"n"` with the total number of arguments.
+"table.remove"              = Removes from `list` the element at position `pos`, returning the value of the removed element.
+"table.sort"                = Sorts list elements in a given order, *in-place*, from `list[1]` to `list[#list]`.
+"table.unpack"              = [[
+Returns the elements from the given list. This function is equivalent to
+```lua
+    return list[i], list[i+1], ···, list[j]
+```
+By default, `i` is `1` and `j` is `#list`.
+]]
+
+utf8                        = ''
+"utf8.char"                 = Receives zero or more integers, converts each one to its corresponding UTF-8 byte sequence and returns a string with the concatenation of all these sequences.
+"utf8.charpattern"          = The pattern which matches exactly one UTF-8 byte sequence, assuming that the subject is a valid UTF-8 string.
+"utf8.codes"                = [[
+Returns values so that the construction
+```lua
+for p, c in utf8.codes(s) do
+    body
+end
+```
+will iterate over all UTF-8 characters in string s, with p being the position (in bytes) and c the code point of each character. It raises an error if it meets any invalid byte sequence.
+]]
+"utf8.codepoint"            = Returns the codepoints (as integers) from all characters in `s` that start between byte position `i` and `j` (both included).
+"utf8.len"                  = Returns the number of UTF-8 characters in string `s` that start between positions `i` and `j` (both inclusive).
+"utf8.offset"               = Returns the position (in bytes) where the encoding of the `n`-th character of `s` (counting from position `i`) starts.