@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/lua.json

@@ -0,0 +1,181 @@
+{
+  "language": "lua",
+  "definitions": {
+    "string": {
+      "signature": "string library",
+      "description": "The string library provides generic functions for string manipulation, such as finding and extracting substrings and pattern matching. In Lua, strings are indexed starting at 1 and can contain embedded zeros. Negative indices count from the end of the string.",
+      "type": "module",
+      "module": "string",
+      "members": {
+        "format": { "signature": "string.format(formatstring, ···)", "description": "Returns a formatted version of its variable number of arguments following the description given in formatstring. Similar to the ISO C function sprintf. Supports format specifiers: %d, %i, %u, %f, %e, %g, %x, %o, %s, %q, %c, and %%.", "type": "function" },
+        "find": { "signature": "string.find(s, pattern [, init [, plain]])", "description": "Looks for the first match of pattern in the string s. If found, returns the indices of s where the match starts and ends; otherwise returns nil. If pattern has captures, the captured values are also returned. The optional init specifies where to start the search (default 1). If plain is true, pattern matching is turned off.", "type": "function" },
+        "match": { "signature": "string.match(s, pattern [, init])", "description": "Looks for the first match of pattern in the string s. If found, returns the captures from the pattern; otherwise returns nil. If pattern specifies no captures, the whole match is returned.", "type": "function" },
+        "gmatch": { "signature": "string.gmatch(s, pattern)", "description": "Returns an iterator function that, each time it is called, returns the next captures from pattern over the string s. If pattern has no captures, the whole match is produced in each call. In Lua 5.4, an optional init argument specifies where to start.", "type": "function" },
+        "gsub": { "signature": "string.gsub(s, pattern, repl [, n])", "description": "Returns a copy of s in which all (or the first n) occurrences of the pattern have been replaced by a replacement string/table/function repl. Also returns the total number of matches as a second value.", "type": "function" },
+        "sub": { "signature": "string.sub(s, i [, j])", "description": "Returns the substring of s that starts at i and continues until j (inclusive). i and j can be negative, counting from the end. Default j is -1 (end of string).", "type": "function" },
+        "rep": { "signature": "string.rep(s, n [, sep])", "description": "Returns a string that is the concatenation of n copies of the string s separated by the string sep. The default value for sep is the empty string. Available since Lua 5.2 for the sep parameter.", "type": "function" },
+        "reverse": { "signature": "string.reverse(s)", "description": "Returns a string that is the string s reversed.", "type": "function" },
+        "upper": { "signature": "string.upper(s)", "description": "Returns a copy of s with all lowercase letters changed to uppercase. The definition of what a lowercase letter is depends on the current locale.", "type": "function" },
+        "lower": { "signature": "string.lower(s)", "description": "Returns a copy of s with all uppercase letters changed to lowercase. The definition of what an uppercase letter is depends on the current locale.", "type": "function" },
+        "len": { "signature": "string.len(s)", "description": "Returns the length of the string s. The empty string has length 0. Embedded zeros are counted, so \"a\\000bc\\000\" has length 5.", "type": "function" },
+        "byte": { "signature": "string.byte(s [, i [, j]])", "description": "Returns the internal numeric codes of the characters s[i], s[i+1], ..., s[j]. The default value for i is 1; the default value for j is i.", "type": "function" },
+        "char": { "signature": "string.char(···)", "description": "Receives zero or more integers. 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.", "type": "function" },
+        "dump": { "signature": "string.dump(function [, strip])", "description": "Returns a string containing a binary representation of the given function, so that a later load on this string returns a copy of the function. In Lua 5.3+, if strip is true, the binary representation may not include debug information.", "type": "function" }
+      }
+    },
+    "table": {
+      "signature": "table library",
+      "description": "The table library provides generic functions for table manipulation. It provides its functions as fields of the global table `table`. Most functions assume the table represents a list/array (integer keys from 1 to a given n).",
+      "type": "module",
+      "module": "table",
+      "members": {
+        "insert": { "signature": "table.insert(list, [pos,] value)", "description": "Inserts element value at position pos in list, shifting up the elements list[pos], list[pos+1], ..., list[#list]. The default value for pos is #list+1, so a call table.insert(t, x) inserts x at the end of list t.", "type": "function" },
+        "remove": { "signature": "table.remove(list [, pos])", "description": "Removes from list the element at position pos, returning the value of the removed element. The default value for pos is #list, so that a call table.remove(l) removes the last element.", "type": "function" },
+        "sort": { "signature": "table.sort(list [, comp])", "description": "Sorts the list elements in a given order, in-place, from list[1] to list[#list]. If comp is given, it must be a function that receives two list elements and returns true when the first element must come before the second. Uses an introsort algorithm (Lua 5.4).", "type": "function" },
+        "concat": { "signature": "table.concat(list [, sep [, i [, j]]])", "description": "Given a list where all elements are strings or numbers, returns the string list[i]..sep..list[i+1]..sep..list[j]. The default value for sep is the empty string, for i is 1, and for j is #list.", "type": "function" },
+        "move": { "signature": "table.move(a1, f, e, t [, a2])", "description": "Moves elements from one position to another in a table (or between tables). Copies elements a1[f]..a1[e] into a2[t]..a2[t+e-f]. The default for a2 is a1. Available in Lua 5.3+.", "type": "function" },
+        "pack": { "signature": "table.pack(···)", "description": "Returns a new table with all arguments stored into keys 1, 2, etc., and with a field 'n' with the total number of arguments. Available in Lua 5.2+.", "type": "function" },
+        "unpack": { "signature": "table.unpack(list [, i [, j]])", "description": "Returns the elements from the given list. This function is equivalent to: return list[i], list[i+1], ···, list[j]. By default, i is 1 and j is #list. In Lua 5.1, this is the global function unpack.", "type": "function" }
+      }
+    },
+    "math": {
+      "signature": "math library",
+      "description": "The math library provides standard mathematical functions. It provides its functions and constants inside the table `math`. Functions with the annotation 'integer/float' give integer results for integer arguments and float results for float arguments (Lua 5.3+).",
+      "type": "module",
+      "module": "math",
+      "members": {
+        "abs": { "signature": "math.abs(x)", "description": "Returns the absolute value of x. (integer/float)", "type": "function" },
+        "ceil": { "signature": "math.ceil(x)", "description": "Returns the smallest integral value greater than or equal to x.", "type": "function" },
+        "floor": { "signature": "math.floor(x)", "description": "Returns the largest integral value less than or equal to x.", "type": "function" },
+        "max": { "signature": "math.max(x, ···)", "description": "Returns the argument with the maximum value, according to the Lua operator <.", "type": "function" },
+        "min": { "signature": "math.min(x, ···)", "description": "Returns the argument with the minimum value, according to the Lua operator <.", "type": "function" },
+        "sqrt": { "signature": "math.sqrt(x)", "description": "Returns the square root of x. You can also use the expression x^0.5 to compute this value.", "type": "function" },
+        "random": { "signature": "math.random([m [, n]])", "description": "When called without arguments, returns a pseudo-random float in [0,1). When called with integer m, returns a pseudo-random integer in [1, m]. When called with m and n, returns a pseudo-random integer in [m, n]. Lua 5.4 uses xoshiro256** algorithm.", "type": "function" },
+        "randomseed": { "signature": "math.randomseed([x [, y]])", "description": "Sets x (and y) as seed for the pseudo-random generator. In Lua 5.4, when called with no arguments, Lua generates a seed with a reasonable amount of randomness.", "type": "function" },
+        "huge": { "signature": "math.huge", "description": "The float value HUGE_VAL, a value greater than any other numeric value (positive infinity).", "type": "constant" },
+        "pi": { "signature": "math.pi", "description": "The value of π (3.14159265358979323846...).", "type": "constant" },
+        "maxinteger": { "signature": "math.maxinteger", "description": "An integer with the maximum value for an integer. Available in Lua 5.3+.", "type": "constant" },
+        "mininteger": { "signature": "math.mininteger", "description": "An integer with the minimum value for an integer. Available in Lua 5.3+.", "type": "constant" },
+        "sin": { "signature": "math.sin(x)", "description": "Returns the sine of x (assumed to be in radians).", "type": "function" },
+        "cos": { "signature": "math.cos(x)", "description": "Returns the cosine of x (assumed to be in radians).", "type": "function" },
+        "tan": { "signature": "math.tan(x)", "description": "Returns the tangent of x (assumed to be in radians).", "type": "function" },
+        "asin": { "signature": "math.asin(x)", "description": "Returns the arc sine of x (in radians).", "type": "function" },
+        "acos": { "signature": "math.acos(x)", "description": "Returns the arc cosine of x (in radians).", "type": "function" },
+        "atan": { "signature": "math.atan(y [, x])", "description": "Returns the arc tangent of y/x (in radians). Uses the signs of both arguments to find the quadrant. In Lua 5.3+, replaced math.atan2.", "type": "function" },
+        "log": { "signature": "math.log(x [, base])", "description": "Returns the logarithm of x in the given base. The default for base is e (natural logarithm). The base parameter is available in Lua 5.2+; use math.log10 for base-10 in Lua 5.1.", "type": "function" },
+        "exp": { "signature": "math.exp(x)", "description": "Returns the value e^x (where e is the base of natural logarithms).", "type": "function" },
+        "fmod": { "signature": "math.fmod(x, y)", "description": "Returns the remainder of the division of x by y that rounds the quotient towards zero. (integer/float)", "type": "function" },
+        "tointeger": { "signature": "math.tointeger(x)", "description": "If the value x is representable as a Lua integer, returns an integer with that value. Otherwise, returns nil. Available in Lua 5.3+.", "type": "function" },
+        "type": { "signature": "math.type(x)", "description": "Returns 'integer' if x is an integer, 'float' if it is a float, or nil if x is not a number. Available in Lua 5.3+.", "type": "function" }
+      }
+    },
+    "io": {
+      "signature": "io library",
+      "description": "The I/O library provides two different styles for file manipulation: the first uses implicit file handles (io.read, io.write operate on default files); the second uses explicit file handles returned by io.open.",
+      "type": "module",
+      "module": "io",
+      "members": {
+        "open": { "signature": "io.open(filename [, mode])", "description": "Opens a file in the mode specified in the string mode. Returns a new file handle, or nil plus an error message. Modes: 'r' (read, default), 'w' (write), 'a' (append), 'r+' (update read), 'w+' (update write), 'a+' (update append). Append 'b' for binary mode.", "type": "function" },
+        "read": { "signature": "io.read(···)", "description": "Equivalent to io.input():read(···). Reads from the default input file. Formats: '*n'/'n' (number), '*a'/'a' (whole file), '*l'/'l' (line without newline, default), '*L'/'L' (line with newline). Lua 5.3+ drops the '*' prefix.", "type": "function" },
+        "write": { "signature": "io.write(···)", "description": "Equivalent to io.output():write(···). Writes each argument to the default output file.", "type": "function" },
+        "close": { "signature": "io.close([file])", "description": "Closes file, or the default output file if no file is given. Equivalent to file:close().", "type": "function" },
+        "lines": { "signature": "io.lines([filename, ···])", "description": "Opens the given file name in read mode and returns an iterator function that works like file:lines(···) over the opened file. The file is closed when the loop ends. If called with no file name, uses the default input file.", "type": "function" },
+        "input": { "signature": "io.input([file])", "description": "When called with a file name, opens the named file (in text mode) and sets its handle as the default input file. When called without arguments, returns the current default input file.", "type": "function" },
+        "output": { "signature": "io.output([file])", "description": "When called with a file name, opens the named file (in text mode) and sets its handle as the default output file. When called without arguments, returns the current default output file.", "type": "function" },
+        "tmpfile": { "signature": "io.tmpfile()", "description": "In case of success, returns a handle for a temporary file. This file is opened in update mode and is automatically removed when the program ends.", "type": "function" },
+        "type": { "signature": "io.type(obj)", "description": "Checks whether obj is a valid file handle. Returns 'file' if obj is an open file handle, 'closed file' if obj is a closed file handle, or nil if obj is not a file handle.", "type": "function" },
+        "popen": { "signature": "io.popen(prog [, mode])", "description": "Starts program prog in a separated process and returns a file handle that you can use to read data from this program (if mode is 'r', the default) or to write data to this program (if mode is 'w').", "type": "function" }
+      }
+    },
+    "os": {
+      "signature": "os library",
+      "description": "The os library provides operating system facilities. Due to the ISO C restriction, the os library offers a limited and portable set of functionality.",
+      "type": "module",
+      "module": "os",
+      "members": {
+        "time": { "signature": "os.time([table])", "description": "Returns the current time when called without arguments, or a time representing the local date and time specified by the given table. The table must have fields year, month, and day, and may have fields hour (default 12), min (default 0), sec (default 0), and isdst.", "type": "function" },
+        "date": { "signature": "os.date([format [, time]])", "description": "Returns a string or a table containing date and time, formatted according to the given format string. If format starts with '!', the date is formatted in UTC. If format is '*t', returns a table with fields year, month, day, hour, min, sec, wday, yday, isdst.", "type": "function" },
+        "clock": { "signature": "os.clock()", "description": "Returns an approximation of the amount in seconds of CPU time used by the program, as returned by the underlying ISO C function clock.", "type": "function" },
+        "execute": { "signature": "os.execute([command])", "description": "Passes command to be executed by an operating system shell. In Lua 5.2+, returns true/nil, exit type ('exit'/'signal'), and exit/signal code. In Lua 5.1, returns the status code.", "type": "function" },
+        "getenv": { "signature": "os.getenv(varname)", "description": "Returns the value of the process environment variable varname, or nil if the variable is not defined.", "type": "function" },
+        "rename": { "signature": "os.rename(oldname, newname)", "description": "Renames the file or directory named oldname to newname. If this function fails, it returns nil, plus a string describing the error and the error code.", "type": "function" },
+        "remove": { "signature": "os.remove(filename)", "description": "Deletes the file (or empty directory on POSIX systems) with the given name. If this function fails, it returns nil, plus a string describing the error and the error code.", "type": "function" },
+        "tmpname": { "signature": "os.tmpname()", "description": "Returns a string with a file name that can be used for a temporary file. The file must be explicitly opened before its use and explicitly removed when no longer needed.", "type": "function" },
+        "exit": { "signature": "os.exit([code [, close]])", "description": "Calls the ISO C function exit to terminate the host program. If code is true, the exit status is EXIT_SUCCESS; if false, EXIT_FAILURE; if a number, the exit status is that number. In Lua 5.2+, if close is true, closes the Lua state before exiting.", "type": "function" },
+        "difftime": { "signature": "os.difftime(t2, t1)", "description": "Returns the difference, in seconds, from time t1 to time t2 (where the times are values returned by os.time).", "type": "function" },
+        "setlocale": { "signature": "os.setlocale(locale [, category])", "description": "Sets the current locale of the program. Returns the name of the new locale, or nil if the request cannot be honored.", "type": "function" }
+      }
+    },
+    "coroutine": {
+      "signature": "coroutine library",
+      "description": "The coroutine library provides operations for coroutine manipulation. A coroutine represents an independent thread of execution that can be suspended (yield) and later resumed. Lua 5.4 adds to-be-closed variables support for coroutines.",
+      "type": "module",
+      "module": "coroutine",
+      "members": {
+        "create": { "signature": "coroutine.create(f)", "description": "Creates a new coroutine with body f. f must be a function. Returns the new coroutine, an object with type 'thread'.", "type": "function" },
+        "resume": { "signature": "coroutine.resume(co [, val1, ···])", "description": "Starts or continues the execution of coroutine co. The first time you resume, it starts running the body function. Values val1, ... are passed as arguments to the body function (first resume) or as results of yield (subsequent resumes). Returns true plus any values passed to yield, or false plus an error message.", "type": "function" },
+        "yield": { "signature": "coroutine.yield(···)", "description": "Suspends the execution of the calling coroutine. Any arguments to yield are passed as extra results to resume.", "type": "function" },
+        "wrap": { "signature": "coroutine.wrap(f)", "description": "Creates a new coroutine with body f and returns a function that resumes the coroutine each time it is called. Any arguments to the function go as extra arguments to resume. Returns the same values as resume, except the first boolean.", "type": "function" },
+        "status": { "signature": "coroutine.status(co)", "description": "Returns the status of coroutine co as a string: 'running' (currently running), 'suspended' (suspended in a yield or not started), 'normal' (active but not running, i.e., it resumed another coroutine), or 'dead' (finished or stopped with an error).", "type": "function" },
+        "isyieldable": { "signature": "coroutine.isyieldable()", "description": "Returns true when the running coroutine can yield. A running coroutine is yieldable if it is not the main thread and it is not inside a non-yieldable C function. Available in Lua 5.3+.", "type": "function" },
+        "close": { "signature": "coroutine.close(co)", "description": "Closes coroutine co, closing all its pending to-be-closed variables and putting the coroutine in a dead state. Available in Lua 5.4 only.", "type": "function" }
+      }
+    },
+    "debug": {
+      "signature": "debug library",
+      "description": "The debug library provides facilities for debugging and introspection. Unlike other libraries, you should use the debug library only for debugging and similar tasks. Misuse can compromise otherwise-safe code.",
+      "type": "module",
+      "module": "debug",
+      "members": {
+        "traceback": { "signature": "debug.traceback([thread,] [message [, level]])", "description": "Returns a string with a traceback of the call stack. The optional message string is appended at the beginning. The optional level number tells at which level to start the traceback (default is 1).", "type": "function" },
+        "getinfo": { "signature": "debug.getinfo([thread,] f [, what])", "description": "Returns a table with information about a function. f can be a function or a stack level number. The what string selects what information to fill in: 'n' (name), 'S' (source), 'l' (current line), 'u' (upvalues), 't' (is tail call), 'L' (valid lines).", "type": "function" },
+        "getlocal": { "signature": "debug.getlocal([thread,] f, local)", "description": "Returns the name and the value of the local variable with index local of the function at level f of the stack.", "type": "function" },
+        "setlocal": { "signature": "debug.setlocal([thread,] level, local, value)", "description": "Assigns the value value to the local variable with index local of the function at level level of the stack.", "type": "function" },
+        "getupvalue": { "signature": "debug.getupvalue(f, up)", "description": "Returns the name and the value of the upvalue with index up of the function f. Returns nil if there is no upvalue with the given index.", "type": "function" },
+        "setupvalue": { "signature": "debug.setupvalue(f, up, value)", "description": "Assigns the value value to the upvalue with index up of the function f. Returns the name of the upvalue, or nil if there is no upvalue with the given index.", "type": "function" },
+        "sethook": { "signature": "debug.sethook([thread,] hook, mask [, count])", "description": "Sets the given function as the debug hook. The mask is a string with 'c' (call), 'r' (return), 'l' (line), and count fires after every count instructions.", "type": "function" },
+        "gethook": { "signature": "debug.gethook([thread])", "description": "Returns the current hook function, the current hook mask, and the current hook count.", "type": "function" },
+        "getmetatable": { "signature": "debug.getmetatable(value)", "description": "Returns the metatable of the given value. Unlike getmetatable, this function does not check __metatable.", "type": "function" },
+        "setmetatable": { "signature": "debug.setmetatable(value, table)", "description": "Sets the metatable for the given value to the given table (which can be nil). Returns value. Unlike setmetatable, works on any type of value.", "type": "function" },
+        "getregistry": { "signature": "debug.getregistry()", "description": "Returns the registry table (a pre-defined table used by the C API to store values).", "type": "function" },
+        "upvalueid": { "signature": "debug.upvalueid(f, n)", "description": "Returns a unique identifier (as a light userdata) for the upvalue numbered n from the given function. Available in Lua 5.2+.", "type": "function" },
+        "upvaluejoin": { "signature": "debug.upvaluejoin(f1, n1, f2, n2)", "description": "Make the n1-th upvalue of the Lua closure f1 refer to the n2-th upvalue of the Lua closure f2. Available in Lua 5.2+.", "type": "function" }
+      }
+    },
+    "metatable": {
+      "signature": "Metatables and Metamethods",
+      "description": "Every value in Lua can have a metatable. A metatable is a regular Lua table that defines the behavior of the original value under certain operations. Metamethods are functions stored in a metatable with special keys that Lua recognizes. Use setmetatable(table, metatable) to set and getmetatable(obj) to retrieve.",
+      "type": "concept",
+      "module": "metatable",
+      "members": {
+        "__index": { "signature": "__index: table | function(table, key)", "description": "Called when a table access (table[key]) fails. If __index is a table, the access is retried on that table. If it is a function, it is called with the table and the key. This is the primary mechanism for implementing inheritance and prototype chains.", "type": "metamethod" },
+        "__newindex": { "signature": "__newindex: table | function(table, key, value)", "description": "Called when a table assignment (table[key] = value) is made to an absent key. If __newindex is a table, the assignment is done on that table. If it is a function, it is called instead of performing the assignment. Use rawset to bypass.", "type": "metamethod" },
+        "__add": { "signature": "__add: function(op1, op2)", "description": "Called for the addition (+) operation. If any operand is not a number (nor a coercible string), Lua tries this metamethod. The function is called with the two operands.", "type": "metamethod" },
+        "__sub": { "signature": "__sub: function(op1, op2)", "description": "Called for the subtraction (-) operation. Behavior analogous to __add.", "type": "metamethod" },
+        "__mul": { "signature": "__mul: function(op1, op2)", "description": "Called for the multiplication (*) operation. Behavior analogous to __add.", "type": "metamethod" },
+        "__div": { "signature": "__div: function(op1, op2)", "description": "Called for the float division (/) operation. Behavior analogous to __add.", "type": "metamethod" },
+        "__mod": { "signature": "__mod: function(op1, op2)", "description": "Called for the modulo (%) operation. Behavior analogous to __add.", "type": "metamethod" },
+        "__pow": { "signature": "__pow: function(op1, op2)", "description": "Called for the exponentiation (^) operation. Behavior analogous to __add.", "type": "metamethod" },
+        "__unm": { "signature": "__unm: function(op)", "description": "Called for the unary minus (negation, -x) operation.", "type": "metamethod" },
+        "__concat": { "signature": "__concat: function(op1, op2)", "description": "Called for the concatenation (..) operation. If any operand is neither a string nor a number, Lua tries this metamethod.", "type": "metamethod" },
+        "__len": { "signature": "__len: function(op)", "description": "Called for the length (#) operation. Allows you to customize the behavior of the # operator for tables.", "type": "metamethod" },
+        "__eq": { "signature": "__eq: function(op1, op2)", "description": "Called for the equality (==) operation. Only called when the two objects being compared share the same metatable for this event (or both have this metamethod). Result is always converted to boolean.", "type": "metamethod" },
+        "__lt": { "signature": "__lt: function(op1, op2)", "description": "Called for the less-than (<) operation. Also used for the greater-than (>) operation (a > b becomes b < a). Result is always converted to boolean.", "type": "metamethod" },
+        "__le": { "signature": "__le: function(op1, op2)", "description": "Called for the less-than-or-equal (<=) operation. Also used for >= operations. Result is always converted to boolean.", "type": "metamethod" },
+        "__call": { "signature": "__call: function(func, ...)", "description": "Called when a value is called as a function. The metamethod receives the called object as first argument, followed by the arguments of the original call. Allows non-function values to be called.", "type": "metamethod" },
+        "__tostring": { "signature": "__tostring: function(op)", "description": "Called by the tostring function and string conversion. Must return a string. If this metamethod exists, tostring calls it with the object as argument and uses the result.", "type": "metamethod" },
+        "__gc": { "signature": "__gc: function(op)", "description": "Called when the garbage collector detects that the corresponding object is unreachable (finalizer). In Lua 5.4, works on tables too. In earlier versions, only userdata. The __gc metamethod must be set before the object becomes garbage.", "type": "metamethod" },
+        "__close": { "signature": "__close: function(op, err)", "description": "Called when a to-be-closed variable goes out of scope. Available in Lua 5.4 only. The second parameter is the error object if the scope was left due to an error, or nil otherwise. Declared with: local obj <close> = value.", "type": "metamethod" },
+        "__idiv": { "signature": "__idiv: function(op1, op2)", "description": "Called for the floor division (//) operation. Available in Lua 5.3+. Behavior analogous to __add.", "type": "metamethod" },
+        "__band": { "signature": "__band: function(op1, op2)", "description": "Called for the bitwise AND (&) operation. Available in Lua 5.3+.", "type": "metamethod" },
+        "__bor": { "signature": "__bor: function(op1, op2)", "description": "Called for the bitwise OR (|) operation. Available in Lua 5.3+.", "type": "metamethod" },
+        "__bxor": { "signature": "__bxor: function(op1, op2)", "description": "Called for the bitwise exclusive OR (~) operation. Available in Lua 5.3+.", "type": "metamethod" },
+        "__bnot": { "signature": "__bnot: function(op)", "description": "Called for the bitwise NOT (~) operation. Available in Lua 5.3+.", "type": "metamethod" },
+        "__shl": { "signature": "__shl: function(op1, op2)", "description": "Called for the bitwise left shift (<<) operation. Available in Lua 5.3+.", "type": "metamethod" },
+        "__shr": { "signature": "__shr: function(op1, op2)", "description": "Called for the bitwise right shift (>>) operation. Available in Lua 5.3+.", "type": "metamethod" },
+        "__metatable": { "signature": "__metatable: any", "description": "If set, getmetatable returns this value instead of the real metatable, and setmetatable raises an error. Used to protect the metatable from being modified.", "type": "field" },
+        "__pairs": { "signature": "__pairs: function(table)", "description": "Called by the pairs function to provide a custom iterator. Available in Lua 5.2; removed in Lua 5.4 (use __iter instead or rely on default behavior).", "type": "metamethod" }
+      }
+    }
+  }
+}