style: wrap comments by 80 columns (#8)

Author: hazzard993

core/coroutine.d.ts

@@ -3,34 +3,53 @@
 /** @noSelfInFile */
 
 /**
- * This library comprises the operations to manipulate coroutines, which come inside the table coroutine.
+ * This library comprises the operations to manipulate coroutines, which come
+ * inside the table coroutine.
  */
 declare namespace coroutine {
   /**
-   * Creates a new coroutine, with body f. f must be a function. Returns this new coroutine, an object with type "thread".
+   * Creates a new coroutine, with body f. f must be a function. Returns this
+   * new coroutine, an object with type "thread".
    */
   function create(f: (...args: any[]) => any): LuaThread;
 
   /**
-   * Starts or continues the execution of coroutine co. The first time you resume a coroutine, it starts running its body. The values val1, ... are passed as the arguments to the body function. If the coroutine has yielded, resume restarts it; the values val1, ... are passed as the results from the yield.
+   * Starts or continues the execution of coroutine co. The first time you
+   * resume a coroutine, it starts running its body. The values val1, ... are
+   * passed as the arguments to the body function. If the coroutine has yielded,
+   * resume restarts it; the values val1, ... are passed as the results from the
+   * yield.
    *
-   * If the coroutine runs without any errors, resume returns true plus any values passed to yield (when the coroutine yields) or any values returned by the body function (when the coroutine terminates). If there is any error, resume returns false plus the error message.
+   * If the coroutine runs without any errors, resume returns true plus any
+   * values passed to yield (when the coroutine yields) or any values returned
+   * by the body function (when the coroutine terminates). If there is any
+   * error, resume returns false plus the error message.
    * @tupleReturn
    */
   function resume(co: LuaThread, ...val: any[]): [true, ...any[]] | [false, string];
 
   /**
-   * Returns the status of coroutine co, as a string: "running", if the coroutine is running (that is, it called status); "suspended", if the coroutine is suspended in a call to yield, or if it has not started running yet; "normal" if the coroutine is active but not running (that is, it has resumed another coroutine); and "dead" if the coroutine has finished its body function, or if it has stopped with an error.
+   * Returns the status of coroutine co, as a string: "running", if the
+   * coroutine is running (that is, it called status); "suspended", if the
+   * coroutine is suspended in a call to yield, or if it has not started running
+   * yet; "normal" if the coroutine is active but not running (that is, it has
+   * resumed another coroutine); and "dead" if the coroutine has finished its
+   * body function, or if it has stopped with an error.
    */
   function status(co: LuaThread): 'running' | 'suspended' | 'normal' | 'dead';
 
   /**
-   * Creates a new coroutine, with body f. f must be a function. Returns a function that resumes the coroutine each time it is called. Any arguments passed to the function behave as the extra arguments to resume. Returns the same values returned by resume, except the first boolean. In case of error, propagates the error.
+   * Creates a new coroutine, with body f. f must be a function. Returns a
+   * function that resumes the coroutine each time it is called. Any arguments
+   * passed to the function behave as the extra arguments to resume. Returns the
+   * same values returned by resume, except the first boolean. In case of error,
+   * propagates the error.
    */
   function wrap(f: (...args: any[]) => any): /** @tupleReturn */ (...args: any[]) => any[];
 
   /**
-   * Suspends the execution of the calling coroutine. Any arguments to yield are passed as extra results to resume.
+   * Suspends the execution of the calling coroutine. Any arguments to yield are
+   * passed as extra results to resume.
    * @tupleReturn
    */
   function yield(...args: any[]): any[];

core/debug.d.ts

@@ -3,20 +3,35 @@
 /** @noSelfInFile */
 
 /**
- * This library provides the functionality of the debug interface (§4.9) to Lua programs. You should exert care when using this library. Several of its functions violate basic assumptions about Lua code (e.g., that variables local to a function cannot be accessed from outside; that userdata metatables cannot be changed by Lua code; that Lua programs do not crash) and therefore can compromise otherwise secure code. Moreover, some functions in this library may be slow.
+ * This library provides the functionality of the debug interface (§4.9) to Lua
+ * programs. You should exert care when using this library. Several of its
+ * functions violate basic assumptions about Lua code (e.g., that variables
+ * local to a function cannot be accessed from outside; that userdata metatables
+ * cannot be changed by Lua code; that Lua programs do not crash) and therefore
+ * can compromise otherwise secure code. Moreover, some functions in this
+ * library may be slow.
  *
- * All functions in this library are provided inside the debug table. All functions that operate over a thread have an optional first argument which is the thread to operate over. The default is always the current thread.
+ * All functions in this library are provided inside the debug table. All
+ * functions that operate over a thread have an optional first argument which is
+ * the thread to operate over. The default is always the current thread.
  */
 declare namespace debug {
   /**
-   * Enters an interactive mode with the user, running each string that the user enters. Using simple commands and other debug facilities, the user can inspect global and local variables, change their values, evaluate expressions, and so on. A line containing only the word cont finishes this function, so that the caller continues its execution.
+   * Enters an interactive mode with the user, running each string that the user
+   * enters. Using simple commands and other debug facilities, the user can
+   * inspect global and local variables, change their values, evaluate
+   * expressions, and so on. A line containing only the word cont finishes this
+   * function, so that the caller continues its execution.
    *
-   * Note that commands for debug.debug are not lexically nested within any function and so have no direct access to local variables.
+   * Note that commands for debug.debug are not lexically nested within any
+   * function and so have no direct access to local variables.
    */
   function debug(): void;
 
   /**
-   * Returns the current hook settings of the thread, as three values: the current hook function, the current hook mask, and the current hook count (as set by the debug.sethook function).
+   * Returns the current hook settings of the thread, as three values: the
+   * current hook function, the current hook mask, and the current hook count
+   * (as set by the debug.sethook function).
    * @tupleReturn
    */
   function gethook(thread?: LuaThread): [undefined, 0] | [Function, number, string?];
@@ -32,13 +47,15 @@ declare namespace debug {
      */
     name?: string;
     /**
-     * What the `name` field means. The empty string means that Lua did not find a name for the function.
+     * What the `name` field means. The empty string means that Lua did not find
+     * a name for the function.
      */
     namewhat: 'global' | 'local' | 'method' | 'field' | '';
 
     source: string;
     /**
-     * A short version of source (up to 60 characters), useful for error messages.
+     * A short version of source (up to 60 characters), useful for error
+     * messages.
      */
     short_src: string;
     linedefined: number;
@@ -57,11 +74,25 @@ declare namespace debug {
   }
 
   /**
-   * Returns a table with information about a function. You can give the function directly or you can give a number as the value of f, which means the function running at level f of the call stack of the given thread: level 0 is the current function (getinfo itself); level 1 is the function that called getinfo (except for tail calls, which do not count on the stack); and so on. If f is a number larger than the number of active functions, then getinfo returns nil.
+   * Returns a table with information about a function. You can give the
+   * function directly or you can give a number as the value of f, which means
+   * the function running at level f of the call stack of the given thread:
+   * level 0 is the current function (getinfo itself); level 1 is the function
+   * that called getinfo (except for tail calls, which do not count on the
+   * stack); and so on. If f is a number larger than the number of active
+   * functions, then getinfo returns nil.
    *
-   * The returned table can contain all the fields returned by lua_getinfo, with the string what describing which fields to fill in. The default for what is to get all information available, except the table of valid lines. If present, the option 'f' adds a field named func with the function itself. If present, the option 'L' adds a field named activelines with the table of valid lines.
+   * The returned table can contain all the fields returned by lua_getinfo, with
+   * the string what describing which fields to fill in. The default for what is
+   * to get all information available, except the table of valid lines. If
+   * present, the option 'f' adds a field named func with the function itself.
+   * If present, the option 'L' adds a field named activelines with the table of
+   * valid lines.
    *
-   * For instance, the expression debug.getinfo(1,"n").name returns a name for the current function, if a reasonable name can be found, and the expression debug.getinfo(print) returns a table with all available information about the print function.
+   * For instance, the expression debug.getinfo(1,"n").name returns a name for
+   * the current function, if a reasonable name can be found, and the expression
+   * debug.getinfo(print) returns a table with all available information about
+   * the print function.
    */
   function getinfo<T extends Function>(f: T): FunctionInfo<T>;
   function getinfo<T extends Function>(f: T, what: string): Partial<FunctionInfo<T>>;
@@ -77,7 +108,8 @@ declare namespace debug {
   function getinfo(thread: LuaThread, f: number, what: string): Partial<FunctionInfo> | undefined;
 
   /**
-   * Returns the metatable of the given value or nil if it does not have a metatable.
+   * Returns the metatable of the given value or nil if it does not have a
+   * metatable.
    */
   function getmetatable<T extends any>(value: T): LuaMetatable<T> | undefined;
 
@@ -87,30 +119,43 @@ declare namespace debug {
   function getregistry(): Record<string, any>;
 
   /**
-   * This function returns the name and the value of the upvalue with index up of the function f. The function returns nil if there is no upvalue with the given index.
+   * This function returns the name and the value of the upvalue with index up
+   * of the function f. The function returns nil if there is no upvalue with the
+   * given index.
    *
-   * Variable names starting with '(' (open parenthesis) represent variables with no known names (variables from chunks saved without debug information).
+   * Variable names starting with '(' (open parenthesis) represent variables
+   * with no known names (variables from chunks saved without debug
+   * information).
    * @tupleReturn
    */
   function getupvalue(f: Function, up: number): [string, any] | [];
 
   /**
-   * Returns the Lua value associated to u. If u is not a full userdata, returns nil.
+   * Returns the Lua value associated to u. If u is not a full userdata, returns
+   * nil.
    */
   function getuservalue(u: LuaUserdata): any;
 
   /**
-   * Sets the given function as a hook. The string mask and the number count describe when the hook will be called. The string mask may have any combination of the following characters, with the given meaning:
+   * Sets the given function as a hook. The string mask and the number count
+   * describe when the hook will be called. The string mask may have any
+   * combination of the following characters, with the given meaning:
    *
    * * 'c': the hook is called every time Lua calls a function;
    * * 'r': the hook is called every time Lua returns from a function;
    * * 'l': the hook is called every time Lua enters a new line of code.
    *
-   * Moreover, with a count different from zero, the hook is called also after every count instructions.
+   * Moreover, with a count different from zero, the hook is called also after
+   * every count instructions.
    *
    * When called without arguments, debug.sethook turns off the hook.
    *
-   * When the hook is called, its first parameter is a string describing the event that has triggered its call: "call" (or "tail call"), "return", "line", and "count". For line events, the hook also gets the new line number as its second parameter. Inside a hook, you can call getinfo with level 2 to get more information about the running function (level 0 is the getinfo function, and level 1 is the hook function).
+   * When the hook is called, its first parameter is a string describing the
+   * event that has triggered its call: "call" (or "tail call"), "return",
+   * "line", and "count". For line events, the hook also gets the new line
+   * number as its second parameter. Inside a hook, you can call getinfo with
+   * level 2 to get more information about the running function (level 0 is the
+   * getinfo function, and level 1 is the hook function).
    */
   function sethook(): void;
   function sethook(
@@ -126,7 +171,12 @@ declare namespace debug {
   ): void;
 
   /**
-   * This function assigns the value value to the local variable with index local of the function at level level of the stack. The function returns nil if there is no local variable with the given index, and raises an error when called with a level out of range. (You can call getinfo to check whether the level is valid.) Otherwise, it returns the name of the local variable.
+   * This function assigns the value value to the local variable with index
+   * local of the function at level level of the stack. The function returns nil
+   * if there is no local variable with the given index, and raises an error
+   * when called with a level out of range. (You can call getinfo to check
+   * whether the level is valid.) Otherwise, it returns the name of the local
+   * variable.
    *
    * See debug.getlocal for more information about variable indices and names.
    */
@@ -139,24 +189,33 @@ declare namespace debug {
   ): string | undefined;
 
   /**
-   * Sets the metatable for the given value to the given table (which can be nil). Returns value.
+   * Sets the metatable for the given value to the given table (which can be
+   * nil). Returns value.
    */
   function setmetatable<T>(value: T, table: LuaMetatable<T> | null | undefined): T;
 
   /**
-   * This function assigns the value value to the upvalue with index up of the function f. The function returns nil if there is no upvalue with the given index. Otherwise, it returns the name of the upvalue.
+   * This function assigns the value value to the upvalue with index up of the
+   * function f. The function returns nil if there is no upvalue with the given
+   * index. Otherwise, it returns the name of the upvalue.
    */
   function setupvalue(f: Function, up: number, value: any): string | undefined;
 
   /**
-   * Sets the given value as the Lua value associated to the given udata. udata must be a full userdata.
+   * Sets the given value as the Lua value associated to the given udata. udata
+   * must be a full userdata.
    *
    * Returns udata.
    */
   function setuservalue(udata: LuaUserdata, value: any): LuaUserdata;
 
   /**
-   * If message is present but is neither a string nor nil, this function returns message without further processing. Otherwise, it returns a string with a traceback of the call stack. The optional message string is appended at the beginning of the traceback. An optional level number tells at which level to start the traceback (default is 1, the function calling traceback).
+   * If message is present but is neither a string nor nil, this function
+   * returns message without further processing. Otherwise, it returns a string
+   * with a traceback of the call stack. The optional message string is appended
+   * at the beginning of the traceback. An optional level number tells at which
+   * level to start the traceback (default is 1, the function calling
+   * traceback).
    */
   function traceback(message?: string | null, level?: number | null): string;
   function traceback(thread?: LuaThread, message?: string | null, level?: number | null): string;