Documentation overhaul.

Rewrote most of the manual and Lua API to complement each other.
Key bindings reference moved from Appendix to modules/textadept/keys.lua LuaDoc.

3 files changed, 234 insertions, 227 deletions

diff --git a/modules/lua/api b/modules/lua/api
index 0f022373..bf61479e 100644
--- a/modules/lua/api
+++ b/modules/lua/api
@@ -1,18 +1,18 @@
 ANNOTATION_BOXED _SCINTILLA.constants.ANNOTATION_BOXED\n2
 ANNOTATION_HIDDEN _SCINTILLA.constants.ANNOTATION_HIDDEN\n0
 ANNOTATION_STANDARD _SCINTILLA.constants.ANNOTATION_STANDARD\n1
-APPLEEVENT_ODOC events.APPLEEVENT_ODOC\nCalled when Mac OSX tells Textadept to open a document.\n  * `uri`: The URI to open encoded in UTF-8.
-AUTOINDENT _M.textadept.editing.AUTOINDENT (bool)\nMatch the indentation level of the previous line when pressing the Enter\nkey.\nThe default value is `true`.
-AUTOPAIR _M.textadept.editing.AUTOPAIR (bool)\nOpening `(`, `[`, `[`, `"`, or `'` characters are automatically closed.\nThe default value is `true`.
-AUTO_C_CHAR_DELETED events.AUTO_C_CHAR_DELETED\nCalled when the user deleted a character while the autocompletion list was\nactive.
-AUTO_C_RELEASE events.AUTO_C_RELEASE\nCalled when the user has cancelled the autocompletion list.
-AUTO_C_SELECTION events.AUTO_C_SELECTION\nCalled when the user has selected an item in an autocompletion list and\nbefore the selection is inserted.\nAutomatic insertion can be cancelled by calling\n`buffer:auto_c_cancel()` before returning from the event handler.\nArguments:\n  * `text`: The text of the selection.\n  * `position`: The start position of the word being completed.
-BUFFER_AFTER_SWITCH events.BUFFER_AFTER_SWITCH\nCalled right after a buffer is switched to.
-BUFFER_BEFORE_SWITCH events.BUFFER_BEFORE_SWITCH\nCalled right before another buffer is switched to.
-BUFFER_DELETED events.BUFFER_DELETED\nCalled after a buffer was deleted.
-BUFFER_NEW events.BUFFER_NEW\nCalled when a new buffer is created.
+APPLEEVENT_ODOC events.APPLEEVENT_ODOC (string)\nCalled when Mac OSX tells Textadept to open a document.\nArguments:\n\n* `uri`: The URI to open encoded in UTF-8.
+AUTOINDENT _M.textadept.editing.AUTOINDENT (bool)\nMatch the indentation level of the previous line when pressing the `Enter`\n(`↩` on Mac OSX | `Enter` in ncurses) key.\nThe default value is `true`.
+AUTOPAIR _M.textadept.editing.AUTOPAIR (bool)\nOpening `(`, `[`, `{`, `"`, or `'` characters are automatically closed.\nThe default value is `true`.\nAuto-paired characters are defined in the `char_matches`\ntable.
+AUTO_C_CHAR_DELETED events.AUTO_C_CHAR_DELETED (string)\nCalled when the user deleted a character while the autocompletion list was\nactive.
+AUTO_C_RELEASE events.AUTO_C_RELEASE (string)\nCalled when the user has cancelled the autocompletion list.
+AUTO_C_SELECTION events.AUTO_C_SELECTION (string)\nCalled when the user has selected an item in an autocompletion list and\nbefore the selection is inserted.\nAutomatic insertion can be cancelled by calling\n`buffer:auto_c_cancel()` before returning from the event handler.\nArguments:\n\n* `text`: The text of the selection.\n* `position`: The start position of the word being completed.
+BUFFER_AFTER_SWITCH events.BUFFER_AFTER_SWITCH (string)\nCalled right after a buffer is switched to.\nThis is emitted by `view:goto_buffer()`.
+BUFFER_BEFORE_SWITCH events.BUFFER_BEFORE_SWITCH (string)\nCalled right before another buffer is switched to.\nThis is emitted by `view:goto_buffer()`.
+BUFFER_DELETED events.BUFFER_DELETED (string)\nCalled after a buffer was deleted.\nThis is emitted by `buffer:delete()`.
+BUFFER_NEW events.BUFFER_NEW (string)\nCalled when a new buffer is created.\nThis is emitted on startup and by `new_buffer()`.
 C lpeg.C(patt)\nCreates a simple capture, which captures the substring of the subject that\nmatches patt. The captured value is a string. If patt has other captures,\ntheir values are returned after this one.
-CALL_TIP_CLICK events.CALL_TIP_CLICK\nCalled when the user clicks on a calltip.\nArguments:\n  * `position`: Set to 1 if the click is in an up arrow, 2 if in a down\n    arrow, and 0 if elsewhere.
+CALL_TIP_CLICK events.CALL_TIP_CLICK (string)\nCalled when the user clicks on a calltip.\nArguments:\n\n* `position`: Set to 1 if the click is in an up arrow, 2 if in a down\n  arrow, and 0 if elsewhere.
 CARETSTYLE_BLOCK _SCINTILLA.constants.CARETSTYLE_BLOCK\n2
 CARETSTYLE_INVISIBLE _SCINTILLA.constants.CARETSTYLE_INVISIBLE\n0
 CARETSTYLE_LINE _SCINTILLA.constants.CARETSTYLE_LINE\n1
@@ -20,13 +20,14 @@ CARET_EVEN _SCINTILLA.constants.CARET_EVEN\n8
 CARET_JUMPS _SCINTILLA.constants.CARET_JUMPS\n16
 CARET_SLOP _SCINTILLA.constants.CARET_SLOP\n1
 CARET_STRICT _SCINTILLA.constants.CARET_STRICT\n4
-CHAR_ADDED events.CHAR_ADDED\nCalled when an ordinary text character is added to the buffer.\nArguments:\n  * `ch`: The text character byte.
+CHAR_ADDED events.CHAR_ADDED (string)\nCalled when an ordinary text character is added to the buffer.\nArguments:\n\n* `ch`: The text character byte.
+CLASS _M.textadept.adeptsense.CLASS (string)\nCtags kind for Adeptsense classes.
 CLASS lexer.CLASS\nToken type for class tokens.
-CLEAR keys.CLEAR (string)\nThe string representing the key sequence that clears the current keychain.\nThe default value is `'esc'` (Escape).
-COMMAND_ENTRY_COMMAND events.COMMAND_ENTRY_COMMAND\nCalled when a command is entered into the Command Entry.\nArguments:\n  * `command`: The command text.
-COMMAND_ENTRY_KEYPRESS events.COMMAND_ENTRY_KEYPRESS\nCalled when a key is pressed in the Command Entry.\nArguments:\n  * `code`: The key code.\n  * `shift`: The Shift key is held down.\n  * `ctrl`: The Control/Command key is held down.\n  * `alt`: The Alt/option key is held down.\n  * `meta`: The Control key on Mac OSX is held down.
+CLEAR keys.CLEAR (string)\nThe string representing the key sequence that clears the current key chain.\nIt cannot be part of a key chain.\nThe default value is `'esc'` for the `Esc` (`⎋` on Mac OSX | `Esc` in\nncurses) key.
+COMMAND_ENTRY_COMMAND events.COMMAND_ENTRY_COMMAND (string)\nCalled when a command is entered into the Command Entry.\nArguments:\n\n* `command`: The command text.
+COMMAND_ENTRY_KEYPRESS events.COMMAND_ENTRY_KEYPRESS (string)\nCalled when a key is pressed in the Command Entry.\nArguments:\n\n* `code`: The key code.\n* `shift`: The Shift key is held down.\n* `ctrl`: The Control/Command key is held down.\n* `alt`: The Alt/option key is held down.\n* `meta`: The Control key on Mac OSX is held down.
 COMMENT lexer.COMMENT\nToken type for comment tokens.
-COMPILE_OUTPUT events.COMPILE_OUTPUT\nCalled after a compile command is executed.\nWhen connecting to this event (typically from a language-specific module),\nconnect with an index of `1` and return `true` if the event was handled and\nyou want to override the default handler that prints the output to a new\nview.\nArguments:\n  * `lexer`: The lexer language.\n  * `output`: The output from the command.
+COMPILE_OUTPUT events.COMPILE_OUTPUT\nCalled after a compile command is executed.\nBy default, compiler output is printed to the message buffer. To override\nthis behavior, connect to the event with an index of `1` and return `true`.\nArguments:\n  * `lexer`: The lexer language.\n  * `output`: The output from the command.
 CONSTANT lexer.CONSTANT\nToken type for constant tokens.
 Carg lpeg.Carg(n)\nCreates an argument capture. This pattern matches the empty string and\nproduces the value given as the nth extra argument given in the call to\nlpeg.match.
 Cb lpeg.Cb(name)\nCreates a back capture. This pattern matches the empty string and produces\nthe values produced by the most recent group capture named name.\n\nMost recent means the last complete outermost group capture with the given\nname. A Complete capture means that the entire pattern corresponding to the\ncapture has matched. An Outermost capture means that the capture is not\ninside another complete capture.
@@ -38,35 +39,37 @@ Cp lpeg.Cp()\nCreates a position capture. It matches the empty string and captur
 Cs lpeg.Cs(patt)\nCreates a substitution capture, which captures the substring of the subject\nthat matches patt, with substitutions. For any capture inside patt with a\nvalue, the substring that matched the capture is replaced by the capture\nvalue (which should be a string). The final captured value is the string\nresulting from all replacements.
 Ct lpeg.Ct(patt)\nCreates a table capture. This capture creates a table and puts all values\nfrom all anonymous captures made by patt inside this table in successive\ninteger keys, starting at 1. Moreover, for each named capture group created\nby patt, the first value of the group is put into the table with the group\nname as its key. The captured value is only the table.
 DEFAULT lexer.DEFAULT\nToken type for default tokens.
-DEFAULT_DEPTH _M.textadept.snapopen.DEFAULT_DEPTH (number)\nMaximum directory depth to search. The default value is `99`.
-DEFAULT_SESSION _M.textadept.session.DEFAULT_SESSION (string)\nThe path to the default session file.
-DOUBLE_CLICK events.DOUBLE_CLICK\nCalled when the mouse button is double-clicked.\nArguments:\n  * `position`: The text position of the double click.\n  * `line`: The line of the double click.\n  * `modifiers`: The key modifiers held down. It is a combination of zero\n    or more of `_SCINTILLA.constants.SCMOD_ALT`,\n    `_SCINTILLA.constants.SCMOD_CTRL`,\n    `_SCINTILLA.constants.SCMOD_SHIFT`, and\n    `_SCINTILLA.constants.SCMOD_META`.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
-DWELL_END events.DWELL_END\nCalled after a `DWELL_START` and the mouse is moved or other activity such\nas key press indicates the dwell is over.\nArguments:\n  * `position`: The nearest position in the document to the position where\n    the mouse pointer was lingering.\n  * `x`: Where the pointer lingered.\n  * `y`: Where the pointer lingered.
-DWELL_START events.DWELL_START\nCalled when the user keeps the mouse in one position for the dwell period\n(see `_SCINTILLA.constants.SCI_SETMOUSEDWELLTIME`).\nArguments:\n  * `position`: The nearest position in the document to the position where\n    the mouse pointer was lingering.\n  * `x`: Where the pointer lingered.\n  * `y`: Where the pointer lingered.
+DEFAULT_DEPTH _M.textadept.snapopen.DEFAULT_DEPTH (number)\nMaximum directory depth to search.\nThe default value is `99`.
+DEFAULT_SESSION _M.textadept.session.DEFAULT_SESSION (string)\nThe path to the default session file.\nThe default value is `_USERHOME/session`, or `_USERHOME/session_term` if\n`_G.NCURSES` is `true`.
+DOUBLE_CLICK events.DOUBLE_CLICK (string)\nCalled when the mouse button is double-clicked.\nArguments:\n\n* `position`: The text position of the double click.\n* `line`: The line of the double click.\n* `modifiers`: The key modifiers held down. It is a combination of zero or\n  more of `_SCINTILLA.constants.SCMOD_ALT`,\n  `_SCINTILLA.constants.SCMOD_CTRL`,\n  `_SCINTILLA.constants.SCMOD_SHIFT`, and\n  `_SCINTILLA.constants.SCMOD_META`.\n  Note: If you set `buffer.rectangular_selection_modifier` to\n  `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n  Ctrl and Alt due to a Scintilla limitation with GTK+.
+DWELL_END events.DWELL_END (string)\nCalled after a `DWELL_START` and the mouse is moved or other activity such\nas key press indicates the dwell is over.\nArguments:\n\n* `position`: The nearest position in the document to the position where\n  the mouse pointer was lingering.\n* `x`: Where the pointer lingered.\n* `y`: Where the pointer lingered.
+DWELL_START events.DWELL_START (string)\nCalled when the user keeps the mouse in one position for the dwell period\n(see `_SCINTILLA.constants.SCI_SETMOUSEDWELLTIME`).\nArguments:\n\n* `position`: The nearest position in the document to the position where\n  the mouse pointer was lingering.\n* `x`: Where the pointer lingered.\n* `y`: Where the pointer lingered.
 EDGE_BACKGROUND _SCINTILLA.constants.EDGE_BACKGROUND\n2
 EDGE_LINE _SCINTILLA.constants.EDGE_LINE\n1
 EDGE_NONE _SCINTILLA.constants.EDGE_NONE\n0
-ERROR events.ERROR\nCalled when an error occurs.\nArguments:\n  * `text`: The error text.
+ERROR events.ERROR (string)\nCalled when an error occurs.\nArguments:\n\n* `text`: The error text.
 ERROR lexer.ERROR\nToken type for error tokens.
+FIELD _M.textadept.adeptsense.FIELD (string)\nCtags kind for Adeptsense fields.
 FIELDS _M.textadept.adeptsense.FIELDS (string)\nXPM image for Adeptsense fields.
-FILE_AFTER_SAVE events.FILE_AFTER_SAVE\nCalled right after a file is saved to disk.\nArguments:\n  * `filename`: The filename encoded in UTF-8.
-FILE_BEFORE_SAVE events.FILE_BEFORE_SAVE\nCalled right before a file is saved to disk.\nArguments:\n  * `filename`: The filename encoded in UTF-8.
-FILE_OPENED events.FILE_OPENED\nCalled when a file is opened in a new buffer.\nArguments:\n  * `filename`: The filename encoded in UTF-8.
-FILE_SAVED_AS events.FILE_SAVED_AS\nCalled when a file is saved under a different filename.\nArguments:\n  * `filename`: The filename encoded in UTF-8.
-FILTER _M.textadept.snapopen.FILTER (table)\nDefault file and directory filters.
-FIND events.FIND\nCalled when finding text via the Find dialog box.\nArguments:\n  * `text`: The text to search for.\n  * `next`: Search forward.
+FILE_AFTER_SAVE events.FILE_AFTER_SAVE\nCalled right after a file is saved to disk.\nThis is emitted by `buffer:save()`\nArguments:\n  * `filename`: The filename encoded in UTF-8.
+FILE_BEFORE_SAVE events.FILE_BEFORE_SAVE\nCalled right before a file is saved to disk.\nThis is emitted by `buffer:save()`\nArguments:\n  * `filename`: The filename encoded in UTF-8.
+FILE_OPENED events.FILE_OPENED\nCalled when a file is opened in a new buffer.\nThis is emitted by `open_file()`\nArguments:\n  * `filename`: The filename encoded in UTF-8.
+FILE_SAVED_AS events.FILE_SAVED_AS\nCalled when a file is saved under a different filename.\nThis is emitted by `buffer:save_as()`\nArguments:\n  * `filename`: The filename encoded in UTF-8.
+FILTER _M.textadept.snapopen.FILTER (table)\nDefault file and directory filters.\nContains common binary file extensions and version control folders.
+FIND events.FIND (string)\nCalled when finding text via the Find dialog box.\nArguments:\n\n* `text`: The text to search for.\n* `next`: Search forward.
+FUNCTION _M.textadept.adeptsense.FUNCTION (string)\nCtags kind for Adeptsense functions.
 FUNCTION lexer.FUNCTION\nToken type for function toeksn.
 FUNCTIONS _M.textadept.adeptsense.FUNCTIONS (string)\nXPM image for Adeptsense functions.
-HIGHLIGHT_BRACES _M.textadept.editing.HIGHLIGHT_BRACES (bool)\nHighlight matching `()[]{}` characters.\nThe default value is `true`.
-HOTSPOT_CLICK events.HOTSPOT_CLICK\nCalled when the user clicks on text that is in a style with the hotspot\nattribute set.\nArguments:\n  * `position`: The text position of the click.\n  * `modifiers`: The key modifiers held down. It is a combination of zero\n    or more of `_SCINTILLA.constants.SCMOD_ALT`,\n    `_SCINTILLA.constants.SCMOD_CTRL`,\n    `_SCINTILLA.constants.SCMOD_SHIFT`, and\n    `_SCINTILLA.constants.SCMOD_META`.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
-HOTSPOT_DOUBLE_CLICK events.HOTSPOT_DOUBLE_CLICK\nCalled when the user double clicks on text that is in a style with the\nhotspot attribute set.\nArguments:\n  * `position`: The text position of the double click.\n  * `modifiers`: The key modifiers held down. It is a combination of zero\n    or more of `_SCINTILLA.constants.SCMOD_ALT`,\n    `_SCINTILLA.constants.SCMOD_CTRL`,\n    `_SCINTILLA.constants.SCMOD_SHIFT`, and\n    `_SCINTILLA.constants.SCMOD_META`.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
-HOTSPOT_RELEASE_CLICK events.HOTSPOT_RELEASE_CLICK\nCalled when the user releases the mouse on text that is in a style with the\nhotspot attribute set.\nArguments:\n  * `position`: The text position of the release.
+HIGHLIGHT_BRACES _M.textadept.editing.HIGHLIGHT_BRACES (bool)\nHighlight matching `()[]{}` characters.\nThe default value is `true`.\nMatching braces are defined in the `braces` table.
+HOTSPOT_CLICK events.HOTSPOT_CLICK (string)\nCalled when the user clicks on text that is in a style with the hotspot\nattribute set.\nArguments:\n\n* `position`: The text position of the click.\n* `modifiers`: The key modifiers held down. It is a combination of zero or\n  more of `_SCINTILLA.constants.SCMOD_ALT`,\n  `_SCINTILLA.constants.SCMOD_CTRL`,\n  `_SCINTILLA.constants.SCMOD_SHIFT`, and\n  `_SCINTILLA.constants.SCMOD_META`.\n  Note: If you set `buffer.rectangular_selection_modifier` to\n  `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n  Ctrl and Alt due to a Scintilla limitation with GTK+.
+HOTSPOT_DOUBLE_CLICK events.HOTSPOT_DOUBLE_CLICK (string)\nCalled when the user double clicks on text that is in a style with the\nhotspot attribute set.\nArguments:\n\n* `position`: The text position of the double click.\n* `modifiers`: The key modifiers held down. It is a combination of zero or\n  more of `_SCINTILLA.constants.SCMOD_ALT`,\n  `_SCINTILLA.constants.SCMOD_CTRL`,\n  `_SCINTILLA.constants.SCMOD_SHIFT`, and\n  `_SCINTILLA.constants.SCMOD_META`.\n  Note: If you set `buffer.rectangular_selection_modifier` to\n  `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n  Ctrl and Alt due to a Scintilla limitation with GTK+.
+HOTSPOT_RELEASE_CLICK events.HOTSPOT_RELEASE_CLICK (string)\nCalled when the user releases the mouse on text that is in a style with the\nhotspot attribute set.\nArguments:\n\n* `position`: The text position of the release.
 IDENTIFIER lexer.IDENTIFIER\nToken type for identifier tokens.
 INDIC0_MASK _SCINTILLA.constants.INDIC0_MASK\n32
 INDIC1_MASK _SCINTILLA.constants.INDIC1_MASK\n64
 INDIC2_MASK _SCINTILLA.constants.INDIC2_MASK\n128
-INDICATOR_CLICK events.INDICATOR_CLICK\nCalled when the user clicks the mouse on text that has an indicator.\nArguments:\n  * `position`: The text position of the click.\n  * `modifiers`: The key modifiers held down. It is a combination of zero\n    or more of `_SCINTILLA.constants.SCMOD_ALT`,\n    `_SCINTILLA.constants.SCMOD_CTRL`,\n    `_SCINTILLA.constants.SCMOD_SHIFT`, and\n    `_SCINTILLA.constants.SCMOD_META`.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
-INDICATOR_RELEASE events.INDICATOR_RELEASE\nCalled when the user releases the mouse on text that has an indicator.\nArguments:\n  * `position`: The text position of the release.
+INDICATOR_CLICK events.INDICATOR_CLICK (string)\nCalled when the user clicks the mouse on text that has an indicator.\nArguments:\n\n* `position`: The text position of the click.\n* `modifiers`: The key modifiers held down. It is a combination of zero or\n  more of `_SCINTILLA.constants.SCMOD_ALT`,\n  `_SCINTILLA.constants.SCMOD_CTRL`,\n  `_SCINTILLA.constants.SCMOD_SHIFT`, and\n  `_SCINTILLA.constants.SCMOD_META`.\n  Note: If you set `buffer.rectangular_selection_modifier` to\n  `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n  Ctrl and Alt due to a Scintilla limitation with GTK+.
+INDICATOR_RELEASE events.INDICATOR_RELEASE (string)\nCalled when the user releases the mouse on text that has an indicator.\nArguments:\n\n* `position`: The text position of the release.
 INDICS_MASK _SCINTILLA.constants.INDICS_MASK\n224
 INDIC_BOX _SCINTILLA.constants.INDIC_BOX\n6
 INDIC_CONTAINER _SCINTILLA.constants.INDIC_CONTAINER\n8
@@ -76,7 +79,7 @@ INDIC_DOTBOX _SCINTILLA.constants.INDIC_DOTBOX\n12
 INDIC_DOTS _SCINTILLA.constants.INDIC_DOTS\n10
 INDIC_HIDDEN _SCINTILLA.constants.INDIC_HIDDEN\n5
 INDIC_HIGHLIGHT_ALPHA _M.textadept.editing.INDIC_HIGHLIGHT_ALPHA (number)\nThe alpha transparency value between `0` (transparent) and `255` (opaque)\nused for an indicator for a highlighted word.\nThe default value is `100`.
-INDIC_HIGHLIGHT_BACK _M.textadept.editing.INDIC_HIGHLIGHT_BACK (number)\nThe color used for an indicator for a highlighted word in `0xBBGGRR`\nformat.
+INDIC_HIGHLIGHT_BACK _M.textadept.editing.INDIC_HIGHLIGHT_BACK (number)\nThe color used for an indicator for a highlighted word\nin `0xBBGGRR` format.
 INDIC_MAX _SCINTILLA.constants.INDIC_MAX\n31
 INDIC_PLAIN _SCINTILLA.constants.INDIC_PLAIN\n0
 INDIC_ROUNDBOX _SCINTILLA.constants.INDIC_ROUNDBOX\n7
@@ -87,40 +90,40 @@ INDIC_STRAIGHTBOX _SCINTILLA.constants.INDIC_STRAIGHTBOX\n8
 INDIC_STRIKE _SCINTILLA.constants.INDIC_STRIKE\n4
 INDIC_TT _SCINTILLA.constants.INDIC_TT\n2
 INVALID_POSITION _SCINTILLA.constants.INVALID_POSITION\n-1
-KEYPRESS events.KEYPRESS\nCalled when a key is pressed.\nArguments:\n  * `code`: The key code.\n  * `shift`: The Shift key is held down.\n  * `ctrl`: The Control/Command key is held down.\n  * `alt`: The Alt/option key is held down.\n  * `meta`: The Control key on Mac OSX is held down.
-KEYSYMS keys.KEYSYMS (table)\nLookup table for key codes higher than 255.\nIf a key code given to `keypress()` is higher than 255, this table is used to\nreturn a string representation of the key if it exists.
+KEYPRESS events.KEYPRESS (string)\nCalled when a key is pressed.\nArguments:\n\n* `code`: The key code.\n* `shift`: The Shift key is held down.\n* `ctrl`: The Control/Command key is held down.\n* `alt`: The Alt/option key is held down.\n* `meta`: The Control key on Mac OSX is held down.
+KEYSYMS keys.KEYSYMS (table)\nLookup table for string representations of GDK key codes higher than 255.\nKey codes can be identified by temporarily uncommenting the `print()`\nstatements in `core/keys.lua`
 KEYWORD lexer.KEYWORD\nToken type for keyword tokens.
 KEYWORDSET_MAX _SCINTILLA.constants.KEYWORDSET_MAX\n8
 LABEL lexer.LABEL\nToken type for label tokens.
-LANGUAGE_MODULE_LOADED events.LANGUAGE_MODULE_LOADED\nCalled when loading a language-specific module.\nThis is useful for overriding its key commands since they are not available\nwhen Textadept starts.\nArguments:\n  * `lang`: The language lexer name.
-LANGUAGE_MODULE_PREFIX keys.LANGUAGE_MODULE_PREFIX (string)\nThe starting key command of the keychain reserved for language-specific\nmodules.\nThe default value is Ctrl/Cmd+L.
-MARGIN_CLICK events.MARGIN_CLICK\nCalled when the mouse is clicked inside a margin.\nArguments:\n  * `margin`: The margin number that was clicked.\n  * `position`: The position of the start of the line in the buffer that\n    corresponds to the margin click.\n  * `modifiers`: The appropriate combination of\n    `_SCINTILLA.constants.SCI_SHIFT`, `_SCINTILLA.constants.SCI_CTRL`,\n    and `_SCINTILLA.constants.SCI_ALT` to indicate the keys that were\n    held down at the time of the margin click.\n    Note: If you set `buffer.rectangular_selection_modifier` to\n    `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n    Ctrl and Alt due to a Scintilla limitation with GTK.
+LANGUAGE_MODULE_LOADED events.LANGUAGE_MODULE_LOADED\nCalled after loading a language-specific module.\nThis is useful for overriding a language-specific module's key bindings\nor other properties since the module is not loaded when Textadept starts.\nArguments:\n  * `lang`: The language lexer name.
+LANGUAGE_MODULE_PREFIX keys.LANGUAGE_MODULE_PREFIX (string)\nThe starting key command of the key chain reserved for language-specific\nmodules.\nThe default value is `Ctrl+L` (`⌘L` on Mac OSX | `M-L` in ncurses).
+MARGIN_CLICK events.MARGIN_CLICK (string)\nCalled when the mouse is clicked inside a margin.\nArguments:\n\n* `margin`: The margin number that was clicked.\n* `position`: The position of the start of the line in the buffer that\n  corresponds to the margin click.\n* `modifiers`: The appropriate combination of\n  `_SCINTILLA.constants.SCI_SHIFT`, `_SCINTILLA.constants.SCI_CTRL`,\n  and `_SCINTILLA.constants.SCI_ALT` to indicate the keys that were held\n  down at the time of the margin click.\n  Note: If you set `buffer.rectangular_selection_modifier` to\n  `_SCINTILLA.constants.SCMOD_CTRL`, the Ctrl key is reported as *both*\n  Ctrl and Alt due to a Scintilla limitation with GTK+.
 MARKER_MAX _SCINTILLA.constants.MARKER_MAX\n31
 MARK_BOOKMARK_COLOR _M.textadept.bookmarks.MARK_BOOKMARK_COLOR (number)\nThe color used for a bookmarked line in `0xBBGGRR` format.
-MARK_HIGHLIGHT_BACK _M.textadept.editing.MARK_HIGHLIGHT_BACK (number)\nThe background color used for a line containing a highlighted word in\n`0xBBGGRR` format.
-MAX _M.textadept.snapopen.MAX (number)\nMaximum number of files to list. The default value is `1000`.
-MAX_RECENT_FILES _M.textadept.session.MAX_RECENT_FILES (number)\nThe maximum number of files from the recent files list to save to the\nsession.\nThe default value is `10`.
-MENU_CLICKED events.MENU_CLICKED\nCalled when a menu item is selected.\nArguments:\n  * `menu_id`: The numeric ID of the menu item set in `gui.gtkmenu()`.
-NCURSES _G.NCURSES (bool)\nIf Textadept is running in the terminal, this flag is `true`.
+MARK_HIGHLIGHT_BACK _M.textadept.editing.MARK_HIGHLIGHT_BACK (number)\nThe background color used for a line containing a\nhighlighted word in `0xBBGGRR` format.
+MAX _M.textadept.snapopen.MAX (number)\nMaximum number of files to list.\nThe default value is `1000`.
+MAX_RECENT_FILES _M.textadept.session.MAX_RECENT_FILES (number)\nThe maximum number of files from `io.recent_files` to save to the\nsession.\nThe default value is `10`.
+MENU_CLICKED events.MENU_CLICKED (string)\nCalled when a menu item is selected.\nArguments:\n\n* `menu_id`: The numeric ID of the menu item set in `gui.menu()`.
+NCURSES _G.NCURSES (bool)\nIf Textadept is running in the terminal, this flag is `true`.\nncurses feature incompatibilities are listed in the Appendix.
 NUMBER lexer.NUMBER\nToken type for number tokens.
 OPERATOR lexer.OPERATOR\nToken type for operator tokens.
 OSX _G.OSX (bool)\nIf Textadept is running on Mac OSX, this flag is `true`.
 P lpeg.P(value)\nConverts the given value into a proper pattern, according to the following\nrules:\n  * If the argument is a pattern, it is returned unmodified.\n  * If the argument is a string, it is translated to a pattern that matches\n    literally the string.\n  * If the argument is a non-negative number n, the result is a pattern that\n    matches exactly n characters.\n  * If the argument is a negative number -n, the result is a pattern that\n    succeeds only if the input string does not have n characters: lpeg.P(-n)\n    is equivalent to -lpeg.P(n) (see the unary minus operation).\n  * If the argument is a boolean, the result is a pattern that always\n    succeeds or always fails (according to the boolean value), without\n    consuming any input.\n  * If the argument is a table, it is interpreted as a grammar (see\n    Grammars).\n  * If the argument is a function, returns a pattern equivalent to a\n    match-time capture over the empty string.
 PATHS _M.textadept.snapopen.PATHS (table)\nTable of default UTF-8 paths to search.
 PREPROCESSOR lexer.PREPROCESSOR\nToken type for preprocessor tokens.
-QUIT events.QUIT\nCalled when quitting Textadept.\nWhen connecting to this event, connect with an index of 1 or the handler\nwill be ignored.
+QUIT events.QUIT (string)\nCalled when quitting Textadept.\nWhen connecting to this event, connect with an index of 1 or the handler\nwill be ignored.\nThis is emitted by `quit()`.
 R lpeg.R({range})\nReturns a pattern that matches any single character belonging to one of the\ngiven ranges. Each range is a string xy of length 2, representing all\ncharacters with code between the codes of x and y (both inclusive).\n\nAs an example, the pattern lpeg.R("09") matches any digit, and lpeg.R("az",\n"AZ") matches any ASCII letter.
 REGEX lexer.REGEX\nToken type for regex tokens.
-REPLACE events.REPLACE\nCalled to replace selected (found) text.\nArguments:\n  * `text`: The text to replace selected text with.
-REPLACE_ALL events.REPLACE_ALL\nCalled to replace all occurances of found text.\nArguments:\n  * `find_text`: The text to search for.\n  * `repl_text`: The text to replace found text with.
+REPLACE events.REPLACE (string)\nCalled to replace selected (found) text.\nArguments:\n\n* `text`: The text to replace selected text with.
+REPLACE_ALL events.REPLACE_ALL (string)\nCalled to replace all occurances of found text.\nArguments:\n\n* `find_text`: The text to search for.\n* `repl_text`: The text to replace found text with.
 RESETTING _G.RESETTING (bool)\nIf `reset()` has been called, this flag is `true` while the Lua\nstate is being re-initialized.
-RESET_AFTER events.RESET_AFTER\nCalled after resetting the Lua state.\nThis is triggered by `reset()`.
-RESET_BEFORE events.RESET_BEFORE\nCalled before resetting the Lua state.\nThis is triggered by `reset()`.
-RUN_OUTPUT events.RUN_OUTPUT\nCalled after a run command is executed.\nWhen connecting to this event (typically from a language-specific module),\nconnect with an index of `1` and return `true` if the event was handled and\nyou want to override the default handler that prints the output to a new\nview.\nArguments:\n  * `lexer`: The lexer language.\n  * `output`: The output from the command.
+RESET_AFTER events.RESET_AFTER (string)\nCalled after resetting the Lua state.\nThis is emitted by `reset()`.
+RESET_BEFORE events.RESET_BEFORE (string)\nCalled before resetting the Lua state.\nThis is emitted by `reset()`.
+RUN_OUTPUT events.RUN_OUTPUT\nCalled after a run command is executed.\nBy default, output is printed to the message buffer. To override this\nbehavior, connect to the event with an index of `1` and return `true`.\nArguments:\n  * `lexer`: The lexer language.\n  * `output`: The output from the command.
 S lpeg.S(string)\nReturns a pattern that matches any single character that appears in the given\nstring. (The S stands for Set.)\n\nAs an example, the pattern lpeg.S("+-*/") matches any arithmetic operator.\n\nNote that, if s is a character (that is, a string of length 1), then\nlpeg.P(s) is equivalent to lpeg.S(s) which is equivalent to lpeg.R(s..s).\nNote also that both lpeg.S("") and lpeg.R() are patterns that always fail.
-SAVE_ON_QUIT _M.textadept.session.SAVE_ON_QUIT (bool)\nSave the session when quitting.\nThe default value is `true` and can be disabled by passing the command line\nswitch `-n` or `--nosession` to Textadept.
-SAVE_POINT_LEFT events.SAVE_POINT_LEFT\nCalled when a save point is left.
-SAVE_POINT_REACHED events.SAVE_POINT_REACHED\nCalled when a save point is entered.
+SAVE_ON_QUIT _M.textadept.session.SAVE_ON_QUIT (bool)\nSave the session when quitting.\nThe default value is `true`, but can be disabled by passing the command\nline switch `-n` or `--nosession` to Textadept.
+SAVE_POINT_LEFT events.SAVE_POINT_LEFT (string)\nCalled when a save point is left.
+SAVE_POINT_REACHED events.SAVE_POINT_REACHED (string)\nCalled when a save point is entered.
 SCEN_CHANGE _SCINTILLA.constants.SCEN_CHANGE\n768
 SCEN_KILLFOCUS _SCINTILLA.constants.SCEN_KILLFOCUS\n256
 SCEN_SETFOCUS _SCINTILLA.constants.SCEN_SETFOCUS\n512
@@ -735,38 +738,38 @@ STYLE_LINENUMBER _SCINTILLA.constants.STYLE_LINENUMBER\n33
 STYLE_MAX _SCINTILLA.constants.STYLE_MAX\n255
 TYPE lexer.TYPE\nToken type for type tokens.
 UNDO_MAY_COALESCE _SCINTILLA.constants.UNDO_MAY_COALESCE\n1
-UPDATE_UI events.UPDATE_UI\nCalled when either the text or styling of the buffer has changed or the\nselection range has changed.
-URI_DROPPED events.URI_DROPPED\nCalled when the user has dragged a URI such as a file name onto the view.\nArguments:\n  * `text`: The URI text encoded in UTF-8.
-USER_LIST_SELECTION events.USER_LIST_SELECTION\nCalled when the user has selected an item in a user list.\nArguments:\n  * `list_type`: This is set to the list_type parameter from the\n    `buffer:user_list_show()` call that initiated the list.\n  * `text`: The text of the selection.\n  * `position`: The position the list was displayed at.
+UPDATE_UI events.UPDATE_UI (string)\nCalled when either the text or styling of the buffer has changed or the\nselection range has changed.
+URI_DROPPED events.URI_DROPPED (string)\nCalled when the user has dragged a URI such as a file name onto the view.\nArguments:\n\n* `text`: The URI text encoded in UTF-8.
+USER_LIST_SELECTION events.USER_LIST_SELECTION (string)\nCalled when the user has selected an item in a user list.\nArguments:\n\n* `list_type`: This is set to the list_type parameter from the\n  `buffer:user_list_show()` call that initiated the list.\n* `text`: The text of the selection.\n* `position`: The position the list was displayed at.
 V lpeg.V(v)\nThis operation creates a non-terminal (a variable) for a grammar. The created\nnon-terminal refers to the rule indexed by v in the enclosing grammar. (See\nGrammars for details.)
 VARIABLE lexer.VARIABLE\nToken type for variable tokens.
-VIEW_AFTER_SWITCH events.VIEW_AFTER_SWITCH\nCalled right after another view is switched to.
-VIEW_BEFORE_SWITCH events.VIEW_BEFORE_SWITCH\nCalled right before another view is switched to.
-VIEW_NEW events.VIEW_NEW\nCalled when a new view is created.
+VIEW_AFTER_SWITCH events.VIEW_AFTER_SWITCH (string)\nCalled right after another view is switched to.\nThis is emitted by `gui.goto_view()`.
+VIEW_BEFORE_SWITCH events.VIEW_BEFORE_SWITCH (string)\nCalled right before another view is switched to.\nThis is emitted by `gui.goto_view()`.
+VIEW_NEW events.VIEW_NEW (string)\nCalled when a new view is created.\nThis is emitted on startup and by `view:split()`.
 VISIBLE_SLOP _SCINTILLA.constants.VISIBLE_SLOP\n1
 VISIBLE_STRICT _SCINTILLA.constants.VISIBLE_STRICT\n4
 WHITESPACE lexer.WHITESPACE\nToken type for whitespace tokens.
 WIN32 _G.WIN32 (bool)\nIf Textadept is running on Windows, this flag is `true`.
-_BUFFERS _G._BUFFERS (table)\nTable of all open buffers in Textadept.\nNumeric keys have buffer values and buffer keys have their associated numeric\nkeys.
-_CHARSET _G._CHARSET (string)\nThe character set encoding of the filesystem.\nThis is used in File I/O.
+_BUFFERS _G._BUFFERS (table)\nTable of all open buffers in Textadept.\nNumeric keys have buffer values and buffer keys have their associated numeric\nkeys.\n@see _G.buffer
+_CHARSET _G._CHARSET (string)\nThe character set encoding of the filesystem.\nThis is used when working with files.
 _EMBEDDEDRULES lexer._EMBEDDEDRULES (table)\nSet of rules for an embedded lexer.\nFor a parent lexer name, contains child's `start_rule`, `token_rule`, and\n`end_rule` patterns.
-_EXISTS M._EXISTS(message)\nReturns whether or not a localized message exists for the given message.\n@param message The message to localize.\n@return `true` if a localization exists, `false` otherwise.
+_EXISTS M._EXISTS(message)\nReturns whether or not a localized message exists for the given message.\nThis function is necessary since `_L[message]` never returns `nil`.\n@param message The message to localize.\n@return `true` if a localization exists, `false` otherwise.
 _G _G._G (module)\nLua _G module.
 _G _G._G (table)\nA global variable (not a function) that holds the global environment\n(see §2.2). Lua itself does not use this variable; changing its value does\nnot affect any environment, nor vice-versa.
 _HOME _G._HOME (string)\nPath to the directory containing Textadept.
-_L _G._L (module)\nTable of all messages used by Textadept for localization.
-_LEXERPATH _G._LEXERPATH (string)\nPaths to lexers, formatted like\n`package.path`.
+_L _G._L (module)\nTable of all messages used by Textadept for localization.\nIf the table does not contain the localized version of a given message, it\nreturns a string indicating so via a metamethod.
+_LEXERPATH _G._LEXERPATH (string)\nPaths to lexers, formatted like `package.path`.
 _M _G._M (module)\nA table of loaded modules.
 _RELEASE _G._RELEASE (string)\nThe Textadept release version.
 _RULES lexer._RULES (table)\nList of rule names with associated LPeg patterns for a specific lexer.\nIt is accessible to other lexers for embedded lexer applications.
-_SCINTILLA _G._SCINTILLA (module)\nScintilla constants, functions, and properties.\nDo not modify anything in this module. Doing so will result in instability.
-_USERHOME _G._USERHOME (string)\nPath to the user's `~/.textadept/`.
+_SCINTILLA _G._SCINTILLA (module)\nScintilla constants, functions, and properties.\nDo not modify anything in this module. Doing so will have unpredicable\nconsequences.
+_USERHOME _G._USERHOME (string)\nPath to the user's `~/.textadept/`, where all preferences and user-data is\nstored.\nOn Windows machines `~/` is the value of the `USERHOME` environment\nvariable, typically `C:\Users\<username>\` or\n`C:\Documents and Settings\<username>\`. On Linux, BSD, and Mac OSX\nmachines `~/` is the value of `HOME`, typically `/home/<username>/` and\n`/Users/<username>/` respectively.
 _VERSION _G._VERSION (string)\nA global variable (not a function) that holds a string containing the\ncurrent interpreter version. The current contents of this variable is\n"`Lua 5.2`".
-_VIEWS _G._VIEWS (table)\nTable of all views in Textadept.\nNumeric keys have view values and view keys have their associated numeric\nkeys.
+_VIEWS _G._VIEWS (table)\nTable of all views in Textadept.\nNumeric keys have view values and view keys have their associated numeric\nkeys.\n@see _G.view
 _cancel_current _M.textadept.snippets._cancel_current()\nCancels the active snippet, reverting to the state before its activation, and\nrestores the previously running snippet (if any).
-_insert _M.textadept.snippets._insert(text)\nInserts a snippet.\n@param text Optional snippet text. If none is specified, the snippet text\n  is determined from the trigger and lexer.\n@return `false` if no snippet was expanded; `true` otherwise.
-_previous _M.textadept.snippets._previous()\nGoes back to the previous placeholder, reverting any changes from the current\none.\n@return `false` if no snippet is active; `nil` otherwise.
-_print gui._print(buffer_type, ...)\nHelper function for printing messages to buffers.\nSplits the view and opens a new buffer for printing messages. If the message\nbuffer is already open and a view is currently showing it, the message is\nprinted to that view. Otherwise the view is split, goes to the open message\nbuffer, and prints to it.\n@param buffer_type String type of message buffer.\n@param ... Message strings.\n@usage gui._print(_L['[Error Buffer]'], error_message)\n@usage gui._print(_L['[Message Buffer]'], message)
+_insert _M.textadept.snippets._insert(text)\nInserts a new snippet or goes to the next placeholder of the active snippet.\n@param text Optional snippet text. If `nil`, attempts to insert a new snippet\n  based on the trigger, the word to the left of the caret, and the current\n  lexer.\n@return `false` if no action was taken; `nil` otherwise.\n@see buffer.word_chars
+_previous _M.textadept.snippets._previous()\nGoes back to the previous snippet placeholder, reverting any changes from the\ncurrent one.\n@return `false` if no snippet is active; `nil` otherwise.
+_print gui._print(buffer_type, ...)\nHelper function for printing messages to buffers.\nSplits the view and opens a new buffer for printing messages to. If the\nmessage buffer is already open in a view, the message is printed to that\nview. Otherwise the view is split and the message buffer is opened or\ndisplayed before being printed to.\n@param buffer_type String type of message buffer.\n@param ... Message strings.\n@usage gui._print(_L['[Error Buffer]'], error_message)\n@usage gui._print(_L['[Message Buffer]'], message)
 _select _M.textadept.snippets._select()\nPrompts the user to select a snippet to insert from a filtered list dialog.\nGlobal snippets and snippets in the current lexer are shown.
 abs math.abs(x)\nReturns the absolute value of `x`.
 acos math.acos(x)\nReturns the arc cosine of `x` (in radians).
@@ -780,11 +783,11 @@ additional_sel_alpha buffer.additional_sel_alpha (number)\nThe alpha of addition
 additional_sel_back buffer.additional_sel_back (number)\nThe background color of additional selections in `0xBBGGRR` format.\n`buffer:set_sel_back(true, ...)` must have been called previously for this\nto have an effect.
 additional_sel_fore buffer.additional_sel_fore (number)\nThe foreground color of additional selections in `0xBBGGRR` format.\n`buffer:set_sel_fore(true, ...)` must have been called previously for this\nto have an effect.
 additional_selection_typing buffer.additional_selection_typing (bool)\nWhether typing can be performed into multiple selections.
-adeptsense _M.textadept.adeptsense (module)\nLanguage autocompletion support for the textadept module.
+adeptsense _M.textadept.adeptsense (module)\nCode autocompletion and documentation support for programming languages.
 allocate buffer.allocate(buffer, bytes)\nEnlarge the document to a particular size of text bytes.\nThe document will not be made smaller than its current contents.\n@param buffer The global buffer.
 alnum lexer.alnum\nMatches any alphanumeric character (`A-Z`, `a-z`, `0-9`).
 alpha lexer.alpha\nMatches any alphabetic character (`A-Z`, `a-z`).
-always_show_globals _M.textadept.adeptsense.always_show_globals (bool)\nInclude globals in the list of completions offered.\nGlobals are classes, functions, and fields that do not belong to another\nclass. They are contained in `completions['']`. The default value is\n`true`.
+always_show_globals _M.textadept.adeptsense.always_show_globals (bool)\nInclude globals in the list of completions offered.\nGlobals are classes, functions, and fields that do not belong to another\nclass. They are contained in `completions['']`.\nThe default value is `true`.
 anchor buffer.anchor (number)\nThe position of the opposite end of the selection to the caret.
 annotation_clear_all buffer.annotation_clear_all(buffer)\nClear the annotations from all lines.\n@param buffer The global buffer.
 annotation_lines buffer.annotation_lines (table, Read-only)\nTable of the number of annotation lines for lines starting from zero.
@@ -793,9 +796,9 @@ annotation_style_offset buffer.annotation_style_offset (number)\nThe start of th
 annotation_text buffer.annotation_text (table)\nTable of annotation text for lines starting from zero.
 annotation_visible buffer.annotation_visible (number)\nThe visibility of annotations.\n\n* `_SCINTILLA.constants.ANNOTATION_HIDDEN` (0)\n  Annotations are not displayed.\n* `_SCINTILLA.constants.ANNOTATION_STANDARD` (1)\n  Annotations are drawn left justified with no adornment.\n* `_SCINTILLA.constants.ANNOTATION_BOXED` (2)\n  Annotations are indented to match the text and are surrounded by a box.
 any lexer.any\nMatches any single character.
-api_files _M.textadept.adeptsense.api_files (table)\nContains a list of api files used by `show_apidoc()`.\nEach line in the api file contains a symbol name (not the full symbol)\nfollowed by a space character and then the symbol's documentation. Since\nthere may be many duplicate symbol names, it is recommended to put the full\nsymbol and arguments, if any, on the first line. (e.g. `Class.function(arg1,\narg2, ...)`). This allows the correct documentation to be shown based on the\ncurrent context. In the documentation, newlines are represented with `\\n`. A\n`\` before `\\n` escapes the newline.
+api_files _M.textadept.adeptsense.api_files (table)\nContains a list of api files used by `show_apidoc()`.\nEach line in the api file contains a symbol name (not the full symbol)\nfollowed by a space character and then the symbol's documentation. Since\nthere may be many duplicate symbol names, it is recommended to put the full\nsymbol and arguments, if any, on the first line. (e.g. `Class.function(arg1,\narg2, ...)`). This allows the correct documentation to be shown based on the\ncurrent context. In the documentation, newlines are represented with `\n`. A\n`\` before `\n` escapes the newline.
 append_text buffer.append_text(buffer, text)\nAppend a string to the end of the document without changing the selection.\nThe current selection is not changed and the new text is not scrolled into\nview.\n@param buffer The global buffer.\n@param text The text.
-arg _G.arg (table)\nCommand line parameters.
+arg _G.arg (table)\nCommand line parameters passed to Textadept.\n@see _G.args
 args _G.args (module)\nProcesses command line arguments for Textadept.
 arshift bit32.arshift(x, disp)\nReturns the number `x` shifted `disp` bits to the right. The number `disp`\nmay be any representable integer. Negative displacements shift to the left.\n\nThis shift operation is what is called arithmetic shift. Vacant bits on the\nleft are filled with copies of the higher bit of `x`; vacant bits on the\nright are filled with zeros. In particular, displacements with absolute\nvalues higher than 31 result in zero or `0xFFFFFFFF` (all original bits are\nshifted out).
 ascii lexer.ascii\nMatches any ASCII character (`0`..`127`).
@@ -824,7 +827,7 @@ auto_c_separator buffer.auto_c_separator (number)\nThe auto-completion list sepa
 auto_c_show buffer.auto_c_show(buffer, len_entered, item_list)\nDisplay an auto-completion list.\n@param len_entered The number of characters before the caret used to provide\n  the context.\n@param item_list List of words separated by separator characters (initially\n  spaces). The list of words should be in sorted order.
 auto_c_stops buffer.auto_c_stops(buffer, chars)\nDefine a set of characters that when typed cancel the auto-completion list.\n@param buffer The global buffer.\n@param chars String list of characters. This list is empty by default.
 auto_c_type_separator buffer.auto_c_type_separator (number)\nThe auto-completion list type-separator character byte.\nThe default is `'?'`. Autocompletion list items may display an image as\nwell as text. Each image is first registered with an integer type. Then\nthis integer is included in the text of the list separated by a `?` from\nthe text.
-autocomplete_word _M.textadept.editing.autocomplete_word(word_chars, default_words)\nPops up an autocompletion list for the current word based on other words in\nthe document.\n@param word_chars String of chars considered to be part of words.\n@param default_words Optional list of words considered to be in the document,\n  even if they are not. Words may contain registered images.\n@return `true` if there were completions to show; `false` otherwise.
+autocomplete_word _M.textadept.editing.autocomplete_word(word_chars, default_words)\nPops up an autocompletion list for the current word based on other words in\nthe document.\n@param word_chars String of characters considered to be part of words. Since\n  this string is used in a Lua pattern character set, character classes and\n  ranges may be used.\n@param default_words Optional list of words considered to be in the document,\n  even if they are not. Words may contain registered images.\n@usage _M.textadept.editing.autocomplete_word('%w_')\n@return `true` if there were completions to show; `false` otherwise.
 back_space_un_indents buffer.back_space_un_indents (bool)\nWhether a backspace pressed when caret is within indentation unindents.
 back_tab buffer.back_tab(buffer)\nDedent the selected lines.\n@param buffer The global buffer.
 band bit32.band(...)\nReturns the bitwise "and" of its operands.
@@ -832,18 +835,19 @@ begin_undo_action buffer.begin_undo_action(buffer)\nStart a sequence of actions
 bit32 _G.bit32 (module)\nLua bit32 module.
 block_comment _M.textadept.editing.block_comment(comment)\nBlock comments or uncomments code with a given comment string.\nIf none is specified, uses the `comment_string` table.\n@param comment The comment string inserted or removed from the beginning of\n  each line in the selection.\n@see comment_string
 bnot bit32.bnot(x)\nReturns the bitwise negation of `x`. For any integer `x`, the following\nidentity holds:\n\n  assert(bit32.bnot(x) == (-1 - x) % 2^32)
-boms io.boms (table)\nList of byte-order marks (BOMs).
-bookmarks _M.textadept.bookmarks (module)\nBookmarks for the textadept module.
+boms io.boms (table)\nList of byte-order marks (BOMs) for identifying unicode file types.
+bookmarks _M.textadept.bookmarks (module)\nBookmarks for Textadept.
 bor bit32.bor(...)\nReturns the bitwise "or" of its operands.
 brace_bad_light buffer.brace_bad_light(buffer, pos)\nHighlight the character at a position indicating there is no matching brace.\n@param buffer The global buffer.\n@param pos The position or -1 to remove the highlight.
 brace_bad_light_indicator buffer.brace_bad_light_indicator(buffer, use_indicator, indic_num)\nUse specified indicator to highlight non matching brace instead of changing\nits style.\n@param buffer The global buffer.\n@param use_indicator Use an indicator.\n@param indic_num The indicator number.
 brace_highlight buffer.brace_highlight(buffer, pos1, pos2)\nHighlight the characters at two positions.\nIf indent guides are enabled, the indent that corresponds with the brace can\nbe highlighted by locating the column with `buffer.column` and highlight the\nindent with `buffer.highlight_guide`.\n@param buffer The global buffer.\n@param pos1 The first position.\n@param pos2 The second position.
 brace_highlight_indicator buffer.brace_highlight_indicator(buffer, use_indicator, indic_num)\nUse specified indicator to highlight matching braces instead of changing\ntheir style.\n@param buffer The global buffer.\n@param use_indicator Use an indicator.\n@param indic_num The indicator number.
 brace_match buffer.brace_match(buffer, pos)\nFind the position of a matching brace or `-1` if no match.\nThe brace characters handled are `(`, `)`, `[`, `]`, `{`, `}`, `<`, and `>`.\nThe search is forwards from an opening brace and backwards from a closing\nbrace. A match only occurs if the style of the matching brace is the same as\nthe starting brace or the matching brace is beyond the end of styling. Nested\nbraces are handled correctly.\n@param buffer The global buffer.\n@param pos The position.\n@return number.
-braces _M.textadept.editing.braces (table)\nHighlighted brace characters.\nKeys are lexer language names and values are tables of characters that count\nas brace characters. This table can be populated by language-specific\nmodules. The defaults are '(', ')', '[', ']', '{', and '}'.\n@see HIGHLIGHT_BRACES
+braces _M.textadept.editing.braces (table)\nHighlighted brace characters.\nKeys are lexer language names and values are tables of character ASCII values\nthat count as brace characters. The defaults are `(`, `)`, `[`, `]`, `{`, and\n`}`.\nThis table can be populated by language-specific modules.\n@see HIGHLIGHT_BRACES
 btest bit32.btest(...)\nReturns a boolean signaling whether the bitwise "and" of its operands is\ndifferent from zero.
-buffer _G.buffer (module)\nThe current buffer in the current view.\nIt also represents the structure of any buffer table in `_G._BUFFER`.
-buffer view.buffer (table)\nThe buffer this view contains. (Read-only)
+buffer _G.buffer (module)\nA Textadept buffer object.\nBe careful when storing references to a buffer object because if you attempt\ncall a buffer function with a non-global buffer, you will get an error. See\n`check_global()` for more information.
+buffer _G.buffer\nThe current buffer in the current view.
+buffer view.buffer (table)\nThe buffer the view contains. (Read-only)
 buffered_draw buffer.buffered_draw (bool)\nWhether drawing is buffered.\nIf drawing is buffered then each line of text is drawn into a bitmap buffer\nbefore drawing it to the screen to avoid flicker. The default is for\ndrawing to be buffered. first or directly onto the screen.
 byte string.byte(s [, i [, j]])\nReturns the internal numerical codes of the characters `s[i]`, `s[i+1]`,\n..., `s[j]`. The default value for `i` is 1; the default value for `j`\nis `i`. These indices are corrected following the same rules of function\n`string.sub`.\n\nNumerical codes are not necessarily portable across platforms.
 call_tip_active buffer.call_tip_active(buffer)\nIs there an active call tip?\n@param buffer The global buffer.\n@return bool
@@ -875,14 +879,14 @@ char_at buffer.char_at (table, Read-only)\nTable of character bytes at positions
 char_left buffer.char_left(buffer)\nMove caret left one character.\n@param buffer The global buffer.
 char_left_extend buffer.char_left_extend(buffer)\nMove caret left one character extending selection to new caret position.\n@param buffer The global buffer.
 char_left_rect_extend buffer.char_left_rect_extend(buffer)\nMove caret left one character, extending rectangular selection to new caret\nposition.\n@param buffer The global buffer.
-char_matches _M.textadept.editing.char_matches (table)\nAuto-matched characters.\nUsed for auto-matching parentheses, brackets, braces, quotes, etc. Keys are\nlexer language names and values are tables of character match pairs. This\ntable can be populated by language-specific modules. The defaults are '()',\n'[]', '{}', '''', and '""'.\n@see AUTOPAIR
+char_matches _M.textadept.editing.char_matches (table)\nAuto-matched characters.\nUsed for auto-matching parentheses, brackets, braces, quotes, etc. Keys are\nlexer language names and values are tables of character match pairs. A pair's\nkey is an ASCII value and the value is the string character match. The\ndefaults are `()`, `[]`, `{}`, `''`, and `""`.\nThis table can be populated by language-specific modules.\n@see AUTOPAIR
 char_position_from_point buffer.char_position_from_point(buffer, x, y)\nFind the position of a character from a point within the window.\n@param buffer The global buffer.\n@return number
 char_position_from_point_close buffer.char_position_from_point_close(buffer, x, y)\nFind the position of a character from a point within the window.\nReturn `-1` if not close to text.\n@param buffer The global buffer.\n@return number
 char_right buffer.char_right(buffer)\nMove caret right one character.\n@param buffer The global buffer.
 char_right_extend buffer.char_right_extend(buffer)\nMove caret right one character extending selection to new caret position.\n@param buffer The global buffer.
 char_right_rect_extend buffer.char_right_rect_extend(buffer)\nMove caret right one character, extending rectangular selection to new caret\nposition.\n@param buffer The global buffer.
 chdir lfs.chdir(path)\nChanges the current working directory to the given path.\n\nReturns true in case of success or nil plus an error string.
-check_global buffer.check_global(buffer)\nChecks whether the given buffer is the global one.\nIf not, throws an error indicating so. It is necessary to call this at the\ntop of all buffer functions to avoid unexpected behavior since most buffer\nfunctions operate on `_G.buffer`, which is not necessarily the given one.\n@param buffer The buffer to check.
+check_global buffer.check_global(buffer)\nChecks whether the given buffer is the global one.\nIf not, throws an error indicating so. It is necessary to call this at the\ntop of all buffer functions to avoid unexpected behavior since most buffer\nfunctions operate on `_G.buffer`, which is not necessarily the given one.\n@param buffer The buffer to check.\n@see _G._G.buffer
 choose_caret_x buffer.choose_caret_x(buffer)\nSet the last x chosen value to be the caret x position.\nThe view remembers the x value of the last position horizontally moved to\nexplicitly by the user and this value is then used when moving vertically\nsuch as by using the up and down keys. This function sets the current x\nposition of the caret as the remembered value.\n@param buffer The global buffer.
 class_definition _M.textadept.adeptsense.syntax.class_definition (table)\nA Lua pattern representing the language's class\n  definition syntax. The first capture returned must be the class name. A\n  second, optional capture contains the class' superclass (if any). If no\n  completions are found for the class name, completions for the superclass\n  are shown (if any). Completions will not be shown for both a class and\n  superclass unless defined in a previously loaded ctags file. Also, multiple\n  superclasses cannot be recognized by this pattern; use a ctags file\n  instead. The default value is `'class%s+([%w_]+)'`.
 clear _M.textadept.adeptsense.clear(sense)\nClears an Adeptsense.\nThis is necessary for loading a new ctags file or completions from a\ndifferent project.\n@param sense The Adeptsense returned by `adeptsense.new()`.
@@ -895,10 +899,10 @@ clear_registered_images buffer.clear_registered_images(buffer)\nClear all the re
 clear_selections buffer.clear_selections(buffer)\nClear selections to a single empty stream selection.\n@param buffer The global buffer.
 clipboard_text gui.clipboard_text (string, Read-only)\nThe text on the clipboard.
 clock os.clock()\nReturns an approximation of the amount in seconds of CPU time used by\nthe program.
-close buffer.close(buffer)\nCloses the current buffer.\n@param buffer The global buffer.\nIf the buffer is dirty, the user is prompted to continue. The buffer is not\nsaved automatically. It must be done manually.
+close buffer.close(buffer)\nCloses the current buffer.\n@param buffer The global buffer.\nIf the buffer is dirty, the user is prompted to continue. The buffer is not\nsaved automatically. It must be done manually.\n@return `true` if the buffer was closed; `nil` otherwise.
 close file:close()\nCloses `file`. Note that files are automatically closed when their\nhandles are garbage collected, but that takes an unpredictable amount of\ntime to happen.\n\nWhen closing a file handle created with `io.popen`, `file:close` returns the\nsame values returned by `os.execute`.
 close io.close([file])\nEquivalent to `file:close()`. Without a `file`, closes the default\noutput file.
-close_all io.close_all()\nCloses all open buffers.\nIf any buffer is dirty, the user is prompted to continue. No buffers are\nsaved automatically. They must be saved manually.\n@usage io.close_all()\n@return `true` if user did not cancel.
+close_all io.close_all()\nCloses all open buffers.\nIf any buffer is dirty, the user is prompted to continue. No buffers are\nsaved automatically. They must be saved manually.\n@usage io.close_all()\n@return `true` if user did not cancel.\n@see buffer.close
 cntrl lexer.cntrl\nMatches any control character (`0`..`31`).
 code_page buffer.code_page (number)\nThe code page used to interpret the bytes of the document as characters.\nThe `_SCINTILLA.constants.SC_CP_UTF8` value can be used to enter Unicode\nmode.
 collectgarbage _G.collectgarbage([opt [, arg]])\nThis function is a generic interface to the garbage collector. It\nperforms different functions according to its first argument, `opt`:\n  "collect": performs a full garbage-collection cycle. This is the default\n             option.\n  "stop": stops automatic execution of the garbage collector.\n  "restart": restarts automatic execution of the garbage collector.\n  "count": returns the total memory in use by Lua (in Kbytes) and a second\n           value with the total memory in bytes modulo 1024. The first value\n           has a fractional part, so the following equality is always true:\n\n             k, b = collectgarbage("count")\n             assert(k*1024 == math.floor(k)*1024 + b)\n\n           (The second result is useful when Lua is compiled with a non\n           floating-point type for numbers.)\n  "step": performs a garbage-collection step. The step "size" is controlled\n          by `arg` (larger values mean more steps) in a non-specified way. If\n          you want to control the step size you must experimentally tune the\n          value of `arg`. Returns true if the step finished a collection\n          cycle.\n  "setpause": sets `arg` as the new value for the *pause* of the collector\n              (see §2.5). Returns the previous value for *pause*.\n  "setstepmul": sets `arg` as the new value for the *step multiplier*\n                of the collector (see §2.5). Returns the previous value for\n                *step*.\n  "isrunning": returns a boolean that tells whether the collector is running\n               (i.e., not stopped).\n  "generational": changes the collector to generational mode. This is an\n                  experimental feature (see §2.5).\n  "incremental": changes the collector to incremental mode. This is the\n                 default mode.
@@ -906,24 +910,24 @@ color lexer.color(r, g, b)\nCreates a Scintilla color.\n@param r The string red
 colors lexer.colors (table)\nTable of common colors for a theme.\nThis table should be redefined in each theme.
 colourise buffer.colourise(buffer, start_pos, end_pos)\nColorise a segment of the document using the current lexing language.\n@param buffer The global buffer.\n@param start_pos The start position.\n@param end_pos The end position or `-1` to style from `start_pos` to the end\n  of the document.
 column buffer.column (table, Read-only)\nTable of column numbers, taking tab widths into account, for positions\nstarting from zero.
-command_entry gui.command_entry (module)\nTextadept's Command entry.
+command_entry gui.command_entry (module)\nTextadept's Command Entry.
 comment_string _M.textadept.editing.comment_string (table)\nComment strings for various lexer languages.\nUsed by the `block_comment()` function. Keys are lexer language names and\nvalues are the line comment delimiters for the language. This table is\ntypically populated by language-specific modules.\n@see block_comment
-compile _M.textadept.run.compile()\nCompiles the file as specified by its extension in the `compile_command`\ntable.\n@see compile_command
-compile_command _M.textadept.run.compile_command (table)\nFile extensions and their associated 'compile' actions.\nEach key is a file extension whose value is a either a command line string to\nexecute or a function returning one.\nThis table is typically populated by language-specific modules.
+compile _M.textadept.run.compile()\nCompiles the file based on its extension using the command from the\n`compile_command` table.\n@see compile_command
+compile_command _M.textadept.run.compile_command (table)\nFile extensions and their associated "compile" shell commands.\nEach key is a file extension whose value is a either a command line string to\nexecute or a function returning one.\nThis table is typically populated by language-specific modules.
 complete _M.textadept.adeptsense.complete(sense, only_fields, only_functions)\nShows an autocompletion list for the symbol behind the caret.\n@param sense The Adeptsense returned by `adeptsense.new()`. If `nil`, uses\n  the current language's Adeptsense (if it exists).\n@param only_fields If `true`, returns list of only fields. The default value\n  is `false`.\n@param only_functions If `true`, returns list of only functions. The default\n  value is `false`.\n@return `true` on success or `false`.\n@see get_symbol\n@see get_completions
 completions _M.textadept.adeptsense.completions (table)\nContains lists of possible completions for known symbols.\nEach symbol key has a table value that contains a list of field completions\nwith a `fields` key and a list of functions completions with a `functions`\nkey. This table is normally populated by `load_ctags()`, but can also be set\nby the user.
 concat table.concat(list [, sep [, i [, j]]])\nGiven a list where all elements are strings or numbers, returns\n`list[i]..sep..list[i+1] ··· sep..list[j]`. The default value for `sep` is\nthe empty string, the default for `i` is 1, and the default for `j` is\n`#list`. If `i` is greater than `j`, returns the empty string.
 config package.config (string)\nA string describing some compile-time configurations for packages. This\nstring is a sequence of lines:\n  The first line is the directory separator string. Default is '`\`' for\n  Windows and '`/`' for all other systems.\n  The second line is the character that separates templates in a path.\n  Default is '`;`'.\n  The third line is the string that marks the substitution points in a\n  template. Default is '`?`'.\n  The fourth line is a string that, in a path in Windows, is replaced by\n  the executable's directory. Default is '`!`'.\n  The fifth line is a mark to ignore all text before it when building the\n  `luaopen_` function name. Default is '`-`'.
-connect events.connect(event, f, index)\nAdds a handler function to an event.\n@param event The string event name. It is arbitrary and need not be defined\n  anywhere.\n@param f The Lua function to add.\n@param index Optional index to insert the handler into.\n@return Index of handler.\n@see disconnect
-constants _SCINTILLA.constants (table)\nScintilla constants.
-context_menu _M.textadept.menu.context_menu (table)\nContains the default right-click context menu.
+connect events.connect(event, f, index)\nAdds a handler function to an event.\n@param event The string event name. It is arbitrary and does not need to be\n  defined previously.\n@param f The Lua function to add.\n@param index Optional index to insert the handler into.\n@usage events.connect('my_event', function(message) gui.print(message) end)\n@return Index of handler.\n@see disconnect
+constants _SCINTILLA.constants (table)\nScintilla constants.\nEach key is a Scintilla constant with its associated numeric value.
+context_menu _M.textadept.menu.context_menu (table)\nContains the default right-click context menu.\n@see set_contextmenu
 context_menu gui.context_menu\nA `gui.menu` defining the editor's context menu.
 contracted_fold_next buffer.contracted_fold_next(buffer, line_start)\nFind the next line at or after line_start that is a contracted fold header\nline.\nReturn `-1` when no more lines.\n@param buffer The global buffer.\n@param line_start The start line number.\n@return number
 control_char_symbol buffer.control_char_symbol (number)\nThe way control characters are displayed.\nIf less than `32`, keep the rounded rectangle as ASCII mnemonics.\nOtherwise, use the given character byte. The default value is `0`.
-control_structure_patterns _M.lua.control_structure_patterns (table)\nPatterns for auto 'end' completion for control structures.\n@see try_to_autocomplete_end
-control_structure_patterns _M.ruby.control_structure_patterns (table)\nPatterns for auto 'end' completion for control structures.\n@see try_to_autocomplete_end
+control_structure_patterns _M.lua.control_structure_patterns (table)\nPatterns for auto `end` completion for control structures.\n@see try_to_autocomplete_end
+control_structure_patterns _M.ruby.control_structure_patterns (table)\nPatterns for auto `end` completion for control structures.\n@see try_to_autocomplete_end
 convert_eo_ls buffer.convert_eo_ls(buffer, mode)\nConverts all line endings in the document to one mode.\n@param buffer The global buffer.\n@param mode The line ending mode. Valid values are:\n  `_SCINTILLA.constants.SC_EOL_CRLF` (0),\n  `_SCINTILLA.constants.SC_EOL_CR (1)`, or\n  `_SCINTILLA.constants.SC_EOL_LF (2)`.
-convert_indentation _M.textadept.editing.convert_indentation()\nConverts indentation between tabs and spaces.
+convert_indentation _M.textadept.editing.convert_indentation()\nConverts indentation between tabs and spaces.\nIf `buffer.use_tabs` is `true`, all indenting spaces are converted to tabs.\nOtherwise, all indenting tabs are converted to spaces.\n@see buffer.use_tabs
 copy buffer.copy(buffer)\nCopy the selection to the clipboard.\n@param buffer The buffer
 copy_allow_line buffer.copy_allow_line(buffer)\nCopy the selection, if selection empty copy the line with the caret.\n@param buffer The global buffer.
 copy_range buffer.copy_range(buffer, start_pos, end_pos)\nCopy a range of text to the clipboard. Positions are clipped into the\ndocument.\n@param buffer The global buffer.\n@param start_pos The start position.\n@param end_pos The end position.
@@ -933,14 +937,14 @@ cos math.cos(x)\nReturns the cosine of `x` (assumed to be in radians).
 cosh math.cosh(x)\nReturns the hyperbolic cosine of `x`.
 count_characters buffer.count_characters(buffer, start_pos, end_pos)\nCount characters between two positions.\n@return number
 cpath package.cpath (string)\nThe path used by `require` to search for a C loader.\nLua initializes the C path `package.cpath` in the same way it initializes\nthe Lua path `package.path`, using the environment variable `LUA_CPATH_5_2`\nor the environment variable `LUA_CPATH` or a default path defined in\n`luaconf.h`.
-cpp _G.keys.cpp (table)\nContainer for C/C++-specific key commands.
+cpp _G.keys.cpp (table)\nContainer for C/C++-specific key bindings.
 cpp _G.snippets.cpp (table)\nContainer for C/C++-specific snippets.
-cpp _M.cpp (module)\nThe cpp module.\nIt provides utilities for editing C/C++ code.\nUser tags are loaded from `_USERHOME/modules/cpp/tags` and user apis are\nloaded from `_USERHOME/modules/cpp/api`.
+cpp _M.cpp (module)\nThe cpp module.\nIt provides utilities for editing C/C++ code.
 create coroutine.create(f)\nCreates a new coroutine, with body `f`. `f` must be a Lua\nfunction. Returns this new coroutine, an object with type `"thread"`.
-css _G.keys.css (table)\nContainer for CSS-specific key commands.
+css _G.keys.css (table)\nContainer for CSS-specific key bindings.
 css _G.snippets.css (table)\nContainer for CSS-specific snippets.
-css _M.css (module)\nThe css module.\nIt provides utilities for editing CSS code.\nUser tags are loaded from `_USERHOME/modules/css/tags` and user apis are\nloaded from `_USERHOME/modules/css/api`.
-ctags_kinds _M.textadept.adeptsense.ctags_kinds (table)\nContains a map of ctags kinds to Adeptsense kinds.\nRecognized kinds are `'functions'`, `'fields'`, and `'classes'`. Classes are\nquite simply containers for functions and fields so Lua modules would count\nas classes. Any other kinds will be passed to `handle_ctag()` for\nuser-defined handling.\n@see handle_ctag
+css _M.css (module)\nThe css module.\nIt provides utilities for editing CSS code.
+ctags_kinds _M.textadept.adeptsense.ctags_kinds (table)\nContains a map of ctags kinds to Adeptsense kinds.\nRecognized kinds are `FUNCTION`, `FIELD`, and `CLASS`. Classes are quite\nsimply containers for functions and fields so Lua modules would count as\nclasses. Any other kinds will be passed to `handle_ctag()` for user-defined\nhandling.\n@see handle_ctag
 current_pos buffer.current_pos (number)\nThe position of the caret.\nWhen setting, the caret is not scrolled into view.
 currentdir lfs.currentdir()\nReturns a string with the current working directory or nil plus an error\nstring.
 cursor buffer.cursor (number)\nThe cursor type.\n\n* `_SCINTILLA.constants.SC_CURSORNORMAL` (-1)\n  The normal cursor is displayed.\n* `_SCINTILLA.constants.SC_CURSORWAIT` (4)\n  The wait cursor is displayed when the mouse is over the view.
@@ -955,21 +959,21 @@ del_line_right buffer.del_line_right(buffer)\nDelete forwards from the current p
 del_word_left buffer.del_word_left(buffer)\nDelete the word to the left of the caret.\n@param buffer The global buffer.
 del_word_right buffer.del_word_right(buffer)\nDelete the word to the right of the caret.\n@param buffer The global buffer.
 del_word_right_end buffer.del_word_right_end(buffer)\nDelete the word to the right of the caret, but not the trailing non-word\ncharacters.\n@param buffer The global buffer.
-delete buffer.delete(buffer)\nDeletes the current buffer.\nWARNING: this function should NOT be called via scripts. Use `buffer:close()`\ninstead, which prompts for confirmation if necessary. Generates a\n`BUFFER_DELETED` event.\n@param buffer The global buffer.
+delete buffer.delete(buffer)\nDeletes the current buffer.\nWARNING: this function should NOT be called via scripts. Use `buffer:close()`\ninstead, which prompts for confirmation if necessary. Emits a\n`BUFFER_DELETED` event.\n@param buffer The global buffer.\n@see events.BUFFER_DELETED
 delete_back buffer.delete_back(buffer)\nDelete the selection or if no selection, the character before the caret.\n@param buffer The global buffer.
 delete_back_not_line buffer.delete_back_not_line(buffer)\nDelete the selection or if no selection, the character before the caret.\nWill not delete the character before at the start of a line.
 delete_range buffer.delete_range(buffer, pos, length)\nDelete a range of text in the document.\n@param pos The start position of the range to delete.\n@param length The length of the range to delete.
 delimited_range lexer.delimited_range(chars, escape, end_optional, balanced, forbidden)\nCreates an LPeg pattern that matches a range of characters delimitted by a\nspecific character(s).\nThis can be used to match a string, parenthesis, etc.\n@param chars The character(s) that bound the matched range.\n@param escape Optional escape character. This parameter may be omitted, nil,\n  or the empty string.\n@param end_optional Optional flag indicating whether or not an ending\n  delimiter is optional or not. If true, the range begun by the start\n  delimiter matches until an end delimiter or the end of the input is\n  reached.\n@param balanced Optional flag indicating whether or not a balanced range is\n  matched, like `%b` in Lua's `string.find`. This flag only applies if\n  `chars` consists of two different characters (e.g. '()').\n@param forbidden Optional string of characters forbidden in a delimited\n  range. Each character is part of the set.\n@usage local sq_str_noescapes = delimited_range("'")\n@usage local sq_str_escapes = delimited_range("'", '\\', true)\n@usage local unbalanced_parens = delimited_range('()', '\\', true)\n@usage local balanced_parens = delimited_range('()', '\\', true, true)
-dialog gui.dialog(kind, ...)\nDisplays a gtdialog of a specified type with the given string arguments.\nEach argument is like a string in Lua's `arg` table. Tables of strings are\nallowed as arguments and are expanded in place. This is useful for\nfilteredlist dialogs with many items.\nFor more information on gtdialog, see http://foicica.com/gtdialog.\n@param kind The kind of gtdialog.\n@param ... Parameters to the gtdialog.\n@return string gtdialog result.
+dialog gui.dialog(kind, ...)\nDisplays a gtdialog of a specified type with the given string arguments.\nEach argument is like a string in Lua's `arg` table. Tables of strings are\nallowed as arguments and are expanded in place. This is useful for\nfiltered list dialogs with many items.\nFor more information on gtdialog, see http://foicica.com/gtdialog.\n@param kind The kind of gtdialog.\n@param ... Parameters to the gtdialog.\n@return string gtdialog result.
 difftime os.difftime(t2, t1)\nReturns the number of seconds from time `t1` to time `t2`. In POSIX,\nWindows, and some other systems, this value is exactly `t2`*-*`t1`.
 digit lexer.digit\nMatches any digit (`0-9`).
 dir lfs.dir(path)\nLua iterator over the entries of a given directory. Each time the iterator is\ncalled with dir_obj it returns a directory entry's name as a string, or nil\nif there are no more entries. You can also iterate by calling dir_obj:next(),\nand explicitly close the directory before the iteration finished with\ndir_obj:close(). Raises an error if path is not a directory.
 direct_function buffer.direct_function (number, Read-only)\nA pointer to a function that processes messages for this view.
 direct_pointer buffer.direct_pointer (number, Read-only)\nA pointer value to use as the first argument when calling the function\nreturned by direct_function.
 dirty buffer.dirty (bool)\nFlag indicating whether or not the buffer has been modified since it was\nlast saved.
-disconnect events.disconnect(event, index)\nDisconnects a handler function from an event.\n@param event The string event name.\n@param index Index of the handler (returned by `events.connect()`).\n@see connect
+disconnect events.disconnect(event, index)\nDisconnects a handler function from an event.\n@param event The string event name.\n@param index Index of the handler returned by `events.connect()`.\n@see connect
 doc_line_from_visible buffer.doc_line_from_visible(buffer)\nFind the document line of a display line taking hidden lines into account.\n@param buffer The global buffer.\n@return number
-docstatusbar_text gui.docstatusbar_text (string, Write-only)\nThe text displayed by the doc statusbar.
+docstatusbar_text gui.docstatusbar_text (string, Write-only)\nThe text displayed by the buffer statusbar.
 document_end buffer.document_end(buffer)\nMove caret to last position in document.\n@param buffer The global buffer.
 document_end_extend buffer.document_end_extend(buffer)\nMove caret to last position in document extending selection to new caret\nposition.\n@param buffer The global buffer.
 document_start buffer.document_start(buffer)\nMove caret to first position in document.\n@param buffer The global buffer.
@@ -980,9 +984,9 @@ edge_colour buffer.edge_colour (number)\nThe color used in edge indication in `0
 edge_column buffer.edge_column (number)\nThe column number which text should be kept within.
 edge_mode buffer.edge_mode (number)\nThe edge highlight mode.\n\n* `_SCINTILLA.constants.EDGE_NONE` (0)\n  Long lines are not marked. This is the default state.\n* `_SCINTILLA.constants.EDGE_LINE` (1)\n  A vertical line is drawn at the column number set by\n  `buffer.edge_column`.\n* `_SCINTILLA.constants.EDGE_BACKGROUND` (2)\n  The background color of characters after the column limit is changed to\n  the color set by `buffer.edge_colour`.
 edit_toggle_overtype buffer.edit_toggle_overtype(buffer)\nSwitch from insert to overtype mode or the reverse.\n@param buffer The global buffer.
-editing _M.textadept.editing (module)\nEditing commands for the textadept module.
+editing _M.textadept.editing (module)\nEditing features for Textadept.
 embed_lexer lexer.embed_lexer(parent, child, start_rule, end_rule)\nEmbeds a child lexer language in a parent one.\n@param parent The parent lexer.\n@param child The child lexer.\n@param start_rule The token that signals the beginning of the embedded\n  lexer.\n@param end_rule The token that signals the end of the embedded lexer.\n@usage embed_lexer(M, css, css_start_rule, css_end_rule)\n@usage embed_lexer(html, M, php_start_rule, php_end_rule)\n@usage embed_lexer(html, ruby, ruby_start_rule, rule_end_rule)
-emit events.emit(event, ...)\nCalls all handlers for the given event in sequence (effectively "generating"\nthe event).\nIf `true` or `false` is explicitly returned by any handler, the event is not\npropagated any further; iteration ceases.\n@param event The string event name.\n@param ... Arguments passed to the handler.\n@return `true` or `false` if any handler explicitly returned such; nil\n  otherwise.
+emit events.emit(event, ...)\nCalls all handlers for the given event in sequence.\nIf `true` or `false` is explicitly returned by any handler, the event is not\npropagated any further; iteration ceases. This is useful if you want to stop\nthe propagation of an event like a keypress.\n@param event The string event name. It is arbitrary and does not need to be\n  defined previously.\n@param ... Arguments passed to the handler.\n@usage events.emit('my_event', 'my message')\n@return `true` or `false` if any handler explicitly returned such; `nil`\n  otherwise.
 empty_undo_buffer buffer.empty_undo_buffer(buffer)\nDelete the undo history.\nIt also sets the save point to the start of the undo buffer, so the document\nwill appear to be unmodified.\n@param buffer The global buffer.
 enclose _M.textadept.editing.enclose(left, right)\nEncloses text within a given pair of strings.\nIf text is selected, it is enclosed. Otherwise, the previous word is\nenclosed.\n@param left The left part of the enclosure.\n@param right The right part of the enclosure.
 encoded_from_utf8 buffer.encoded_from_utf8(buffer, string)\nTranslates a UTF8 string into the document encoding.\nReturn the length of the result in bytes. On error return `0`.\n@param buffer The global buffer.\n@param string The string.\n@return number
@@ -996,31 +1000,31 @@ ensure_visible_enforce_policy buffer.ensure_visible_enforce_policy(buffer, line)
 entry_text gui.command_entry.entry_text (string)\nThe text in the entry.
 eol_mode buffer.eol_mode (number)\nThe current end of line mode.\n\n* `_SCINTILLA.constants.SC_EOL_CRLF` (0)\n  `CRLF`.\n* `_SCINTILLA.constants.SC_EOL_CR` (1)\n  `CR`.\n* `_SCINTILLA.constants.SC_EOL_LF` (2)\n  `LF`.
 error _G.error(message [, level])\nTerminates the last protected function called and returns `message`\nas the error message. Function `error` never returns.\n\nUsually, `error` adds some information about the error position at the\nbeginning of the message, if the message is a string. The `level` argument\nspecifies how to get the error position. With level 1 (the default), the\nerror position is where the `error` function was called. Level 2 points the\nerror to where the function that called `error` was called; and so on.\nPassing a level 0 avoids the addition of error position information to the\nmessage.
-error_detail _M.textadept.run.error_detail (table)\nA table of error string details.\nEach entry is a table with the following fields:\n\n  + `pattern`: The Lua pattern that matches a specific error string.\n  + `filename`: The index of the Lua capture that contains the filename the\n    error occured in.\n  + `line`: The index of the Lua capture that contains the line number the\n    error occured on.\n  + `message`: [Optional] The index of the Lua capture that contains the\n    error's message. A call tip will be displayed if a message was captured.\n\nWhen an error message is double-clicked, the user is taken to the point of\nerror.\nThis table is usually populated by language-specific modules.
+error_detail _M.textadept.run.error_detail (table)\nA table of error string details for different programming languages.\nEach key is a lexer name whose value is a table with the following fields:\n\n  + `pattern`: The Lua pattern that matches a specific error string with\n    captures for the filename the error occurs in, the line number the error\n    occurred on, and an optional error message.\n  + `filename`: The index of the Lua capture that contains the filename the\n    error occured in.\n  + `line`: The index of the Lua capture that contains the line number the\n    error occured on.\n  + `message`: (Optional) The index of the Lua capture that contains the\n    error's message. An annotation will be displayed if a message was\n    captured.\n\nWhen an error message is double-clicked, the user is taken to the point of\nerror.\nThis table is usually populated by language-specific modules.
 events _G.events (module)\nTextadept's core event structure and handlers.
-execute _M.textadept.run.execute(command, lexer)\nExecutes the command line parameter and prints the output to Textadept.\n@param command The command line string.\n  It can have the following macros:\n    + `%(filepath)`: The full path of the current file.\n    + `%(filedir)`: The current file's directory path.\n    + `%(filename)`: The name of the file including extension.\n    + `%(filename_noext)`: The name of the file excluding extension.\n@param lexer The current lexer.
+execute _M.textadept.run.execute(command, compiling)\nExecutes the command line parameter.\nEmits a `COMPILE_OUTPUT` or `RUN_OUTPUT` event based on the `compiling` flag.\n@param command The command line string.\n  It can have the following macros:\n    + `%(filepath)`: The full path of the current file.\n    + `%(filedir)`: The current file's directory path.\n    + `%(filename)`: The name of the file including extension.\n    + `%(filename_noext)`: The name of the file excluding extension.\n@param compiling Flag indicating whether or not the command is a compiler\n  command. The default value is `false`.\n@see _G.events
 execute os.execute([command])\nThis function is equivalent to the C function `system`. It passes\n`command` to be executed by an operating system shell. Its first result is\n`true` if the command terminated successfully, or `nil` otherwise. After this\nfirst result the function returns a string and a number, as follows:\n  "exit": the command terminated normally; the following number is the exit\n          status of the command.\n  "signal": the command was terminated by a signal; the following number is\n            the signal that terminated the command.\n\nWhen called without a `command`, `os.execute` returns a boolean that is true\nif a shell is available.
 exit os.exit([code [, close]])\nCalls the C function `exit` to terminate the host program. If `code` is\n`true`, the returned status is `EXIT_SUCCESS`; if `code` is `false`, the\nreturned status is `EXIT_FAILURE`; if `code` is a number, the returned status\nis this number. The default value for `code` is `true`.\n\nIf the optional second argument `close` is true, closes the Lua state before\nexiting.
 exp math.exp(x)\nReturns the value *e^x*.
 extend lexer.extend\nMatches any ASCII extended character (`0`..`255`).
-extensions _M.textadept.mime_types.extensions (table)\nFile extensions with their associated lexers.
+extensions _M.textadept.mime_types.extensions (table)\nTable of file extensions with their associated lexers.\nIf the file type is not recognized by shebang words or first-line patterns,\neach file extension is matched against the file's extension.
 extra_ascent buffer.extra_ascent (number)\nThe extra ascent, the maximum that any style extends above the baseline,\nadded to each line.
 extra_descent buffer.extra_descent (number)\nThe extra descent, the maximum that any style extends below the baseline,\nadded to each line.
 extract bit32.extract(n, field [, width])\nReturns the unsigned number formed by the bits `field` to `field + width - 1`\nfrom `n`. Bits are numbered from 0 (least significant) to 31 (most\nsignificant). All accessed bits must be in the range [0, 31].\n\nThe default for `width` is 1.
 filename buffer.filename (string)\nThe absolute path to the file associated with this buffer.\nIt is encoded in UTF-8. Use `string.iconv()` for\ncharset conversions.
-filter_through _M.textadept.filter_through (module)\nFilter-Through for the textadept module.
-filter_through _M.textadept.filter_through.filter_through()\nPrompts for a Linux, Mac OSX, or Windows shell command to filter text\nthrough.\nThe standard input (stdin) for shell commands is determined as follows:\n\n1. If text is selected and spans multiple lines, all text on the lines\ncontaining the selection is used. However, if the end of the selection is at\nthe beginning of a line, only the EOL (end of line) characters from the\nprevious line are included as input. The rest of the line is excluded.\n2. If text is selected and spans a single line, only the selected text is\nused.\n3. If no text is selected, the entire buffer is used.\n\nThe input text is replaced with the standard output (stdout) of the command.
-filteredlist gui.filteredlist(title, columns, items, int_return, ...)\nShortcut function for `gui.dialog('filtered_list', ...)` with 'Ok' and\n'Cancel' buttons.\n@param title The title for the filteredlist dialog.\n@param columns A column name or list of column names.\n@param items An item or list of items.\n@param int_return If `true`, returns the integer index of the selected item\n  in the filteredlist. The default value is `false`, which returns the string\n  item. Not compatible with a `'--select-multiple'` filteredlist.\n@param ... Additional parameters to pass to `gui.dialog()`.\n@usage gui.filteredlist('Title', 'Foo', { 'Bar', 'Baz' })\n@usage gui.filteredlist('Title', { 'Foo', 'Bar' }, { 'a', 'b', 'c', 'd' },\n                        false, '--output-column', '2')\n@return Either a string or integer on success; `nil` otherwise.
-find gui.find (module)\nTextadept's integrated find/replace dialog.
+filter_through _M.textadept.filter_through (module)\nFilters text through shell commands.
+filter_through _M.textadept.filter_through.filter_through()\nPrompts for a Linux, BSD, Mac OSX, or Windows shell command to filter text\nthrough.\nThe standard input (stdin) for shell commands is determined as follows:\n\n1. If text is selected and spans multiple lines, all text on the lines\ncontaining the selection is used. However, if the end of the selection is at\nthe beginning of a line, only the EOL (end of line) characters from the\nprevious line are included as input. The rest of the line is excluded.\n2. If text is selected and spans a single line, only the selected text is\nused.\n3. If no text is selected, the entire buffer is used.\n\nThe input text is replaced with the standard output (stdout) of the command.
+filteredlist gui.filteredlist(title, columns, items, int_return, ...)\nShortcut function for `gui.dialog('filteredlist', ...)` with 'Ok' and\n'Cancel' buttons.\n@param title The title for the filtered list dialog.\n@param columns A column name or list of column names.\n@param items An item or list of items.\n@param int_return If `true`, returns the integer index of the selected item\n  in the filtered list and is not compatible with the `'--select-multiple'`\n  option. The default value is `false`, which returns the string item(s).\n@param ... Additional parameters to pass to `gui.dialog()`.\n@usage gui.filteredlist('Title', 'Foo', { 'Bar', 'Baz' })\n@usage gui.filteredlist('Title', { 'Foo', 'Bar' }, { 'a', 'b', 'c', 'd' },\n                        false, '--output-column', '2')\n@return Either a string or integer on success; `nil` otherwise. In strings,\n  multiple items are separated by newlines.\n@see dialog
+find gui.find (module)\nTextadept's Find & Replace pane.
 find string.find(s, pattern [, init [, plain]])\nLooks for the first match of `pattern` in the string `s`. If it finds a\nmatch, then `find` returns the indices of `s` where this occurrence starts\nand ends; otherwise, it returns nil. A third, optional numerical argument\n`init` specifies where to start the search; its default value is 1 and\ncan be negative. A value of true as a fourth, optional argument `plain`\nturns off the pattern matching facilities, so the function does a plain\n"find substring" operation, with no characters in `pattern` being considered\nmagic. Note that if `plain` is given, then `init` must be given as well.\n\nIf the pattern has captures, then in a successful match the captured values\nare also returned, after the two indices.
 find_column buffer.find_column(buffer, line, column)\nFind the position of a column on a line taking into account tabs and\nmulti-byte characters.\nIf beyond end of line, return line end position.\n@param buffer The global buffer.\n@param line The line number.\n@param column The column number.
 find_entry_text gui.find.find_entry_text (string)\nThe text in the find entry.
-find_in_files gui.find.find_in_files(utf8_dir)\nPerforms a find in files with the given directory.\nUse the `gui.find` fields to set the text to find and option flags.\n@param utf8_dir UTF-8 encoded directory name. If none is provided, the user\n  is prompted for one.
-find_incremental gui.find.find_incremental()\nBegins an incremental find using the Lua command entry.\nLua command functionality will be unavailable until the search is finished\n(pressing 'Escape' by default).
+find_in_files gui.find.find_in_files(utf8_dir)\nSearches the given directory for files that match search text and options and\nprints the results to a buffer.\nUse the `find_text`, `match_case`, `whole_word`, and `lua` fields to set the\nsearch text and option flags, respectively.\n@param utf8_dir UTF-8 encoded directory name. If `nil`, the user is prompted\nfor one.
+find_incremental gui.find.find_incremental()\nBegins an incremental find using the command entry.\nOnly the `match_case` find option is recognized. Normal command entry\nfunctionality will be unavailable until the search is finished by pressing\n`Esc` (`⎋` on Mac OSX | `Esc` in ncurses).
 find_label_text gui.find.find_label_text (string, Write-only)\nThe text of the 'Find' label.\nThis is primarily used for localization.
-find_next gui.find.find_next()\nMimicks a press of the 'Find Next' button in the Find box.
+find_next gui.find.find_next()\nMimicks a press of the 'Find Next' button.
 find_next_button_text gui.find.find_next_button_text (string, Write-only)\nThe text of the 'Find Next' button.\nThis is primarily used for localization.
-find_prev gui.find.find_prev()\nMimicks a press of the 'Find Prev' button in the Find box.
+find_prev gui.find.find_prev()\nMimicks a press of the 'Find Prev' button.
 find_prev_button_text gui.find.find_prev_button_text (string, Write-only)\nThe text of the 'Find Prev' button.\nThis is primarily used for localization.
 first_visible_line buffer.first_visible_line (number)\nThe display line at the top of the display.
 float lexer.float\nMatches a floating point number.
@@ -1030,7 +1034,7 @@ flush io.flush()\nEquivalent to `io.output():flush()`.
 fmod math.fmod(x, y)\nReturns the remainder of the division of `x` by `y` that rounds the\nquotient towards zero.
 focus buffer.focus (bool)\nThe internal focus flag.
 focus gui.command_entry.focus()\nFocuses the command entry.
-focus gui.find.focus()\nDisplays and focuses the find/replace dialog.
+focus gui.find.focus()\nDisplays and focuses the Find & Replace pane.
 fold lexer.fold(text, start_pos, start_line, start_level)\nFolds the given text.\nCalled by LexLPeg.cxx; do not call from Lua.\nIf the current lexer has no _fold function, folding by indentation is\nperformed if the 'fold.by.indentation' property is set.\n@param text The document text to fold.\n@param start_pos The position in the document text starts at.\n@param start_line The line number text starts on.\n@param start_level The fold level text starts on.\n@return Table of fold levels.
 fold_expanded buffer.fold_expanded (bool)\nExpanded state of a header line.
 fold_flags buffer.fold_flags (number)\nThe style options for folding.\nBits set in flags determine where folding lines are drawn:\n\n* `_SCINTILLA.constants.SC_FOLDFLAG_LINEBEFORE_EXPANDED` (2)\n  Draw above if expanded.\n* `_SCINTILLA.constants.SC_FOLDFLAG_LINEBEFORE_CONTRACTED` (4)\n  Draw above if not expanded.\n* `_SCINTILLA.constants.SC_FOLDFLAG_LINEAFTER_EXPANDED` (8)\n  Draw below if expanded.\n* `_SCINTILLA.constants.SC_FOLDFLAG_LINEAFTER_CONTRACTED` (16)\n  Draw below if not expanded.
@@ -1039,9 +1043,9 @@ fold_line_comments lexer.fold_line_comments(prefix)\nReturns a fold function tha
 fold_parent buffer.fold_parent (table, Read-only)\nTable of parent line numbers for child lines starting from zero.\n`-1` means no line was found.
 font_quality buffer.font_quality (number)\n(Windows only)\n  The quality level for text.\n\n  * `_SCINTILLA.constants.SC_EFF_QUALITY_DEFAULt` (0).\n  * `_SCINTILLA.constants.SC_EFF_QUALITY_NON_ANTIALIASED` (1).\n  * `_SCINTILLA.constants.SC_EFF_QUALITY_ANTIALIASED` (2).\n  * `_SCINTILLA.constants.SC_EFF_QUALITY_LCD_OPTIMIZED` (3).
 form_feed buffer.form_feed(buffer)\nInsert a Form Feed character.\n@param buffer The global buffer.
-format string.format(formatstring, ···)\nReturns a formatted version of its variable number of arguments following the\ndescription given in its first argument (which must be a string). The format\nstring follows the same rules as the C function `sprintf`. The only\ndifferences are that the options/modifiers `*`, `h`, `L`, `l`, `n`, and `p`\nare not supported and that there is an extra option, `q`. The `q` option\nformats a string between double quotes, using escape sequences when necessary\nto ensure that it can safely be read back by the Lua interpreter. For\ninstance, the call\n\n  string.format('%q', 'a string with "quotes" and \\n new line')\n\nmay produce the string:\n\n  "a string with \"quotes\" and \\n      new line"\n\nOptions `A` and `a` (when available), `E`, `e`, `f`, `G`, and `g` all expect\na number as argument. Options `c`, `d`, `i`, `o`, `u`, `X`, and `x` also\nexpect a number, but the range of that number may be limited by the\nunderlying C implementation. For options `o`, `u`, `X`, and `x`, the number\ncannot be negative. Option `q` expects a string; option `s` expects a string\nwithout embedded zeros. If the argument to option `s` is not a string, it is\nconverted to one following the same rules of `tostring`.
+format string.format(formatstring, ···)\nReturns a formatted version of its variable number of arguments following the\ndescription given in its first argument (which must be a string). The format\nstring follows the same rules as the C function `sprintf`. The only\ndifferences are that the options/modifiers `*`, `h`, `L`, `l`, `n`, and `p`\nare not supported and that there is an extra option, `q`. The `q` option\nformats a string between double quotes, using escape sequences when necessary\nto ensure that it can safely be read back by the Lua interpreter. For\ninstance, the call\n\n  string.format('%q', 'a string with "quotes" and \n new line')\n\nmay produce the string:\n\n  "a string with \"quotes\" and \\n      new line"\n\nOptions `A` and `a` (when available), `E`, `e`, `f`, `G`, and `g` all expect\na number as argument. Options `c`, `d`, `i`, `o`, `u`, `X`, and `x` also\nexpect a number, but the range of that number may be limited by the\nunderlying C implementation. For options `o`, `u`, `X`, and `x`, the number\ncannot be negative. Option `q` expects a string; option `s` expects a string\nwithout embedded zeros. If the argument to option `s` is not a string, it is\nconverted to one following the same rules of `tostring`.
 frexp math.frexp(x)\nReturns `m` and `e` such that 'x = m2^e', `e` is an integer and the\nabsolute value of `m` is in the range *[0.5, 1)* (or zero when `x` is zero).
-functions _SCINTILLA.functions (table)\nScintilla functions.
+functions _SCINTILLA.functions (table)\nScintilla functions.\nEach key is a Scintilla function name with a table value containing its ID,\nreturn type, wParam type, and lParam type. Types are as follows:\n\n  + `0`: Void.\n  + `1`: Integer.\n  + `2`: Length of the given lParam string.\n  + `3`: Integer position.\n  + `4`: Colour in `0xBBGGRR` format.\n  + `5`: Boolean `true` or `false`.\n  + `6`: Bitmask of Scintilla key modifiers and a key value.\n  + `7`: String parameter.\n  + `8`: String return value.
 gap_position buffer.gap_position (number, Read-only)\nA position which, to avoid performance costs, should not be within the\nrange of a call to `buffer:get_range_pointer()`.
 get_apidoc _M.textadept.adeptsense.get_apidoc(sense, symbol)\nReturns a list of apidocs for the given symbol.\nIf there are multiple apidocs, the index of one to display is the value of\nthe `pos` key in the returned list.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param symbol The symbol to get apidocs for.\n@return apidoc_list or `nil`
 get_class _M.textadept.adeptsense.get_class(sense, symbol)\nReturns the class name for a given symbol.\nIf the symbol is `sense.syntax.self` and a class definition using the\n`sense.syntax.class_definition` keyword is found, that class is returned.\nOtherwise the buffer is searched backwards for a type declaration of the\nsymbol according to the patterns in `sense.syntax.type_declarations`.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param symbol The symbol to get the class of.\n@return class or `nil`\n@see syntax
@@ -1059,7 +1063,7 @@ get_line_sel_start_position buffer.get_line_sel_start_position(buffer, line)\nRe
 get_property lexer.get_property(key, default)\nReturns an integer property value for a given key.\n@param key The property key.\n@param default Optional integer value to return if key is not set.
 get_range_pointer buffer.get_range_pointer(buffer, position, range_length)\nReturn a read-only pointer to a range of characters in the document.\nMay move the gap so that the range is contiguous, but will only move up to\nrange_length bytes.\nThe gap is not moved unless it is within the requested range so this call can\nbe faster than `SCI_GETCHARACTERPOINTER`. This can be used by application\ncode that is able to act on blocks of text or ranges of lines.
 get_sel_text buffer.get_sel_text(buffer)\nRetrieve the selected text.\nAlso returns the length of the text.\n@param buffer The global buffer.\n@return string, number
-get_split_table gui.get_split_table()\nGets the current split view structure.\n@return table of split views. Each split view entry is a table with 4\n  fields: `1`, `2`, `vertical`, and `size`. `1` and `2` have values of either\n  nested split view entries or the views themselves; `vertical` is a flag\n  indicating if the split is vertical or not; and `size` is the integer\n  position of the split resizer.
+get_split_table gui.get_split_table()\nGets the current split view structure.\nThis is primarily used in session saving.\n@return table of split views. Each split view entry is a table with 4\n  fields: `1`, `2`, `vertical`, and `size`. `1` and `2` have values of either\n  nested split view entries or the views themselves; `vertical` is a flag\n  indicating if the split is vertical or not; and `size` is the integer\n  position of the split resizer.
 get_style_at lexer.get_style_at(pos)\nReturns the string style name and style number at a given position.\n@param pos The position to get the style for.
 get_style_name buffer.get_style_name(buffer, style_num)\nReturns the name of the style associated with a style number.\n@param buffer The global buffer.\n@param style_num A style number from `0` to `255`.\n@see buffer.style_at
 get_symbol _M.textadept.adeptsense.get_symbol(sense)\nReturns a full symbol (if any) and current symbol part (if any) behind the\ncaret.\nFor example: `buffer.cur` would return `'buffer'` and `'cur'`.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@return symbol or `''`\n@return part or `''`
@@ -1075,24 +1079,22 @@ getupvalue debug.getupvalue(f, up)\nThis function returns the name and the value
 getuservalue debug.getuservalue(u)\nReturns the Lua value associated to `u`. If `u` is not a userdata, returns\nnil.
 gmatch string.gmatch(s, pattern)\nReturns an iterator function that, each time it is called, returns the\nnext captures from `pattern` over the string `s`. If `pattern` specifies no\ncaptures, then the whole match is produced in each call.\n\nAs an example, the following loop will iterate over all the words from string\n`s`, printing one per line:\n\n  s = "hello world from Lua"\n  for w in string.gmatch(s, "%a+") do\n    print(w)\n  end\n\nThe next example collects all pairs `key=value` from the given string into a\ntable:\n\n  t = {}\n  s = "from=world, to=Lua"\n  for k, v in string.gmatch(s, "(%w+)=(%w+)") do\n    t[k] = v\n  end\n\nFor this function, a caret '`^`' at the start of a pattern does not work as\nan anchor, as this would prevent the iteration.
 goto_bookmark _M.textadept.bookmarks.goto_bookmark()\nGoes to selected bookmark from a filtered list.
-goto_buffer view:goto_buffer(n, relative)\nGoes to the specified buffer in the indexed view.\nGenerates `BUFFER_BEFORE_SWITCH` and `BUFFER_AFTER_SWITCH` events.\n@param n A relative or absolute buffer index. An absolute index of `-1` goes\n  to the last buffer.\n@param relative Flag indicating if `n` is a relative index or not. The\n  default value is `false`.
-goto_ctag _M.textadept.adeptsense.goto_ctag(sense, k, title)\nDisplays a filteredlist of all known symbols of the given kind (classes,\nfunctions, fields, etc.) and jumps to the source of the selected one.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param k The ctag character kind (e.g. `'f'` for a Lua function).\n@param title The title for the filteredlist dialog.
-goto_error _M.textadept.run.goto_error(pos, line_num)\nGoes to the line in the file an error occured at and displays a calltip with\nthe error message.\nThis is typically called when the user double-clicks an error message,\n@param pos The position of the caret.\n@param line_num The line the error occurs on.\n@see error_detail
+goto_buffer view.goto_buffer(view, n, relative)\nGoes to the specified buffer in the given view.\nEmits `BUFFER_BEFORE_SWITCH` and `BUFFER_AFTER_SWITCH` events.\n@param view The view to switch buffers in.\n@param n A relative or absolute buffer index in `_G._BUFFERS`. An absolute\n  index of `-1` goes to the last buffer.\n@param relative Flag indicating if `n` is a relative index or not. The\n  default value is `false`.\n@see _G._G._BUFFERS\n@see events.BUFFER_BEFORE_SWITCH\n@see events.BUFFER_AFTER_SWITCH
+goto_ctag _M.textadept.adeptsense.goto_ctag(sense, k, title)\nDisplays a filtered list dialog of all known symbols of the given kind\n(classes, functions, fields, etc.) and jumps to the source of the selected\none.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param k The ctag character kind (e.g. `'f'` for a Lua function).\n@param title The title for the filtered list dialog.
+goto_error _M.textadept.run.goto_error(pos, line_num)\nGoes to the line in the file an error occured at based on the error message\nat the given position and displays an annotation with the error message.\nThis is typically called by an event handler for when the user double-clicks\non an error message.\n@param pos The position of the caret.\n@param line_num The line number the caret is on with the error message.\n@see error_detail
 goto_file gui.goto_file(filename, split, preferred_view, sloppy)\nGoes to the buffer with the given filename.\nIf the desired buffer is open in a view, goes to that view. Otherwise, opens\nthe buffer in either the `preferred_view` if given, the first view that is\nnot the current one, a split view if `split` is `true`, or the current view.\n@param filename The filename of the buffer to go to.\n@param split If there is only one view, split it and open the buffer in the\n  other view.\n@param preferred_view When multiple views exist and the desired buffer is not\n  open in any of them, open it in this one.\n@param sloppy Flag indicating whether or not to not match `filename` to\n  `buffer.filename` exactly. When `true`, matches `filename` to only the last\n  part of `buffer.filename` This is useful for run and compile commands which\n  output relative filenames and paths instead of full ones and it is likely\n  that the file in question is already open. The default value is `false`.
-goto_file_in_list gui.find.goto_file_in_list(next)\nGoes to the next or previous file found relative to the file\non the current line.\n@param next Flag indicating whether or not to go to the next file.
+goto_file_in_list gui.find.goto_file_in_list(next)\nGoes to the next or previous file found relative to the file on the current\nline in the results list.\n@param next Flag indicating whether or not to go to the next file.
 goto_line _M.textadept.editing.goto_line(line)\nGoes to the requested line.\n@param line Optional line number to go to. If `nil`, the user is prompted for\n  one.
 goto_line buffer.goto_line(buffer, line)\nSet caret to start of a line and ensure it is visible.\n@param buffer The global buffer.\n@param line The line number.
 goto_next _M.textadept.bookmarks.goto_next()\nGoes to the next bookmark in the current buffer.
 goto_pos buffer.goto_pos(buffer, pos)\nSet caret to a position and ensure it is visible.\nThe anchor position is set the same as the current position.\n@param buffer The global buffer.\n@param pos The position.
 goto_prev _M.textadept.bookmarks.goto_prev()\nGoes to the previous bookmark in the current buffer.
-goto_required _M.php.goto_required()\nDetermines the PHP file being 'require'd or 'include'd, and opens it in\nTextadept.
-goto_required _M.ruby.goto_required()\nDetermine the Ruby file being 'require'd, and search through the RUBYPATH\nfor that file and open it in Textadept.
-goto_view gui.goto_view(n, relative)\nGoes to the specified view.\nGenerates `VIEW_BEFORE_SWITCH` and `VIEW_AFTER_SWITCH` events.\n@param n A relative or absolute view index.\n@param relative Flag indicating if n is a relative index or not. The default\n  value is `false`.
+goto_view gui.goto_view(n, relative)\nGoes to the specified view.\nEmits `VIEW_BEFORE_SWITCH` and `VIEW_AFTER_SWITCH` events.\n@param n A relative or absolute view index in `_G._VIEWS`.\n@param relative Flag indicating if n is a relative index or not. The default\n  value is `false`.\n@see _G._G._VIEWS\n@see events.VIEW_BEFORE_SWITCH\n@see events.VIEW_AFTER_SWITCH
 grab_focus buffer.grab_focus(buffer)\nSet the focus to this view.\n@param buffer The global buffer.
 graph lexer.graph\nMatches any graphical character (`!` to `~`).
-grow_selection _M.textadept.editing.grow_selection(amount)\nGrows the selection by a character amount on either end.\n@param amount The amount to grow the selection on either end.
+grow_selection _M.textadept.editing.grow_selection(amount)\nGrows the selection by the given number of characters on either end.\n@param amount The number of characters to grow the selection by on either\n  end.
 gsub string.gsub(s, pattern, repl [, n])\nReturns a copy of `s` in which all (or the first `n`, if given)\noccurrences of the `pattern` have been replaced by a replacement string\nspecified by `repl`, which can be a string, a table, or a function. `gsub`\nalso returns, as its second value, the total number of matches that occurred.\nThe name `gsub` comes from "Global SUBstitution".\n\nIf `repl` is a string, then its value is used for replacement. The character\n`%` works as an escape character: any sequence in `repl` of the form `%d`,\nwith `d` between 1 and 9, stands for the value of the `d`-th captured\nsubstring (see below). The sequence `%0` stands for the whole match. The\nsequence `%%` stands for a single `%`.\n\nIf `repl` is a table, then the table is queried for every match, using\nthe first capture as the key; if the pattern specifies no captures, then\nthe whole match is used as the key.\nIf `repl` is a function, then this function is called every time a match\noccurs, with all captured substrings passed as arguments, in order; if\nthe pattern specifies no captures, then the whole match is passed as a\nsole argument.\n\nIf the value returned by the table query or by the function call is a\nstring or a number, then it is used as the replacement string; otherwise,\nif it is false or nil, then there is no replacement (that is, the original\nmatch is kept in the string).\n\nHere are some examples:\n\n  x = string.gsub("hello world", "(%w+)", "%1 %1")\n  --> x="hello hello world world"\n  x = string.gsub("hello world", "%w+", "%0 %0", 1)\n  --> x="hello hello world"\n  x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")\n  --> x="world hello Lua from"\n  x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)\n  --> x="home = /home/roberto, user = roberto"\n  x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)\n        return load(s)()\n      end)\n  --> x="4+5 = 9"\n  local t = {name="lua", version="5.2"}\n  x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)\n  --> x="lua-5.2.tar.gz"
-gui _G.gui (module)\nThe core gui table.
+gui _G.gui (module)\nUtilities for Textadept's user interface.
 h_scroll_bar buffer.h_scroll_bar (bool)\nWhether the horizontal scroll bar is visible.\nSet to `false` to never see it and `true` to enable it again. The default\nstate is to display it when needed.
 handle_clear _M.textadept.adeptsense.handle_clear(sense)\nCalled when clearing an Adeptsense.\nThis function should be replaced with your own if you have any persistant\nobjects that need to be deleted.\n@param sense The Adeptsense returned by `adeptsense.new()`.
 handle_ctag _M.textadept.adeptsense.handle_ctag(sense, tag_name, file_name, ex_cmd, ext_fields)\nCalled by `load_ctags()` when a ctag kind is not recognized.\nThis method should be replaced with your own that is specific to the\nlanguage.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param tag_name The tag name.\n@param file_name The name of the file the tag belongs to.\n@param ex_cmd The `ex_cmd` returned by ctags.\n@param ext_fields The `ext_fields` returned by ctags.
@@ -1101,7 +1103,7 @@ hex_num lexer.hex_num\nMatches a hexadecimal number.
 hide_lines buffer.hide_lines(buffer, start_line, end_line)\nMake a range of lines invisible.\nThis has no effect on fold levels or fold flags. `start_line` can not be\nhidden.\n@param buffer The global buffer.\n@param start_line The start line.\n@param end_line The end line.
 hide_selection buffer.hide_selection(buffer, normal)\nDraw the selection in normal style or with selection highlighted.\n@param buffer The global buffer.\n@param normal Draw normal selection.
 highlight_guide buffer.highlight_guide (number)\nThe highlighted indentation guide column.\nSet to `0` to cancel this highlight.
-highlight_word _M.textadept.editing.highlight_word()\nHighlights all occurances of the word under the caret and adds markers to the\nlines they are on.
+highlight_word _M.textadept.editing.highlight_word()\nHighlights all occurances of either the selected text or the word under the\ncaret and adds markers to the lines they are on.\n@see buffer.word_chars
 home buffer.home(buffer)\nMove caret to first position on line.\n@param buffer The global buffer.
 home_display buffer.home_display(buffer)\nMove caret to first position on display line.\n@param buffer The global buffer.
 home_display_extend buffer.home_display_extend(buffer)\nMove caret to first position on display line extending selection to new caret\nposition.\n@param buffer The global buffer.
@@ -1112,9 +1114,9 @@ home_wrap_extend buffer.home_wrap_extend(buffer)\nLike `buffer:home_wrap()` but
 hotspot_active_underline buffer.hotspot_active_underline (bool)\nWhether active hotspots are underlined.
 hotspot_single_line buffer.hotspot_single_line (bool)\nWhether hotspots are limited to single line so hotspots on two lines do not\nmerge.
 huge math.huge (number)\nThe value `HUGE_VAL`, a value larger than or equal to any other numerical\nvalue.
-hypertext _G.keys.hypertext (table)\nContainer for HTML-specific key commands.
+hypertext _G.keys.hypertext (table)\nContainer for HTML-specific key bindings.
 hypertext _G.snippets.hypertext (table)\nContainer for HTML-specific snippets.
-hypertext _M.hypertext (module)\nThe hypertext module.\nIt provides utilities for editing HTML code.\nUser tags are loaded from `_USERHOME/modules/hypertext/tags` and user apis\nare loaded from `_USERHOME/modules/hypertext/api`.
+hypertext _M.hypertext (module)\nThe hypertext module.\nIt provides utilities for editing HTML code.
 iconv string.iconv(text, to, from)\nConverts a string from one character set to another using iconv.\nValid character sets are GNU iconv's character sets.\n@param text The text to convert.\n@param to The character set to convert to.\n@param from The character set to convert from.
 in_files gui.find.in_files (bool)\nSearch for the text in a list of files.
 in_files_label_text gui.find.in_files_label_text (string, Write-only)\nThe text of the 'In files' label.\nThis is primarily used for localization.
@@ -1140,12 +1142,12 @@ insert_text buffer.insert_text(buffer, pos, text)\nInsert string at a position.\
 integer lexer.integer\nMatches a decimal, hexadecimal, or octal number.
 io _G.io (module)\nLua io module.
 ipairs _G.ipairs(t)\nIf `t` has a metamethod `__ipairs`, calls it with `t` as argument and returns\nthe first three results from the call.\n\nOtherwise, returns three values: an iterator function, the table `t`, and 0,\nso that the construction\n\n  for i,v in ipairs(t) do *body* end\n\nwill iterate over the pairs (`1,t[1]`), (`2,t[2]`), ..., up to the\nfirst integer key absent from the table.
-java _G.keys.java (table)\nContainer for Java-specific key commands.
+java _G.keys.java (table)\nContainer for Java-specific key bindings.
 java _G.snippets.java (table)\nContainer for Java-specific snippets.
-java _M.java (module)\nThe java module.\nIt provides utilities for editing Java code.\nUser tags are loaded from `_USERHOME/modules/java/tags` and user apis are\nloaded from `_USERHOME/modules/java/api`.
-join_lines _M.textadept.editing.join_lines()\nJoins the currently selected lines.\nIf no lines are selected, joins the current line with the line below.
-keys _G.keys (module)\nManages key commands in Textadept.
-keys _M.textadept.keys (module)\nDefines key commands for Textadept.\nThis set of key commands is pretty standard among other text editors.\nThis module, should be `require`d last, but before `_M.textadept.menu`.
+java _M.java (module)\nThe java module.\nIt provides utilities for editing Java code.
+join_lines _M.textadept.editing.join_lines()\nJoins the currently selected lines.\nAs long as any part of a line is selected, the entire line is eligible for\njoining. If no lines are selected, joins the current line with the line\nbelow.
+keys _G.keys (module)\nManages key bindings in Textadept.
+keys _M.textadept.keys (module)\nDefines key commands for Textadept.\nThis set of key commands is pretty standard among other text editors.\nThis module should be `require`d last, but before `_M.textadept.menu`.
 keys_unicode buffer.keys_unicode (bool)\nInterpret keyboard input as Unicode.
 last_char_includes lexer.last_char_includes(s)\nCreates an LPeg pattern that matches any previous non-whitespace character\nin the given set.\n@param s String character set like one passed to `lpeg.S()`.\n@usage local regex = l.last_char_includes('+-*!%^&|=,([{') *\n  l.delimited_range('/', '\\')
 layout_cache buffer.layout_cache (number)\nThe degree of caching of layout information.\n\n* `_SCINTILLA.constants.SC_CACHE_NONE` (0)\n  No lines are cached.\n* `_SCINTILLA.constants.SC_CACHE_CARET` (1)\n  The line containing the text caret.\n  This is the default.\n* `_SCINTILLA.constants.SC_CACHE_PAGE` (2)\n  Visible lines plus the line containing the caret.\n* `_SCINTILLA.constants.SC_CACHE_DOCUMENT` (3)\n  All lines in the document.
@@ -1197,7 +1199,7 @@ load _G.load(ld [, source [, mode [, env]]])\nLoads a chunk.\n\nIf `ld` is a str
 load _M.textadept.session.load(filename)\nLoads a Textadept session file.\nTextadept restores split views, opened buffers, cursor information, and\nrecent files.\n@param filename The absolute path to the session file to load. If `nil`, the\n  user is prompted for one.\n@usage _M.textadept.session.load(filename)\n@return `true` if the session file was opened and read; `false` otherwise.\n@see DEFAULT_SESSION
 load lexer.load(lexer_name)\nInitializes the specified lexer.\n@param lexer_name The name of the lexing language.
 load_ctags _M.textadept.adeptsense.load_ctags(sense, tag_file, nolocations)\nLoads the given ctags file for autocompletion.\nIt is recommended to pass `-n` to ctags in order to use line numbers instead\nof text patterns to locate tags. This will greatly reduce memory usage for a\nlarge number of symbols if `nolocations` is not `true`.\n@param sense The Adeptsense returned by `adeptsense.new()`.\n@param tag_file The path of the ctags file to load.\n@param nolocations If `true`, does not store the locations of the tags for\n  use by `goto_ctag()`. The default value is `false`.
-load_project _M.rails.load_project(utf8_dir)\nSets keys.al.o to snapopen a Rails project.\nIf not directory is provided, the user is prompted for one.\n@param utf8_dir The UTF-8 Rails project directory.
+load_project _M.rails.load_project(utf8_dir)\nOpens a Rails project for snapopen.\nIf not directory is provided, the user is prompted for one.\n@param utf8_dir The UTF-8 Rails project directory.
 loaded package.loaded (table)\nA table used by `require` to control which modules are already loaded. When\nyou require a module `modname` and `package.loaded[modname]` is not false,\n`require` simply returns the value stored there.\nThis variable is only a reference to the real table; assignments to this\nvariable do not change the table used by `require`.
 loadfile _G.loadfile([filename [, mode [, env]]])\nSimilar to `load`, but gets the chunk from file `filename` or from the\nstandard input, if no file name is given.
 loadlib package.loadlib(libname, funcname)\nDynamically links the host program with the C library `libname`.\n\nIf `funcname` is "`*`", then it only links with the library, making the\nsymbols exported by the library available to other dynamically linked\nlibraries. Otherwise, it looks for a function `funcname` inside the library\nand returns this function as a C function. (So, `funcname` must follow the\nprototype `lua_CFunction`).\n\nThis is a low-level function. It completely bypasses the package and module\nsystem. Unlike `require`, it does not perform any path searching and does\nnot automatically adds extensions. `libname` must be the complete file name\nof the C library, including if necessary a path and an extension. `funcname`\nmust be the exact name exported by the C library (which may depend on the\nC compiler and linker used).\n\nThis function is not supported by Standard C. As such, it is only available\non some platforms (Windows, Linux, Mac OS X, Solaris, BSD, plus other Unix\nsystems that support the `dlfcn` standard).
@@ -1212,9 +1214,9 @@ lower_case buffer.lower_case(buffer)\nTransform the selection to lower case.\n@p
 lpeg _G.lpeg (module)\nLua lpeg module.
 lrotate bit32.lrotate(x, disp)\nReturns the number `x` rotated `disp` bits to the left. The number `disp` may\nbe any representable integer.\n\nFor any valid displacement, the following identity holds:\n\n  assert(bit32.lrotate(x, disp) == bit32.lrotate(x, disp % 32))\n\nIn particular, negative displacements rotate to the right.
 lshift bit32.lshift(x, disp)\nReturns the number `x` shifted `disp` bits to the left. The number `disp` may\nbe any representable integer. Negative displacements shift to the right. In\nany direction, vacant bits are filled with zeros. In particular,\ndisplacements with absolute values higher than 31 result in zero (all bits\nare shifted out).\n\nFor positive displacements, the following equality holds:\n\n  assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
-lua _G.keys.lua (table)\nContainer for Lua-specific key commands.
+lua _G.keys.lua (table)\nContainer for Lua-specific key bindings.
 lua _G.snippets.lua (table)\nContainer for Lua-specific snippets.
-lua _M.lua (module)\nThe lua module.\nIt provides utilities for editing Lua code.\nUser tags are loaded from `_USERHOME/modules/lua/tags` and user apis are\nloaded from `_USERHOME/modules/lua/api`.
+lua _M.lua (module)\nThe lua module.\nIt provides utilities for editing Lua code.
 lua gui.find.lua (bool)\nThe search text is interpreted as a Lua pattern.
 lua_pattern_label_text gui.find.lua_pattern_label_text (string, Write-only)\nThe text of the 'Lua pattern' label.\nThis is primarily used for localization.
 main_selection buffer.main_selection (number)\nThe main selection.\nThe main selection may be displayed in different colors or with a\ndifferently styled caret. Only an already existing selection can be made\nmain.
@@ -1257,10 +1259,10 @@ math _G.math (module)\nLua math module.
 max math.max(x, ···)\nReturns the maximum value among its arguments.
 max_line_state buffer.max_line_state (number, Read-only)\nThe last line number that has line state.
 menu _M.textadept.menu (module)\nProvides dynamic menus for Textadept.\nThis module should be `require`d last, after `_M.textadept.keys` since it\nlooks up defined key commands to show them in menus.
-menu gui.menu(menu_table)\nCreates a menu, returning the userdata.\n@param menu_table A table defining the menu. It is an ordered list of tables\n  with a string menu item, integer menu ID, and optional GDK keycode and\n  modifier mask. The latter two are used to display key shortcuts in the\n  menu. `_` characters are treated as a menu mnemonics. If the menu item is\n  empty, a menu separator item is created. Submenus are just nested\n  menu-structure tables. Their title text is defined with a `title` key.\n@usage gui.menu{ { '_New', 1 }, { '_Open', 2 }, { '' }, { '_Quit', 4 } }\n@usage gui.menu{ { '_New', 1, keys.get_gdk_key('cn') } }\n@see keys.get_gdk_key
-menubar _M.textadept.menu.menubar (table)\nContains the main menubar.
-menubar gui.menubar (table)\nA table of menus defining a menubar. (Write-only)
-mime_types _M.textadept.mime_types (module)\nHandles file-specific settings.
+menu gui.menu(menu_table)\nCreates a menu, returning the userdata.\nThis is a low-level function. You probably want to use the higher-level\n`_M.textadept.menu.set_menubar()` or `_M.textadept.menu.set_contextmenu()`\nfunctions. Emits a `MENU_CLICKED` event when a menu item is selected.\n@param menu_table A table defining the menu. It is an ordered list of tables\n  with a string menu item, integer menu ID, and optional GDK keycode and\n  modifier mask. The latter two are used to display key shortcuts in the\n  menu. `_` characters are treated as a menu mnemonics. If the menu item is\n  empty, a menu separator item is created. Submenus are just nested\n  menu-structure tables. Their title text is defined with a `title` key.\n@usage gui.menu{ { '_New', 1 }, { '_Open', 2 }, { '' }, { '_Quit', 4 } }\n@usage gui.menu{ { '_New', 1, string.byte('n'), 4 } } -- 'Ctrl+N'\n@see events.MENU_CLICKED\n@see _M.textadept.menu.set_menubar\n@see _M.textadept.menu.set_contextmenu
+menubar _M.textadept.menu.menubar (table)\nContains the main menubar.\n@see set_menubar
+menubar gui.menubar (table)\nA table of menus defining a menubar. (Write-only)\n@see _M.textadept.menu.set_menubar
+mime_types _M.textadept.mime_types (module)\nHandles file type detection.
 min math.min(x, ···)\nReturns the minimum value among its arguments.
 mkdir lfs.mkdir(dirname)\nCreates a new directory. The argument is the name of the new directory.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string.
 modf math.modf(x)\nReturns two numbers, the integral part of `x` and the fractional part of\n`x`.
@@ -1274,19 +1276,19 @@ multi_paste buffer.multi_paste (bool)\nThe effect of pasting when there are mult
 multiple_selection buffer.multiple_selection (bool)\nWhether multiple selections can be made.\nWhen multiple selection is disabled, it is not possible to select multiple\nranges by holding down the Ctrl key while dragging with the mouse.
 nested_pair lexer.nested_pair(start_chars, end_chars, end_optional)\nSimilar to `delimited_range()`, but allows for multi-character delimitters.\nThis is useful for lexers with tokens such as nested block comments. With\nsingle-character delimiters, this function is identical to\n`delimited_range(start_chars..end_chars, nil, end_optional, true)`.\n@param start_chars The string starting a nested sequence.\n@param end_chars The string ending a nested sequence.\n@param end_optional Optional flag indicating whether or not an ending\n  delimiter is optional or not. If true, the range begun by the start\n  delimiter matches until an end delimiter or the end of the input is\n  reached.\n@usage local nested_comment = l.nested_pair('/*', '*/', true)
 new _M.textadept.adeptsense.new(lang)\nCreates a new Adeptsense for the given lexer language.\nOnly one sense can exist per language.\n@param lang The lexer language to create an Adeptsense for.\n@usage local lua_sense = _M.textadept.adeptsense.new('lua')\n@return adeptsense
-new_buffer _G.new_buffer()\nCreates a new buffer.\nGenerates a `BUFFER_NEW` event.\n@return the new buffer.
+new_buffer _G.new_buffer()\nCreates a new buffer.\nEmits a `BUFFER_NEW` event.\n@return the new buffer.\n@see events.BUFFER_NEW
 new_line buffer.new_line(buffer)\nInsert a new line, may use a CRLF, CR or LF depending on EOL mode.\n@param buffer The global buffer.
 newline lexer.newline\nMatches any newline characters.
 next _G.next(table [, index])\nAllows a program to traverse all fields of a table. Its first argument is\na table and its second argument is an index in this table. `next` returns\nthe next index of the table and its associated value. When called with nil\nas its second argument, `next` returns an initial index and its associated\nvalue. When called with the last index, or with nil in an empty table, `next`\nreturns nil. If the second argument is absent, then it is interpreted as\nnil. In particular, you can use `next(t)` to check whether a table is empty.\n\nThe order in which the indices are enumerated is not specified, *even for\nnumeric indices*. (To traverse a table in numeric order, use a numerical\n`for`.)\n\nThe behavior of `next` is undefined if, during the traversal, you assign any\nvalue to a non-existent field in the table. You may however modify existing\nfields. In particular, you may clear existing fields.
 next_indic_number _SCINTILLA.next_indic_number()\nReturns a unique indicator number.\nUse this function for custom indicators in order to prevent clashes with\nidentifiers of other custom indicators.\n@usage local indic_num = _SCINTILLA.next_indic_number()\n@see buffer.indic_style
 next_marker_number _SCINTILLA.next_marker_number()\nReturns a unique marker number.\nUse this function for custom markers in order to prevent clashes with\nidentifiers of other custom markers.\n@usage local marknum = _SCINTILLA.next_marker_number()\n@see buffer.marker_define
-next_user_list_type _SCINTILLA.next_user_list_type()\nReturns a unique user list type.\nUse this function for custom user lists in order to prevent clashes with\ntype identifiers of other custom user lists.\n@usage local list_type = _SCINTILLA.next_user_list_type()\n@see buffer.user_list_show
+next_user_list_type _SCINTILLA.next_user_list_type()\nReturns a unique user list type.\nUse this function for custom user lists in order to prevent clashes with\nlist identifiers of other custom user lists.\n@usage local list_type = _SCINTILLA.next_user_list_type()\n@see buffer.user_list_show
 nonnewline lexer.nonnewline\nMatches any non-newline character.
 nonnewline_esc lexer.nonnewline_esc\nMatches any non-newline character excluding newlines escaped with `\\`.
 oct_num lexer.oct_num\nMatches an octal number.
-open _M.textadept.snapopen.open(utf8_paths, filter, exclude_PATHS, exclude_FILTER, depth)\nQuickly open a file in set of directories.\n@param utf8_paths A UTF-8 string directory path or table of UTF-8 directory\n  paths to search.\n@param filter A filter for files and folders to exclude. The filter may be\n  a string or table. Each filter is a Lua pattern. Any files matching a\n  filter are excluded. Prefix a pattern with `!` to exclude any files that\n  do not match the filter. File extensions can be more efficiently excluded\n  by adding the extension text to a table assigned to an `extensions` key in\n  the filter table instead of using individual filters. Directories can be\n  excluded by adding filters to a table assigned to a `folders` key in the\n  filter table. All strings should be UTF-8 encoded.\n@param exclude_PATHS Flag indicating whether or not to exclude `PATHS` in the\n  search. The default value is `false`.\n@param exclude_FILTER Flag indicating whether or not to exclude `FILTER` from\n  `filter` in the search. If false, adds `FILTER` to the given `filter`.\n  The default value is `false`.\n@param depth Number of directories to recurse into for finding files.\n  The default value is `DEFAULT_DEPTH`.\n@usage _M.textadept.snapopen.open()\n@usage _M.textadept.snapopen.open(buffer.filename:match('^.+/'), nil, true)\n@usage _M.textadept.snapopen.open(nil, '!%.lua$')\n@usage _M.textadept.snapopen.open(nil, { folders = { '%.hg' } })
+open _M.textadept.snapopen.open(utf8_paths, filter, exclude_PATHS, exclude_FILTER, depth)\nQuickly open files in set of directories using a filtered list dialog.\nThe number of files in the list is capped at `MAX`.\n@param utf8_paths A UTF-8 string directory path or table of UTF-8 directory\n  paths to search.\n@param filter A filter for files and folders to exclude. The filter may be\n  a string or table. Each filter is a Lua pattern. Any files matching a\n  filter are excluded. Prefix a pattern with `!` to exclude any files that\n  do not match a filter. File extensions can be more efficiently excluded by\n  adding the extension text to a table assigned to an `extensions` key in the\n  filter table instead of using individual filters. Directories can be\n  excluded by adding filters to a table assigned to a `folders` key in the\n  filter table. All strings should be UTF-8 encoded.\n@param exclude_PATHS Flag indicating whether or not to exclude `PATHS` in the\n  search. The default value is `false`.\n@param exclude_FILTER Flag indicating whether or not to exclude `FILTER` from\n  `filter` in the search. If false, adds `FILTER` to the given `filter`.\n  The default value is `false`.\n@param depth Number of directories to recurse into for finding files.\n  The default value is `DEFAULT_DEPTH`.\n@usage _M.textadept.snapopen.open() -- list all files in PATHS\n@usage _M.textadept.snapopen.open(buffer.filename:match('^.+/'), nil, true)\n  -- list all files in the current file's directory\n@usage _M.textadept.snapopen.open(nil, '!%.lua$') -- list all Lua files in\n   PATHS\n@usage _M.textadept.snapopen.open('/project', { folders = { 'secret' } },\n  true) -- list all project files except those in a secret folder\n@see PATHS\n@see FILTER\n@see DEFAULT_DEPTH\n@see MAX
 open io.open(filename [, mode])\nThis function opens a file, in the mode specified in the string `mode`. It\nreturns a new file handle, or, in case of errors, nil plus an error message.\n\nThe `mode` string can be any of the following:\n  "r": read mode (the default);\n  "w": write mode;\n  "a": append mode;\n  "r+": update mode, all previous data is preserved;\n  "w+": update mode, all previous data is erased;\n  "a+": append update mode, previous data is preserved, writing is only\n        allowed at the end of file.\n\nThe `mode` string can also have a '`b`' at the end, which is needed in\nsome systems to open the file in binary mode.
-open_file io.open_file(utf8_filenames)\nOpens a list of files.\n@param utf8_filenames A `\\n` separated list of UTF-8-encoded filenames to\n  open. If `nil`, the user is prompted with a fileselect dialog.\n@usage io.open_file(utf8_encoded_filename)
+open_file io.open_file(utf8_filenames)\nOpens a list of files.\nEmits a `FILE_OPENED` event.\n@param utf8_filenames A `\n` separated list of UTF-8-encoded filenames to\n  open. If `nil`, the user is prompted with a fileselect dialog.\n@usage io.open_file(utf8_encoded_filename)\n@see _G.events
 open_recent_file io.open_recent_file()\nPrompts the user to open a recently opened file.\n@see recent_files
 os _G.os (module)\nLua os module.
 output io.output([file])\nSimilar to `io.input`, but operates over the default output file.
@@ -1306,11 +1308,11 @@ para_up buffer.para_up(buffer)\nMove caret one paragraph up (delimited by empty
 para_up_extend buffer.para_up_extend(buffer)\nMove caret one paragraph up (delimited by empty lines) extending selection to\nnew caret position.\n@param buffer The global buffer.
 paste buffer.paste(buffer)\nPaste the contents of the clipboard into the document replacing the\nselection.\n@param buffer The global buffer.
 path package.path (string)\nThe path used by `require` to search for a Lua loader.\nAt start-up, Lua initializes this variable with the value of the\nenvironment variable `LUA_PATH_5_2` or the environment variable `LUA_PATH`\nor with a default path defined in `luaconf.h`, if those environment\nvariables are not defined. Any "`;;`" in the value of the environment\nvariable is replaced by the default path.
-patterns _M.textadept.mime_types.patterns (table)\nFirst-line patterns and their associated lexers.
+patterns _M.textadept.mime_types.patterns (table)\nTable of first-line patterns and their associated lexers.\nIf a file type is not recognized by shebang words, each pattern is matched\nagainst the first line in the file.
 pcall _G.pcall(f [, arg1, ···])\nCalls function `f` with the given arguments in *protected mode*. This\nmeans that any error inside `f` is not propagated; instead, `pcall` catches\nthe error and returns a status code. Its first result is the status code (a\nboolean), which is true if the call succeeds without errors. In such case,\n`pcall` also returns all results from the call, after this first result. In\ncase of any error, `pcall` returns false plus the error message.
-php _G.keys.php (table)\nContainer for PHP-specific key commands.
+php _G.keys.php (table)\nContainer for PHP-specific key bindings.
 php _G.snippets.php (table)\nContainer for PHP-specific snippets.
-php _M.php (module)\nThe php module.\nIt provides utilities for editing PHP code.\nUser tags are loaded from `_USERHOME/modules/php/tags` and user apis are\nloaded from `_USERHOME/modules/php/api`.
+php _M.php (module)\nThe php module.\nIt provides utilities for editing PHP code.
 pi math.pi (number)\nThe value of 'π'.
 point_x_from_position buffer.point_x_from_position(buffer, pos)\nRetrieve the x value of the point in the window where a position is\ndisplayed.\n@param buffer The global buffer.\n@param pos The position.\n@return number
 point_y_from_position buffer.point_y_from_position(buffer, pos)\nRetrieve the y value of the point in the window where a position is\ndisplayed.\n@param buffer The global buffer.\n@param pos The position.\n@return number
@@ -1324,24 +1326,24 @@ position_from_point_close buffer.position_from_point_close(buffer, x, y)\nReturn
 pow math.pow(x, y)\nReturns *x^y*. (You can also use the expression `x^y` to compute this\nvalue.)
 preload package.preload (table)\nA table to store loaders for specific modules (see `require`).\nThis variable is only a reference to the real table; assignments to this\nvariable do not change the table used by `require`.
 print _G.print(···)\nReceives any number of arguments and prints their values to `stdout`, using\nthe `tostring` function to convert each argument to a string. `print` is not\nintended for formatted output, but only as a quick way to show a value,\nfor instance for debugging. For complete control over the output, use\n`string.format` and `io.write`.
-print gui.print(...)\nPrints messages to the Textadept message buffer.\nOpens a new buffer (if one has not already been opened) for printing\nmessages.\n@param ... Message strings.
+print gui.print(...)\nPrints messages to the Textadept message buffer.\nOpens a new buffer if one has not already been opened for printing messages.\n@param ... Message strings.
 print lexer.print\nMatches any printable character (space to `~`).
 print_colour_mode buffer.print_colour_mode (number)\nThe print color mode.\n\n* `_SCINTILLA.constants.SC_PRINT_NORMAL` (0)\n  Print using the current screen colors.\n  This is the default.\n* `_SCINTILLA.constants.SC_PRINT_INVERTLIGHT` (1)\n  If you use a dark screen background this saves ink by inverting the light\n  value of all colors and printing on a white background.\n* `_SCINTILLA.constants.SC_PRINT_BLACKONWHITE` (2)\n  Print all text as black on a white background.\n* `_SCINTILLA.constants.SC_PRINT_COLOURONWHITE` (3)\n  Everything prints in its own color on a white background.\n* `_SCINTILLA.constants.SC_PRINT_COLOURONWHITEDEFAULTBG` (4)\n  Everything prints in its own color on a white background except that line\n  numbers use their own background color.
 print_magnification buffer.print_magnification (number)\nThe print magnification added to the point size of each style for printing.
 print_wrap_mode buffer.print_wrap_mode (number)\nPrinting line wrap mode.\n\n* `_SCINTILLA.constants.SC_WRAP_NONE` (0)\n  Each line of text generates one line of output and the line is truncated\n  if it is too long to fit into the print area.\n* `_SCINTILLA.constants.SC_WRAP_WORD` (1)\n  Wraps printed output so that all characters fit into the print rectangle.\n  Tries to wrap only between words as indicated by white space or style\n  changes although if a word is longer than a line, it will be wrapped\n  before the line end. This is the default.\n* `_SCINTILLA.constants.SC_WRAP_CHAR` (2).
 private_lexer_call buffer.private_lexer_call(buffer, operation, data)\nFor private communication between an application and a known lexer.\n@param buffer The global buffer.\n@param operation An operation number.\n@param data Number data.
-process args.process(arg)\nProcesses command line arguments.\nAdd command line switches with `args.register()`. Any unrecognized arguments\nare treated as filepaths and opened.\nGenerates an `'arg_none'` event when no args are present.\n@param arg Argument table.\n@see register
-properties _SCINTILLA.properties (table)\nScintilla properties.
+process args.process(arg)\nProcesses command line arguments.\nAdd command line switches with `args.register()`. Any unrecognized arguments\nare treated as filepaths and opened.\nEmits an `'arg_none'` event when no args are present.\n@param arg Argument table.\n@see register\n@see events
+properties _SCINTILLA.properties (table)\nScintilla properties.\nEach key is a Scintilla property name with a table value containing the ID of\nits "get" function, the ID of its "set" function, its return type, and its\nwParam type. The wParam type will be non-zero if the property is an indexable\nproperty. Types are the same as in the `functions` table.\n@see functions
 property buffer.property (table)\nTable of keyword:value string pairs used by a lexer for some optional\nfeatures.
 property_expanded buffer.property_expanded (table)\nTable of keyword:value string pairs used by a lexer for some optional\nfeatures with `$()` variable replacement on returned string.
 property_int buffer.property_int (table, Read-only)\nInterprets `buffer.property[keyword]` as an integer if found or returns\n`0`.
 punct lexer.punct\nMatches any punctuation character not alphanumeric (`!` to `/`, `:` to `@`,\n  `[` to `'`, `{` to `~`).
 punctuation_chars buffer.punctuation_chars (string)\nThe set of characters making up punctuation characters.\nUse after setting `buffer.word_chars`.
-quit _G.quit()\nQuits Textadept.
+quit _G.quit()\nQuits Textadept.\nEmits a `QUIT` event. If any handler returns `false`, Textadept does not\nquit.\n@see events.QUIT
 rad math.rad(x)\nReturns the angle `x` (given in degrees) in radians.
-rails _G.keys.rails (table)\nContainer for Rails-specific key commands.
+rails _G.keys.rails (table)\nContainer for Rails-specific key bindings.
 rails _G.snippets.rails (table)\nContainer for Rails-specific snippets.
-rails _M.rails (module)\nThe rails module.\nIt provides utilities for editing Ruby on Rails code.\nUser tags are loaded from `_USERHOME/modules/rails/tags` and user apis are\nloaded from `_USERHOME/modules/rails/api`.
+rails _M.rails (module)\nThe rails module.\nIt provides utilities for editing Ruby on Rails code.
 random math.random([m [, n]])\nThis function is an interface to the simple pseudo-random generator\nfunction `rand` provided by Standard C. (No guarantees can be given for its\nstatistical properties.)\n\nWhen called without arguments, returns a uniform pseudo-random real\nnumber in the range [0,1). When called with an integer number `m`,\n`math.random` returns a uniform pseudo-random integer in the range [1, m].\nWhen called with two integer numbers `m` and `n`, `math.random` returns a\nuniform pseudo-random integer in the range [m, n].
 randomseed math.randomseed(x)\nSets `x` as the "seed" for the pseudo-random generator: equal seeds\nproduce equal sequences of numbers.
 rawequal _G.rawequal(v1, v2)\nChecks whether `v1` is equal to `v2`, without invoking any\nmetamethod. Returns a boolean.
@@ -1351,7 +1353,6 @@ rawset _G.rawset(table, index, value)\nSets the real value of `table[index]` to
 read file:read(···)\nReads the file `file`, according to the given formats, which specify\nwhat to read. For each format, the function returns a string (or a number)\nwith the characters read, or nil if it cannot read data with the specified\nformat. When called without formats, it uses a default format that reads\nthe next line (see below).\n\nThe available formats are\n  "*n": reads a number; this is the only format that returns a number\n        instead of a string.\n  "*a": reads the whole file, starting at the current position. On end of\n        file, it returns the empty string.\n  "*l": reads the next line skipping the end of line, returning nil on\n        end of file. This is the default format.\n  "*L": reads the next line keeping the end of line (if present), returning\n        nil on end of file.\n  *number*: reads a string with up to this number of bytes, returning nil on\n        end of file. If number is zero, it reads nothing and returns an empty\n        string, or nil on end of file.
 read io.read(···)\nEquivalent to `io.input():read(···)`.
 read_only buffer.read_only (bool)\nRead-only mode.
-rebuild_command_tables _M.textadept.menu.rebuild_command_tables()\nRebuilds the tables used by `select_command()`.\nThis should be called every time `set_menubar()` is called.
 recent_files io.recent_files (table)\nList of recently opened files.\nThe most recent are towards the top.
 rectangular_selection_anchor buffer.rectangular_selection_anchor (number)\nThe position of the anchor of the rectangular selection.
 rectangular_selection_anchor_virtual_space buffer.rectangular_selection_anchor_virtual_space (number)\nThe amount of virtual space for the anchor of the rectangular selection.
@@ -1359,7 +1360,7 @@ rectangular_selection_caret buffer.rectangular_selection_caret (number)\nThe pos
 rectangular_selection_caret_virtual_space buffer.rectangular_selection_caret_virtual_space (number)\nThe amount of virtual space for the caret of the rectangular selection.
 rectangular_selection_modifier buffer.rectangular_selection_modifier (number)\nThe modifier key used to indicate that a rectangular selection should be\ncreated when combined with a mouse drag.\n\n* `_SCINTILLA.constants.SCMOD_CTRL` (2)\n  Control key (default).\n* `_SCINTILLA.constants.SCMOD_ALT` (4)\n  Alt key.\n* `_SCINTILLA.constants.SCMOD_SUPER` (8)\n  Left Windows key on a Windows keyboard or the Command key on a Mac.
 redo buffer.redo(buffer)\nRedoes the next action on the undo history.\n@param buffer The global buffer.
-register args.register(switch1, switch2, narg, f, description)\nRegisters a command line switch.\n@param switch1 String switch (short version).\n@param switch2 String switch (long version).\n@param narg The number of expected parameters for the switch.\n@param f The Lua function to run when the switch is tripped.\n@param description Description of the switch.
+register args.register(switch1, switch2, narg, f, description)\nRegisters a command line switch.\n@param switch1 String switch (short version).\n@param switch2 String switch (long version).\n@param narg The number of expected parameters for the switch.\n@param f The Lua function to run when the switch is tripped.\n@param description Description of the switch for command line help.
 register_image buffer.register_image(buffer, type, xpm_data)\nRegister an XPM image for use in autocompletion lists.\n@param buffer The global buffer.\n@param type Integer type to register the image with.\n@param xpm_data XPM data as is described for `buffer:marker_define_pixmap()`.
 register_rgba_image buffer.register_rgba_image(buffer, type, pixels)\nRegister an RGBA image for use in autocompletion lists.\nIt has the width and height from `buffer.rgba_image_width` and\n`buffer.rgba_image_height`.\n@param buffer The global buffer.\n@param type Integer type to register the image with.\n@param pixels RGBA data as is described for\n  `buffer:marker_define_rgba_image()`.
 reload buffer.reload(buffer)\nReloads the file in a given buffer.\n@param buffer The global buffer.
@@ -1368,8 +1369,8 @@ remove table.remove(list [, pos])\nRemoves from `list` the element at position `
 rename os.rename(oldname, newname)\nRenames file or directory named `oldname` to `newname`. If this function\nfails, it returns nil, plus a string describing the error and the error code.
 rep string.rep(s, n [, sep])\nReturns a string that is the concatenation of `n` copies of the string `s`\nseparated by the string `sep`. The default value for `sep` is the empty\nstring (that is, no separator).
 replace bit32.replace(n, v, field [, width])\nReturns a copy of `n` with the bits `field` to `field + width - 1` replaced\nby the value `v`. See `bit32.extract` for details about `field` and `width`.
-replace gui.find.replace()\nMimicks a press of the 'Replace' button in the Find box.
-replace_all gui.find.replace_all()\nMimicks a press of the 'Replace All' button in the Find box.
+replace gui.find.replace()\nMimicks a press of the 'Replace' button.
+replace_all gui.find.replace_all()\nMimicks a press of the 'Replace All' button.
 replace_all_button_text gui.find.replace_all_button_text (string, Write-only)\nThe text of the 'Replace All' button.\nThis is primarily used for localization.
 replace_button_text gui.find.replace_button_text (string, Write-only)\nThe text of the 'Replace' button.\nThis is primarily used for localization.
 replace_entry_text gui.find.replace_entry_text (string)\nThe text in the replace entry.
@@ -1378,30 +1379,30 @@ replace_sel buffer.replace_sel(buffer, text)\nReplace the selected text with the
 replace_target buffer.replace_target(buffer, text)\nReplace the target text with the argument text.\nAfter replacement, the target range refers to the replacement text.\nReturns the length of the replacement text.\n@param buffer The global buffer.\n@param text The text (can contain NULs).\n@return number
 replace_target_re buffer.replace_target_re(buffer, text)\nReplace the target text with the argument text after `\d` processing.\nLooks for `\d` where `d` is between `1` and `9` and replaces these with the\nstrings matched in the last search operation which were surrounded by `\(`\nand `\)`. Returns the length of the replacement text including any change\ncaused by processing the `\d` patterns.\n@param buffer The global buffer.\n@param text The text (can contain NULs).\n@return number
 require _G.require(modname)\nLoads the given module. The function starts by looking into the\n`package.loaded` table to determine whether `modname` is already\nloaded. If it is, then `require` returns the value stored at\n`package.loaded[modname]`. Otherwise, it tries to find a *loader* for\nthe module.\n\nTo find a loader, `require` is guided by the `package.searchers` sequence. By\nchanging this sequence, we can change how `require` looks for a module. The\nfollowing explanation is based on the default configuration for\n`package.searchers`.\n\nFirst `require` queries `package.preload[modname]`. If it has a value,\nthis value (which should be a function) is the loader. Otherwise `require`\nsearches for a Lua loader using the path stored in `package.path`. If\nthat also fails, it searches for a C loader using the path stored in\n`package.cpath`. If that also fails, it tries an *all-in-one* loader (see\n`package.searchers`).\n\nOnce a loader is found, `require` calls the loader with two arguments:\n`modname` and an extra value dependent on how it got the loader. (If the\nloader came from a file, this extra value is the file name.) If the loader\nreturns any non-nil value, `require` assigns the returned value to\n`package.loaded[modname]`. If the loader does not return a non-nil value and\nhas not assigned any value to `package.loaded[modname]`, then `require`\nassigns <b>true</b> to this entry. In any case, `require` returns the final\nvalue of `package.loaded[modname]`.\n\nIf there is any error loading or running the module, or if it cannot find\nany loader for the module, then `require` raises an error.
-reset _G.reset()\nResets the Lua state by reloading all init scripts.\nLanguage-specific modules for opened files are NOT reloaded. Re-opening the\nfiles that use them will reload those modules.\nThis function is useful for modifying init scripts (such as the user's\n`modules/textadept/keys.lua`) on the fly without having to restart Textadept.\n`_G.RESETTING` is set to `true` when re-initing the Lua State. Any scripts\nthat need to differentiate between startup and reset can utilize this\nvariable.\n@see RESETTING
+reset _G.reset()\nResets the Lua state by reloading all init scripts.\nLanguage-specific modules for opened files are NOT reloaded. Re-opening the\nfiles that use them will reload those modules instead.\nThis function is useful for modifying user scripts (such as\n`~/.textadept/init.lua` and `~/.textadept/modules/textadept/keys.lua`) on\nthe fly without having to restart Textadept. `_G.RESETTING` is set to `true`\nwhen re-initing the Lua State. Any scripts that need to differentiate between\nstartup and reset can utilize this variable.\n@see RESETTING
 resume coroutine.resume(co [, val1, ···])\nStarts or continues the execution of coroutine `co`. The first time\nyou resume a coroutine, it starts running its body. The values `val1`,\n... are passed as the arguments to the body function. If the coroutine\nhas yielded, `resume` restarts it; the values `val1`, ... are passed\nas the results from the yield.\n\nIf the coroutine runs without any errors, `resume` returns true plus any\nvalues passed to `yield` (if the coroutine yields) or any values returned\nby the body function (if the coroutine terminates). If there is any error,\n`resume` returns false plus the error message.
 reverse string.reverse(s)\nReturns a string that is the string `s` reversed.
 rgba_image_height buffer.rgba_image_height (number)\nThe height for future RGBA image data.
 rgba_image_scale buffer.rgba_image_scale (number)\nThe scale factor in percent for future RGBA image data.\nThis is useful on OSX with a retina display where each display unit is 2\npixels: use a factor of 200 so that each image pixel is dsplayed using a\nscreen pixel. The default scale, 100, will stretch each image pixel to\ncover 4 screen pixels on a retina display.
 rgba_image_width buffer.rgba_image_width (number)\nThe width for future RGBA image data.
-rhtml _G.keys.rhtml (table)\nContainer for RHTML-specific key commands.
+rhtml _G.keys.rhtml (table)\nContainer for RHTML-specific key bindings.
 rhtml _G.snippets.rhtml (table)\nContainer for RHTML-specific snippets.
-rhtml _M.rhtml (module)\nThe RHTML module.\nIt provides utilities for editing RHTML.\nUser tags are loaded from `_USERHOME/modules/rhtml/tags` and user apis are\nloaded from `_USERHOME/modules/rhtml/api`.
+rhtml _M.rhtml (module)\nThe RHTML module.\nIt provides utilities for editing RHTML.
 rmdir lfs.rmdir(dirname)\nRemoves an existing directory. The argument is the name of the directory.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string.
 rotate_selection buffer.rotate_selection(buffer)\nSet the main selection to the next selection.\n@param buffer The global buffer.
 rrotate bit32.rrotate(x, disp)\nReturns the number `x` rotated `disp` bits to the right. The number `disp`\nmay be any representable integer.\n\nFor any valid displacement, the following identity holds:\n\n  assert(bit32.rrotate(x, disp) == bit32.rrotate(x, disp % 32))\n\nIn particular, negative displacements rotate to the left.
 rshift bit32.rshift(x, disp)\nReturns the number `x` shifted `disp` bits to the right. The number `disp`\nmay be any representable integer. Negative displacements shift to the left.\nIn any direction, vacant bits are filled with zeros. In particular,\ndisplacements with absolute values higher than 31 result in zero (all bits\nare shifted out).\n\nFor positive displacements, the following equality holds:\n\n  assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))\n\nThis shift operation is what is called logical shift.
-ruby _G.keys.ruby (table)\nContainer for Ruby-specific key commands.
+ruby _G.keys.ruby (table)\nContainer for Ruby-specific key bindings.
 ruby _G.snippets.ruby (table)\nContainer for Ruby-specific snippets.
-ruby _M.ruby (module)\nThe ruby module.\nIt provides utilities for editing Ruby code.\nUser tags are loaded from `_USERHOME/modules/ruby/tags` and user apis are\nloaded from `_USERHOME/modules/ruby/api`.
-run _M.textadept.run (module)\nModule for running/executing source files.\nTypically, language-specific modules populate the `compile_command`,\n`run_command`, and `error_detail` tables for a particular language's file\nextension.
-run _M.textadept.run.run()\nRuns/executes the file as specified by its extension in the `run_command`\ntable.\n@see run_command
-run_command _M.textadept.run.run_command (table)\nFile extensions and their associated 'go' actions.\nEach key is a file extension whose value is either a command line string to\nexecute or a function returning one.\nThis table is typically populated by language-specific modules.
+ruby _M.ruby (module)\nThe ruby module.\nIt provides utilities for editing Ruby code.
+run _M.textadept.run (module)\nCompile and run/execute source files with Textadept.\nTypically, language-specific modules populate the `compile_command`,\n`run_command`, and `error_detail` tables for a particular language's file\nextension.
+run _M.textadept.run.run()\nRuns/executes the file based on its extension using the command from the\n`run_command` table.\n@see run_command
+run_command _M.textadept.run.run_command (table)\nFile extensions and their associated "run" shell commands.\nEach key is a file extension whose value is either a command line string to\nexecute or a function returning one.\nThis table is typically populated by language-specific modules.
 running coroutine.running()\nReturns the running coroutine plus a boolean, true when the running coroutine\nis the main one.
 save _M.textadept.session.save(filename)\nSaves a Textadept session to a file.\nSaves split views, opened buffers, cursor information, and recent files.\n@param filename The absolute path to the session file to save. If `nil`, the\n  user is prompted for one.\n@usage _M.textadept.session.save(filename)\n@see DEFAULT_SESSION
-save buffer.save(buffer)\nSaves the current buffer to a file.\n@param buffer The global buffer.
-save_all io.save_all()\nSaves all dirty buffers to their respective files.\n@usage io.save_all()
-save_as buffer.save_as(buffer, utf8_filename)\nSaves the current buffer to a file different than its filename property.\n@param buffer The global buffer.\n@param utf8_filename The new filepath to save the buffer to. Must be UTF-8\n  encoded.
+save buffer.save(buffer)\nSaves the current buffer to a file.\nEmits `FILE_BEFORE_SAVE` and `FILE_AFTER_SAVE` events.\n@param buffer The global buffer.\n@see _G.events
+save_all io.save_all()\nSaves all dirty buffers to their respective files.\n@usage io.save_all()\n@see buffer.save
+save_as buffer.save_as(buffer, utf8_filename)\nSaves the current buffer to a file different than its filename property.\nEmits a `FILE_SAVED_AS` event.\n@param buffer The global buffer.\n@param utf8_filename The new filepath to save the buffer to. Must be UTF-8\n  encoded.\n@see _G.events
 scroll_caret buffer.scroll_caret(buffer)\nEnsure the caret is visible.\n@param buffer The global buffer.
 scroll_to_end buffer.scroll_to_end(buffer)\nScroll to end of document.\n@param buffer The global buffer.
 scroll_to_start buffer.scroll_to_start(buffer)\nScroll to start of document.\n@param buffer The global buffer.
@@ -1419,14 +1420,14 @@ sel_alpha buffer.sel_alpha (number)\nThe alpha of the selection, between `0` (tr
 sel_eol_filled buffer.sel_eol_filled (bool)\nThe selection end of line fill.\nThe selection can be drawn up to the right hand border by setting this\nproperty.
 select _G.select(index, ···)\nIf `index` is a number, returns all arguments after argument number\n`index`; a negative number indexes from the end (-1 is the last argument).\nOtherwise, `index` must be the string `"#"`, and `select` returns the total\nnumber of extra arguments it received.
 select_all buffer.select_all(buffer)\nSelect all the text in the document.\nThe current position is not scrolled into view.\n@param buffer The global buffer.
-select_command _M.textadept.menu.select_command()\nPrompts the user with a filteredlist to run menu commands.
+select_command _M.textadept.menu.select_command()\nPrompts the user with a filtered list dialog to run menu commands.
 select_enclosed _M.textadept.editing.select_enclosed(left, right)\nSelects text between a given pair of strings.\n@param left The left part of the enclosure.\n@param right The right part of the enclosure.
-select_indented_block _M.textadept.editing.select_indented_block()\nSelects indented blocks intelligently.\nIf no block of text is selected, all text with the current level of\nindentation is selected. If a block of text is selected and the lines to the\ntop and bottom of it are one indentation level lower, they are added to the\nselection. In all other cases, the behavior is the same as if no text is\nselected.
-select_lexer _M.textadept.mime_types.select_lexer()\nPrompts the user to select a lexer from a filtered list for the current\nbuffer.
+select_indented_block _M.textadept.editing.select_indented_block()\nSelects indented blocks intelligently.\nIf no block of text is selected, all text with the current level of\nindentation is selected. If a block of text is selected and the lines\nimmediately above and below it are one indentation level lower, they are\nadded to the selection. In all other cases, the behavior is the same as if no\ntext is selected.
+select_lexer _M.textadept.mime_types.select_lexer()\nPrompts the user to select a lexer from a filtered list for the current\nbuffer.\n@see buffer.set_lexer
 select_line _M.textadept.editing.select_line()\nSelects the current line.
-select_paragraph _M.textadept.editing.select_paragraph()\nSelects the current paragraph.\nParagraphs are delimited by two or more consecutive newlines.
-select_theme gui.select_theme()\nPrompts the user to select an editor theme from a filtered list.
-select_word _M.textadept.editing.select_word()\nSelects the current word under the caret.
+select_paragraph _M.textadept.editing.select_paragraph()\nSelects the current paragraph.\nParagraphs are surrounded by one or more blank lines.
+select_theme gui.select_theme()\nPrompts the user to select an editor theme from a filtered list dialog.\nThemes in the `_HOME/themes/` and `_USERHOME/themes/` directories are listed.
+select_word _M.textadept.editing.select_word()\nSelects the current word under the caret.\n@see buffer.word_chars
 selection_duplicate buffer.selection_duplicate(buffer)\nDuplicate the selection.\nIf selection empty duplicate the line containing the caret.\n@param buffer The global buffer.
 selection_empty buffer.selection_empty (bool, Read-only)\nIs every selected range empty?
 selection_end buffer.selection_end (number)\nThe position that ends the selection - this becomes the current position.\nThis does not make the caret visible.
@@ -1441,16 +1442,16 @@ selection_n_start buffer.selection_n_start (table)\nTable of positions that star
 selection_start buffer.selection_start (number)\nThe position that starts the selection - this becomes the anchor.\nThis does not make the caret visible.
 selections buffer.selections (number, Read-only)\nThe number of selections currently active.
 self _M.textadept.adeptsense.syntax.self (table)\nThe language's syntax-equivalent of `self`. Default is `'self'`.
-sense _M.cpp.sense\nThe C/C++ Adeptsense.
-sense _M.css.sense\nThe CSS Adeptsense.
-sense _M.hypertext.sense\nThe HTML Adeptsense.
-sense _M.java.sense\nThe Java Adeptsense.
-sense _M.lua.sense\nThe Lua Adeptsense.
-sense _M.php.sense\nThe PHP Adeptsense.
-sense _M.rails.sense\nThe Rails Adeptsense.
-sense _M.rhtml.sense\nThe RHTML Adeptsense.
-sense _M.ruby.sense\nThe Ruby Adeptsense.
-session _M.textadept.session (module)\nSession support for the textadept module.
+sense _M.cpp.sense\nThe C/C++ Adeptsense.\n  It loads user tags from `_USERHOME/modules/cpp/tags` and user apidocs from\n  `_USERHOME/modules/cpp/api`.
+sense _M.css.sense\nThe CSS Adeptsense.\n  It loads user tags from `_USERHOME/modules/css/tags` and user apidocs from\n  `_USERHOME/modules/css/api`.
+sense _M.hypertext.sense\nThe HTML Adeptsense.\n  It loads user tags from `_USERHOME/modules/hypertext/tags` and user apidocs\n  from `_USERHOME/modules/hypertext/api`.
+sense _M.java.sense\nThe Java Adeptsense.\n  It loads user tags from `_USERHOME/modules/java/tags` and user apidocs from\n  `_USERHOME/modules/java/api`.
+sense _M.lua.sense\nThe Lua Adeptsense.\n  It loads user tags from `_USERHOME/modules/lua/tags` and user apidocs from\n  `_USERHOME/modules/lua/api`.
+sense _M.php.sense\nThe PHP Adeptsense.\n  It loads user tags from `_USERHOME/modules/php/tags` and user apidocs from\n  `_USERHOME/modules/php/api`.
+sense _M.rails.sense\nThe Rails Adeptsense.\n  It loads user tags from `_USERHOME/modules/rails/tags` and user apidocs\n  from `_USERHOME/modules/rails/api`.
+sense _M.rhtml.sense\nThe RHTML Adeptsense.\n  It loads user tags from `_USERHOME/modules/rhtml/tags` and user apidocs\n  from `_USERHOME/modules/rhtml/api`.
+sense _M.ruby.sense\nThe Ruby Adeptsense.\n  It loads user tags from `_USERHOME/modules/ruby/tags` and user apidocs from\n  `_USERHOME/modules/ruby/api`.
+session _M.textadept.session (module)\nSession support for Textadept.
 set_buffer_properties _M.cpp.set_buffer_properties()\nSets default buffer properties for C/C++ files.
 set_buffer_properties _M.css.set_buffer_properties()\nSets default buffer properties for CSS files.
 set_buffer_properties _M.hypertext.set_buffer_properties()\nSets default buffer properties for HTML files.
@@ -1459,16 +1460,16 @@ set_buffer_properties _M.lua.set_buffer_properties()\nSets default buffer proper
 set_buffer_properties _M.php.set_buffer_properties()\nSets default buffer properties for PHP files.
 set_buffer_properties _M.ruby.set_buffer_properties()\nSets default buffer properties for Ruby files.
 set_chars_default buffer.set_chars_default(buffer)\nReset the set of characters for whitespace and word characters to the\ndefaults.\nThis sets whitespace to space, tab and other characters with codes less than\n`0x20`, with word characters set to alphanumeric and `'_'`.\n@param buffer The global buffer.
-set_contextmenu _M.textadept.menu.set_contextmenu(menu_table)\nSets `gui.context_menu` from the given menu table.\n@param menu_table The menu table to create the context menu from. Each table\n  entry is either a submenu or menu text and a function or action table.\n@see set_menubar
+set_contextmenu _M.textadept.menu.set_contextmenu(menu_table)\nSets `gui.context_menu` from the given menu table.\n@param menu_table The menu table to create the context menu from. The menu is\n  an ordered list of menu entries and, if applicable, has a `title` key for\n  the submenu title. Menu entries are either submenus of the same form as\n  menus, or tables containing menu text and either a function to call or a\n  table containing the function to call with its parameters.\n@see gui.context_menu\n@see gui.menu
 set_empty_selection buffer.set_empty_selection(buffer, pos)\nSet caret to a position, while removing any existing selection.\nThe caret is not scrolled into view.\n@param buffer The buffer\n@param pos The position to move to.
-set_encoding buffer.set_encoding(buffer, encoding)\nSets the encoding for the buffer, converting its contents in the process.\n@param buffer The global buffer.\n@param encoding The encoding to set. Valid encodings are ones that GTK's\n  `g_convert()` function accepts (typically GNU iconv's encodings).\n@usage buffer.set_encoding(buffer, 'ASCII')
+set_encoding buffer.set_encoding(buffer, encoding)\nSets the encoding for the buffer, converting its contents in the process.\n@param buffer The global buffer.\n@param encoding The encoding to set. Valid encodings are ones that GNU iconv\n  accepts.\n@usage buffer.set_encoding(buffer, 'ASCII')
 set_fold_margin_colour buffer.set_fold_margin_colour(buffer, use_setting, color)\nSet the colors used as a chequerboard pattern in the fold margin.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
 set_fold_margin_hi_colour buffer.set_fold_margin_hi_colour(buffer, use_setting, color)\nSet the colors used as a checkerboard pattern in the fold margin.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
 set_hotspot_active_back buffer.set_hotspot_active_back(buffer, use_setting, color)\nSet a back color for active hotspots.\n@param buffer The global buffer.\n@param use_setting Enable the color change.\n@param color A color in `0xBBGGRR` format.
 set_hotspot_active_fore buffer.set_hotspot_active_fore(buffer, use_setting, color)\nSet a fore color for active hotspots.\n@param buffer The global buffer.\n@param use_setting Enable the color change.\n@param color A color in `0xBBGGRR` format.
 set_length_for_encode buffer.set_length_for_encode(buffer, bytes)\nSet the length of the utf8 argument for calling `buffer:encoded_from_utf8()`.\n@param buffer The global buffer.\n@param bytes Bytes or `-1` for measuring to first NUL.
 set_lexer buffer.set_lexer(buffer, lang)\nReplacement for `buffer.lexer_language =`.\nSets a `buffer._lexer` field so it can be restored without querying the\nmime-types tables. Also if the user manually sets the lexer, it should be\nrestored.\nLoads the language-specific module if it exists.\nThis function is added by `_M.textadept.mime_types`.\n@param buffer The global buffer.\n@param lang The string language to set.\n@usage buffer.set_lexer(buffer, 'language_name')
-set_menubar _M.textadept.menu.set_menubar(menubar)\nSets `gui.menubar` from the given table of menus.\n@param menubar The table of menus to create the menubar from.\n@see gui.menu\n@see rebuild_command_tables
+set_menubar _M.textadept.menu.set_menubar(menubar)\nSets `gui.menubar` from the given table of menus.\n@param menubar The table of menus to create the menubar from. Each menu is\n  an ordered list of menu entries and has a `title` key for the menu/submenu\n  title. Menu entries are either submenus of the same form as menus, or\n  tables containing menu text and either a function to call or a table\n  containing the function to call with its parameters.\n@see gui.menubar\n@see gui.menu
 set_save_point buffer.set_save_point(buffer)\nRemember the current position in the undo history as the position at which\nthe document was saved.\n@param buffer The global buffer.
 set_sel buffer.set_sel(buffer, start_pos, end_pos)\nSelect a range of text.\nThe caret is scrolled into view after this operation.\n@param buffer The global buffer.\n@param start_pos Start position. If negative, it means the end of the\n  document.\n@param end_pos End position. If negative, it means remove any selection (i.e.\n  set the `anchor` to the same position as `current_pos`).
 set_sel_back buffer.set_sel_back(buffer, use_setting, color)\nSet the background color of the main and additional selections and whether to\nuse this setting.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
@@ -1476,7 +1477,7 @@ set_sel_fore buffer.set_sel_fore(buffer, use_setting, color)\nSet the foreground
 set_selection buffer.set_selection(buffer, caret, anchor)\nSet a simple selection from anchor to caret.\n@param buffer The global buffer.\n@param caret The caret.\n@param anchor The anchor.
 set_styling buffer.set_styling(buffer, length, style)\nChange style from current styling position for length characters to a style\nand move the current styling position to after this newly styled segment.\n@param buffer The global buffer.\n@param length The length to style.\n@param style The style number to set.
 set_text buffer.set_text(buffer, text)\nReplace the contents of the document with the argument text.\n@param buffer The global buffer.\n@param text The text.
-set_theme gui.set_theme(name)\nSets the editor theme from the given name.\nThemes in `_USERHOME/themes/` are checked first, followed by `_HOME/themes/`.\nIf the name contains slashes ('/' on Linux and Mac OSX and '\' on Win32), it\nis assumed to be an absolute path so `_USERHOME` and `_HOME` are not checked.\nThrows an error if the theme is not found. Any errors in the theme are\nprinted to `io.stderr`.\n@param name The name or absolute path of a theme. If nil, sets the default\n  theme.
+set_theme gui.set_theme(name)\nSets the editor theme from the given name.\nThemes with the given name in the `_USERHOME/themes/` directory override\nthemes of the same name in `_HOME/themes/`. If the name contains slashes (`\`\non Windows, `/` otherwise), it is assumed to be an absolute path to a theme\ninstead of a theme name. An error is thrown if the theme is not found. Any\nerrors in the theme are printed to `io.stderr`.\n@param name The name or absolute path of a theme. If nil, sets the default\n  theme.
 set_visible_policy buffer.set_visible_policy(buffer, visible_policy, visible_slop)\nSet the way the display area is determined when a particular line is to be\nmoved to by `buffer:goto_line()`, etc.\nIt is similar in operation to `buffer:set_y_caret_policy()`.\n@param buffer The global buffer.\n@param visible_policy A combination of `_SCINTILLA.constants.VISIBLE_SLOP`,\n  (0x01) and `_SCINTILLA.constants.VISIBLE_STRICT` (0x04).\n@param visible_slop The slop value.
 set_whitespace_back buffer.set_whitespace_back(buffer, use_setting, color)\nSet the background color of all whitespace and whether to use this setting.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
 set_whitespace_fore buffer.set_whitespace_fore(buffer, use_setting, color)\nSet the foreground color of all whitespace and whether to use this setting.\n@param buffer The global buffer.\n@param use_setting Enable color change.\n@param color A color in `0xBBGGRR` format.
@@ -1492,21 +1493,21 @@ setmode lfs.setmode(file, mode)\nSets the writing mode for a file. The mode stri
 setupvalue debug.setupvalue(f, up, value)\nThis function assigns the value `value` to the upvalue with index `up`\nof the function `f`. The function returns nil if there is no upvalue with the\ngiven index. Otherwise, it returns the name of the upvalue.
 setuservalue debug.setuservalue(udata, value)\nSets the given `value` as the Lua value associated to the given `udata`.\n`value` must be a table or nil; `udata` must be a full userdata.\n\nReturns `udata`.
 setvbuf file:setvbuf(mode [, size])\nSets the buffering mode for an output file. There are three available\nmodes:\n  "no": no buffering; the result of any output operation appears immediately.\n  "full": full buffering; output operation is performed only when the\n          buffer is full or when you explicitly `flush` the file (see\n          `io.flush`).\n  "line": line buffering; output is buffered until a newline is output or\n          there is any input from some special files (such as a terminal\n          device).\n\nFor the last two cases, `size` specifies the size of the buffer, in\nbytes. The default is an appropriate size.
-shebangs _M.textadept.mime_types.shebangs (table)\nShebang words and their associated lexers.
+shebangs _M.textadept.mime_types.shebangs (table)\nTable of shebang words and their associated lexers.\nIf the file has a shebang line, a line that starts with `#!` and is the first\nline in the file, each shebang word is matched against that line.
 show_apidoc _M.textadept.adeptsense.show_apidoc(sense)\nShows a calltip with API documentation for the symbol behind the caret.\nIf documentation is already being shown, cycles through multiple definitions.\n@param sense The Adeptsense returned by `adeptsense.new()`. If `nil`, uses\n  the current language's Adeptsense (if it exists).\n@return list of api docs on success or `nil`.\n@see get_symbol\n@see get_apidoc
-show_completions gui.command_entry.show_completions(completions)\nShows the given list of completions for the current word prefix.\nOn selection, the current word prefix is replaced with the completion.\n@param completions The table of completions to show. Non-string values are\n  ignored.
+show_completions gui.command_entry.show_completions(completions)\nShows the given list of completions for the current word prefix.\nOn selection, the current word prefix is replaced with the completion. Word\nprefix characters are alphanumerics and underscores.\n@param completions The table of completions to show. Non-string values are\n  ignored.
 show_lines buffer.show_lines(buffer, start_line, end_line)\nMake a range of lines visible.\nThis has no effect on fold levels or fold flags. `start_line` can not be\nhidden.\n@param buffer The global buffer.\n@param start_line The start line.\n@param end_line The end line.
 sin math.sin(x)\nReturns the sine of `x` (assumed to be in radians).
-singular _M.rails.singular\nA map of plural controller names to their singulars. Add key-value pairs to\nthis if singularize() is incorrectly converting your plural\ncontroller name to its singular model name.
+singular _M.rails.singular\nA map of plural controller names to their singulars. Add key-value pairs to\n  this if the local function `singularize()` is incorrectly converting your\n  plural controller name to its singular model name.
 sinh math.sinh(x)\nReturns the hyperbolic sine of `x`.
-size gui.size (table)\nThe size of the Textadept window (`{ width, height }`).
+size gui.size (table)\nA table containing the width and height values of the Textadept window.
 size view.size (number)\nThe position of the split resizer (if this view is part of a split view).
-snapopen _M.textadept.snapopen (module)\nSnapopen for the textadept module.
-snippets _G.snippets (table)\nProvides access to snippets from `_G`.
-snippets _M.textadept.snippets (module)\nProvides Lua-style snippets for Textadept.
+snapopen _M.textadept.snapopen (module)\nQuickly open files in a set of directories using a filtered list dialog.
+snippets _G.snippets (table)\nTable of snippet triggers with their snippet text.\nLanguage-specific snippets are in another table value whose key is the\nlanguage's lexer name.\nThis table also contains the `_M.textadept.snippets` module.
+snippets _M.textadept.snippets (module)\nSnippets for Textadept.
 sort table.sort(list [, comp])\nSorts list elements in a given order, *in-place*, from `list[1]` to\n`list[#list]`. If `comp` is given, then it must be a function that receives\ntwo list elements and returns true when the first element must come before\nthe second in the final order (so that `not comp(list[i+1],list[i])` will be\ntrue after the sort). If `comp` is not given, then the standard Lua operator\n`<` is used instead.\n\nThe sort algorithm is not stable; that is, elements considered equal by the\ngiven order may have their relative positions changed by the sort.
-space lexer.space\nMatches any whitespace character (`\t`, `\v`, `\f`, `\\n`, `\r`, space).
-split view:split(vertical)\nSplits the indexed view vertically or horizontally and focuses the new view.\n@param vertical Flag indicating a vertical split. The default value is\n  `false` for horizontal.\n@return old view and new view tables.
+space lexer.space\nMatches any whitespace character (`\t`, `\v`, `\f`, `\n`, `\r`, space).
+split view.split(view, vertical)\nSplits the given view vertically or horizontally and focuses the new view.\nEmits a `VIEW_NEW` event.\n@param view The view to split.\n@param vertical Flag indicating a vertical split. The default value is\n  `false` for horizontal.\n@return old view and new view.\n@see events.VIEW_NEW
 sqrt math.sqrt(x)\nReturns the square root of `x`. (You can also use the expression `x^0.5`\nto compute this value.)
 start_record buffer.start_record(buffer)\nStart notifying the container of all key presses and commands.\n@param buffer The global buffer.
 start_styling buffer.start_styling(buffer, position, mask)\nSet the current styling position to pos and the styling mask to mask.\nThe styling mask can be used to protect some bits in each styling byte from\nmodification.\n@param buffer The global buffer.\n@param position The styling position.\n@param mask The bit mask of the style bytes that can be set.
@@ -1523,7 +1524,7 @@ stuttered_page_down buffer.stuttered_page_down(buffer)\nMove caret to bottom of
 stuttered_page_down_extend buffer.stuttered_page_down_extend(buffer)\nMove caret to bottom of page, or one page down if already at bottom of page,\nextending selection to new caret position.\n@param buffer The global buffer.
 stuttered_page_up buffer.stuttered_page_up(buffer)\nMove caret to top of page, or one page up if already at top of page.\n@param buffer The global buffer.
 stuttered_page_up_extend buffer.stuttered_page_up_extend(buffer)\nMove caret to top of page, or one page up if already at top of page,\nextending selection to new caret position.\n@param buffer The global buffer.
-style lexer.style(style_table)\nCreates a Scintilla style from a table of style properties.\n@param style_table A table of style properties.\nStyle properties available:\n    * font [string]\n    * size [integer]\n    * bold [boolean]\n    * italic [boolean]\n    * underline [boolean]\n    * fore [integer] (Use value returned by [`color()`](#color))\n    * back [integer] (Use value returned by [`color()`](#color))\n    * eolfilled [boolean]\n    * characterset [?]\n    * case [integer]\n    * visible [boolean]\n    * changeable [boolean]\n    * hotspot [boolean]\n@usage local bold_italic = style { bold = true, italic = true }\n@see color
+style lexer.style(style_table)\nCreates a Scintilla style from a table of style properties.\n@param style_table A table of style properties.\nStyle properties available:\n    * font [string]\n    * size [integer]\n    * bold [boolean]\n    * italic [boolean]\n    * underline [boolean]\n    * fore [integer] (Use value returned by `color()`)\n    * back [integer] (Use value returned by `color()`)\n    * eolfilled [boolean]\n    * characterset [?]\n    * case [integer]\n    * visible [boolean]\n    * changeable [boolean]\n    * hotspot [boolean]\n@usage local bold_italic = style { bold = true, italic = true }\n@see color
 style_at buffer.style_at (table, Read-only)\nTable of style bytes at positions in the document starting at zero.
 style_back buffer.style_back (table)\nTable of background colors in `0xBBGGRR` format for styles from `0` to\n`255`.
 style_bits buffer.style_bits (number)\nThe number of bits in style bytes used to hold the lexical state.
@@ -1567,7 +1568,7 @@ style_whitespace lexer.style_whitespace\nStyle typically used for whitespace.
 sub string.sub(s, i [, j])\nReturns the substring of `s` that starts at `i` and continues until\n`j`; `i` and `j` can be negative. If `j` is absent, then it is assumed to\nbe equal to -1 (which is the same as the string length). In particular,\nthe call `string.sub(s,1,j)` returns a prefix of `s` with length `j`, and\n`string.sub(s, -i)` returns a suffix of `s` with length `i`.\n\nIf, after the translation of negative indices, `i` is less than 1, it is\ncorrected to 1. If `j` is greater than the string length, it is corrected to\nthat length. If, after these corrections, `i` is greater than `j`, the\nfunction returns the empty string.
 swap_main_anchor_caret buffer.swap_main_anchor_caret(buffer)\nSwap that caret and anchor of the main selection.\n@param buffer The global buffer.
 switch_buffer gui.switch_buffer()\nDisplays a dialog with a list of buffers to switch to and switches to the\nselected one, if any.
-symbol_chars _M.textadept.adeptsense.syntax.symbol_chars (table)\nA Lua pattern of characters allowed in a symbol,\n  including member operators. The pattern should be a character set. The\n  default is `'[%w_%.]'`.
+symbol_chars _M.textadept.adeptsense.syntax.symbol_chars (table)\nA Lua pattern of characters allowed in a symbol,\n  including member operators. The pattern should be a character set.\n  The default is `'[%w_%.]'`.
 symlinkattributes lfs.symlinkattributes(filepath [, aname])\nIdentical to lfs.attributes except that it obtains information about the link\nitself (not the file it refers to). This function is not available in Windows\nso you may want to make sure that lfs.symlinkattributes exists before using\nit.
 syntax _M.textadept.adeptsense.syntax (table)\nContains syntax-specific values for the language.\n@see get_class
 tab buffer.tab(buffer)\nIf selection is empty or all on one line replace the selection with a tab\ncharacter, or if more than one line selected, indent the lines.\n@param buffer The global buffer.
@@ -1587,12 +1588,12 @@ text_range buffer.text_range(buffer, start_pos, end_pos)\nGets a range of text f
 text_width buffer.text_width(buffer, style_num, text)\nMeasure the pixel width of some text in a particular style.\nDoes not handle tab or control characters.\n@param buffer The global buffer.\n@param style_num The style number between `0` and `255`.\n@param text The text.\n@return number
 textadept _M.textadept (module)\nThe textadept module.\nIt provides utilities for editing text in Textadept.
 time os.time([table])\nReturns the current time when called without arguments, or a time\nrepresenting the date and time specified by the given table. This table\nmust have fields `year`, `month`, and `day`, and may have fields `hour`\n(default is 12), `min` (default is 0), `sec` (default is 0), and `isdst`\n(default is nil). For a description of these fields, see the `os.date`\nfunction.\n\nThe returned value is a number, whose meaning depends on your system. In\nPOSIX, Windows, and some other systems, this number counts the number of\nseconds since some given start time (the "epoch"). In other systems, the\nmeaning is not specified, and the number returned by `time` can be used only\nas an argument to `os.date` and `os.difftime`.
-timeout _G.timeout(interval, f, ...)\nCalls a given function after an interval of time.\nTo repeatedly call the function, return true inside the function. A `nil` or\n`false` return value stops repetition.\n@param interval The interval in seconds to call the function after.\n@param f The function to call.\n@param ... Additional arguments to pass to `f`.
+timeout _G.timeout(interval, f, ...)\nCalls a given function after an interval of time.\nTo repeatedly call the function, return `true` inside the function. A `nil`\nor `false` return value stops repetition.\n@param interval The interval in seconds to call the function after.\n@param f The function to call.\n@param ... Additional arguments to pass to `f`.
 title gui.title (string, Write-only)\nThe title of the Textadept window.
 tmpfile io.tmpfile()\nReturns a handle for a temporary file. This file is opened in update\nmode and it is automatically removed when the program ends.
 tmpname os.tmpname()\nReturns a string with a file name that can be used for a temporary\nfile. The file must be explicitly opened before its use and explicitly\nremoved when no longer needed.\n\nOn POSIX systems, this function also creates a file with that name, to avoid\nsecurity risks. (Someone else might create the file with wrong permissions in\nthe time between getting the name and creating the file.) You still have to\nopen the file to use it and to remove it (even if you do not use it).\n\nWhen possible, you may prefer to use `io.tmpfile`, which automatically\nremoves the file when the program ends.
 toggle _M.textadept.bookmarks.toggle(on)\nToggles a bookmark on the current line.\n@param on If `true`, adds a bookmark to the current line. If `false`, removes\n  the bookmark on the current line. Otherwise, toggles a bookmark.
-toggle_block _M.ruby.toggle_block()\nToggles between { ... } and do ... end Ruby blocks.\nIf the caret is inside a { ... } single-line block, that block is converted\nto a multiple-line do .. end block. If the caret is on a line that contains\nsingle-line do ... end block, that block is converted to a single-line\n{ ... } block. If the caret is inside a multiple-line do ... end block, that\nblock is converted to a single-line { ... } block with all newlines replaced\nby a space. Indentation is important. The 'do' and 'end' keywords must be on\nlines with the same level of indentation to toggle correctly
+toggle_block _M.ruby.toggle_block()\nToggles between `{ ... }` and `do ... end` Ruby blocks.\nIf the caret is inside a `{ ... }` single-line block, that block is converted\nto a multiple-line `do .. end` block. If the caret is on a line that contains\nsingle-line `do ... end` block, that block is converted to a single-line\n`{ ... }` block. If the caret is inside a multiple-line `do ... end` block,\nthat block is converted to a single-line `{ ... }` block with all newlines\nreplaced by a space. Indentation is important. The `do` and `end` keywords\nmust be on lines with the same level of indentation to toggle correctly.
 toggle_caret_sticky buffer.toggle_caret_sticky(buffer)\nSwitch between sticky and non-sticky: meant to be bound to a key.\nSee `buffer.caret_sticky`.\n@param buffer The global buffer.
 toggle_fold buffer.toggle_fold(buffer, line)\nSwitch a header line between expanded and contracted.\n@param buffer The global buffer.\n@param line The line number.
 token lexer.token(name, patt)\nCreates an LPeg capture table index with the name and position of the token.\n@param name The name of token. If this name is not in `l.tokens` then you\n  will have to specify a style for it in `lexer._tokenstyles`.\n@param patt The LPeg pattern associated with the token.\n@usage local ws = token(l.WHITESPACE, l.space^1)\n@usage php_start_rule = token('php_tag', '<?' * ('php' * l.space)^-1)
@@ -1601,21 +1602,21 @@ tostring _G.tostring(v)\nReceives a value of any type and converts it to a strin
 touch lfs.touch(filepath [, atime [, mtime]])\nSet access and modification times of a file. This function is a bind to utime\nfunction. The first argument is the filename, the second argument (atime) is\nthe access time, and the third argument (mtime) is the modification time.\nBoth times are provided in seconds (which should be generated with Lua\nstandard function os.time). If the modification time is omitted, the access\ntime provided is used; if both times are omitted, the current time is used.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string.
 traceback debug.traceback([thread, ] [message] [, level])\nIf `message` is present but is neither a string nor nil, this function\nreturns `message` without further processing. Otherwise, it returns a string\nwith a traceback of the call stack. An optional `message` string is appended\nat the beginning of the traceback. An optional `level` number tells at which\nlevel to start the traceback (default is 1, the function calling\n`traceback`).
 transpose_chars _M.textadept.editing.transpose_chars()\nTransposes characters intelligently.\nIf the caret is at the end of a line, the two characters before the caret are\ntransposed. Otherwise, the characters to the left and right are.
-try_encodings io.try_encodings (table)\nList of encodings to try to decode files as after UTF-8.
-try_to_autocomplete_end _M.lua.try_to_autocomplete_end()\nTries to autocomplete Lua's 'end' keyword for control structures like 'if',\n'while', 'for', etc.\n@see control_structure_patterns
-try_to_autocomplete_end _M.ruby.try_to_autocomplete_end()\nTries to autocomplete Ruby's 'end' keyword for control structures like 'if',\n'while', 'for', etc.\n@see control_structure_patterns
+try_encodings io.try_encodings (table)\nList of encodings to try to decode files as.\nYou should add to this list if you get a "Conversion failed" error when\ntrying to open a file whose encoding is not recognized. Valid encodings are\nGNU iconv's encodings.
+try_to_autocomplete_end _M.lua.try_to_autocomplete_end()\nTries to autocomplete Lua's `end` keyword for control structures like `if`,\n`while`, `for`, etc.\n@see control_structure_patterns
+try_to_autocomplete_end _M.ruby.try_to_autocomplete_end()\nTries to autocomplete Ruby's `end` keyword for control structures like `if`,\n`while`, `for`, etc.\n@see control_structure_patterns
 two_phase_draw buffer.two_phase_draw (bool)\nTwo phase drawing mode.\nWhen `true`, drawing is performed in two phases, first the background and\nthen the foreground. This avoids chopping off characters that overlap the\nnext run. The default is for drawing to be two phase.
 type _G.type(v)\nReturns the type of its only argument, coded as a string. The possible\nresults of this function are "\n`nil`" (a string, not the value nil), "`number`", "`string`", "`boolean`",\n"`table`", "`function`", "`thread`", and "`userdata`".
 type io.type(obj)\nChecks whether `obj` is a valid file handle. Returns the string `"file"`\nif `obj` is an open file handle, `"closed file"` if `obj` is a closed file\nhandle, or nil if `obj` is not a file handle.
 type lpeg.type(value)\nIf the given value is a pattern, returns the string "pattern". Otherwise\nreturns nil.
 type_assignments _M.textadept.adeptsense.syntax.type_assignments (table)\nA map of Lua patterns to class types for variable\n  assignments. This is typically used for dynamically typed languages. For\n  example, `sense.type_assignments['^"'] = 'string'`  would recognize string\n  assignments in Lua so the `foo` in `foo = "bar"` would be recognized as\n  type `string`. The class type value can contain pattern captures.
-type_declarations _M.textadept.adeptsense.syntax.type_declarations (table)\nA list of Lua patterns used for determining the\n  class type of a symbol. The first capture returned must be the class name.\n  Use `%_` to match the symbol. The default value is `'(%u[%w_%.]+)%s+%_'`.
-type_declarations_exclude _M.textadept.adeptsense.syntax.type_declarations_exclude (table)\nA table of types to exclude, even if they\n  match a type_declaration pattern. Each excluded type is a table key and has\n  a `true` boolean value. For example, `{ Foo = true }` excludes any type\n  whose name is `Foo`. The default value is `{}`.
+type_declarations _M.textadept.adeptsense.syntax.type_declarations (table)\nA list of Lua patterns used for determining the\n  class type of a symbol. The first capture returned must be the class name.\n  Use `%_` to match the symbol.\n  The default value is `'(%u[%w_%.]+)%s+%_'`.
+type_declarations_exclude _M.textadept.adeptsense.syntax.type_declarations_exclude (table)\nA table of types to exclude, even if they\n  match a type_declaration pattern. Each excluded type is a table key and has\n  a `true` boolean value. For example, `{ Foo = true }` excludes any type\n  whose name is `Foo`.\n  The default value is `{}`.
 undo buffer.undo(buffer)\nUndo one action in the undo history.\n@param buffer The global buffer.
 undo_collection buffer.undo_collection (bool)\nWhether to collect undo information.\nWhen stopping collection, use `buffer:empty_undo_buffer()` to avoid the\nundo buffer being unsynchronized with the data in the buffer.
 unlock lfs.unlock(filehandle[, start[, length]])\nUnlocks a file or a part of it. This function works on open files; the file\nhandle should be specified as the first argument. The optional arguments\nstart and length can be used to specify a starting point and its length; both\nshould be numbers.\n\nReturns true if the operation was successful; in case of error, it returns\nnil plus an error string.
 unpack table.unpack(list [, i [, j]])\nReturns the elements from the given table. This function is equivalent to\n\n  return list[i], list[i+1], ···, list[j]\n\nBy default, `i` is 1 and `j` is `#list`.
-unsplit view:unsplit()\nUnsplits the indexed view if possible.\n@return boolean if the view was unsplit or not.
+unsplit view.unsplit(view)\nUnsplits the given view if possible.\n@param view The view to unsplit.\n@return boolean if the view was unsplit or not.
 upper lexer.upper\nMatches any uppercase character (`A-Z`).
 upper string.upper(s)\nReceives a string and returns a copy of this string with all lowercase\nletters changed to uppercase. All other characters are left unchanged. The\ndefinition of what a lowercase letter is depends on the current locale.
 upper_case buffer.upper_case(buffer)\nTransform the selection to upper case.\n@param buffer The global buffer.
@@ -1634,7 +1635,8 @@ vc_home_wrap buffer.vc_home_wrap(buffer)\nMove caret to before first visible cha
 vc_home_wrap_extend buffer.vc_home_wrap_extend(buffer)\nLike `buffer:vc_home_wrap()` but extending selection to new caret position.\n@param buffer The global buffer.
 version lpeg.version()\nReturns a string with the running version of LPeg.
 vertical_centre_caret buffer.vertical_centre_caret(buffer)\nCenter current line in window.\n@param buffer The global buffer.
-view _G.view (module)\nThe currently focused view.\nIt also represents the structure of any view table in `_G._VIEWS`.
+view _G.view (module)\nA Textadept view object.
+view _G.view\nThe currently focused view.
 view_eol buffer.view_eol (bool)\nWhether the end of line characters are visible.\nNormally, the end of line characters are hidden.
 view_ws buffer.view_ws (number)\nThe visibility of white space characters.\n\n* `_SCINTILLA.constants.SCWS_INVISIBLE` (0)\n  The normal display mode with white space displayed as an empty background\n  color.\n* `_SCINTILLA.constants.SCWS_VISIBLEALWAYS` (1)\n  White space characters are drawn as dots and arrows.\n* `_SCINTILLA.constants.SCWS_VISIBLEAFTERINDENT` (2)\n  White space used for indentation is displayed normally but after the\n  first visible character, it is shown as dots and arrows.
 virtual_space_options buffer.virtual_space_options (number)\nVirtual space options.\n\n* `_SCINTILLA.constants.SCVS_NONE` (0)\n  Disables all use of virtual space (default).\n* `_SCINTILLA.constants.SCVS_RECTANGULARSELECTION` (1)\n  Enabled only for rectangular selections.\n* `_SCINTILLA.constants.SCVS_USERACCESSIBLE` (2)\n  Enabled.
@@ -1644,7 +1646,7 @@ whitespace_size buffer.whitespace_size (number)\nThe size of the dots used to ma
 whole_word gui.find.whole_word (bool)\nOnly whole-word matches are allowed in searches.
 whole_word_label_text gui.find.whole_word_label_text (string, Write-only)\nThe text of the 'Whole word' label.\nThis is primarily used for localization.
 word lexer.word\nMatches a typical word starting with a letter or underscore and then any\n  alphanumeric or underscore characters.
-word_chars _M.textadept.adeptsense.syntax.word_chars (table)\nA Lua pattern of characters allowed in a word. The default\n  is `'%w_'`.
+word_chars _M.textadept.adeptsense.syntax.word_chars (table)\nA Lua pattern of characters allowed in a word.\n  The default is `'%w_'`.
 word_chars buffer.word_chars (string)\nThe set of characters making up words when moving or selecting by word.
 word_end_position buffer.word_end_position(buffer, pos, only_word_chars)\nGet position of end of word.\n@param buffer The global buffer.\n@param pos The position.\n@param only_word_chars If `true`, stops searching at the first non-word\n  character in the search direction. Otherwise, the first character in the\n  search direction sets the type of the search as word or non-word and the\n  search stops at the first non-matching character. Searches are also\n  terminated by the start or end of the document.
 word_left buffer.word_left(buffer)\nMove caret left one word.\n@param buffer The global buffer.
diff --git a/modules/lua/init.lua b/modules/lua/init.lua
index 32dd5742..7d00a030 100644
--- a/modules/lua/init.lua
+++ b/modules/lua/init.lua
@@ -6,15 +6,14 @@ local M = {}
 ---
 -- The lua module.
 -- It provides utilities for editing Lua code.
--- User tags are loaded from `_USERHOME/modules/lua/tags` and user apis are
--- loaded from `_USERHOME/modules/lua/api`.
 --
--- ## Key Commands
+-- ## Key Bindings
 --
--- + `Ctrl+L, M` (`⌘L, M` on Mac OSX)
+-- + `Ctrl+L, M` (`⌘L, M` on Mac OSX | `M-L, M` in ncurses)
 --   Open this module for editing.
--- + `Shift+Return` (`⇧↩`)
---   Try to autocomplete an `if`, `for`, etc. statement with `end`.
+-- + `Shift+Enter` (`⇧↩` | `S-Enter`)
+--   Try to autocomplete an `if`, `while`, `for`, etc. control structures with
+--   `end`.
 -- + `.`
 --   When to the right of a known symbol, show an autocompletion list of fields
 --   and functions.
@@ -23,12 +22,15 @@ local M = {}
 --   functions only.
 -- @field sense
 --   The Lua [Adeptsense](_M.textadept.adeptsense.html).
+--   It loads user tags from `_USERHOME/modules/lua/tags` and user apidocs from
+--   `_USERHOME/modules/lua/api`.
 module('_M.lua')]]
 
 local m_editing, m_run = _M.textadept.editing, _M.textadept.run
 -- Comment string tables use lexer names.
 m_editing.comment_string.lua = '--'
 -- Compile and Run command tables use file extensions.
+m_run.compile_command.lua = 'luac %(filename)'
 m_run.run_command.lua = 'lua %(filename)'
 m_run.error_detail.lua = {
   pattern = '^lua: (.-):(%d+): (.+)$',
@@ -60,8 +62,9 @@ M.sense:add_trigger('.')
 M.sense:add_trigger(':', false, true)
 
 -- script/update_doc generates a fake set of ctags used for autocompletion.
+local as = _M.textadept.adeptsense
 M.sense.ctags_kinds = {
-  f = 'functions', F = 'fields', m = 'classes', t = 'fields'
+  f = as.FUNCTION, F = as.FIELD, m = as.CLASS, t = as.FIELD
 }
 M.sense:load_ctags(_HOME..'/modules/lua/tags', true)
 
@@ -93,7 +96,7 @@ end
 -- Commands.
 
 ---
--- Patterns for auto 'end' completion for control structures.
+-- Patterns for auto `end` completion for control structures.
 -- @class table
 -- @name control_structure_patterns
 -- @see try_to_autocomplete_end
@@ -103,8 +106,8 @@ local control_structure_patterns = {
 }
 
 ---
--- Tries to autocomplete Lua's 'end' keyword for control structures like 'if',
--- 'while', 'for', etc.
+-- Tries to autocomplete Lua's `end` keyword for control structures like `if`,
+-- `while`, `for`, etc.
 -- @see control_structure_patterns
 -- @name try_to_autocomplete_end
 function M.try_to_autocomplete_end()
@@ -146,7 +149,7 @@ events.connect(events.FILE_AFTER_SAVE, function()
 end)
 
 ---
--- Container for Lua-specific key commands.
+-- Container for Lua-specific key bindings.
 -- @class table
 -- @name _G.keys.lua
 keys.lua = {
diff --git a/modules/lua/tags b/modules/lua/tags
index 0c2c1bc5..ea27ba31 100644
--- a/modules/lua/tags
+++ b/modules/lua/tags
@@ -21,6 +21,7 @@ CARET_JUMPS	_	0;"	F	class:_SCINTILLA.constants
 CARET_SLOP	_	0;"	F	class:_SCINTILLA.constants
 CARET_STRICT	_	0;"	F	class:_SCINTILLA.constants
 CHAR_ADDED	_	0;"	F	class:events
+CLASS	_	0;"	F	class:_M.textadept.adeptsense
 CLASS	_	0;"	F	class:lexer
 CLEAR	_	0;"	F	class:keys
 COMMAND_ENTRY_COMMAND	_	0;"	F	class:events
@@ -48,6 +49,7 @@ EDGE_LINE	_	0;"	F	class:_SCINTILLA.constants
 EDGE_NONE	_	0;"	F	class:_SCINTILLA.constants
 ERROR	_	0;"	F	class:events
 ERROR	_	0;"	F	class:lexer
+FIELD	_	0;"	F	class:_M.textadept.adeptsense
 FIELDS	_	0;"	F	class:_M.textadept.adeptsense
 FILE_AFTER_SAVE	_	0;"	F	class:events
 FILE_BEFORE_SAVE	_	0;"	F	class:events
@@ -55,6 +57,7 @@ FILE_OPENED	_	0;"	F	class:events
 FILE_SAVED_AS	_	0;"	F	class:events
 FILTER	_	0;"	t	class:_M.textadept.snapopen
 FIND	_	0;"	F	class:events
+FUNCTION	_	0;"	F	class:_M.textadept.adeptsense
 FUNCTION	_	0;"	F	class:lexer
 FUNCTIONS	_	0;"	F	class:_M.textadept.adeptsense
 HIGHLIGHT_BRACES	_	0;"	F	class:_M.textadept.editing
@@ -868,6 +871,7 @@ brace_highlight_indicator	_	0;"	f	class:buffer
 brace_match	_	0;"	f	class:buffer
 braces	_	0;"	t	class:_M.textadept.editing
 btest	_	0;"	f	class:bit32
+buffer	_	0;"	F	
 buffer	_	0;"	m	
 buffer	_	0;"	t	
 buffer	_	0;"	t	class:view
@@ -1115,8 +1119,6 @@ goto_line	_	0;"	f	class:buffer
 goto_next	_	0;"	f	class:_M.textadept.bookmarks
 goto_pos	_	0;"	f	class:buffer
 goto_prev	_	0;"	f	class:_M.textadept.bookmarks
-goto_required	_	0;"	f	class:_M.php
-goto_required	_	0;"	f	class:_M.ruby
 goto_view	_	0;"	f	class:gui
 grab_focus	_	0;"	f	class:buffer
 graph	_	0;"	F	class:lexer
@@ -1392,7 +1394,6 @@ rawset	_	0;"	f
 read	_	0;"	f	class:file
 read	_	0;"	f	class:io
 read_only	_	0;"	F	class:buffer
-rebuild_command_tables	_	0;"	f	class:_M.textadept.menu
 recent_files	_	0;"	t	class:io
 rectangular_selection_anchor	_	0;"	F	class:buffer
 rectangular_selection_anchor_virtual_space	_	0;"	F	class:buffer
@@ -1677,6 +1678,7 @@ vc_home_wrap	_	0;"	f	class:buffer
 vc_home_wrap_extend	_	0;"	f	class:buffer
 version	_	0;"	f	class:lpeg
 vertical_centre_caret	_	0;"	f	class:buffer
+view	_	0;"	F	
 view	_	0;"	m	
 view	_	0;"	t	
 view_eol	_	0;"	F	class:buffer