docs: replace <pre> with ``` (#25136)

43 files changed, 1361 insertions, 1256 deletions

diff --git a/runtime/doc/api.txt b/runtime/doc/api.txt
index 34e2aedabf..ffd90ec3d7 100644
--- a/runtime/doc/api.txt
+++ b/runtime/doc/api.txt
@@ -1791,9 +1791,9 @@ nvim_create_user_command({name}, {command}, {*opts})
     For Lua usage see |lua-guide-commands-create|.
 
     Example: >vim
-       :call nvim_create_user_command('SayHello', 'echo "Hello world!"', {'bang': v:true})
-       :SayHello
-       Hello world!
+        :call nvim_create_user_command('SayHello', 'echo "Hello world!"', {'bang': v:true})
+        :SayHello
+        Hello world!
 <
 
     Parameters: ~
@@ -2041,10 +2041,14 @@ whether a buffer is loaded.
 nvim_buf_attach({buffer}, {send_buffer}, {opts})           *nvim_buf_attach()*
     Activates buffer-update events on a channel, or as Lua callbacks.
 
-    Example (Lua): capture buffer updates in a global `events` variable (use "vim.print(events)" to see its contents): >lua
-      events = {}
-      vim.api.nvim_buf_attach(0, false, {
-        on_lines=function(...) table.insert(events, {...}) end})
+    Example (Lua): capture buffer updates in a global `events` variable (use
+    "vim.print(events)" to see its contents): >lua
+        events = {}
+        vim.api.nvim_buf_attach(0, false, {
+          on_lines = function(...)
+            table.insert(events, {...})
+          end,
+        })
 <
 
     Parameters: ~
@@ -2553,8 +2557,8 @@ nvim_buf_get_extmarks({buffer}, {ns_id}, {start}, {end}, {*opts})
     Region can be given as (row,col) tuples, or valid extmark ids (whose
     positions define the bounds). 0 and -1 are understood as (0,0) and (-1,-1)
     respectively, thus the following are equivalent: >lua
-      vim.api.nvim_buf_get_extmarks(0, my_ns, 0, -1, {})
-      vim.api.nvim_buf_get_extmarks(0, my_ns, {0,0}, {-1,-1}, {})
+        vim.api.nvim_buf_get_extmarks(0, my_ns, 0, -1, {})
+        vim.api.nvim_buf_get_extmarks(0, my_ns, {0,0}, {-1,-1}, {})
 <
 
     If `end` is less than `start`, traversal works backwards. (Useful with
@@ -2565,18 +2569,18 @@ nvim_buf_get_extmarks({buffer}, {ns_id}, {start}, {end}, {*opts})
     an extmark will be considered.
 
     Example: >lua
-      local api = vim.api
-      local pos = api.nvim_win_get_cursor(0)
-      local ns  = api.nvim_create_namespace('my-plugin')
-      -- Create new extmark at line 1, column 1.
-      local m1  = api.nvim_buf_set_extmark(0, ns, 0, 0, {})
-      -- Create new extmark at line 3, column 1.
-      local m2  = api.nvim_buf_set_extmark(0, ns, 2, 0, {})
-      -- Get extmarks only from line 3.
-      local ms  = api.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})
-      -- Get all marks in this buffer + namespace.
-      local all = api.nvim_buf_get_extmarks(0, ns, 0, -1, {})
-      vim.print(ms)
+        local api = vim.api
+        local pos = api.nvim_win_get_cursor(0)
+        local ns  = api.nvim_create_namespace('my-plugin')
+        -- Create new extmark at line 1, column 1.
+        local m1  = api.nvim_buf_set_extmark(0, ns, 0, 0, {})
+        -- Create new extmark at line 3, column 1.
+        local m2  = api.nvim_buf_set_extmark(0, ns, 2, 0, {})
+        -- Get extmarks only from line 3.
+        local ms  = api.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})
+        -- Get all marks in this buffer + namespace.
+        local all = api.nvim_buf_get_extmarks(0, ns, 0, -1, {})
+        vim.print(ms)
 <
 
     Parameters: ~
@@ -3062,6 +3066,7 @@ nvim_open_win({buffer}, {enter}, {*config})                  *nvim_open_win()*
     Example (Lua): buffer-relative float (travels as buffer is scrolled) >lua
         vim.api.nvim_open_win(0, false,
           {relative='win', width=12, height=3, bufpos={100,10}})
+        })
 <
 
     Attributes: ~
@@ -3340,9 +3345,9 @@ nvim_create_autocmd({event}, {*opts})                  *nvim_create_autocmd()*
         })
 <
 
-    Note: `pattern` is NOT automatically expanded (unlike with |:autocmd|), thus names like
-    "$HOME" and "~" must be expanded explicitly: >lua
-      pattern = vim.fn.expand("~") .. "/some/path/*.py"
+    Note: `pattern` is NOT automatically expanded (unlike with |:autocmd|),
+    thus names like "$HOME" and "~" must be expanded explicitly: >lua
+        pattern = vim.fn.expand("~") .. "/some/path/*.py"
 <
 
     Parameters: ~
@@ -3447,17 +3452,17 @@ nvim_get_autocmds({*opts})                               *nvim_get_autocmds()*
     Get all autocommands that match the corresponding {opts}.
 
     These examples will get autocommands matching ALL the given criteria: >lua
-      -- Matches all criteria
-      autocommands = vim.api.nvim_get_autocmds({
-        group = "MyGroup",
-        event = {"BufEnter", "BufWinEnter"},
-        pattern = {"*.c", "*.h"}
-      })
-
-      -- All commands from one group
-      autocommands = vim.api.nvim_get_autocmds({
-        group = "MyGroup",
-      })
+        -- Matches all criteria
+        autocommands = vim.api.nvim_get_autocmds({
+          group = "MyGroup",
+          event = {"BufEnter", "BufWinEnter"},
+          pattern = {"*.c", "*.h"}
+        })
+
+        -- All commands from one group
+        autocommands = vim.api.nvim_get_autocmds({
+          group = "MyGroup",
+        })
 <
 
     NOTE: When multiple patterns or events are provided, it will find all the
diff --git a/runtime/doc/develop.txt b/runtime/doc/develop.txt
index 0ed537c248..71c16659eb 100644
--- a/runtime/doc/develop.txt
+++ b/runtime/doc/develop.txt
@@ -238,7 +238,7 @@ Docstring format:
   `---@see`, `---@param`, `---@returns`
 - Limited markdown is supported.
   - List-items start with `-` (useful to nest or "indent")
-- Use `<pre>` for code samples.
+- Use ``` for code samples.
   Code samples can be annotated as `vim` or `lua`
 - Use `@nodoc` to prevent documentation generation.
 - Files which has `@meta` are only used for typing and documentation.
@@ -250,12 +250,13 @@ vim.paste in runtime/lua/vim/_editor.lua like this: >
     --- (such as the |TUI|) pastes text into the editor.
     ---
     --- Example: To remove ANSI color codes when pasting:
-    --- <pre>lua
+    ---
+    --- ```lua
     --- vim.paste = (function()
     ---   local overridden = vim.paste
     ---   ...
     --- end)()
-    --- </pre>
+    --- ```
     ---
     ---@see |paste|
     ---
diff --git a/runtime/doc/diagnostic.txt b/runtime/doc/diagnostic.txt
index 866c32722a..e9ca9ee347 100644
--- a/runtime/doc/diagnostic.txt
+++ b/runtime/doc/diagnostic.txt
@@ -359,13 +359,11 @@ config({opts}, {namespace})                          *vim.diagnostic.config()*
     followed by namespace configuration, and finally global configuration.
 
     For example, if a user enables virtual text globally with >lua
-
-       vim.diagnostic.config({ virtual_text = true })
+        vim.diagnostic.config({ virtual_text = true })
 <
 
     and a diagnostic producer sets diagnostics with >lua
-
-       vim.diagnostic.set(ns, 0, diagnostics, { virtual_text = false })
+        vim.diagnostic.set(ns, 0, diagnostics, { virtual_text = false })
 <
 
     then virtual text will not be enabled for those diagnostics.
@@ -608,16 +606,14 @@ match({str}, {pat}, {groups}, {severity_map}, {defaults})
     Parse a diagnostic from a string.
 
     For example, consider a line of output from a linter: >
-
-     WARNING filename:27:3: Variable 'foo' does not exist
+        WARNING filename:27:3: Variable 'foo' does not exist
 <
 
     This can be parsed into a diagnostic |diagnostic-structure| with: >lua
-
-       local s = "WARNING filename:27:3: Variable 'foo' does not exist"
-       local pattern = "^(%w+) %w+:(%d+):(%d+): (.+)$"
-       local groups = { "severity", "lnum", "col", "message" }
-       vim.diagnostic.match(s, pattern, groups, { WARNING = vim.diagnostic.WARN })
+        local s = "WARNING filename:27:3: Variable 'foo' does not exist"
+        local pattern = "^(%w+) %w+:(%d+):(%d+): (.+)$"
+        local groups = { "severity", "lnum", "col", "message" }
+        vim.diagnostic.match(s, pattern, groups, { WARNING = vim.diagnostic.WARN })
 <
 
     Parameters: ~
diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt
index 29c08fb32d..5103cc223f 100644
--- a/runtime/doc/lsp.txt
+++ b/runtime/doc/lsp.txt
@@ -901,12 +901,11 @@ start({config}, {opts})                                      *vim.lsp.start()*
     the current buffer to the client.
 
     Example: >lua
-
-     vim.lsp.start({
-        name = 'my-server-name',
-        cmd = {'name-of-language-server-executable'},
-        root_dir = vim.fs.dirname(vim.fs.find({'pyproject.toml', 'setup.py'}, { upward = true })[1]),
-     })
+        vim.lsp.start({
+           name = 'my-server-name',
+           cmd = {'name-of-language-server-executable'},
+           root_dir = vim.fs.dirname(vim.fs.find({'pyproject.toml', 'setup.py'}, { upward = true })[1]),
+        })
 <
 
     See |vim.lsp.start_client()| for all available options. The most important
@@ -1078,9 +1077,9 @@ status()                                                    *vim.lsp.status()*
 stop_client({client_id}, {force})                      *vim.lsp.stop_client()*
     Stops a client(s).
 
-    You can also use the `stop()` function on a |vim.lsp.client| object. To stop all clients: >lua
-
-     vim.lsp.stop_client(vim.lsp.get_clients())
+    You can also use the `stop()` function on a |vim.lsp.client| object. To
+    stop all clients: >lua
+        vim.lsp.stop_client(vim.lsp.get_clients())
 <
 
     By default asks the server to shutdown, unless stop was requested already
@@ -1196,10 +1195,10 @@ definition({options})                               *vim.lsp.buf.definition()*
 document_highlight()                        *vim.lsp.buf.document_highlight()*
     Send request to the server to resolve document highlights for the current
     text document position. This request can be triggered by a key mapping or
-    by events such as `CursorHold` , e.g.: >vim
-      autocmd CursorHold  <buffer> lua vim.lsp.buf.document_highlight()
-      autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight()
-      autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()
+    by events such as `CursorHold`, e.g.: >vim
+        autocmd CursorHold  <buffer> lua vim.lsp.buf.document_highlight()
+        autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight()
+        autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()
 <
 
     Note: Usage of |vim.lsp.buf.document_highlight()| requires the following
@@ -1242,12 +1241,12 @@ format({options})                                       *vim.lsp.buf.format()*
                      buffer (0).
                    • filter (function|nil): Predicate used to filter clients.
                      Receives a client as argument and must return a boolean.
-                     Clients matching the predicate are included. Example:               • >lua
+                     Clients matching the predicate are included. Example: >lua
 
-               -- Never request typescript-language-server for formatting
-               vim.lsp.buf.format {
-                 filter = function(client) return client.name ~= "tsserver" end
-               }
+                         -- Never request typescript-language-server for formatting
+                         vim.lsp.buf.format {
+                           filter = function(client) return client.name ~= "tsserver" end
+                         }
 <
                    • async boolean|nil If true the method won't block.
                      Defaults to false. Editing the buffer while formatting
@@ -1366,24 +1365,23 @@ on_diagnostic({_}, {result}, {ctx}, {config})
 
     See |vim.diagnostic.config()| for configuration options. Handler-specific
     configuration can be set using |vim.lsp.with()|: >lua
-
-     vim.lsp.handlers["textDocument/diagnostic"] = vim.lsp.with(
-       vim.lsp.diagnostic.on_diagnostic, {
-         -- Enable underline, use default values
-         underline = true,
-         -- Enable virtual text, override spacing to 4
-         virtual_text = {
-           spacing = 4,
-         },
-         -- Use a function to dynamically turn signs off
-         -- and on, using buffer local variables
-         signs = function(namespace, bufnr)
-           return vim.b[bufnr].show_signs == true
-         end,
-         -- Disable a feature
-         update_in_insert = false,
-       }
-     )
+        vim.lsp.handlers["textDocument/diagnostic"] = vim.lsp.with(
+          vim.lsp.diagnostic.on_diagnostic, {
+            -- Enable underline, use default values
+            underline = true,
+            -- Enable virtual text, override spacing to 4
+            virtual_text = {
+              spacing = 4,
+            },
+            -- Use a function to dynamically turn signs off
+            -- and on, using buffer local variables
+            signs = function(namespace, bufnr)
+              return vim.b[bufnr].show_signs == true
+            end,
+            -- Disable a feature
+            update_in_insert = false,
+          }
+        )
 <
 
     Parameters: ~
@@ -1395,24 +1393,23 @@ on_publish_diagnostics({_}, {result}, {ctx}, {config})
 
     See |vim.diagnostic.config()| for configuration options. Handler-specific
     configuration can be set using |vim.lsp.with()|: >lua
-
-     vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
-       vim.lsp.diagnostic.on_publish_diagnostics, {
-         -- Enable underline, use default values
-         underline = true,
-         -- Enable virtual text, override spacing to 4
-         virtual_text = {
-           spacing = 4,
-         },
-         -- Use a function to dynamically turn signs off
-         -- and on, using buffer local variables
-         signs = function(namespace, bufnr)
-           return vim.b[bufnr].show_signs == true
-         end,
-         -- Disable a feature
-         update_in_insert = false,
-       }
-     )
+        vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
+          vim.lsp.diagnostic.on_publish_diagnostics, {
+            -- Enable underline, use default values
+            underline = true,
+            -- Enable virtual text, override spacing to 4
+            virtual_text = {
+              spacing = 4,
+            },
+            -- Use a function to dynamically turn signs off
+            -- and on, using buffer local variables
+            signs = function(namespace, bufnr)
+              return vim.b[bufnr].show_signs == true
+            end,
+            -- Disable a feature
+            update_in_insert = false,
+          }
+        )
 <
 
     Parameters: ~
@@ -1457,7 +1454,7 @@ refresh()                                         *vim.lsp.codelens.refresh()*
     It is recommended to trigger this using an autocmd or via keymap.
 
     Example: >vim
-      autocmd BufEnter,CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh()
+        autocmd BufEnter,CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh()
 <
 
 run()                                                 *vim.lsp.codelens.run()*
@@ -1534,8 +1531,7 @@ start({bufnr}, {client_id}, {opts})          *vim.lsp.semantic_tokens.start()*
     server that supports it, you can delete the semanticTokensProvider table
     from the {server_capabilities} of your client in your |LspAttach| callback
     or your configuration's `on_attach` callback: >lua
-
-       client.server_capabilities.semanticTokensProvider = nil
+        client.server_capabilities.semanticTokensProvider = nil
 <
 
     Parameters: ~
@@ -1565,15 +1561,14 @@ Lua module: vim.lsp.handlers                                    *lsp-handlers*
 
 hover({_}, {result}, {ctx}, {config})               *vim.lsp.handlers.hover()*
     |lsp-handler| for the method "textDocument/hover" >lua
-
-       vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(
-         vim.lsp.handlers.hover, {
-           -- Use a sharp border with `FloatBorder` highlights
-           border = "single",
-           -- add the title in hover float window
-           title = "hover"
-         }
-       )
+        vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(
+          vim.lsp.handlers.hover, {
+            -- Use a sharp border with `FloatBorder` highlights
+            border = "single",
+            -- add the title in hover float window
+            title = "hover"
+          }
+        )
 <
 
     Parameters: ~
@@ -1585,18 +1580,20 @@ hover({_}, {result}, {ctx}, {config})               *vim.lsp.handlers.hover()*
 
                                            *vim.lsp.handlers.signature_help()*
 signature_help({_}, {result}, {ctx}, {config})
-    |lsp-handler| for the method "textDocument/signatureHelp". The active
-    parameter is highlighted with |hl-LspSignatureActiveParameter|. >lua
-
-       vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with(
-         vim.lsp.handlers.signature_help, {
-           -- Use a sharp border with `FloatBorder` highlights
-           border = "single"
-         }
-       )
+    |lsp-handler| for the method "textDocument/signatureHelp".
+
+    The active parameter is highlighted with |hl-LspSignatureActiveParameter|. >lua
+        vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with(
+          vim.lsp.handlers.signature_help, {
+            -- Use a sharp border with `FloatBorder` highlights
+            border = "single"
+          }
+        )
 <
 
     Parameters: ~
+      • {result}  (table) Response from the language server
+      • {ctx}     (table) Client context
       • {config}  (table) Configuration table.
                   • border: (default=nil)
                     • Add borders to the floating window
diff --git a/runtime/doc/lua.txt b/runtime/doc/lua.txt
index c7f5a292e7..6cfec45523 100644
--- a/runtime/doc/lua.txt
+++ b/runtime/doc/lua.txt
@@ -582,17 +582,20 @@ VIM.HIGHLIGHT                                                  *vim.highlight*
 
 Nvim includes a function for highlighting a selection on yank.
 
-To enable it, add the following to your `init.vim` : >vim
+To enable it, add the following to your `init.vim`: >vim
     au TextYankPost * silent! lua vim.highlight.on_yank()
+
 <
 
 You can customize the highlight group and the duration of the highlight
 via: >vim
     au TextYankPost * silent! lua vim.highlight.on_yank {higroup="IncSearch", timeout=150}
+
 <
 
 If you want to exclude visual selections from highlighting on yank, use: >vim
     au TextYankPost * silent! lua vim.highlight.on_yank {on_visual=false}
+
 <
 
 vim.highlight.on_yank({opts})                        *vim.highlight.on_yank()*
@@ -688,19 +691,18 @@ vim.diff({a}, {b}, {opts})                                        *vim.diff()*
     either directly or via callback arguments, are 1-based.
 
     Examples: >lua
+        vim.diff('a\n', 'b\nc\n')
+        -- =>
+        -- @@ -1 +1,2 @@
+        -- -a
+        -- +b
+        -- +c
 
-         vim.diff('a\n', 'b\nc\n')
-         -- =>
-         -- @ -1 +1,2 @
-         -- -a
-         -- +b
-         -- +c
-
-         vim.diff('a\n', 'b\nc\n', {result_type = 'indices'})
-         -- =>
-         -- {
-         --   {1, 1, 1, 2}
-         -- }
+        vim.diff('a\n', 'b\nc\n', {result_type = 'indices'})
+        -- =>
+        -- {
+        --   {1, 1, 1, 2}
+        -- }
 <
 
     Parameters: ~
@@ -781,16 +783,18 @@ vim.json.decode({str}, {opts})                             *vim.json.decode()*
     • Decodes empty array as `{}` (empty Lua table).
 
     Example: >lua
-
-     :lua vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))
-     --> { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }
-
-    < Parameters: ~ • {str} Stringified JSON data. • {opts} Options map keys: •
-    luanil: { object: bool, array: bool } • `luanil.object=true` converts `null` in JSON objects to Lua `nil` instead of `vim.NIL` . • `luanil.array=true` converts `null` in JSON arrays to Lua `nil` instead of `vim.NIL` .
+        vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))
+        -- { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }
+<
 
     Parameters: ~
-      • {str}   (string)
-      • {opts}  table<string,|nil any>
+      • {str}   (string) Stringified JSON data.
+      • {opts}  table<string,any>|nil Options table with keys:
+                • luanil: (table) Table with keys:
+                  • object: (boolean) When true, converts `null` in JSON
+                    objects to Lua `nil` instead of |vim.NIL|.
+                  • array: (boolean) When true, converts `null` in JSON arrays
+                    to Lua `nil` instead of |vim.NIL|.
 
     Return: ~
         any
@@ -817,12 +821,11 @@ vim.spell.check({str})                                     *vim.spell.check()*
     the buffer. Consider calling this with |nvim_buf_call()|.
 
     Example: >lua
-
-         vim.spell.check("the quik brown fox")
-         -- =>
-         -- {
-         --     {'quik', 'bad', 5}
-         -- }
+        vim.spell.check("the quik brown fox")
+        -- =>
+        -- {
+        --     {'quik', 'bad', 5}
+        -- }
 <
 
     Parameters: ~
@@ -978,14 +981,13 @@ vim.str_utf_end({str}, {index})                            *vim.str_utf_end()*
     (character) that {index} points to.
 
     Examples: >lua
+        -- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
 
-     -- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
-
-     -- Returns 0 because the index is pointing at the last byte of a character
-     vim.str_utf_end('æ', 2)
+        -- Returns 0 because the index is pointing at the last byte of a character
+        vim.str_utf_end('æ', 2)
 
-     -- Returns 1 because the index is pointing at the penultimate byte of a character
-     vim.str_utf_end('æ', 1)
+        -- Returns 1 because the index is pointing at the penultimate byte of a character
+        vim.str_utf_end('æ', 1)
 <
 
     Parameters: ~
@@ -1015,14 +1017,13 @@ vim.str_utf_start({str}, {index})                        *vim.str_utf_start()*
     character.
 
     Examples: >lua
+        -- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
 
-     -- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
+        -- Returns 0 because the index is pointing at the first byte of a character
+        vim.str_utf_start('æ', 1)
 
-     -- Returns 0 because the index is pointing at the first byte of a character
-     vim.str_utf_start('æ', 1)
-
-     -- Returns -1 because the index is pointing at the second byte of a character
-     vim.str_utf_start('æ', 2)
+        -- Returns -1 because the index is pointing at the second byte of a character
+        vim.str_utf_start('æ', 2)
 <
 
     Parameters: ~
@@ -1080,20 +1081,19 @@ vim.ui_attach({ns}, {options}, {callback})                   *vim.ui_attach()*
     likewise experimental).
 
     Example (stub for a |ui-popupmenu| implementation): >lua
-
-       ns = vim.api.nvim_create_namespace('my_fancy_pum')
-
-       vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)
-         if event == "popupmenu_show" then
-           local items, selected, row, col, grid = ...
-           print("display pum ", #items)
-         elseif event == "popupmenu_select" then
-           local selected = ...
-           print("selected", selected)
-         elseif event == "popupmenu_hide" then
-           print("FIN")
-         end
-       end)
+        ns = vim.api.nvim_create_namespace('my_fancy_pum')
+
+        vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)
+          if event == "popupmenu_show" then
+            local items, selected, row, col, grid = ...
+            print("display pum ", #items)
+          elseif event == "popupmenu_select" then
+            local selected = ...
+            print("selected", selected)
+          elseif event == "popupmenu_hide" then
+            print("FIN")
+          end
+        end)
 <
 
     Parameters: ~
@@ -1116,27 +1116,26 @@ vim.wait({time}, {callback}, {interval}, {fast_only})             *vim.wait()*
     time.
 
     Examples: >lua
+        ---
+        -- Wait for 100 ms, allowing other events to process
+        vim.wait(100, function() end)
 
-     ---
-     -- Wait for 100 ms, allowing other events to process
-     vim.wait(100, function() end)
+        ---
+        -- Wait for 100 ms or until global variable set.
+        vim.wait(100, function() return vim.g.waiting_for_var end)
 
-     ---
-     -- Wait for 100 ms or until global variable set.
-     vim.wait(100, function() return vim.g.waiting_for_var end)
+        ---
+        -- Wait for 1 second or until global variable set, checking every ~500 ms
+        vim.wait(1000, function() return vim.g.waiting_for_var end, 500)
 
-     ---
-     -- Wait for 1 second or until global variable set, checking every ~500 ms
-     vim.wait(1000, function() return vim.g.waiting_for_var end, 500)
+        ---
+        -- Schedule a function to set a value in 100ms
+        vim.defer_fn(function() vim.g.timer_result = true end, 100)
 
-     ---
-     -- Schedule a function to set a value in 100ms
-     vim.defer_fn(function() vim.g.timer_result = true end, 100)
-
-     -- Would wait ten seconds if results blocked. Actually only waits  100 ms
-     if vim.wait(10000, function() return vim.g.timer_result end) then
-       print('Only waiting a little bit of time!')
-     end
+        -- Would wait ten seconds if results blocked. Actually only waits  100 ms
+        if vim.wait(10000, function() return vim.g.timer_result end) then
+          print('Only waiting a little bit of time!')
+        end
 <
 
     Parameters: ~
@@ -1171,6 +1170,7 @@ Lua list: >lua
     local list = { 1, 2, 3 }
     vim.fn.remove(list, 0)
     vim.print(list)  --> "{ 1, 2, 3 }"
+
 <
 
 vim.call({func}, {...})                                           *vim.call()*
@@ -1430,13 +1430,12 @@ vim.bo                                                                *vim.bo*
         print(vim.bo.baz)                 -- error: invalid key
 <
 
-    Parameters: ~
-      • {bufnr}  (integer|nil)
-
 vim.env                                                              *vim.env*
     Environment variables defined in the editor session. See |expand-env| and
     |:let-environment| for the Vimscript behavior. Invalid or unset key
-    returns `nil` . Example: >lua
+    returns `nil`.
+
+    Example: >lua
         vim.env.FOO = 'bar'
         print(vim.env.TERM)
 <
@@ -1497,31 +1496,30 @@ vim.cmd                                                            *vim.cmd()*
     callable function to the command.
 
     Example: >lua
+        vim.cmd('echo 42')
+        vim.cmd([[
+          augroup My_group
+            autocmd!
+            autocmd FileType c setlocal cindent
+          augroup END
+        ]])
 
-       vim.cmd('echo 42')
-       vim.cmd([[
-         augroup My_group
-           autocmd!
-           autocmd FileType c setlocal cindent
-         augroup END
-       ]])
+        -- Ex command :echo "foo"
+        -- Note string literals need to be double quoted.
+        vim.cmd('echo "foo"')
+        vim.cmd { cmd = 'echo', args = { '"foo"' } }
+        vim.cmd.echo({ args = { '"foo"' } })
+        vim.cmd.echo('"foo"')
 
-       -- Ex command :echo "foo"
-       -- Note string literals need to be double quoted.
-       vim.cmd('echo "foo"')
-       vim.cmd { cmd = 'echo', args = { '"foo"' } }
-       vim.cmd.echo({ args = { '"foo"' } })
-       vim.cmd.echo('"foo"')
+        -- Ex command :write! myfile.txt
+        vim.cmd('write! myfile.txt')
+        vim.cmd { cmd = 'write', args = { "myfile.txt" }, bang = true }
+        vim.cmd.write { args = { "myfile.txt" }, bang = true }
+        vim.cmd.write { "myfile.txt", bang = true }
 
-       -- Ex command :write! myfile.txt
-       vim.cmd('write! myfile.txt')
-       vim.cmd { cmd = 'write', args = { "myfile.txt" }, bang = true }
-       vim.cmd.write { args = { "myfile.txt" }, bang = true }
-       vim.cmd.write { "myfile.txt", bang = true }
-
-       -- Ex command :colorscheme blue
-       vim.cmd('colorscheme blue')
-       vim.cmd.colorscheme('blue')
+        -- Ex command :colorscheme blue
+        vim.cmd('colorscheme blue')
+        vim.cmd.colorscheme('blue')
 <
 
     Parameters: ~
@@ -1579,9 +1577,8 @@ vim.keycode({str})                                             *vim.keycode()*
     Translate keycodes.
 
     Example: >lua
-
-       local k = vim.keycode
-       vim.g.mapleader = k'<bs>'
+        local k = vim.keycode
+        vim.g.mapleader = k'<bs>'
 <
 
     Parameters: ~
@@ -1653,16 +1650,15 @@ vim.paste({lines}, {phase})                                      *vim.paste()*
     |TUI|) pastes text into the editor.
 
     Example: To remove ANSI color codes when pasting: >lua
-
-     vim.paste = (function(overridden)
-       return function(lines, phase)
-         for i,line in ipairs(lines) do
-           -- Scrub ANSI color codes from paste input.
-           lines[i] = line:gsub('\27%[[0-9;mK]+', '')
-         end
-         overridden(lines, phase)
-       end
-     end)(vim.paste)
+        vim.paste = (function(overridden)
+          return function(lines, phase)
+            for i,line in ipairs(lines) do
+              -- Scrub ANSI color codes from paste input.
+              lines[i] = line:gsub('\27%[[0-9;mK]+', '')
+            end
+            overridden(lines, phase)
+          end
+        end)(vim.paste)
 <
 
     Parameters: ~
@@ -1684,8 +1680,7 @@ vim.print({...})                                                 *vim.print()*
     "Pretty prints" the given arguments and returns them unmodified.
 
     Example: >lua
-
-       local hl_normal = vim.print(vim.api.nvim_get_hl_by_name('Normal', true))
+        local hl_normal = vim.print(vim.api.nvim_get_hl_by_name('Normal', true))
 <
 
     Return: ~
@@ -1737,20 +1732,19 @@ vim.system({cmd}, {opts}, {on_exit})                            *vim.system()*
     Run a system command
 
     Examples: >lua
+        local on_exit = function(obj)
+          print(obj.code)
+          print(obj.signal)
+          print(obj.stdout)
+          print(obj.stderr)
+        end
 
-       local on_exit = function(obj)
-         print(obj.code)
-         print(obj.signal)
-         print(obj.stdout)
-         print(obj.stderr)
-       end
-
-       -- Run asynchronously
-       vim.system({'echo', 'hello'}, { text = true }, on_exit)
+        -- Run asynchronously
+        vim.system({'echo', 'hello'}, { text = true }, on_exit)
 
-       -- Run synchronously
-       local obj = vim.system({'echo', 'hello'}, { text = true }):wait()
-       -- { code = 0, signal = 0, stdout = 'hello', stderr = '' }
+        -- Run synchronously
+        local obj = vim.system({'echo', 'hello'}, { text = true }):wait()
+        -- { code = 0, signal = 0, stdout = 'hello', stderr = '' }
 <
 
     See |uv.spawn()| for more details.
@@ -1894,12 +1888,9 @@ vim.defaulttable({create})                                *vim.defaulttable()*
 
     If {create} is `nil`, this will create a defaulttable whose constructor
     function is this function, effectively allowing to create nested tables on
-    the fly:
-
-    >lua
-
-     local a = vim.defaulttable()
-     a.b.c = 1
+    the fly: >lua
+        local a = vim.defaulttable()
+        a.b.c = 1
 <
 
     Parameters: ~
@@ -1924,18 +1915,16 @@ vim.gsplit({s}, {sep}, {opts})                                  *vim.gsplit()*
     in "lazy" fashion (as opposed to |vim.split()| which is "eager").
 
     Example: >lua
-
-       for s in vim.gsplit(':aa::b:', ':', {plain=true}) do
-         print(s)
-       end
+        for s in vim.gsplit(':aa::b:', ':', {plain=true}) do
+          print(s)
+        end
 <
 
     If you want to also inspect the separator itself (instead of discarding
     it), use |string.gmatch()|. Example: >lua
-
-       for word, num in ('foo111bar222'):gmatch('([^0-9]*)(d*)') do
-         print(('word: s num: s'):format(word, num))
-       end
+        for word, num in ('foo111bar222'):gmatch('([^0-9]*)(%d*)') do
+          print(('word: %s num: %s'):format(word, num))
+        end
 <
 
     Parameters: ~
@@ -2021,22 +2010,20 @@ vim.pesc({s})                                                     *vim.pesc()*
 
 vim.ringbuf({size})                                            *vim.ringbuf()*
     Create a ring buffer limited to a maximal number of items. Once the buffer
-    is full, adding a new entry overrides the oldest entry.
->
-
-    local ringbuf = vim.ringbuf(4)
-    ringbuf:push("a")
-    ringbuf:push("b")
-    ringbuf:push("c")
-    ringbuf:push("d")
-    ringbuf:push("e")    -- overrides "a"
-    print(ringbuf:pop()) -- returns "b"
-    print(ringbuf:pop()) -- returns "c"
-
-    -- Can be used as iterator. Pops remaining items:
-    for val in ringbuf do
-      print(val)
-    end
+    is full, adding a new entry overrides the oldest entry. >lua
+        local ringbuf = vim.ringbuf(4)
+        ringbuf:push("a")
+        ringbuf:push("b")
+        ringbuf:push("c")
+        ringbuf:push("d")
+        ringbuf:push("e")    -- overrides "a"
+        print(ringbuf:pop()) -- returns "b"
+        print(ringbuf:pop()) -- returns "c"
+
+        -- Can be used as iterator. Pops remaining items:
+        for val in ringbuf do
+          print(val)
+        end
 <
 
     Returns a Ringbuf instance with the following methods:
@@ -2090,11 +2077,10 @@ vim.split({s}, {sep}, {opts})                                    *vim.split()*
     a table (unlike |vim.gsplit()|).
 
     Examples: >lua
-
-      split(":aa::b:", ":")                   --> {'','aa','','b',''}
-      split("axaby", "ab?")                   --> {'','x','y'}
-      split("x*yz*o", "*", {plain=true})      --> {'x','yz','o'}
-      split("|x|y|z|", "|", {trimempty=true}) --> {'x', 'y', 'z'}
+        split(":aa::b:", ":")                   --> {'','aa','','b',''}
+        split("axaby", "ab?")                   --> {'','x','y'}
+        split("x*yz*o", "*", {plain=true})      --> {'x','yz','o'}
+        split("|x|y|z|", "|", {trimempty=true}) --> {'x', 'y', 'z'}
 <
 
     Parameters: ~
@@ -2137,11 +2123,10 @@ vim.tbl_contains({t}, {value}, {opts})                    *vim.tbl_contains()*
     a predicate that is checked for each value.
 
     Example: >lua
-
-      vim.tbl_contains({ 'a', { 'b', 'c' } }, function(v)
-        return vim.deep_equal(v, { 'b', 'c' })
-      end, { predicate = true })
-      -- true
+        vim.tbl_contains({ 'a', { 'b', 'c' } }, function(v)
+          return vim.deep_equal(v, { 'b', 'c' })
+        end, { predicate = true })
+        -- true
 <
 
     Parameters: ~
@@ -2158,12 +2143,9 @@ vim.tbl_contains({t}, {value}, {opts})                    *vim.tbl_contains()*
       • |vim.list_contains()| for checking values in list-like tables
 
 vim.tbl_count({t})                                           *vim.tbl_count()*
-    Counts the number of non-nil values in table `t`.
-
-    >lua
-
-     vim.tbl_count({ a=1, b=2 })  --> 2
-     vim.tbl_count({ 1, 2 })      --> 2
+    Counts the number of non-nil values in table `t`. >lua
+        vim.tbl_count({ a=1, b=2 })  --> 2
+        vim.tbl_count({ 1, 2 })      --> 2
 <
 
     Parameters: ~
@@ -2237,9 +2219,8 @@ vim.tbl_get({o}, {...})                                        *vim.tbl_get()*
     arguments. Return `nil` if the key does not exist.
 
     Examples: >lua
-
-      vim.tbl_get({ key = { nested_key = true }}, 'key', 'nested_key') == true
-      vim.tbl_get({ key = {}}, 'key', 'nested_key') == nil
+        vim.tbl_get({ key = { nested_key = true }}, 'key', 'nested_key') == true
+        vim.tbl_get({ key = {}}, 'key', 'nested_key') == nil
 <
 
     Parameters: ~
@@ -2340,36 +2321,33 @@ vim.validate({opt})                                           *vim.validate()*
     Validates a parameter specification (types and values).
 
     Usage example: >lua
-
-      function user.new(name, age, hobbies)
-        vim.validate{
-          name={name, 'string'},
-          age={age, 'number'},
-          hobbies={hobbies, 'table'},
-        }
-        ...
-      end
+        function user.new(name, age, hobbies)
+          vim.validate{
+            name={name, 'string'},
+            age={age, 'number'},
+            hobbies={hobbies, 'table'},
+          }
+          ...
+        end
 <
 
     Examples with explicit argument values (can be run directly): >lua
+        vim.validate{arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
+           --> NOP (success)
 
-      vim.validate{arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
-         --> NOP (success)
-
-      vim.validate{arg1={1, 'table'}}
-         --> error('arg1: expected table, got number')
+        vim.validate{arg1={1, 'table'}}
+           --> error('arg1: expected table, got number')
 
-      vim.validate{arg1={3, function(a) return (a % 2) == 0 end, 'even number'}}
-         --> error('arg1: expected even number, got 3')
+        vim.validate{arg1={3, function(a) return (a % 2) == 0 end, 'even number'}}
+           --> error('arg1: expected even number, got 3')
 <
 
     If multiple types are valid they can be given as a list. >lua
+        vim.validate{arg1={{'foo'}, {'table', 'string'}}, arg2={'foo', {'table', 'string'}}}
+        -- NOP (success)
 
-      vim.validate{arg1={{'foo'}, {'table', 'string'}}, arg2={'foo', {'table', 'string'}}}
-         --> NOP (success)
-
-      vim.validate{arg1={1, {'string', 'table'}}}
-         --> error('arg1: expected string|table, got number')
+        vim.validate{arg1={1, {'string', 'table'}}}
+        -- error('arg1: expected string|table, got number')
 <
 
     Parameters: ~
@@ -2506,10 +2484,9 @@ vim.ui.input({opts}, {on_confirm})                            *vim.ui.input()*
     work until `on_confirm`.
 
     Example: >lua
-
-     vim.ui.input({ prompt = 'Enter value for shiftwidth: ' }, function(input)
-         vim.o.shiftwidth = tonumber(input)
-     end)
+        vim.ui.input({ prompt = 'Enter value for shiftwidth: ' }, function(input)
+            vim.o.shiftwidth = tonumber(input)
+        end)
 <
 
     Parameters: ~
@@ -2535,10 +2512,9 @@ vim.ui.open({path})                                            *vim.ui.open()*
     Expands "~/" and environment variables in filesystem paths.
 
     Examples: >lua
-
-     vim.ui.open("https://neovim.io/")
-     vim.ui.open("~/path/to/file")
-     vim.ui.open("$VIMRUNTIME")
+        vim.ui.open("https://neovim.io/")
+        vim.ui.open("~/path/to/file")
+        vim.ui.open("$VIMRUNTIME")
 <
 
     Parameters: ~
@@ -2556,19 +2532,18 @@ vim.ui.select({items}, {opts}, {on_choice})                  *vim.ui.select()*
     (potentially asynchronous) work until `on_choice`.
 
     Example: >lua
-
-     vim.ui.select({ 'tabs', 'spaces' }, {
-         prompt = 'Select tabs or spaces:',
-         format_item = function(item)
-             return "I'd like to choose " .. item
-         end,
-     }, function(choice)
-         if choice == 'spaces' then
-             vim.o.expandtab = true
-         else
-             vim.o.expandtab = false
-         end
-     end)
+        vim.ui.select({ 'tabs', 'spaces' }, {
+            prompt = 'Select tabs or spaces:',
+            format_item = function(item)
+                return "I'd like to choose " .. item
+            end,
+        }, function(choice)
+            if choice == 'spaces' then
+                vim.o.expandtab = true
+            else
+                vim.o.expandtab = false
+            end
+        end)
 <
 
     Parameters: ~
@@ -2620,58 +2595,56 @@ vim.filetype.add({filetypes})                             *vim.filetype.add()*
     See $VIMRUNTIME/lua/vim/filetype.lua for more examples.
 
     Example: >lua
-
-      vim.filetype.add({
-        extension = {
-          foo = 'fooscript',
-          bar = function(path, bufnr)
-            if some_condition() then
-              return 'barscript', function(bufnr)
-                -- Set a buffer variable
-                vim.b[bufnr].barscript_version = 2
+        vim.filetype.add({
+          extension = {
+            foo = 'fooscript',
+            bar = function(path, bufnr)
+              if some_condition() then
+                return 'barscript', function(bufnr)
+                  -- Set a buffer variable
+                  vim.b[bufnr].barscript_version = 2
+                end
               end
-            end
-            return 'bar'
-          end,
-        },
-        filename = {
-          ['.foorc'] = 'toml',
-          ['/etc/foo/config'] = 'toml',
-        },
-        pattern = {
-          ['.*/etc/foo/.*'] = 'fooscript',
-          -- Using an optional priority
-          ['.*/etc/foo/.*%.conf'] = { 'dosini', { priority = 10 } },
-          -- A pattern containing an environment variable
-          ['${XDG_CONFIG_HOME}/foo/git'] = 'git',
-          ['README.(a+)$'] = function(path, bufnr, ext)
-            if ext == 'md' then
-              return 'markdown'
-            elseif ext == 'rst' then
-              return 'rst'
-            end
-          end,
-        },
-      })
+              return 'bar'
+            end,
+          },
+          filename = {
+            ['.foorc'] = 'toml',
+            ['/etc/foo/config'] = 'toml',
+          },
+          pattern = {
+            ['.*&zwj;/etc/foo/.*'] = 'fooscript',
+            -- Using an optional priority
+            ['.*&zwj;/etc/foo/.*%.conf'] = { 'dosini', { priority = 10 } },
+            -- A pattern containing an environment variable
+            ['${XDG_CONFIG_HOME}/foo/git'] = 'git',
+            ['README.(%a+)$'] = function(path, bufnr, ext)
+              if ext == 'md' then
+                return 'markdown'
+              elseif ext == 'rst' then
+                return 'rst'
+              end
+            end,
+          },
+        })
 <
 
     To add a fallback match on contents, use >lua
-
-     vim.filetype.add {
-       pattern = {
-         ['.*'] = {
-           priority = -math.huge,
-           function(path, bufnr)
-             local content = vim.api.nvim_buf_get_lines(bufnr, 0, 1, false)[1] or ''
-             if vim.regex([[^#!.*\<mine\>]]):match_str(content) ~= nil then
-               return 'mine'
-             elseif vim.regex([[\<drawing\>]]):match_str(content) ~= nil then
-               return 'drawing'
-             end
-           end,
-         },
-       },
-     }
+        vim.filetype.add {
+          pattern = {
+            ['.*'] = {
+              priority = -math.huge,
+              function(path, bufnr)
+                local content = vim.api.nvim_buf_get_lines(bufnr, 0, 1, false)[1] or ''
+                if vim.regex([[^#!.*\\<mine\\>]]):match_str(content) ~= nil then
+                  return 'mine'
+                elseif vim.regex([[\\<drawing\\>]]):match_str(content) ~= nil then
+                  return 'drawing'
+                end
+              end,
+            },
+          },
+        }
 <
 
     Parameters: ~
@@ -2687,8 +2660,7 @@ vim.filetype.get_option({filetype}, {option})
     files.
 
     Example: >lua
-
-       vim.filetype.get_option('vim', 'commentstring')
+        vim.filetype.get_option('vim', 'commentstring')
 <
 
     Note: this uses |nvim_get_option_value()| but caches the result. This
@@ -2717,21 +2689,18 @@ vim.filetype.match({args})                              *vim.filetype.match()*
     the filetype.
 
     Each of the three options is specified using a key to the single argument
-    of this function. Example:
+    of this function. Example: >lua
+        -- Using a buffer number
+        vim.filetype.match({ buf = 42 })
 
-    >lua
+        -- Override the filename of the given buffer
+        vim.filetype.match({ buf = 42, filename = 'foo.c' })
 
-       -- Using a buffer number
-       vim.filetype.match({ buf = 42 })
+        -- Using a filename without a buffer
+        vim.filetype.match({ filename = 'main.lua' })
 
-       -- Override the filename of the given buffer
-       vim.filetype.match({ buf = 42, filename = 'foo.c' })
-
-       -- Using a filename without a buffer
-       vim.filetype.match({ filename = 'main.lua' })
-
-       -- Using file contents
-       vim.filetype.match({ contents = {'#!/usr/bin/env bash'} })
+        -- Using file contents
+        vim.filetype.match({ contents = {'#!/usr/bin/env bash'} })
 <
 
     Parameters: ~
@@ -2762,10 +2731,9 @@ Lua module: vim.keymap                                            *vim.keymap*
 
 vim.keymap.del({modes}, {lhs}, {opts})                      *vim.keymap.del()*
     Remove an existing mapping. Examples: >lua
+        vim.keymap.del('n', 'lhs')
 
-       vim.keymap.del('n', 'lhs')
-
-       vim.keymap.del({'n', 'i', 'v'}, '<leader>w', { buffer = 5 })
+        vim.keymap.del({'n', 'i', 'v'}, '<leader>w', { buffer = 5 })
 <
 
     Parameters: ~
@@ -2778,19 +2746,18 @@ vim.keymap.del({modes}, {lhs}, {opts})                      *vim.keymap.del()*
 
 vim.keymap.set({mode}, {lhs}, {rhs}, {opts})                *vim.keymap.set()*
     Adds a new |mapping|. Examples: >lua
-
-       -- Map to a Lua function:
-       vim.keymap.set('n', 'lhs', function() print("real lua function") end)
-       -- Map to multiple modes:
-       vim.keymap.set({'n', 'v'}, '<leader>lr', vim.lsp.buf.references, { buffer = true })
-       -- Buffer-local mapping:
-       vim.keymap.set('n', '<leader>w', "<cmd>w<cr>", { silent = true, buffer = 5 })
-       -- Expr mapping:
-       vim.keymap.set('i', '<Tab>', function()
-         return vim.fn.pumvisible() == 1 and "<C-n>" or "<Tab>"
-       end, { expr = true })
-       -- <Plug> mapping:
-       vim.keymap.set('n', '[%', '<Plug>(MatchitNormalMultiBackward)')
+        -- Map to a Lua function:
+        vim.keymap.set('n', 'lhs', function() print("real lua function") end)
+        -- Map to multiple modes:
+        vim.keymap.set({'n', 'v'}, '<leader>lr', vim.lsp.buf.references, { buffer = true })
+        -- Buffer-local mapping:
+        vim.keymap.set('n', '<leader>w', "<cmd>w<cr>", { silent = true, buffer = 5 })
+        -- Expr mapping:
+        vim.keymap.set('i', '<Tab>', function()
+          return vim.fn.pumvisible() == 1 and "<C-n>" or "<Tab>"
+        end, { expr = true })
+        -- <Plug> mapping:
+        vim.keymap.set('n', '[%%', '<Plug>(MatchitNormalMultiBackward)')
 <
 
     Parameters: ~
@@ -2871,24 +2838,23 @@ vim.fs.find({names}, {opts})                                   *vim.fs.find()*
     narrow the search to find only that type.
 
     Examples: >lua
+        -- location of Cargo.toml from the current buffer's path
+        local cargo = vim.fs.find('Cargo.toml', {
+          upward = true,
+          stop = vim.uv.os_homedir(),
+          path = vim.fs.dirname(vim.api.nvim_buf_get_name(0)),
+        })
 
-     -- location of Cargo.toml from the current buffer's path
-     local cargo = vim.fs.find('Cargo.toml', {
-       upward = true,
-       stop = vim.uv.os_homedir(),
-       path = vim.fs.dirname(vim.api.nvim_buf_get_name(0)),
-     })
+        -- list all test directories under the runtime directory
+        local test_dirs = vim.fs.find(
+          {'test', 'tst', 'testdir'},
+          {limit = math.huge, type = 'directory', path = './runtime/'}
+        )
 
-     -- list all test directories under the runtime directory
-     local test_dirs = vim.fs.find(
-       {'test', 'tst', 'testdir'},
-       {limit = math.huge, type = 'directory', path = './runtime/'}
-     )
-
-     -- get all files ending with .cpp or .hpp inside lib/
-     local cpp_hpp = vim.fs.find(function(name, path)
-       return name:match('.*%.[ch]pp$') and path:match('[/\\]lib$')
-     end, {limit = math.huge, type = 'file'})
+        -- get all files ending with .cpp or .hpp inside lib/
+        local cpp_hpp = vim.fs.find(function(name, path)
+          return name:match('.*%.[ch]pp$') and path:match('[/\\\\]lib$')
+        end, {limit = math.huge, type = 'file'})
 <
 
     Parameters: ~
@@ -2934,15 +2900,14 @@ vim.fs.normalize({path}, {opts})                          *vim.fs.normalize()*
     variables are also expanded.
 
     Examples: >lua
+        vim.fs.normalize('C:\\\\Users\\\\jdoe')
+        -- 'C:/Users/jdoe'
 
-       vim.fs.normalize('C:\\Users\\jdoe')
-       --> 'C:/Users/jdoe'
-
-       vim.fs.normalize('~/src/neovim')
-       --> '/home/jdoe/src/neovim'
+        vim.fs.normalize('~/src/neovim')
+        -- '/home/jdoe/src/neovim'
 
-       vim.fs.normalize('$XDG_CONFIG_HOME/nvim/init.vim')
-       --> '/Users/jdoe/.config/nvim/init.vim'
+        vim.fs.normalize('$XDG_CONFIG_HOME/nvim/init.vim')
+        -- '/Users/jdoe/.config/nvim/init.vim'
 <
 
     Parameters: ~
@@ -2958,18 +2923,17 @@ vim.fs.parents({start})                                     *vim.fs.parents()*
     Iterate over all the parents of the given path.
 
     Example: >lua
+        local root_dir
+        for dir in vim.fs.parents(vim.api.nvim_buf_get_name(0)) do
+          if vim.fn.isdirectory(dir .. "/.git") == 1 then
+            root_dir = dir
+            break
+          end
+        end
 
-     local root_dir
-     for dir in vim.fs.parents(vim.api.nvim_buf_get_name(0)) do
-       if vim.fn.isdirectory(dir .. "/.git") == 1 then
-         root_dir = dir
-         break
-       end
-     end
-
-     if root_dir then
-       print("Found git repository at", root_dir)
-     end
+        if root_dir then
+          print("Found git repository at", root_dir)
+        end
 <
 
     Parameters: ~
@@ -3033,11 +2997,10 @@ spec. Plugins, and plugin managers, can use this to check available tools
 and dependencies on the current system.
 
 Example: >lua
-
-   local v = vim.version.parse(vim.fn.system({'tmux', '-V'}), {strict=false})
-   if vim.version.gt(v, {3, 2, 0}) then
-     -- ...
-   end
+    local v = vim.version.parse(vim.fn.system({'tmux', '-V'}), {strict=false})
+    if vim.version.gt(v, {3, 2, 0}) then
+      -- ...
+    end
 
 <
 
@@ -3050,34 +3013,33 @@ tested against a version, using |vim.version.range()|.
 
 Supported range specs are shown in the following table. Note: suffixed
 versions (1.2.3-rc1) are not matched. >
-
-   1.2.3             is 1.2.3
-   =1.2.3            is 1.2.3
-   >1.2.3            greater than 1.2.3
-   <1.2.3            before 1.2.3
-   >=1.2.3           at least 1.2.3
-   ~1.2.3            is >=1.2.3 <1.3.0       "reasonably close to 1.2.3"
-   ^1.2.3            is >=1.2.3 <2.0.0       "compatible with 1.2.3"
-   ^0.2.3            is >=0.2.3 <0.3.0       (0.x.x is special)
-   ^0.0.1            is =0.0.1               (0.0.x is special)
-   ^1.2              is >=1.2.0 <2.0.0       (like ^1.2.0)
-   ~1.2              is >=1.2.0 <1.3.0       (like ~1.2.0)
-   ^1                is >=1.0.0 <2.0.0       "compatible with 1"
-   ~1                same                    "reasonably close to 1"
-   1.x               same
-   1.*               same
-   1                 same
-   *                 any version
-   x                 same
-
-   1.2.3 - 2.3.4     is >=1.2.3 <=2.3.4
-
-   Partial right: missing pieces treated as x (2.3 => 2.3.x).
-   1.2.3 - 2.3       is >=1.2.3 <2.4.0
-   1.2.3 - 2         is >=1.2.3 <3.0.0
-
-   Partial left: missing pieces treated as 0 (1.2 => 1.2.0).
-   1.2 - 2.3.0       is 1.2.0 - 2.3.0
+    1.2.3             is 1.2.3
+    =1.2.3            is 1.2.3
+    >1.2.3            greater than 1.2.3
+    <1.2.3            before 1.2.3
+    >=1.2.3           at least 1.2.3
+    ~1.2.3            is >=1.2.3 <1.3.0       "reasonably close to 1.2.3"
+    ^1.2.3            is >=1.2.3 <2.0.0       "compatible with 1.2.3"
+    ^0.2.3            is >=0.2.3 <0.3.0       (0.x.x is special)
+    ^0.0.1            is =0.0.1               (0.0.x is special)
+    ^1.2              is >=1.2.0 <2.0.0       (like ^1.2.0)
+    ~1.2              is >=1.2.0 <1.3.0       (like ~1.2.0)
+    ^1                is >=1.0.0 <2.0.0       "compatible with 1"
+    ~1                same                    "reasonably close to 1"
+    1.x               same
+    1.*               same
+    1                 same
+    *                 any version
+    x                 same
+
+    1.2.3 - 2.3.4     is >=1.2.3 <=2.3.4
+
+    Partial right: missing pieces treated as x (2.3 => 2.3.x).
+    1.2.3 - 2.3       is >=1.2.3 <2.4.0
+    1.2.3 - 2         is >=1.2.3 <3.0.0
+
+    Partial left: missing pieces treated as 0 (1.2 => 1.2.0).
+    1.2 - 2.3.0       is 1.2.0 - 2.3.0
 
 <
 
@@ -3087,15 +3049,14 @@ vim.version.cmp({v1}, {v2})                                *vim.version.cmp()*
     tuple, e.g. `{1, 0, 3}`).
 
     Example: >lua
-
-       if vim.version.cmp({1,0,3}, {0,2,1}) == 0 then
-         -- ...
-       end
-       local v1 = vim.version.parse('1.0.3-pre')
-       local v2 = vim.version.parse('0.2.1')
-       if vim.version.cmp(v1, v2) == 0 then
-         -- ...
-       end
+        if vim.version.cmp({1,0,3}, {0,2,1}) == 0 then
+          -- ...
+        end
+        local v1 = vim.version.parse('1.0.3-pre')
+        local v2 = vim.version.parse('0.2.1')
+        if vim.version.cmp(v1, v2) == 0 then
+          -- ...
+        end
 <
 
     Note: ~
@@ -3150,9 +3111,9 @@ vim.version.lt({v1}, {v2})                                  *vim.version.lt()*
 
 vim.version.parse({version}, {opts})                     *vim.version.parse()*
     Parses a semantic version string and returns a version object which can be
-    used with other `vim.version` functions. For example "1.0.1-rc1+build.2" returns: >
-
-       { major = 1, minor = 0, patch = 1, prerelease = "rc1", build = "build.2" }
+    used with other `vim.version` functions. For example "1.0.1-rc1+build.2"
+    returns: >
+        { major = 1, minor = 0, patch = 1, prerelease = "rc1", build = "build.2" }
 <
 
     Parameters: ~
@@ -3171,29 +3132,26 @@ vim.version.parse({version}, {opts})                     *vim.version.parse()*
 
 vim.version.range({spec})                                *vim.version.range()*
     Parses a semver |version-range| "spec" and returns a range object: >
-
-       {
-         from: Version
-         to: Version
-         has(v: string|Version)
-       }
+        {
+          from: Version
+          to: Version
+          has(v: string|Version)
+        }
 <
 
     `:has()` checks if a version is in the range (inclusive `from`, exclusive
     `to`).
 
     Example: >lua
-
-       local r = vim.version.range('1.0.0 - 2.0.0')
-       print(r:has('1.9.9'))       -- true
-       print(r:has('2.0.0'))       -- false
-       print(r:has(vim.version())) -- check against current Nvim version
+        local r = vim.version.range('1.0.0 - 2.0.0')
+        print(r:has('1.9.9'))       -- true
+        print(r:has('2.0.0'))       -- false
+        print(r:has(vim.version())) -- check against current Nvim version
 <
 
     Or use cmp(), eq(), lt(), and gt() to compare `.to` and `.from` directly: >lua
-
-       local r = vim.version.range('1.0.0 - 2.0.0')
-       print(vim.version.gt({1,0,3}, r.from) and vim.version.lt({1,0,3}, r.to))
+        local r = vim.version.range('1.0.0 - 2.0.0')
+        print(vim.version.gt({1,0,3}, r.from) and vim.version.lt({1,0,3}, r.to))
 <
 
     Parameters: ~
@@ -3228,7 +3186,6 @@ iterator runs out of values (for function iterators, this means that the
 first value returned by the function is nil).
 
 Examples: >lua
-
     local it = vim.iter({ 1, 2, 3, 4, 5 })
     it:map(function(v)
       return v * 3
@@ -3275,7 +3232,6 @@ filter({f}, {src}, {...})                                  *vim.iter.filter()*
     Filter a table or iterator.
 
     This is a convenience function that performs: >lua
-
         vim.iter(src):filter(f):totable()
 <
 
@@ -3325,19 +3281,16 @@ Iter:enumerate()                                            *Iter:enumerate()*
     the iterator value.
 
     For list tables, prefer >lua
-
         vim.iter(ipairs(t))
 <
 
     over >lua
-
         vim.iter(t):enumerate()
 <
 
     as the former is faster.
 
     Example: >lua
-
         local it = vim.iter(vim.gsplit('abc', '')):enumerate()
         it:next()
         -- 1   'a'
@@ -3354,7 +3307,6 @@ Iter:filter({f})                                               *Iter:filter()*
     Add a filter step to the iterator pipeline.
 
     Example: >lua
-
         local bufs = vim.iter(vim.api.nvim_list_bufs()):filter(vim.api.nvim_buf_is_loaded)
 <
 
@@ -3373,7 +3325,6 @@ Iter:find({f})                                                   *Iter:find()*
     found.
 
     Examples: >lua
-
         local it = vim.iter({ 3, 6, 9, 12 })
         it:find(12)
         -- 12
@@ -3394,7 +3345,6 @@ Iter:fold({init}, {f})                                           *Iter:fold()*
     Fold ("reduce") an iterator or table into a single value.
 
     Examples: >lua
-
         -- Create a new table with only even values
         local t = { a = 1, b = 2, c = 3, d = 4 }
         local it = vim.iter(t)
@@ -3419,7 +3369,6 @@ Iter:last()                                                      *Iter:last()*
     Drains the iterator.
 
     Example: >lua
-
         local it = vim.iter(vim.gsplit('abcdefg', ''))
         it:last()
         -- 'g'
@@ -3438,7 +3387,6 @@ Iter:map({f})                                                     *Iter:map()*
     If the map function returns nil, the value is filtered from the iterator.
 
     Example: >lua
-
         local it = vim.iter({ 1, 2, 3, 4 }):map(function(v)
           if v % 2 == 0 then
             return v * 3
@@ -3461,7 +3409,6 @@ Iter:next()                                                      *Iter:next()*
     Return the next value from the iterator.
 
     Example: >lua
-
         local it = vim.iter(string.gmatch('1 2 3', '%d+')):map(tonumber)
         it:next()
         -- 1
@@ -3480,7 +3427,6 @@ Iter:nextback()                                              *Iter:nextback()*
     Only supported for iterators on list-like tables.
 
     Example: >lua
-
         local it = vim.iter({1, 2, 3, 4})
         it:nextback()
         -- 4
@@ -3497,7 +3443,6 @@ Iter:nth({n})                                                     *Iter:nth()*
     This function advances the iterator.
 
     Example: >lua
-
         local it = vim.iter({ 3, 6, 9, 12 })
         it:nth(2)
         -- 6
@@ -3519,7 +3464,6 @@ Iter:nthback({n})                                             *Iter:nthback()*
     Only supported for iterators on list-like tables.
 
     Example: >lua
-
         local it = vim.iter({ 3, 6, 9, 12 })
         it:nthback(2)
         -- 9
@@ -3539,7 +3483,6 @@ Iter:peek()                                                      *Iter:peek()*
     Only supported for iterators on list-like tables.
 
     Example: >lua
-
         local it = vim.iter({ 3, 6, 9, 12 })
         it:peek()
         -- 3
@@ -3558,7 +3501,6 @@ Iter:peekback()                                              *Iter:peekback()*
     Only supported for iterators on list-like tables.
 
     Example: >lua
-
         local it = vim.iter({1, 2, 3, 4})
         it:peekback()
         -- 4
@@ -3577,7 +3519,6 @@ Iter:rev()                                                        *Iter:rev()*
     Only supported for iterators on list-like tables.
 
     Example: >lua
-
         local it = vim.iter({ 3, 6, 9, 12 }):rev()
         it:totable()
         -- { 12, 9, 6, 3 }
@@ -3596,7 +3537,6 @@ Iter:rfind({f})                                                 *Iter:rfind()*
     Only supported for iterators on list-like tables.
 
     Examples: >lua
-
         local it = vim.iter({ 1, 2, 3, 2, 1 }):enumerate()
         it:rfind(1)
         -- 5   1
@@ -3614,7 +3554,6 @@ Iter:skip({n})                                                   *Iter:skip()*
     Skip values in the iterator.
 
     Example: >lua
-
         local it = vim.iter({ 3, 6, 9, 12 }):skip(2)
         it:next()
         -- 9
@@ -3632,7 +3571,6 @@ Iter:skipback({n})                                           *Iter:skipback()*
     Only supported for iterators on list-like tables.
 
     Example: >lua
-
         local it = vim.iter({ 1, 2, 3, 4, 5 }):skipback(2)
         it:next()
         -- 1
@@ -3669,7 +3607,6 @@ Iter:totable()                                                *Iter:totable()*
     the iterator pipeline, each value will be included in a table.
 
     Examples: >lua
-
         vim.iter(string.gmatch('100 20 50', '%d+')):map(tonumber):totable()
         -- { 100, 20, 50 }
 
@@ -3691,7 +3628,6 @@ map({f}, {src}, {...})                                        *vim.iter.map()*
     Map and filter a table or iterator.
 
     This is a convenience function that performs: >lua
-
         vim.iter(src):map(f):totable()
 <
 
@@ -3711,7 +3647,6 @@ totable({f}, {...})                                       *vim.iter.totable()*
     Collect an iterator into a table.
 
     This is a convenience function that performs: >lua
-
         vim.iter(f):totable()
 <
 
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index f758782f09..e1518c58bb 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -945,7 +945,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 	backups if you don't care about losing the file.
 
 	Note that environment variables are not expanded.  If you want to use
-	$HOME you must expand it explicitly, e.g.: >
+	$HOME you must expand it explicitly, e.g.: >vim
 		:let &backupskip = escape(expand('$HOME'), '\') .. '/tmp/*'
 
 <	Note that the default also makes sure that "crontab -e" works (when a
diff --git a/runtime/doc/treesitter.txt b/runtime/doc/treesitter.txt
index 9d07aee290..c62e210be1 100644
--- a/runtime/doc/treesitter.txt
+++ b/runtime/doc/treesitter.txt
@@ -551,8 +551,7 @@ Lua module: vim.treesitter                               *lua-treesitter-core*
 foldexpr({lnum})                                   *vim.treesitter.foldexpr()*
     Returns the fold level for {lnum} in the current buffer. Can be set
     directly to 'foldexpr': >lua
-
-     vim.wo.foldexpr = 'v:lua.vim.treesitter.foldexpr()'
+        vim.wo.foldexpr = 'v:lua.vim.treesitter.foldexpr()'
 <
 
     Parameters: ~
@@ -746,13 +745,12 @@ start({bufnr}, {lang})                                *vim.treesitter.start()*
     the call to `start`.
 
     Example: >lua
-
-     vim.api.nvim_create_autocmd( 'FileType', { pattern = 'tex',
-         callback = function(args)
-             vim.treesitter.start(args.buf, 'latex')
-             vim.bo[args.buf].syntax = 'on'  -- only if additional legacy syntax is needed
-         end
-     })
+        vim.api.nvim_create_autocmd( 'FileType', { pattern = 'tex',
+            callback = function(args)
+                vim.treesitter.start(args.buf, 'latex')
+                vim.bo[args.buf].syntax = 'on'  -- only if additional legacy syntax is needed
+            end
+        })
 <
 
     Parameters: ~
@@ -922,7 +920,7 @@ omnifunc({findstart}, {base})                *vim.treesitter.query.omnifunc()*
     Omnifunc for completing node names and predicates in treesitter queries.
 
     Use via >lua
-      vim.bo.omnifunc = 'v:lua.vim.treesitter.query.omnifunc'
+        vim.bo.omnifunc = 'v:lua.vim.treesitter.query.omnifunc'
 <
 
 parse({lang}, {query})                          *vim.treesitter.query.parse()*
@@ -958,14 +956,13 @@ Query:iter_captures({node}, {source}, {start}, {stop})
     The iterator returns three values: a numeric id identifying the capture,
     the captured node, and metadata from any directives processing the match.
     The following example shows how to get captures by name: >lua
-
-     for id, node, metadata in query:iter_captures(tree:root(), bufnr, first, last) do
-       local name = query.captures[id] -- name of the capture in the query
-       -- typically useful info about the node:
-       local type = node:type() -- type of the captured node
-       local row1, col1, row2, col2 = node:range() -- range of the capture
-       -- ... use the info here ...
-     end
+        for id, node, metadata in query:iter_captures(tree:root(), bufnr, first, last) do
+          local name = query.captures[id] -- name of the capture in the query
+          -- typically useful info about the node:
+          local type = node:type() -- type of the captured node
+          local row1, col1, row2, col2 = node:range() -- range of the capture
+          -- ... use the info here ...
+        end
 <
 
     Parameters: ~
@@ -988,18 +985,18 @@ Query:iter_matches({node}, {source}, {start}, {stop}, {opts})
     (1-based) index of the pattern in the query, a table mapping capture
     indices to nodes, and metadata from any directives processing the match.
     If the query has more than one pattern, the capture table might be sparse
-    and e.g. `pairs()` method should be used over `ipairs` . Here is an example iterating over all captures in every match: >lua
-
-     for pattern, match, metadata in cquery:iter_matches(tree:root(), bufnr, first, last) do
-       for id, node in pairs(match) do
-         local name = query.captures[id]
-         -- `node` was captured by the `name` capture in the match
-
-         local node_data = metadata[id] -- Node level metadata
-
-         -- ... use the info here ...
-       end
-     end
+    and e.g. `pairs()` method should be used over `ipairs`. Here is an example
+    iterating over all captures in every match: >lua
+        for pattern, match, metadata in cquery:iter_matches(tree:root(), bufnr, first, last) do
+          for id, node in pairs(match) do
+            local name = query.captures[id]
+            -- `node` was captured by the `name` capture in the match
+
+            local node_data = metadata[id] -- Node level metadata
+
+            -- ... use the info here ...
+          end
+        end
 <
 
     Parameters: ~
@@ -1039,11 +1036,8 @@ inject other languages, recursively. For example a Lua buffer containing
 some Vimscript commands needs multiple parsers to fully understand its
 contents.
 
-To create a LanguageTree (parser object) for a given buffer and language, use:
-
->lua
-
-     local parser = vim.treesitter.get_parser(bufnr, lang)
+To create a LanguageTree (parser object) for a given buffer and language, use: >lua
+    local parser = vim.treesitter.get_parser(bufnr, lang)
 
 <
 
@@ -1052,11 +1046,8 @@ Note: currently the parser is retained for the lifetime of a buffer but
 this may change; a plugin should keep a reference to the parser object if
 it wants incremental updates.
 
-Whenever you need to access the current syntax tree, parse the buffer:
-
->lua
-
-     local tree = parser:parse({ start_row, end_row })
+Whenever you need to access the current syntax tree, parse the buffer: >lua
+    local tree = parser:parse({ start_row, end_row })
 
 <
 
diff --git a/runtime/lua/vim/F.lua b/runtime/lua/vim/F.lua
index 16c834b371..5ed60ca8ab 100644
--- a/runtime/lua/vim/F.lua
+++ b/runtime/lua/vim/F.lua
@@ -5,13 +5,14 @@ local F = {}
 --- If all arguments are nil, returns nil.
 ---
 --- Examples:
---- <pre>
+---
+--- ```lua
 --- local a = nil
 --- local b = nil
 --- local c = 42
 --- local d = true
 --- assert(vim.F.if_nil(a, b, c, d) == 42)
---- </pre>
+--- ```
 ---
 ---@param ... any
 ---@return any
diff --git a/runtime/lua/vim/_editor.lua b/runtime/lua/vim/_editor.lua
index 64aeb64736..0215cae0cb 100644
--- a/runtime/lua/vim/_editor.lua
+++ b/runtime/lua/vim/_editor.lua
@@ -70,23 +70,24 @@ vim.log = {
 --- Run a system command
 ---
 --- Examples:
---- <pre>lua
 ---
----   local on_exit = function(obj)
----     print(obj.code)
----     print(obj.signal)
----     print(obj.stdout)
----     print(obj.stderr)
----   end
+--- ```lua
 ---
----   -- Run asynchronously
----   vim.system({'echo', 'hello'}, { text = true }, on_exit)
+--- local on_exit = function(obj)
+---   print(obj.code)
+---   print(obj.signal)
+---   print(obj.stdout)
+---   print(obj.stderr)
+--- end
 ---
----   -- Run synchronously
----   local obj = vim.system({'echo', 'hello'}, { text = true }):wait()
----   -- { code = 0, signal = 0, stdout = 'hello', stderr = '' }
+--- -- Run asynchronously
+--- vim.system({'echo', 'hello'}, { text = true }, on_exit)
 ---
---- </pre>
+--- -- Run synchronously
+--- local obj = vim.system({'echo', 'hello'}, { text = true }):wait()
+--- -- { code = 0, signal = 0, stdout = 'hello', stderr = '' }
+---
+--- ```
 ---
 --- See |uv.spawn()| for more details.
 ---
@@ -200,7 +201,8 @@ do
   --- (such as the |TUI|) pastes text into the editor.
   ---
   --- Example: To remove ANSI color codes when pasting:
-  --- <pre>lua
+  ---
+  --- ```lua
   --- vim.paste = (function(overridden)
   ---   return function(lines, phase)
   ---     for i,line in ipairs(lines) do
@@ -210,7 +212,7 @@ do
   ---     overridden(lines, phase)
   ---   end
   --- end)(vim.paste)
-  --- </pre>
+  --- ```
   ---
   ---@see |paste|
   ---@alias paste_phase -1 | 1 | 2 | 3
@@ -361,32 +363,33 @@ local VIM_CMD_ARG_MAX = 20
 --- command.
 ---
 --- Example:
---- <pre>lua
----   vim.cmd('echo 42')
----   vim.cmd([[
----     augroup My_group
----       autocmd!
----       autocmd FileType c setlocal cindent
----     augroup END
----   ]])
 ---
----   -- Ex command :echo "foo"
----   -- Note string literals need to be double quoted.
----   vim.cmd('echo "foo"')
----   vim.cmd { cmd = 'echo', args = { '"foo"' } }
----   vim.cmd.echo({ args = { '"foo"' } })
----   vim.cmd.echo('"foo"')
+--- ```lua
+--- vim.cmd('echo 42')
+--- vim.cmd([[
+---   augroup My_group
+---     autocmd!
+---     autocmd FileType c setlocal cindent
+---   augroup END
+--- ]])
+---
+--- -- Ex command :echo "foo"
+--- -- Note string literals need to be double quoted.
+--- vim.cmd('echo "foo"')
+--- vim.cmd { cmd = 'echo', args = { '"foo"' } }
+--- vim.cmd.echo({ args = { '"foo"' } })
+--- vim.cmd.echo('"foo"')
 ---
----   -- Ex command :write! myfile.txt
----   vim.cmd('write! myfile.txt')
----   vim.cmd { cmd = 'write', args = { "myfile.txt" }, bang = true }
----   vim.cmd.write { args = { "myfile.txt" }, bang = true }
----   vim.cmd.write { "myfile.txt", bang = true }
+--- -- Ex command :write! myfile.txt
+--- vim.cmd('write! myfile.txt')
+--- vim.cmd { cmd = 'write', args = { "myfile.txt" }, bang = true }
+--- vim.cmd.write { args = { "myfile.txt" }, bang = true }
+--- vim.cmd.write { "myfile.txt", bang = true }
 ---
----   -- Ex command :colorscheme blue
----   vim.cmd('colorscheme blue')
----   vim.cmd.colorscheme('blue')
---- </pre>
+--- -- Ex command :colorscheme blue
+--- vim.cmd('colorscheme blue')
+--- vim.cmd.colorscheme('blue')
+--- ```
 ---
 ---@param command string|table Command(s) to execute.
 ---                            If a string, executes multiple lines of Vim script at once. In this
@@ -871,9 +874,10 @@ end
 --- "Pretty prints" the given arguments and returns them unmodified.
 ---
 --- Example:
---- <pre>lua
----   local hl_normal = vim.print(vim.api.nvim_get_hl_by_name('Normal', true))
---- </pre>
+---
+--- ```lua
+--- local hl_normal = vim.print(vim.api.nvim_get_hl_by_name('Normal', true))
+--- ```
 ---
 --- @see |vim.inspect()|
 --- @see |:=|
@@ -900,10 +904,12 @@ end
 --- Translate keycodes.
 ---
 --- Example:
---- <pre>lua
----   local k = vim.keycode
----   vim.g.mapleader = k'<bs>'
---- </pre>
+---
+--- ```lua
+--- local k = vim.keycode
+--- vim.g.mapleader = k'<bs>'
+--- ```
+---
 --- @param str string String to be converted.
 --- @return string
 --- @see |nvim_replace_termcodes()|
diff --git a/runtime/lua/vim/_meta/api.lua b/runtime/lua/vim/_meta/api.lua
index 7cd0d825a1..6573c68493 100644
--- a/runtime/lua/vim/_meta/api.lua
+++ b/runtime/lua/vim/_meta/api.lua
@@ -127,11 +127,16 @@ function vim.api.nvim__unpack(str) end
 function vim.api.nvim_buf_add_highlight(buffer, ns_id, hl_group, line, col_start, col_end) end
 
 --- Activates buffer-update events on a channel, or as Lua callbacks.
---- Example (Lua): capture buffer updates in a global `events` variable (use "vim.print(events)" to see its contents):
+--- Example (Lua): capture buffer updates in a global `events` variable (use
+--- "vim.print(events)" to see its contents):
+---
 --- ```lua
----   events = {}
----   vim.api.nvim_buf_attach(0, false, {
----     on_lines=function(...) table.insert(events, {...}) end})
+---     events = {}
+---     vim.api.nvim_buf_attach(0, false, {
+---       on_lines = function(...)
+---         table.insert(events, {...})
+---       end,
+---     })
 --- ```
 ---
 --- @param buffer integer Buffer handle, or 0 for current buffer
@@ -314,29 +319,32 @@ function vim.api.nvim_buf_get_extmark_by_id(buffer, ns_id, id, opts) end
 --- Region can be given as (row,col) tuples, or valid extmark ids (whose
 --- positions define the bounds). 0 and -1 are understood as (0,0) and (-1,-1)
 --- respectively, thus the following are equivalent:
+---
 --- ```lua
----   vim.api.nvim_buf_get_extmarks(0, my_ns, 0, -1, {})
----   vim.api.nvim_buf_get_extmarks(0, my_ns, {0,0}, {-1,-1}, {})
+---     vim.api.nvim_buf_get_extmarks(0, my_ns, 0, -1, {})
+---     vim.api.nvim_buf_get_extmarks(0, my_ns, {0,0}, {-1,-1}, {})
 --- ```
+---
 --- If `end` is less than `start`, traversal works backwards. (Useful with
 --- `limit`, to get the first marks prior to a given position.)
 --- Note: when using extmark ranges (marks with a end_row/end_col position)
 --- the `overlap` option might be useful. Otherwise only the start position of
 --- an extmark will be considered.
 --- Example:
+---
 --- ```lua
----   local api = vim.api
----   local pos = api.nvim_win_get_cursor(0)
----   local ns  = api.nvim_create_namespace('my-plugin')
----   -- Create new extmark at line 1, column 1.
----   local m1  = api.nvim_buf_set_extmark(0, ns, 0, 0, {})
----   -- Create new extmark at line 3, column 1.
----   local m2  = api.nvim_buf_set_extmark(0, ns, 2, 0, {})
----   -- Get extmarks only from line 3.
----   local ms  = api.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})
----   -- Get all marks in this buffer + namespace.
----   local all = api.nvim_buf_get_extmarks(0, ns, 0, -1, {})
----   vim.print(ms)
+---     local api = vim.api
+---     local pos = api.nvim_win_get_cursor(0)
+---     local ns  = api.nvim_create_namespace('my-plugin')
+---     -- Create new extmark at line 1, column 1.
+---     local m1  = api.nvim_buf_set_extmark(0, ns, 0, 0, {})
+---     -- Create new extmark at line 3, column 1.
+---     local m2  = api.nvim_buf_set_extmark(0, ns, 2, 0, {})
+---     -- Get extmarks only from line 3.
+---     local ms  = api.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})
+---     -- Get all marks in this buffer + namespace.
+---     local all = api.nvim_buf_get_extmarks(0, ns, 0, -1, {})
+---     vim.print(ms)
 --- ```
 ---
 --- @param buffer integer Buffer handle, or 0 for current buffer
@@ -775,6 +783,7 @@ function vim.api.nvim_command_output(command) end
 
 --- Create or get an autocommand group `autocmd-groups`.
 --- To get an existing group id, do:
+---
 --- ```lua
 ---     local id = vim.api.nvim_create_augroup("MyGroup", {
 ---         clear = false
@@ -790,6 +799,7 @@ function vim.api.nvim_create_augroup(name, opts) end
 
 --- Creates an `autocommand` event handler, defined by `callback` (Lua function or Vimscript function name string) or `command` (Ex command string).
 --- Example using Lua callback:
+---
 --- ```lua
 ---     vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
 ---       pattern = {"*.c", "*.h"},
@@ -798,17 +808,21 @@ function vim.api.nvim_create_augroup(name, opts) end
 ---       end
 ---     })
 --- ```
+---
 --- Example using an Ex command as the handler:
+---
 --- ```lua
 ---     vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
 ---       pattern = {"*.c", "*.h"},
 ---       command = "echo 'Entering a C or C++ file'",
 ---     })
 --- ```
---- Note: `pattern` is NOT automatically expanded (unlike with `:autocmd`), thus names like
---- "$HOME" and "~" must be expanded explicitly:
+---
+--- Note: `pattern` is NOT automatically expanded (unlike with `:autocmd`),
+--- thus names like "$HOME" and "~" must be expanded explicitly:
+---
 --- ```lua
----   pattern = vim.fn.expand("~") .. "/some/path/*.py"
+---     pattern = vim.fn.expand("~") .. "/some/path/*.py"
 --- ```
 ---
 --- @param event any (string|array) Event(s) that will trigger the handler
@@ -870,10 +884,11 @@ function vim.api.nvim_create_namespace(name) end
 --- Creates a global `user-commands` command.
 --- For Lua usage see `lua-guide-commands-create`.
 --- Example:
+---
 --- ```vim
----    :call nvim_create_user_command('SayHello', 'echo "Hello world!"', {'bang': v:true})
----    :SayHello
----    Hello world!
+---     :call nvim_create_user_command('SayHello', 'echo "Hello world!"', {'bang': v:true})
+---     :SayHello
+---     Hello world!
 --- ```
 ---
 --- @param name string Name of the new user command. Must begin with an uppercase
@@ -1084,6 +1099,7 @@ function vim.api.nvim_execute_lua(code, args) end
 --- with escape_ks=false) to replace `keycodes`, then pass the result to
 --- nvim_feedkeys().
 --- Example:
+---
 --- ```vim
 ---     :let key = nvim_replace_termcodes("<C-o>", v:true, v:false, v:true)
 ---     :call nvim_feedkeys(key, 'n', v:false)
@@ -1111,19 +1127,21 @@ function vim.api.nvim_get_api_info() end
 
 --- Get all autocommands that match the corresponding {opts}.
 --- These examples will get autocommands matching ALL the given criteria:
+---
 --- ```lua
----   -- Matches all criteria
----   autocommands = vim.api.nvim_get_autocmds({
----     group = "MyGroup",
----     event = {"BufEnter", "BufWinEnter"},
----     pattern = {"*.c", "*.h"}
----   })
----
----   -- All commands from one group
----   autocommands = vim.api.nvim_get_autocmds({
----     group = "MyGroup",
----   })
+---     -- Matches all criteria
+---     autocommands = vim.api.nvim_get_autocmds({
+---       group = "MyGroup",
+---       event = {"BufEnter", "BufWinEnter"},
+---       pattern = {"*.c", "*.h"}
+---     })
+---
+---     -- All commands from one group
+---     autocommands = vim.api.nvim_get_autocmds({
+---       group = "MyGroup",
+---     })
 --- ```
+---
 --- NOTE: When multiple patterns or events are provided, it will find all the
 --- autocommands that match any combination of them.
 ---
@@ -1149,6 +1167,7 @@ function vim.api.nvim_get_chan_info(chan) end
 --- Returns the 24-bit RGB value of a `nvim_get_color_map()` color name or
 --- "#rrggbb" hexadecimal string.
 --- Example:
+---
 --- ```vim
 ---     :echo nvim_get_color_by_name("Pink")
 ---     :echo nvim_get_color_by_name("#cbcbcb")
@@ -1471,14 +1490,18 @@ function vim.api.nvim_open_term(buffer, opts) end
 --- could let floats hover outside of the main window like a tooltip, but this
 --- should not be used to specify arbitrary WM screen positions.
 --- Example (Lua): window-relative float
+---
 --- ```lua
 ---     vim.api.nvim_open_win(0, false,
 ---       {relative='win', row=3, col=3, width=12, height=3})
 --- ```
+---
 --- Example (Lua): buffer-relative float (travels as buffer is scrolled)
+---
 --- ```lua
 ---     vim.api.nvim_open_win(0, false,
 ---       {relative='win', width=12, height=3, bufpos={100,10}})
+---     })
 --- ```
 ---
 --- @param buffer integer Buffer to display, or 0 for current buffer
@@ -1856,10 +1879,13 @@ function vim.api.nvim_set_hl_ns_fast(ns_id) end
 --- Unlike `:map`, leading/trailing whitespace is accepted as part of the
 --- {lhs} or {rhs}. Empty {rhs} is `<Nop>`. `keycodes` are replaced as usual.
 --- Example:
+---
 --- ```vim
 ---     call nvim_set_keymap('n', ' <NL>', '', {'nowait': v:true})
 --- ```
+---
 --- is equivalent to:
+---
 --- ```vim
 ---     nmap <nowait> <Space><NL> <Nop>
 --- ```
diff --git a/runtime/lua/vim/_meta/builtin.lua b/runtime/lua/vim/_meta/builtin.lua
index d7b76a803c..0a6dd3e151 100644
--- a/runtime/lua/vim/_meta/builtin.lua
+++ b/runtime/lua/vim/_meta/builtin.lua
@@ -131,7 +131,8 @@ function vim.str_utf_pos(str) end
 --- The result can be added to {index} to get the starting byte of a character.
 ---
 --- Examples:
---- <pre>lua
+---
+--- ```lua
 --- -- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
 ---
 --- -- Returns 0 because the index is pointing at the first byte of a character
@@ -139,7 +140,7 @@ function vim.str_utf_pos(str) end
 ---
 --- -- Returns -1 because the index is pointing at the second byte of a character
 --- vim.str_utf_start('æ', 2)
---- </pre>
+--- ```
 ---
 --- @param str string
 --- @param index number
@@ -150,7 +151,8 @@ function vim.str_utf_start(str, index) end
 --- to.
 ---
 --- Examples:
---- <pre>lua
+---
+--- ```lua
 --- -- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
 ---
 --- -- Returns 0 because the index is pointing at the last byte of a character
@@ -158,7 +160,7 @@ function vim.str_utf_start(str, index) end
 ---
 --- -- Returns 1 because the index is pointing at the penultimate byte of a character
 --- vim.str_utf_end('æ', 1)
---- </pre>
+--- ```
 ---
 --- @param str string
 --- @param index number
@@ -204,7 +206,8 @@ function vim.schedule(callback) end
 --- this time.
 ---
 --- Examples:
---- <pre>lua
+---
+--- ```lua
 ---
 --- ---
 --- -- Wait for 100 ms, allowing other events to process
@@ -226,7 +229,7 @@ function vim.schedule(callback) end
 --- if vim.wait(10000, function() return vim.g.timer_result end) then
 ---   print('Only waiting a little bit of time!')
 --- end
---- </pre>
+--- ```
 ---
 --- @param time integer Number of milliseconds to wait
 --- @param callback? fun(): boolean Optional callback. Waits until {callback} returns true
@@ -258,22 +261,23 @@ function vim.wait(time, callback, interval, fast_only) end
 --- likewise experimental).
 ---
 --- Example (stub for a |ui-popupmenu| implementation):
---- <pre>lua
----
----   ns = vim.api.nvim_create_namespace('my_fancy_pum')
----
----   vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)
----     if event == "popupmenu_show" then
----       local items, selected, row, col, grid = ...
----       print("display pum ", #items)
----     elseif event == "popupmenu_select" then
----       local selected = ...
----       print("selected", selected)
----     elseif event == "popupmenu_hide" then
----       print("FIN")
----     end
----   end)
---- </pre>
+---
+--- ```lua
+--- ns = vim.api.nvim_create_namespace('my_fancy_pum')
+---
+--- vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)
+---   if event == "popupmenu_show" then
+---     local items, selected, row, col, grid = ...
+---     print("display pum ", #items)
+---   elseif event == "popupmenu_select" then
+---     local selected = ...
+---     print("selected", selected)
+---   elseif event == "popupmenu_hide" then
+---     print("FIN")
+---   end
+--- end)
+--- ```
+---
 --- @param ns integer
 --- @param options table<string, any>
 --- @param callback fun()
diff --git a/runtime/lua/vim/_meta/diff.lua b/runtime/lua/vim/_meta/diff.lua
index 246ac0c75a..f265139448 100644
--- a/runtime/lua/vim/_meta/diff.lua
+++ b/runtime/lua/vim/_meta/diff.lua
@@ -6,24 +6,25 @@
 --- either directly or via callback arguments, are 1-based.
 ---
 --- Examples:
---- <pre>lua
----     vim.diff('a\\n', 'b\\nc\\n')
----     -- =>
----     -- @@ -1 +1,2 @@
----     -- -a
----     -- +b
----     -- +c
 ---
----     vim.diff('a\\n', 'b\\nc\\n', {result_type = 'indices'})
----     -- =>
----     -- {
----     --   {1, 1, 1, 2}
----     -- }
---- </pre>
+--- ```lua
+--- vim.diff('a\n', 'b\nc\n')
+--- -- =>
+--- -- @@ -1 +1,2 @@
+--- -- -a
+--- -- +b
+--- -- +c
 ---
---- @param a string First string to compare
---- @param b string Second string to compare
---- @param opts table<string,any> Optional parameters:
+--- vim.diff('a\n', 'b\nc\n', {result_type = 'indices'})
+--- -- =>
+--- -- {
+--- --   {1, 1, 1, 2}
+--- -- }
+--- ```
+---
+---@param a string First string to compare
+---@param b string Second string to compare
+---@param opts table<string,any> Optional parameters:
 ---     - `on_hunk` (callback):
 ---       Invoked for each hunk in the diff. Return a negative number
 ---       to cancel the callback for any remaining hunks.
@@ -64,6 +65,6 @@
 ---       Use the indent heuristic for the internal
 ---       diff library.
 ---
---- @return string|table|nil
+---@return string|table|nil
 ---     See {opts.result_type}. `nil` if {opts.on_hunk} is given.
 function vim.diff(a, b, opts) end
diff --git a/runtime/lua/vim/_meta/json.lua b/runtime/lua/vim/_meta/json.lua
index 76a6c7b733..edf905c7c6 100644
--- a/runtime/lua/vim/_meta/json.lua
+++ b/runtime/lua/vim/_meta/json.lua
@@ -1,8 +1,8 @@
---- @meta
+---@meta
 
 -- luacheck: no unused args
 
---- @defgroup vim.json
+---@defgroup vim.json
 ---
 --- This module provides encoding and decoding of Lua objects to and
 --- from JSON-encoded strings. Supports |vim.NIL| and |vim.empty_dict()|.
@@ -14,24 +14,23 @@
 --- - Decodes empty array as `{}` (empty Lua table).
 ---
 --- Example:
---- <pre>lua
---- :lua vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))
---- --> { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }
---- </pre>
---- Parameters: ~
----   • {str}    Stringified JSON data.
----   • {opts}   Options map keys:
----              • luanil: { object: bool, array: bool }
----                • `luanil.object=true` converts `null` in JSON objects to
----                  Lua `nil` instead of `vim.NIL`.
----                • `luanil.array=true` converts `null` in JSON arrays to Lua
----                  `nil` instead of `vim.NIL`.
---- @param str string
---- @param opts? table<string, any>
---- @return any
+---
+--- ```lua
+--- vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))
+--- -- { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }
+--- ```
+---
+---@param str string Stringified JSON data.
+---@param opts? table<string,any> Options table with keys:
+---                                 - luanil: (table) Table with keys:
+---                                   * object: (boolean) When true, converts `null` in JSON objects
+---                                                       to Lua `nil` instead of |vim.NIL|.
+---                                   * array: (boolean) When true, converts `null` in JSON arrays
+---                                                      to Lua `nil` instead of |vim.NIL|.
+---@return any
 function vim.json.decode(str, opts) end
 
 --- Encodes (or "packs") Lua object {obj} as JSON in a Lua string.
---- @param obj any
---- @return string
+---@param obj any
+---@return string
 function vim.json.encode(obj) end
diff --git a/runtime/lua/vim/_meta/misc.lua b/runtime/lua/vim/_meta/misc.lua
index 8a76755962..0d70e16314 100644
--- a/runtime/lua/vim/_meta/misc.lua
+++ b/runtime/lua/vim/_meta/misc.lua
@@ -5,9 +5,11 @@
 --- Invokes |vim-function| or |user-function| {func} with arguments {...}.
 --- See also |vim.fn|.
 --- Equivalent to:
---- <pre>lua
----     vim.fn[func]({...})
---- </pre>
+---
+--- ```lua
+--- vim.fn[func]({...})
+--- ```
+---
 --- @param func fun()
 --- @param ... any
 function vim.call(func, ...) end
diff --git a/runtime/lua/vim/_meta/options.lua b/runtime/lua/vim/_meta/options.lua
index 92dc4b2c7f..af676fa961 100644
--- a/runtime/lua/vim/_meta/options.lua
+++ b/runtime/lua/vim/_meta/options.lua
@@ -141,6 +141,7 @@ vim.bo.ai = vim.bo.autoindent
 --- 	:set autoread<
 --- ```
 ---
+---
 --- @type boolean
 vim.o.autoread = true
 vim.o.ar = vim.o.autoread
@@ -354,6 +355,7 @@ vim.go.bkc = vim.go.backupcopy
 --- ```
 ---     :set bdir=c:\\tmp,\ dir\\,with\\,commas,\\\ dir\ with\ spaces
 --- ```
+---
 --- See also 'backup' and 'writebackup' options.
 --- If you want to hide your backup files on Unix, consider this value:
 --- ```
@@ -409,9 +411,9 @@ vim.go.bex = vim.go.backupext
 ---
 --- Note that environment variables are not expanded.  If you want to use
 --- $HOME you must expand it explicitly, e.g.:
---- ```
---- 	:let &backupskip = escape(expand('$HOME'), '\') .. '/tmp/*'
 ---
+--- ```vim
+--- 	:let &backupskip = escape(expand('$HOME'), '\') .. '/tmp/*'
 --- ```
 --- Note that the default also makes sure that "crontab -e" works (when a
 --- backup would be made by renaming the original file crontab won't see
@@ -833,6 +835,7 @@ vim.bo.cino = vim.bo.cinoptions
 --- 	set cinscopedecls+=signals,public\ slots,private\ slots
 --- ```
 ---
+---
 --- @type string
 vim.o.cinscopedecls = "public,protected,private"
 vim.o.cinsd = vim.o.cinscopedecls
@@ -916,11 +919,11 @@ vim.go.cwh = vim.go.cmdwinheight
 --- The screen column can be an absolute number, or a number preceded with
 --- '+' or '-', which is added to or subtracted from 'textwidth'.
 --- ```
----
 --- 	:set cc=+1	  " highlight column after 'textwidth'
 --- 	:set cc=+1,+2,+3  " highlight three columns after 'textwidth'
 --- 	:hi ColorColumn ctermbg=lightgrey guibg=lightgrey
 --- ```
+---
 --- When 'textwidth' is zero then the items with '-' and '+' are not used.
 --- A maximum of 256 columns are highlighted.
 ---
@@ -1418,6 +1421,7 @@ vim.wo.crb = vim.wo.cursorbind
 --- 	au WinEnter * set cursorline cursorcolumn
 --- ```
 ---
+---
 --- @type boolean
 vim.o.cursorcolumn = false
 vim.o.cuc = vim.o.cursorcolumn
@@ -1499,6 +1503,7 @@ vim.go.debug = vim.o.debug
 --- 	let &l:define = '^\s*\ze\k\+\s*=\s*function('
 --- ```
 ---
+---
 --- @type string
 vim.o.define = ""
 vim.o.def = vim.o.define
@@ -1679,6 +1684,7 @@ vim.go.dex = vim.go.diffexpr
 --- 	:set diffopt-=internal  " do NOT use the internal diff parser
 --- ```
 ---
+---
 --- @type string
 vim.o.diffopt = "internal,filler,closeoff"
 vim.o.dip = vim.o.diffopt
@@ -1729,6 +1735,7 @@ vim.go.dg = vim.go.digraph
 --- ```
 ---     :set dir=c:\\tmp,\ dir\\,with\\,commas,\\\ dir\ with\ spaces
 --- ```
+---
 --- Editing the same file twice will result in a warning.  Using "/tmp" on
 --- is discouraged: if the system crashes you lose the swap file. And
 --- others on the computer may be able to see the files.
@@ -1917,6 +1924,7 @@ vim.go.efm = vim.go.errorformat
 ---     :set ei=WinEnter,WinLeave
 --- ```
 ---
+---
 --- @type string
 vim.o.eventignore = ""
 vim.o.ei = vim.o.eventignore
@@ -2634,14 +2642,12 @@ vim.go.gp = vim.go.grepprg
 --- To disable cursor-styling, reset the option:
 --- ```
 --- 	:set guicursor=
----
 --- ```
 --- To enable mode shapes, "Cursor" highlight, and blinking:
 --- ```
 --- 	:set guicursor=n-v-c:block,i-ci-ve:ver25,r-cr:hor20,o:hor50
 --- 	  \,a:blinkwait700-blinkoff400-blinkon250-Cursor/lCursor
 --- 	  \,sm:block-blinkwait175-blinkoff150-blinkon175
----
 --- ```
 --- The option is a comma-separated list of parts.  Each part consists of a
 --- mode-list and an argument-list:
@@ -2719,6 +2725,7 @@ vim.go.gp = vim.go.grepprg
 ---     :highlight Cursor gui=NONE guifg=bg guibg=fg
 --- ```
 ---
+---
 --- @type string
 vim.o.guicursor = "n-v-c-sm:block,i-ci-ve:ver25,r-cr-o:hor20"
 vim.o.gcr = vim.o.guicursor
@@ -2790,6 +2797,7 @@ vim.go.gcr = vim.go.guicursor
 ---     :set guifont=Andale_Mono:h7.5:w4.5
 --- ```
 ---
+---
 --- @type string
 vim.o.guifont = ""
 vim.o.gfn = vim.o.guifont
@@ -2944,6 +2952,7 @@ vim.go.gtl = vim.go.guitablabel
 --- 	:let &guitabtooltip = "line one\nline two"
 --- ```
 ---
+---
 --- @type string
 vim.o.guitabtooltip = ""
 vim.o.gtt = vim.o.guitabtooltip
@@ -3206,6 +3215,7 @@ vim.go.inc = vim.go.include
 --- ```
 --- 	:setlocal includeexpr=tr(v:fname,'.','/')
 --- ```
+---
 --- Also used for the `gf` command if an unmodified file name can't be
 --- found.  Allows doing "gf" on the name after an 'include' statement.
 --- Also used for `<cfile>`.
@@ -3258,6 +3268,7 @@ vim.bo.inex = vim.bo.includeexpr
 --- 	  autocmd CmdlineLeave /,\? :set nohlsearch
 --- 	augroup END
 --- ```
+---
 --- CTRL-L can be used to add one character from after the current match
 --- to the command line.  If 'ignorecase' and 'smartcase' are set and the
 --- command line has no uppercase characters, the added character is
@@ -3565,6 +3576,7 @@ vim.go.kp = vim.go.keywordprg
 --- ```
 ---     :set langmap=zy,yz,ZY,YZ
 --- ```
+---
 --- The 'langmap' option is a list of parts, separated with commas.  Each
 --- part can be in one of two forms:
 --- 1.  A list of pairs.  Each pair is a "from" character immediately
@@ -3762,6 +3774,7 @@ vim.go.lw = vim.go.lispwords
 --- ```
 --- 	:set list lcs=tab:\ \
 --- ```
+---
 --- Note that list mode will also affect formatting (set with 'textwidth'
 --- or 'wrapmargin') when 'cpoptions' includes 'L'.  See 'listchars' for
 --- changing the way tabs are displayed.
@@ -3790,6 +3803,7 @@ vim.wo.list = vim.o.list
 --- 			>--
 --- 			etc.
 --- ```
+---
 ---   tab:xyz	The 'z' is always used, then 'x' is prepended, and
 --- 		then 'y' is used as many times as will fit.  Thus
 --- 		"tab:<->" displays:
@@ -3801,6 +3815,7 @@ vim.wo.list = vim.o.list
 --- 			<-->
 --- 			etc.
 --- ```
+---
 --- 		When "tab:" is omitted, a tab is shown as ^I.
 --- 						*lcs-space*
 ---   space:c	Character to show for a space.  When omitted, spaces
@@ -3816,6 +3831,7 @@ vim.wo.list = vim.o.list
 --- ```
 --- 			---+---+--
 --- ```
+---
 --- 						*lcs-lead*
 ---   lead:c	Character to show for leading spaces.  When omitted,
 --- 		leading spaces are blank.  Overrides the "space" and
@@ -3824,6 +3840,7 @@ vim.wo.list = vim.o.list
 --- ```
 --- 			:set listchars+=tab:>-,lead:.
 --- ```
+---
 --- 						*lcs-leadmultispace*
 ---   leadmultispace:c...
 --- 		Like the `lcs-multispace` value, but for leading
@@ -3834,6 +3851,7 @@ vim.wo.list = vim.o.list
 --- ```
 --- 			---+---+--XXX
 --- ```
+---
 --- 		Where "XXX" denotes the first non-blank characters in
 --- 		the line.
 --- 						*lcs-trail*
@@ -3941,6 +3959,7 @@ vim.go.mef = vim.go.makeef
 --- 	:set makeencoding=char	" system locale is used
 --- ```
 ---
+---
 --- @type string
 vim.o.makeencoding = ""
 vim.o.menc = vim.o.makeencoding
@@ -3986,13 +4005,11 @@ vim.go.mp = vim.go.makeprg
 --- '>' (for HTML):
 --- ```
 --- 	:set mps+=<:>
----
 --- ```
 --- A more exotic example, to jump between the '=' and ';' in an
 --- assignment, useful for languages like C and Java:
 --- ```
 --- 	:au FileType c,cpp,java set mps+==:;
----
 --- ```
 --- For a more advanced way of using "%", see the matchit.vim plugin in
 --- the $VIMRUNTIME/plugin directory. `add-local-help`
@@ -4078,6 +4095,7 @@ vim.go.mis = vim.go.menuitems
 --- ```
 --- 	{start},{inc},{added}
 --- ```
+---
 --- For most languages the uncompressed word tree fits in memory.  {start}
 --- gives the amount of memory in Kbyte that can be used before any
 --- compression is done.  It should be a bit smaller than the amount of
@@ -4196,6 +4214,7 @@ vim.go.more = vim.o.more
 --- ```
 --- 	:set mouse=nv
 --- ```
+---
 --- To temporarily disable mouse support, hold the shift key while using
 --- the mouse.
 ---
@@ -4299,6 +4318,7 @@ vim.go.mh = vim.go.mousehide
 ---    :map <4-S-LeftDrag>    <4-RightDrag>
 ---    :map <4-S-LeftRelease> <4-RightRelease>
 --- ```
+---
 --- Mouse commands requiring the CTRL modifier can be simulated by typing
 --- the "g" key before using the mouse:
 ---     "g<LeftMouse>"  is "<C-LeftMouse>	(jump to tag under mouse click)
@@ -4477,6 +4497,7 @@ vim.bo.nf = vim.bo.nrformats
 ---     |there          |  4 there      |  1 there      |  1 there
 --- ```
 ---
+---
 --- @type boolean
 vim.o.number = false
 vim.o.nu = vim.o.number
@@ -4710,10 +4731,10 @@ vim.wo.pvw = vim.wo.previewwindow
 --- the popupmenu using `highlight-blend`. For instance, to enable
 --- transparency but force the current selected element to be fully opaque:
 --- ```
----
 --- 	:set pumblend=15
 --- 	:hi PmenuSel blend=0
 --- ```
+---
 --- UI-dependent. Works best with RGB colors. 'termguicolors'
 ---
 --- @type integer
@@ -4986,6 +5007,7 @@ vim.go.ru = vim.go.ruler
 --- 	:set rulerformat=%15(%c%V\ %p%%%)
 --- ```
 ---
+---
 --- @type string
 vim.o.rulerformat = ""
 vim.o.ruf = vim.o.rulerformat
@@ -5363,6 +5385,7 @@ vim.go.ssop = vim.go.sessionoptions
 --- ```
 ---     :set shada='50,<1000,s100,:0,n~/nvim/shada
 --- ```
+---
 --- '50		Marks will be remembered for the last 50 files you
 --- 		edited.
 --- <1000		Contents of registers (up to 1000 lines each) will be
@@ -5449,7 +5472,6 @@ vim.go.sdf = vim.go.shadafile
 --- 	let &shellredir = '2>&1 | %%{ "$_" } | Out-File %s; exit $LastExitCode'
 --- 	let &shellpipe  = '2>&1 | %%{ "$_" } | tee %s; exit $LastExitCode'
 --- 	set shellquote= shellxquote=
----
 --- ```
 --- This option cannot be set from a `modeline` or in the `sandbox`, for
 --- security reasons.
@@ -5726,6 +5748,7 @@ vim.go.shm = vim.go.shortmess
 --- 	:setlocal showbreak=NONE
 --- ```
 ---
+---
 --- @type string
 vim.o.showbreak = ""
 vim.o.sbr = vim.o.showbreak
@@ -5858,15 +5881,16 @@ vim.go.ss = vim.go.sidescroll
 --- 	setlocal sidescrolloff<
 --- 	setlocal sidescrolloff=-1
 --- ```
+---
 --- Example: Try this together with 'sidescroll' and 'listchars' as
 --- 	 in the following example to never allow the cursor to move
 --- 	 onto the "extends" character:
 --- ```
----
 --- 	 :set nowrap sidescroll=1 listchars=extends:>,precedes:<
 --- 	 :set sidescrolloff=1
 --- ```
 ---
+---
 --- @type integer
 vim.o.sidescrolloff = 0
 vim.o.siso = vim.o.sidescrolloff
@@ -6171,6 +6195,7 @@ vim.bo.spo = vim.bo.spelloptions
 --- ```
 --- 	:set sps=file:~/.config/nvim/sugg,best,expr:MySuggest()
 --- ```
+---
 --- This option cannot be set from a `modeline` or in the `sandbox`, for
 --- security reasons.
 ---
@@ -6263,6 +6288,7 @@ vim.go.sol = vim.go.startofline
 --- handler should be written with this in mind.
 ---
 --- Examples:
+---
 --- ```vim
 --- 	" Relative number with bar separator and click handlers:
 --- 	:set statuscolumn=%@SignCb@%s%=%T%@NumCb@%r│%T
@@ -6282,7 +6308,6 @@ vim.go.sol = vim.go.startofline
 --- 	:let &stc='%#NonText#%{&nu?v:lnum:""}' .
 --- 	 '%=%{&rnu&&(v:lnum%2)?"\ ".v:relnum:""}' .
 --- 	 '%#LineNr#%{&rnu&&!(v:lnum%2)?"\ ".v:relnum:""}'
----
 --- ```
 --- WARNING: this expression is evaluated for each screen line so defining
 --- an expensive expression can negatively affect render performance.
@@ -6522,6 +6547,7 @@ vim.wo.stc = vim.wo.statuscolumn
 ---   :endfunction
 --- ```
 ---
+---
 --- @type string
 vim.o.statusline = ""
 vim.o.stl = vim.o.statusline
@@ -6553,6 +6579,7 @@ vim.go.su = vim.go.suffixes
 --- 	:set suffixesadd=.java
 --- ```
 ---
+---
 --- @type string
 vim.o.suffixesadd = ""
 vim.o.sua = vim.o.suffixesadd
@@ -7445,6 +7472,7 @@ vim.go.ww = vim.go.whichwrap
 --- 	:set wc=<Tab>
 --- ```
 ---
+---
 --- @type integer
 vim.o.wildchar = 9
 vim.o.wc = vim.o.wildchar
@@ -7533,6 +7561,7 @@ vim.go.wic = vim.go.wildignorecase
 --- 	:cnoremap <Left> <Space><BS><Left>
 --- 	:cnoremap <Right> <Space><BS><Right>
 --- ```
+---
 --- `hl-WildMenu` highlights the current match.
 ---
 --- @type boolean
@@ -7762,6 +7791,7 @@ vim.go.wh = vim.go.winheight
 --- 	set winhighlight=Normal:MyNormal,NormalNC:MyNormalNC
 --- ```
 ---
+---
 --- @type string
 vim.o.winhighlight = ""
 vim.o.winhl = vim.o.winhighlight
diff --git a/runtime/lua/vim/_meta/spell.lua b/runtime/lua/vim/_meta/spell.lua
index d55867f769..57f2180895 100644
--- a/runtime/lua/vim/_meta/spell.lua
+++ b/runtime/lua/vim/_meta/spell.lua
@@ -10,13 +10,14 @@
 --- the buffer. Consider calling this with |nvim_buf_call()|.
 ---
 --- Example:
---- <pre>lua
----     vim.spell.check("the quik brown fox")
----     -- =>
----     -- {
----     --     {'quik', 'bad', 5}
----     -- }
---- </pre>
+---
+--- ```lua
+--- vim.spell.check("the quik brown fox")
+--- -- =>
+--- -- {
+--- --     {'quik', 'bad', 5}
+--- -- }
+--- ```
 ---
 --- @param str string
 --- @return {[1]: string, [2]: string, [3]: string}[]
diff --git a/runtime/lua/vim/_options.lua b/runtime/lua/vim/_options.lua
index e1c125baf2..7b44f6b35f 100644
--- a/runtime/lua/vim/_options.lua
+++ b/runtime/lua/vim/_options.lua
@@ -7,11 +7,12 @@
 ---"references". |lua-guide-variables| For example, using \`vim.fn.remove()\` on
 ---a Lua list copies the list object to Vimscript and does NOT modify the Lua
 ---list:
----<pre>lua
----    local list = { 1, 2, 3 }
----    vim.fn.remove(list, 0)
----    vim.print(list)  --> "{ 1, 2, 3 }"
----</pre>
+---
+--- ```lua
+--- local list = { 1, 2, 3 }
+--- vim.fn.remove(list, 0)
+--- vim.print(list)  --> "{ 1, 2, 3 }"
+--- ```
 
 ---@addtogroup lua-vimscript
 ---@brief <pre>help
@@ -131,13 +132,17 @@ local function get_options_info(name)
   return info
 end
 
----Environment variables defined in the editor session.
----See |expand-env| and |:let-environment| for the Vimscript behavior.
----Invalid or unset key returns `nil`.
----Example: <pre>lua
----    vim.env.FOO = 'bar'
----    print(vim.env.TERM)
----</pre>
+--- Environment variables defined in the editor session.
+--- See |expand-env| and |:let-environment| for the Vimscript behavior.
+--- Invalid or unset key returns `nil`.
+---
+--- Example:
+---
+--- ```lua
+--- vim.env.FOO = 'bar'
+--- print(vim.env.TERM)
+--- ```
+---
 ---@param var string
 vim.env = setmetatable({}, {
   __index = function(_, k)
@@ -226,16 +231,18 @@ end
 ---global value of a |global-local| option, see |:setglobal|.
 ---</pre>
 
----Get or set |options|. Like `:set`. Invalid key is an error.
+--- Get or set |options|. Like `:set`. Invalid key is an error.
 ---
----Note: this works on both buffer-scoped and window-scoped options using the
----current buffer and window.
+--- Note: this works on both buffer-scoped and window-scoped options using the
+--- current buffer and window.
 ---
----Example: <pre>lua
----    vim.o.cmdheight = 4
----    print(vim.o.columns)
----    print(vim.o.foo)     -- error: invalid key
----</pre>
+--- Example:
+---
+--- ```lua
+--- vim.o.cmdheight = 4
+--- print(vim.o.columns)
+--- print(vim.o.foo)     -- error: invalid key
+--- ```
 vim.o = setmetatable({}, {
   __index = function(_, k)
     return api.nvim_get_option_value(k, {})
@@ -245,18 +252,20 @@ vim.o = setmetatable({}, {
   end,
 })
 
----Get or set global |options|. Like `:setglobal`. Invalid key is
----an error.
+--- Get or set global |options|. Like `:setglobal`. Invalid key is
+--- an error.
 ---
----Note: this is different from |vim.o| because this accesses the global
----option value and thus is mostly useful for use with |global-local|
----options.
+--- Note: this is different from |vim.o| because this accesses the global
+--- option value and thus is mostly useful for use with |global-local|
+--- options.
 ---
----Example: <pre>lua
----    vim.go.cmdheight = 4
----    print(vim.go.columns)
----    print(vim.go.bar)     -- error: invalid key
----</pre>
+--- Example:
+---
+--- ```lua
+--- vim.go.cmdheight = 4
+--- print(vim.go.columns)
+--- print(vim.go.bar)     -- error: invalid key
+--- ```
 vim.go = setmetatable({}, {
   __index = function(_, k)
     return api.nvim_get_option_value(k, { scope = 'global' })
@@ -266,37 +275,39 @@ vim.go = setmetatable({}, {
   end,
 })
 
----Get or set buffer-scoped |options| for the buffer with number {bufnr}.
----Like `:set` and `:setlocal`. If [{bufnr}] is omitted then the current
----buffer is used. Invalid {bufnr} or key is an error.
+--- Get or set buffer-scoped |options| for the buffer with number {bufnr}.
+--- Like `:set` and `:setlocal`. If [{bufnr}] is omitted then the current
+--- buffer is used. Invalid {bufnr} or key is an error.
 ---
----Note: this is equivalent to both `:set` and `:setlocal`.
+--- Note: this is equivalent to both `:set` and `:setlocal`.
 ---
----Example: <pre>lua
----    local bufnr = vim.api.nvim_get_current_buf()
----    vim.bo[bufnr].buflisted = true    -- same as vim.bo.buflisted = true
----    print(vim.bo.comments)
----    print(vim.bo.baz)                 -- error: invalid key
----</pre>
----@param bufnr integer|nil
+--- Example:
+---
+--- ```lua
+--- local bufnr = vim.api.nvim_get_current_buf()
+--- vim.bo[bufnr].buflisted = true    -- same as vim.bo.buflisted = true
+--- print(vim.bo.comments)
+--- print(vim.bo.baz)                 -- error: invalid key
+--- ```
 vim.bo = new_buf_opt_accessor()
 
----Get or set window-scoped |options| for the window with handle {winid} and
----buffer with number {bufnr}. Like `:setlocal` if {bufnr} is provided, like
----`:set` otherwise. If [{winid}] is omitted then the current window is
----used. Invalid {winid}, {bufnr} or key is an error.
+--- Get or set window-scoped |options| for the window with handle {winid} and
+--- buffer with number {bufnr}. Like `:setlocal` if {bufnr} is provided, like
+--- `:set` otherwise. If [{winid}] is omitted then the current window is
+--- used. Invalid {winid}, {bufnr} or key is an error.
 ---
----Note: only {bufnr} with value `0` (the current buffer in the window) is
----supported.
+--- Note: only {bufnr} with value `0` (the current buffer in the window) is
+--- supported.
 ---
----Example: <pre>lua
----    local winid = vim.api.nvim_get_current_win()
----    vim.wo[winid].number = true    -- same as vim.wo.number = true
----    print(vim.wo.foldmarker)
----    print(vim.wo.quux)             -- error: invalid key
----    vim.wo[winid][0].spell = false -- like ':setlocal nospell'
+--- Example:
 ---
----</pre>
+--- ```lua
+--- local winid = vim.api.nvim_get_current_win()
+--- vim.wo[winid].number = true    -- same as vim.wo.number = true
+--- print(vim.wo.foldmarker)
+--- print(vim.wo.quux)             -- error: invalid key
+--- vim.wo[winid][0].spell = false -- like ':setlocal nospell'
+--- ```
 vim.wo = new_win_opt_accessor()
 
 ---@brief [[
@@ -795,77 +806,93 @@ end
 --- @diagnostic disable-next-line:unused-local used for gen_vimdoc
 local Option = {} -- luacheck: no unused
 
----Returns a Lua-representation of the option. Boolean, number and string
----values will be returned in exactly the same fashion.
+--- Returns a Lua-representation of the option. Boolean, number and string
+--- values will be returned in exactly the same fashion.
 ---
----For values that are comma-separated lists, an array will be returned with
----the values as entries in the array: <pre>lua
----    vim.cmd [[set wildignore=*.pyc,*.o]]
+--- For values that are comma-separated lists, an array will be returned with
+--- the values as entries in the array:
 ---
----    vim.print(vim.opt.wildignore:get())
----    -- { "*.pyc", "*.o", }
+--- ```lua
+--- vim.cmd [[set wildignore=*.pyc,*.o]]
 ---
----    for _, ignore_pattern in ipairs(vim.opt.wildignore:get()) do
----        print("Will ignore:", ignore_pattern)
----    end
----    -- Will ignore: *.pyc
----    -- Will ignore: *.o
----</pre>
+--- vim.print(vim.opt.wildignore:get())
+--- -- { "*.pyc", "*.o", }
 ---
----For values that are comma-separated maps, a table will be returned with
----the names as keys and the values as entries: <pre>lua
----    vim.cmd [[set listchars=space:_,tab:>~]]
+--- for _, ignore_pattern in ipairs(vim.opt.wildignore:get()) do
+---     print("Will ignore:", ignore_pattern)
+--- end
+--- -- Will ignore: *.pyc
+--- -- Will ignore: *.o
+--- ```
 ---
----    vim.print(vim.opt.listchars:get())
----    --  { space = "_", tab = ">~", }
+--- For values that are comma-separated maps, a table will be returned with
+--- the names as keys and the values as entries:
 ---
----    for char, representation in pairs(vim.opt.listchars:get()) do
----        print(char, "=>", representation)
----    end
----</pre>
+--- ```lua
+--- vim.cmd [[set listchars=space:_,tab:>~]]
 ---
----For values that are lists of flags, a set will be returned with the flags
----as keys and `true` as entries. <pre>lua
----    vim.cmd [[set formatoptions=njtcroql]]
+--- vim.print(vim.opt.listchars:get())
+--- --  { space = "_", tab = ">~", }
 ---
----    vim.print(vim.opt.formatoptions:get())
----    -- { n = true, j = true, c = true, ... }
+--- for char, representation in pairs(vim.opt.listchars:get()) do
+---     print(char, "=>", representation)
+--- end
+--- ```
+---
+--- For values that are lists of flags, a set will be returned with the flags
+--- as keys and `true` as entries.
+---
+--- ```lua
+--- vim.cmd [[set formatoptions=njtcroql]]
+---
+--- vim.print(vim.opt.formatoptions:get())
+--- -- { n = true, j = true, c = true, ... }
+---
+--- local format_opts = vim.opt.formatoptions:get()
+--- if format_opts.j then
+---     print("J is enabled!")
+--- end
+--- ```
 ---
----    local format_opts = vim.opt.formatoptions:get()
----    if format_opts.j then
----        print("J is enabled!")
----    end
----</pre>
 ---@return string|integer|boolean|nil value of option
 ---@diagnostic disable-next-line:unused-local used for gen_vimdoc
 function Option:get() end
 
----Append a value to string-style options. See |:set+=|
+--- Append a value to string-style options. See |:set+=|
+---
+--- These are equivalent:
+---
+--- ```lua
+--- vim.opt.formatoptions:append('j')
+--- vim.opt.formatoptions = vim.opt.formatoptions + 'j'
+--- ```
 ---
----These are equivalent: <pre>lua
----    vim.opt.formatoptions:append('j')
----    vim.opt.formatoptions = vim.opt.formatoptions + 'j'
----</pre>
 ---@param value string Value to append
---- @diagnostic disable-next-line:unused-local used for gen_vimdoc
+---@diagnostic disable-next-line:unused-local used for gen_vimdoc
 function Option:append(value) end -- luacheck: no unused
 
----Prepend a value to string-style options. See |:set^=|
+--- Prepend a value to string-style options. See |:set^=|
+---
+--- These are equivalent:
+---
+--- ```lua
+--- vim.opt.wildignore:prepend('*.o')
+--- vim.opt.wildignore = vim.opt.wildignore ^ '*.o'
+--- ```
 ---
----These are equivalent: <pre>lua
----    vim.opt.wildignore:prepend('*.o')
----    vim.opt.wildignore = vim.opt.wildignore ^ '*.o'
----</pre>
 ---@param value string Value to prepend
 ---@diagnostic disable-next-line:unused-local used for gen_vimdoc
 function Option:prepend(value) end -- luacheck: no unused
 
----Remove a value from string-style options. See |:set-=|
+--- Remove a value from string-style options. See |:set-=|
+---
+--- These are equivalent:
+---
+--- ```lua
+--- vim.opt.wildignore:remove('*.pyc')
+--- vim.opt.wildignore = vim.opt.wildignore - '*.pyc'
+--- ```
 ---
----These are equivalent: <pre>lua
----    vim.opt.wildignore:remove('*.pyc')
----    vim.opt.wildignore = vim.opt.wildignore - '*.pyc'
----</pre>
 ---@param value string Value to remove
 ---@diagnostic disable-next-line:unused-local used for gen_vimdoc
 function Option:remove(value) end -- luacheck: no unused
diff --git a/runtime/lua/vim/diagnostic.lua b/runtime/lua/vim/diagnostic.lua
index a1f3020c88..b8d3906b7f 100644
--- a/runtime/lua/vim/diagnostic.lua
+++ b/runtime/lua/vim/diagnostic.lua
@@ -553,14 +553,16 @@ end
 --- followed by namespace configuration, and finally global configuration.
 ---
 --- For example, if a user enables virtual text globally with
---- <pre>lua
----   vim.diagnostic.config({ virtual_text = true })
---- </pre>
+---
+--- ```lua
+--- vim.diagnostic.config({ virtual_text = true })
+--- ```
 ---
 --- and a diagnostic producer sets diagnostics with
---- <pre>lua
----   vim.diagnostic.set(ns, 0, diagnostics, { virtual_text = false })
---- </pre>
+---
+--- ```lua
+--- vim.diagnostic.set(ns, 0, diagnostics, { virtual_text = false })
+--- ```
 ---
 --- then virtual text will not be enabled for those diagnostics.
 ---
@@ -1601,18 +1603,20 @@ end
 --- Parse a diagnostic from a string.
 ---
 --- For example, consider a line of output from a linter:
---- <pre>
+---
+--- ```
 --- WARNING filename:27:3: Variable 'foo' does not exist
---- </pre>
+--- ```
 ---
 --- This can be parsed into a diagnostic |diagnostic-structure|
 --- with:
---- <pre>lua
----   local s = "WARNING filename:27:3: Variable 'foo' does not exist"
----   local pattern = "^(%w+) %w+:(%d+):(%d+): (.+)$"
----   local groups = { "severity", "lnum", "col", "message" }
----   vim.diagnostic.match(s, pattern, groups, { WARNING = vim.diagnostic.WARN })
---- </pre>
+---
+--- ```lua
+--- local s = "WARNING filename:27:3: Variable 'foo' does not exist"
+--- local pattern = "^(%w+) %w+:(%d+):(%d+): (.+)$"
+--- local groups = { "severity", "lnum", "col", "message" }
+--- vim.diagnostic.match(s, pattern, groups, { WARNING = vim.diagnostic.WARN })
+--- ```
 ---
 ---@param str string String to parse diagnostics from.
 ---@param pat string Lua pattern with capture groups.
diff --git a/runtime/lua/vim/filetype.lua b/runtime/lua/vim/filetype.lua
index 6fb6f475bc..d847c28f5c 100644
--- a/runtime/lua/vim/filetype.lua
+++ b/runtime/lua/vim/filetype.lua
@@ -2081,43 +2081,45 @@ end
 --- See $VIMRUNTIME/lua/vim/filetype.lua for more examples.
 ---
 --- Example:
---- <pre>lua
----  vim.filetype.add({
----    extension = {
----      foo = 'fooscript',
----      bar = function(path, bufnr)
----        if some_condition() then
----          return 'barscript', function(bufnr)
----            -- Set a buffer variable
----            vim.b[bufnr].barscript_version = 2
----          end
----        end
----        return 'bar'
----      end,
----    },
----    filename = {
----      ['.foorc'] = 'toml',
----      ['/etc/foo/config'] = 'toml',
----    },
----    pattern = {
----      ['.*/etc/foo/.*'] = 'fooscript',
----      -- Using an optional priority
----      ['.*/etc/foo/.*%.conf'] = { 'dosini', { priority = 10 } },
----      -- A pattern containing an environment variable
----      ['${XDG_CONFIG_HOME}/foo/git'] = 'git',
----      ['README.(%a+)$'] = function(path, bufnr, ext)
----        if ext == 'md' then
----          return 'markdown'
----        elseif ext == 'rst' then
----          return 'rst'
----        end
----      end,
----    },
----  })
---- </pre>
+---
+--- ```lua
+--- vim.filetype.add({
+---   extension = {
+---     foo = 'fooscript',
+---     bar = function(path, bufnr)
+---       if some_condition() then
+---         return 'barscript', function(bufnr)
+---           -- Set a buffer variable
+---           vim.b[bufnr].barscript_version = 2
+---         end
+---       end
+---       return 'bar'
+---     end,
+---   },
+---   filename = {
+---     ['.foorc'] = 'toml',
+---     ['/etc/foo/config'] = 'toml',
+---   },
+---   pattern = {
+---     ['.*/etc/foo/.*'] = 'fooscript',
+---     -- Using an optional priority
+---     ['.*/etc/foo/.*%.conf'] = { 'dosini', { priority = 10 } },
+---     -- A pattern containing an environment variable
+---     ['${XDG_CONFIG_HOME}/foo/git'] = 'git',
+---     ['README.(%a+)$'] = function(path, bufnr, ext)
+---       if ext == 'md' then
+---         return 'markdown'
+---       elseif ext == 'rst' then
+---         return 'rst'
+---       end
+---     end,
+---   },
+--- })
+--- ```
 ---
 --- To add a fallback match on contents, use
---- <pre>lua
+---
+--- ```lua
 --- vim.filetype.add {
 ---   pattern = {
 ---     ['.*'] = {
@@ -2133,7 +2135,7 @@ end
 ---     },
 ---   },
 --- }
---- </pre>
+--- ```
 ---
 ---@param filetypes vim.filetype.add.filetypes A table containing new filetype maps (see example).
 function M.add(filetypes)
@@ -2256,19 +2258,19 @@ end
 --- Each of the three options is specified using a key to the single argument of this function.
 --- Example:
 ---
---- <pre>lua
----   -- Using a buffer number
----   vim.filetype.match({ buf = 42 })
+--- ```lua
+--- -- Using a buffer number
+--- vim.filetype.match({ buf = 42 })
 ---
----   -- Override the filename of the given buffer
----   vim.filetype.match({ buf = 42, filename = 'foo.c' })
+--- -- Override the filename of the given buffer
+--- vim.filetype.match({ buf = 42, filename = 'foo.c' })
 ---
----   -- Using a filename without a buffer
----   vim.filetype.match({ filename = 'main.lua' })
+--- -- Using a filename without a buffer
+--- vim.filetype.match({ filename = 'main.lua' })
 ---
----   -- Using file contents
----   vim.filetype.match({ contents = {'#!/usr/bin/env bash'} })
---- </pre>
+--- -- Using file contents
+--- vim.filetype.match({ contents = {'#!/usr/bin/env bash'} })
+--- ```
 ---
 ---@param args vim.filetype.match.args Table specifying which matching strategy to use.
 ---                 Accepted keys are:
@@ -2404,9 +2406,10 @@ end
 --- is set, meaning it should respect all FileType autocmds and ftplugin files.
 ---
 --- Example:
---- <pre>lua
----   vim.filetype.get_option('vim', 'commentstring')
---- </pre>
+---
+--- ```lua
+--- vim.filetype.get_option('vim', 'commentstring')
+--- ```
 ---
 --- Note: this uses |nvim_get_option_value()| but caches the result.
 --- This means |ftplugin| and |FileType| autocommands are only
diff --git a/runtime/lua/vim/fs.lua b/runtime/lua/vim/fs.lua
index 7cd9e3cf04..22612a7255 100644
--- a/runtime/lua/vim/fs.lua
+++ b/runtime/lua/vim/fs.lua
@@ -5,7 +5,8 @@ local iswin = vim.uv.os_uname().sysname == 'Windows_NT'
 --- Iterate over all the parents of the given path.
 ---
 --- Example:
---- <pre>lua
+---
+--- ```lua
 --- local root_dir
 --- for dir in vim.fs.parents(vim.api.nvim_buf_get_name(0)) do
 ---   if vim.fn.isdirectory(dir .. "/.git") == 1 then
@@ -17,7 +18,7 @@ local iswin = vim.uv.os_uname().sysname == 'Windows_NT'
 --- if root_dir then
 ---   print("Found git repository at", root_dir)
 --- end
---- </pre>
+--- ```
 ---
 ---@param start (string) Initial path.
 ---@return fun(_, dir: string): string? # Iterator
@@ -165,7 +166,8 @@ end
 --- to narrow the search to find only that type.
 ---
 --- Examples:
---- <pre>lua
+---
+--- ```lua
 --- -- location of Cargo.toml from the current buffer's path
 --- local cargo = vim.fs.find('Cargo.toml', {
 ---   upward = true,
@@ -183,7 +185,7 @@ end
 --- local cpp_hpp = vim.fs.find(function(name, path)
 ---   return name:match('.*%.[ch]pp$') and path:match('[/\\\\]lib$')
 --- end, {limit = math.huge, type = 'file'})
---- </pre>
+--- ```
 ---
 ---@param names (string|string[]|fun(name: string, path: string): boolean) Names of the items to find.
 ---             Must be base names, paths and globs are not supported when {names} is a string or a table.
@@ -322,16 +324,17 @@ end
 --- variables are also expanded.
 ---
 --- Examples:
---- <pre>lua
----   vim.fs.normalize('C:\\\\Users\\\\jdoe')
----   --> 'C:/Users/jdoe'
 ---
----   vim.fs.normalize('~/src/neovim')
----   --> '/home/jdoe/src/neovim'
+--- ```lua
+--- vim.fs.normalize('C:\\\\Users\\\\jdoe')
+--- -- 'C:/Users/jdoe'
+---
+--- vim.fs.normalize('~/src/neovim')
+--- -- '/home/jdoe/src/neovim'
 ---
----   vim.fs.normalize('$XDG_CONFIG_HOME/nvim/init.vim')
----   --> '/Users/jdoe/.config/nvim/init.vim'
---- </pre>
+--- vim.fs.normalize('$XDG_CONFIG_HOME/nvim/init.vim')
+--- -- '/Users/jdoe/.config/nvim/init.vim'
+--- ```
 ---
 ---@param path (string) Path to normalize
 ---@param opts table|nil Options:
diff --git a/runtime/lua/vim/highlight.lua b/runtime/lua/vim/highlight.lua
index fd4fb54a5b..fc2fd43c97 100644
--- a/runtime/lua/vim/highlight.lua
+++ b/runtime/lua/vim/highlight.lua
@@ -1,23 +1,24 @@
 ---@defgroup vim.highlight
 ---
----@brief
----Nvim includes a function for highlighting a selection on yank.
+--- Nvim includes a function for highlighting a selection on yank.
 ---
----To enable it, add the following to your `init.vim`:
----<pre>vim
----    au TextYankPost * silent! lua vim.highlight.on_yank()
----</pre>
+--- To enable it, add the following to your `init.vim`:
 ---
----You can customize the highlight group and the duration of
----the highlight via:
----<pre>vim
----    au TextYankPost * silent! lua vim.highlight.on_yank {higroup="IncSearch", timeout=150}
----</pre>
+--- ```vim
+--- au TextYankPost * silent! lua vim.highlight.on_yank()
+--- ```
 ---
----If you want to exclude visual selections from highlighting on yank, use:
----<pre>vim
----    au TextYankPost * silent! lua vim.highlight.on_yank {on_visual=false}
----</pre>
+--- You can customize the highlight group and the duration of the highlight via:
+---
+--- ```vim
+--- au TextYankPost * silent! lua vim.highlight.on_yank {higroup="IncSearch", timeout=150}
+--- ```
+---
+--- If you want to exclude visual selections from highlighting on yank, use:
+---
+--- ```vim
+--- au TextYankPost * silent! lua vim.highlight.on_yank {on_visual=false}
+--- ```
 
 local api = vim.api
 
diff --git a/runtime/lua/vim/keymap.lua b/runtime/lua/vim/keymap.lua
index 2b55ddc787..df593be097 100644
--- a/runtime/lua/vim/keymap.lua
+++ b/runtime/lua/vim/keymap.lua
@@ -2,20 +2,21 @@ local keymap = {}
 
 --- Adds a new |mapping|.
 --- Examples:
---- <pre>lua
----   -- Map to a Lua function:
----   vim.keymap.set('n', 'lhs', function() print("real lua function") end)
----   -- Map to multiple modes:
----   vim.keymap.set({'n', 'v'}, '<leader>lr', vim.lsp.buf.references, { buffer = true })
----   -- Buffer-local mapping:
----   vim.keymap.set('n', '<leader>w', "<cmd>w<cr>", { silent = true, buffer = 5 })
----   -- Expr mapping:
----   vim.keymap.set('i', '<Tab>', function()
----     return vim.fn.pumvisible() == 1 and "<C-n>" or "<Tab>"
----   end, { expr = true })
----   -- <Plug> mapping:
----   vim.keymap.set('n', '[%%', '<Plug>(MatchitNormalMultiBackward)')
---- </pre>
+---
+--- ```lua
+--- -- Map to a Lua function:
+--- vim.keymap.set('n', 'lhs', function() print("real lua function") end)
+--- -- Map to multiple modes:
+--- vim.keymap.set({'n', 'v'}, '<leader>lr', vim.lsp.buf.references, { buffer = true })
+--- -- Buffer-local mapping:
+--- vim.keymap.set('n', '<leader>w', "<cmd>w<cr>", { silent = true, buffer = 5 })
+--- -- Expr mapping:
+--- vim.keymap.set('i', '<Tab>', function()
+---   return vim.fn.pumvisible() == 1 and "<C-n>" or "<Tab>"
+--- end, { expr = true })
+--- -- <Plug> mapping:
+--- vim.keymap.set('n', '[%%', '<Plug>(MatchitNormalMultiBackward)')
+--- ```
 ---
 ---@param mode string|table    Mode short-name, see |nvim_set_keymap()|.
 ---                            Can also be list of modes to create mapping on multiple modes.
@@ -80,11 +81,13 @@ end
 
 --- Remove an existing mapping.
 --- Examples:
---- <pre>lua
----   vim.keymap.del('n', 'lhs')
 ---
----   vim.keymap.del({'n', 'i', 'v'}, '<leader>w', { buffer = 5 })
---- </pre>
+--- ```lua
+--- vim.keymap.del('n', 'lhs')
+---
+--- vim.keymap.del({'n', 'i', 'v'}, '<leader>w', { buffer = 5 })
+--- ```
+---
 ---@param opts table|nil A table of optional arguments:
 ---                      - "buffer": (number|boolean) Remove a mapping from the given buffer.
 ---                        When `0` or `true`, use the current buffer.
diff --git a/runtime/lua/vim/lsp.lua b/runtime/lua/vim/lsp.lua
index c25358e557..f68ca7e88c 100644
--- a/runtime/lua/vim/lsp.lua
+++ b/runtime/lua/vim/lsp.lua
@@ -809,13 +809,14 @@ end
 --- Attaches the current buffer to the client.
 ---
 --- Example:
---- <pre>lua
+---
+--- ```lua
 --- vim.lsp.start({
 ---    name = 'my-server-name',
 ---    cmd = {'name-of-language-server-executable'},
 ---    root_dir = vim.fs.dirname(vim.fs.find({'pyproject.toml', 'setup.py'}, { upward = true })[1]),
 --- })
---- </pre>
+--- ```
 ---
 --- See |vim.lsp.start_client()| for all available options. The most important are:
 ---
@@ -1988,9 +1989,10 @@ end
 ---
 --- You can also use the `stop()` function on a |vim.lsp.client| object.
 --- To stop all clients:
---- <pre>lua
+---
+--- ```lua
 --- vim.lsp.stop_client(vim.lsp.get_clients())
---- </pre>
+--- ```
 ---
 --- By default asks the server to shutdown, unless stop was requested
 --- already for this client, then force-shutdown is attempted.
@@ -2502,12 +2504,7 @@ end
 ---@param bufnr integer Buffer number
 ---@param fn function Function to run on each client attached to buffer
 ---                   {bufnr}. The function takes the client, client ID, and
----                   buffer number as arguments. Example:
----             <pre>lua
----               vim.lsp.for_each_buffer_client(0, function(client, client_id, bufnr)
----                 vim.print(client)
----               end)
----             </pre>
+---                   buffer number as arguments.
 ---@deprecated use lsp.get_clients({ bufnr = bufnr }) with regular loop
 function lsp.for_each_buffer_client(bufnr, fn)
   return for_each_buffer_client(bufnr, fn)
diff --git a/runtime/lua/vim/lsp/buf.lua b/runtime/lua/vim/lsp/buf.lua
index 6cd0aa1e95..8a29fac2b5 100644
--- a/runtime/lua/vim/lsp/buf.lua
+++ b/runtime/lua/vim/lsp/buf.lua
@@ -168,13 +168,11 @@ end
 ---
 ---     - filter (function|nil):
 ---         Predicate used to filter clients. Receives a client as argument and must return a
----         boolean. Clients matching the predicate are included. Example:
----
----         <pre>lua
----           -- Never request typescript-language-server for formatting
----           vim.lsp.buf.format {
----             filter = function(client) return client.name ~= "tsserver" end
----           }
+---         boolean. Clients matching the predicate are included. Example: <pre>lua
+---                     -- Never request typescript-language-server for formatting
+---                     vim.lsp.buf.format {
+---                       filter = function(client) return client.name ~= "tsserver" end
+---                     }
 ---         </pre>
 ---
 ---     - async boolean|nil
@@ -555,11 +553,12 @@ end
 --- Send request to the server to resolve document highlights for the current
 --- text document position. This request can be triggered by a  key mapping or
 --- by events such as `CursorHold`, e.g.:
---- <pre>vim
----   autocmd CursorHold  <buffer> lua vim.lsp.buf.document_highlight()
----   autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight()
----   autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()
---- </pre>
+---
+--- ```vim
+--- autocmd CursorHold  <buffer> lua vim.lsp.buf.document_highlight()
+--- autocmd CursorHoldI <buffer> lua vim.lsp.buf.document_highlight()
+--- autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()
+--- ```
 ---
 --- Note: Usage of |vim.lsp.buf.document_highlight()| requires the following highlight groups
 ---       to be defined or you won't be able to see the actual highlights.
diff --git a/runtime/lua/vim/lsp/codelens.lua b/runtime/lua/vim/lsp/codelens.lua
index d581eb985f..384d09ee48 100644
--- a/runtime/lua/vim/lsp/codelens.lua
+++ b/runtime/lua/vim/lsp/codelens.lua
@@ -255,10 +255,10 @@ end
 --- It is recommended to trigger this using an autocmd or via keymap.
 ---
 --- Example:
---- <pre>vim
----   autocmd BufEnter,CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh()
---- </pre>
 ---
+--- ```vim
+--- autocmd BufEnter,CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh()
+--- ```
 function M.refresh()
   local params = {
     textDocument = util.make_text_document_params(),
diff --git a/runtime/lua/vim/lsp/diagnostic.lua b/runtime/lua/vim/lsp/diagnostic.lua
index 2a77992c4d..73ffa1a46c 100644
--- a/runtime/lua/vim/lsp/diagnostic.lua
+++ b/runtime/lua/vim/lsp/diagnostic.lua
@@ -203,7 +203,8 @@ end
 ---
 --- See |vim.diagnostic.config()| for configuration options. Handler-specific
 --- configuration can be set using |vim.lsp.with()|:
---- <pre>lua
+---
+--- ```lua
 --- vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
 ---   vim.lsp.diagnostic.on_publish_diagnostics, {
 ---     -- Enable underline, use default values
@@ -221,7 +222,7 @@ end
 ---     update_in_insert = false,
 ---   }
 --- )
---- </pre>
+--- ```
 ---
 ---@param config table Configuration table (see |vim.diagnostic.config()|).
 function M.on_publish_diagnostics(_, result, ctx, config)
@@ -263,7 +264,8 @@ end
 ---
 --- See |vim.diagnostic.config()| for configuration options. Handler-specific
 --- configuration can be set using |vim.lsp.with()|:
---- <pre>lua
+---
+--- ```lua
 --- vim.lsp.handlers["textDocument/diagnostic"] = vim.lsp.with(
 ---   vim.lsp.diagnostic.on_diagnostic, {
 ---     -- Enable underline, use default values
@@ -281,7 +283,7 @@ end
 ---     update_in_insert = false,
 ---   }
 --- )
---- </pre>
+--- ```
 ---
 ---@param config table Configuration table (see |vim.diagnostic.config()|).
 function M.on_diagnostic(_, result, ctx, config)
diff --git a/runtime/lua/vim/lsp/handlers.lua b/runtime/lua/vim/lsp/handlers.lua
index 81d4d6cceb..4ea3dde81c 100644
--- a/runtime/lua/vim/lsp/handlers.lua
+++ b/runtime/lua/vim/lsp/handlers.lua
@@ -342,16 +342,18 @@ M[ms.textDocument_completion] = function(_, result, _, _)
 end
 
 --- |lsp-handler| for the method "textDocument/hover"
---- <pre>lua
----   vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(
----     vim.lsp.handlers.hover, {
----       -- Use a sharp border with `FloatBorder` highlights
----       border = "single",
----       -- add the title in hover float window
----       title = "hover"
----     }
----   )
---- </pre>
+---
+--- ```lua
+--- vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(
+---   vim.lsp.handlers.hover, {
+---     -- Use a sharp border with `FloatBorder` highlights
+---     border = "single",
+---     -- add the title in hover float window
+---     title = "hover"
+---   }
+--- )
+--- ```
+---
 ---@param config table Configuration table.
 ---     - border:     (default=nil)
 ---         - Add borders to the floating window
@@ -430,15 +432,20 @@ M[ms.textDocument_typeDefinition] = location_handler
 M[ms.textDocument_implementation] = location_handler
 
 --- |lsp-handler| for the method "textDocument/signatureHelp".
+---
 --- The active parameter is highlighted with |hl-LspSignatureActiveParameter|.
---- <pre>lua
----   vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with(
----     vim.lsp.handlers.signature_help, {
----       -- Use a sharp border with `FloatBorder` highlights
----       border = "single"
----     }
----   )
---- </pre>
+---
+--- ```lua
+--- vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with(
+---   vim.lsp.handlers.signature_help, {
+---     -- Use a sharp border with `FloatBorder` highlights
+---     border = "single"
+---   }
+--- )
+--- ```
+---
+---@param result table Response from the language server
+---@param ctx table Client context
 ---@param config table Configuration table.
 ---     - border:     (default=nil)
 ---         - Add borders to the floating window
diff --git a/runtime/lua/vim/lsp/semantic_tokens.lua b/runtime/lua/vim/lsp/semantic_tokens.lua
index 5b20344bd3..a5831c0beb 100644
--- a/runtime/lua/vim/lsp/semantic_tokens.lua
+++ b/runtime/lua/vim/lsp/semantic_tokens.lua
@@ -555,9 +555,10 @@ local M = {}
 --- delete the semanticTokensProvider table from the {server_capabilities} of
 --- your client in your |LspAttach| callback or your configuration's
 --- `on_attach` callback:
---- <pre>lua
----   client.server_capabilities.semanticTokensProvider = nil
---- </pre>
+---
+--- ```lua
+--- client.server_capabilities.semanticTokensProvider = nil
+--- ```
 ---
 ---@param bufnr integer
 ---@param client_id integer
diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua
index 422d49d746..0c38fa955a 100644
--- a/runtime/lua/vim/shared.lua
+++ b/runtime/lua/vim/shared.lua
@@ -65,19 +65,21 @@ end
 --- (as opposed to |vim.split()| which is "eager").
 ---
 --- Example:
----   <pre>lua
----   for s in vim.gsplit(':aa::b:', ':', {plain=true}) do
----     print(s)
----   end
----   </pre>
+---
+--- ```lua
+--- for s in vim.gsplit(':aa::b:', ':', {plain=true}) do
+---   print(s)
+--- end
+--- ```
 ---
 --- If you want to also inspect the separator itself (instead of discarding it), use
 --- |string.gmatch()|. Example:
----   <pre>lua
----   for word, num in ('foo111bar222'):gmatch('([^0-9]*)(%d*)') do
----     print(('word: %s num: %s'):format(word, num))
----   end
----   </pre>
+---
+--- ```lua
+--- for word, num in ('foo111bar222'):gmatch('([^0-9]*)(%d*)') do
+---   print(('word: %s num: %s'):format(word, num))
+--- end
+--- ```
 ---
 --- @see |string.gmatch()|
 --- @see |vim.split()|
@@ -165,12 +167,13 @@ end
 --- |vim.gsplit()|).
 ---
 --- Examples:
---- <pre>lua
----  split(":aa::b:", ":")                   --> {'','aa','','b',''}
----  split("axaby", "ab?")                   --> {'','x','y'}
----  split("x*yz*o", "*", {plain=true})      --> {'x','yz','o'}
----  split("|x|y|z|", "|", {trimempty=true}) --> {'x', 'y', 'z'}
---- </pre>
+---
+--- ```lua
+--- split(":aa::b:", ":")                   --> {'','aa','','b',''}
+--- split("axaby", "ab?")                   --> {'','x','y'}
+--- split("x*yz*o", "*", {plain=true})      --> {'x','yz','o'}
+--- split("|x|y|z|", "|", {trimempty=true}) --> {'x', 'y', 'z'}
+--- ```
 ---
 ---@see |vim.gsplit()|
 ---@see |string.gmatch()|
@@ -259,12 +262,13 @@ end
 --- a predicate that is checked for each value.
 ---
 --- Example:
---- <pre>lua
----  vim.tbl_contains({ 'a', { 'b', 'c' } }, function(v)
----    return vim.deep_equal(v, { 'b', 'c' })
----  end, { predicate = true })
----  -- true
---- </pre>
+---
+--- ```lua
+--- vim.tbl_contains({ 'a', { 'b', 'c' } }, function(v)
+---   return vim.deep_equal(v, { 'b', 'c' })
+--- end, { predicate = true })
+--- -- true
+--- ```
 ---
 ---@see |vim.list_contains()| for checking values in list-like tables
 ---
@@ -455,10 +459,11 @@ end
 --- Return `nil` if the key does not exist.
 ---
 --- Examples:
---- <pre>lua
----  vim.tbl_get({ key = { nested_key = true }}, 'key', 'nested_key') == true
----  vim.tbl_get({ key = {}}, 'key', 'nested_key') == nil
---- </pre>
+---
+--- ```lua
+--- vim.tbl_get({ key = { nested_key = true }}, 'key', 'nested_key') == true
+--- vim.tbl_get({ key = {}}, 'key', 'nested_key') == nil
+--- ```
 ---
 ---@param o table Table to index
 ---@param ... any Optional keys (0 or more, variadic) via which to index the table
@@ -626,10 +631,10 @@ end
 
 --- Counts the number of non-nil values in table `t`.
 ---
---- <pre>lua
+--- ```lua
 --- vim.tbl_count({ a=1, b=2 })  --> 2
 --- vim.tbl_count({ 1, 2 })      --> 2
---- </pre>
+--- ```
 ---
 ---@see https://github.com/Tieske/Penlight/blob/master/lua/pl/tablex.lua
 ---@param t table Table
@@ -703,38 +708,41 @@ end
 --- Validates a parameter specification (types and values).
 ---
 --- Usage example:
---- <pre>lua
----  function user.new(name, age, hobbies)
----    vim.validate{
----      name={name, 'string'},
----      age={age, 'number'},
----      hobbies={hobbies, 'table'},
----    }
----    ...
----  end
---- </pre>
+---
+--- ```lua
+--- function user.new(name, age, hobbies)
+---   vim.validate{
+---     name={name, 'string'},
+---     age={age, 'number'},
+---     hobbies={hobbies, 'table'},
+---   }
+---   ...
+--- end
+--- ```
 ---
 --- Examples with explicit argument values (can be run directly):
---- <pre>lua
----  vim.validate{arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
----     --> NOP (success)
 ---
----  vim.validate{arg1={1, 'table'}}
----     --> error('arg1: expected table, got number')
+--- ```lua
+--- vim.validate{arg1={{'foo'}, 'table'}, arg2={'foo', 'string'}}
+---    --> NOP (success)
 ---
----  vim.validate{arg1={3, function(a) return (a % 2) == 0 end, 'even number'}}
----     --> error('arg1: expected even number, got 3')
---- </pre>
+--- vim.validate{arg1={1, 'table'}}
+---    --> error('arg1: expected table, got number')
+---
+--- vim.validate{arg1={3, function(a) return (a % 2) == 0 end, 'even number'}}
+---    --> error('arg1: expected even number, got 3')
+--- ```
 ---
 --- If multiple types are valid they can be given as a list.
---- <pre>lua
----  vim.validate{arg1={{'foo'}, {'table', 'string'}}, arg2={'foo', {'table', 'string'}}}
----     --> NOP (success)
 ---
----  vim.validate{arg1={1, {'string', 'table'}}}
----     --> error('arg1: expected string|table, got number')
+--- ```lua
+--- vim.validate{arg1={{'foo'}, {'table', 'string'}}, arg2={'foo', {'table', 'string'}}}
+--- -- NOP (success)
+---
+--- vim.validate{arg1={1, {'string', 'table'}}}
+--- -- error('arg1: expected string|table, got number')
 ---
---- </pre>
+--- ```
 ---
 ---@param opt table Names of parameters to validate. Each key is a parameter
 ---          name; each value is a tuple in one of these forms:
@@ -866,10 +874,10 @@ end
 --- If {create} is `nil`, this will create a defaulttable whose constructor function is
 --- this function, effectively allowing to create nested tables on the fly:
 ---
---- <pre>lua
+--- ```lua
 --- local a = vim.defaulttable()
 --- a.b.c = 1
---- </pre>
+--- ```
 ---
 ---@param create function?(key:any):any The function called to create a missing value.
 ---@return table Empty table with metamethod
@@ -938,7 +946,7 @@ do
   --- Create a ring buffer limited to a maximal number of items.
   --- Once the buffer is full, adding a new entry overrides the oldest entry.
   ---
-  --- <pre>
+  --- ```lua
   ---   local ringbuf = vim.ringbuf(4)
   ---   ringbuf:push("a")
   ---   ringbuf:push("b")
@@ -952,7 +960,7 @@ do
   ---   for val in ringbuf do
   ---     print(val)
   ---   end
-  --- </pre>
+  --- ```
   ---
   --- Returns a Ringbuf instance with the following methods:
   ---
diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index 4f84fc2e0f..169aa6c269 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -441,14 +441,15 @@ end
 --- In this case, add ``vim.bo.syntax = 'on'`` after the call to `start`.
 ---
 --- Example:
---- <pre>lua
+---
+--- ```lua
 --- vim.api.nvim_create_autocmd( 'FileType', { pattern = 'tex',
 ---     callback = function(args)
 ---         vim.treesitter.start(args.buf, 'latex')
 ---         vim.bo[args.buf].syntax = 'on'  -- only if additional legacy syntax is needed
 ---     end
 --- })
---- </pre>
+--- ```
 ---
 ---@param bufnr (integer|nil) Buffer to be highlighted (default: current buffer)
 ---@param lang (string|nil) Language of the parser (default: buffer filetype)
@@ -502,9 +503,11 @@ function M.preview_query()
 end
 
 --- Returns the fold level for {lnum} in the current buffer. Can be set directly to 'foldexpr':
---- <pre>lua
+---
+--- ```lua
 --- vim.wo.foldexpr = 'v:lua.vim.treesitter.foldexpr()'
---- </pre>
+--- ```
+---
 ---@param lnum integer|nil Line number to calculate fold level for
 ---@return string
 function M.foldexpr(lnum)
diff --git a/runtime/lua/vim/treesitter/languagetree.lua b/runtime/lua/vim/treesitter/languagetree.lua
index 1ea0f6b2b9..79f36a27fd 100644
--- a/runtime/lua/vim/treesitter/languagetree.lua
+++ b/runtime/lua/vim/treesitter/languagetree.lua
@@ -7,9 +7,9 @@
 ---
 --- To create a LanguageTree (parser object) for a given buffer and language, use:
 ---
---- <pre>lua
----     local parser = vim.treesitter.get_parser(bufnr, lang)
---- </pre>
+--- ```lua
+--- local parser = vim.treesitter.get_parser(bufnr, lang)
+--- ```
 ---
 --- (where `bufnr=0` means current buffer). `lang` defaults to 'filetype'.
 --- Note: currently the parser is retained for the lifetime of a buffer but this may change;
@@ -17,9 +17,9 @@
 ---
 --- Whenever you need to access the current syntax tree, parse the buffer:
 ---
---- <pre>lua
----     local tree = parser:parse({ start_row, end_row })
---- </pre>
+--- ```lua
+--- local tree = parser:parse({ start_row, end_row })
+--- ```
 ---
 --- This returns a table of immutable |treesitter-tree| objects representing the current state of
 --- the buffer. When the plugin wants to access the state after a (possible) edit it must call
diff --git a/runtime/lua/vim/treesitter/query.lua b/runtime/lua/vim/treesitter/query.lua
index 3093657313..350ccba7e4 100644
--- a/runtime/lua/vim/treesitter/query.lua
+++ b/runtime/lua/vim/treesitter/query.lua
@@ -692,7 +692,8 @@ end
 --- The iterator returns three values: a numeric id identifying the capture,
 --- the captured node, and metadata from any directives processing the match.
 --- The following example shows how to get captures by name:
---- <pre>lua
+---
+--- ```lua
 --- for id, node, metadata in query:iter_captures(tree:root(), bufnr, first, last) do
 ---   local name = query.captures[id] -- name of the capture in the query
 ---   -- typically useful info about the node:
@@ -700,7 +701,7 @@ end
 ---   local row1, col1, row2, col2 = node:range() -- range of the capture
 ---   -- ... use the info here ...
 --- end
---- </pre>
+--- ```
 ---
 ---@param node TSNode under which the search will occur
 ---@param source (integer|string) Source buffer or string to extract text from
@@ -743,7 +744,8 @@ end
 --- If the query has more than one pattern, the capture table might be sparse
 --- and e.g. `pairs()` method should be used over `ipairs`.
 --- Here is an example iterating over all captures in every match:
---- <pre>lua
+---
+--- ```lua
 --- for pattern, match, metadata in cquery:iter_matches(tree:root(), bufnr, first, last) do
 ---   for id, node in pairs(match) do
 ---     local name = query.captures[id]
@@ -754,7 +756,7 @@ end
 ---     -- ... use the info here ...
 ---   end
 --- end
---- </pre>
+--- ```
 ---
 ---@param node TSNode under which the search will occur
 ---@param source (integer|string) Source buffer or string to search
@@ -824,9 +826,11 @@ end
 --- Omnifunc for completing node names and predicates in treesitter queries.
 ---
 --- Use via
---- <pre>lua
----   vim.bo.omnifunc = 'v:lua.vim.treesitter.query.omnifunc'
---- </pre>
+---
+--- ```lua
+--- vim.bo.omnifunc = 'v:lua.vim.treesitter.query.omnifunc'
+--- ```
+---
 function M.omnifunc(findstart, base)
   return require('vim.treesitter._query_linter').omnifunc(findstart, base)
 end
diff --git a/runtime/lua/vim/ui.lua b/runtime/lua/vim/ui.lua
index cd90886489..b6ddf337ce 100644
--- a/runtime/lua/vim/ui.lua
+++ b/runtime/lua/vim/ui.lua
@@ -3,6 +3,23 @@ local M = {}
 --- Prompts the user to pick from a list of items, allowing arbitrary (potentially asynchronous)
 --- work until `on_choice`.
 ---
+--- Example:
+---
+--- ```lua
+--- vim.ui.select({ 'tabs', 'spaces' }, {
+---     prompt = 'Select tabs or spaces:',
+---     format_item = function(item)
+---         return "I'd like to choose " .. item
+---     end,
+--- }, function(choice)
+---     if choice == 'spaces' then
+---         vim.o.expandtab = true
+---     else
+---         vim.o.expandtab = false
+---     end
+--- end)
+--- ```
+---
 ---@param items table Arbitrary items
 ---@param opts table Additional options
 ---     - prompt (string|nil)
@@ -19,23 +36,6 @@ local M = {}
 ---               Called once the user made a choice.
 ---               `idx` is the 1-based index of `item` within `items`.
 ---               `nil` if the user aborted the dialog.
----
----
---- Example:
---- <pre>lua
---- vim.ui.select({ 'tabs', 'spaces' }, {
----     prompt = 'Select tabs or spaces:',
----     format_item = function(item)
----         return "I'd like to choose " .. item
----     end,
---- }, function(choice)
----     if choice == 'spaces' then
----         vim.o.expandtab = true
----     else
----         vim.o.expandtab = false
----     end
---- end)
---- </pre>
 function M.select(items, opts, on_choice)
   vim.validate({
     items = { items, 'table', false },
@@ -58,6 +58,14 @@ end
 --- Prompts the user for input, allowing arbitrary (potentially asynchronous) work until
 --- `on_confirm`.
 ---
+--- Example:
+---
+--- ```lua
+--- vim.ui.input({ prompt = 'Enter value for shiftwidth: ' }, function(input)
+---     vim.o.shiftwidth = tonumber(input)
+--- end)
+--- ```
+---
 ---@param opts table Additional options. See |input()|
 ---     - prompt (string|nil)
 ---               Text of the prompt
@@ -77,13 +85,6 @@ end
 ---               `input` is what the user typed (it might be
 ---               an empty string if nothing was entered), or
 ---               `nil` if the user aborted the dialog.
----
---- Example:
---- <pre>lua
---- vim.ui.input({ prompt = 'Enter value for shiftwidth: ' }, function(input)
----     vim.o.shiftwidth = tonumber(input)
---- end)
---- </pre>
 function M.input(opts, on_confirm)
   vim.validate({
     on_confirm = { on_confirm, 'function', false },
@@ -110,11 +111,12 @@ end
 --- Expands "~/" and environment variables in filesystem paths.
 ---
 --- Examples:
---- <pre>lua
+---
+--- ```lua
 --- vim.ui.open("https://neovim.io/")
 --- vim.ui.open("~/path/to/file")
 --- vim.ui.open("$VIMRUNTIME")
---- </pre>
+--- ```
 ---
 ---@param path string Path or URL to open
 ---
diff --git a/runtime/lua/vim/version.lua b/runtime/lua/vim/version.lua
index 056e1678ff..306eef90d3 100644
--- a/runtime/lua/vim/version.lua
+++ b/runtime/lua/vim/version.lua
@@ -5,12 +5,13 @@
 --- available tools and dependencies on the current system.
 ---
 --- Example:
----   <pre>lua
----   local v = vim.version.parse(vim.fn.system({'tmux', '-V'}), {strict=false})
----   if vim.version.gt(v, {3, 2, 0}) then
----     -- ...
----   end
----   </pre>
+---
+--- ```lua
+--- local v = vim.version.parse(vim.fn.system({'tmux', '-V'}), {strict=false})
+--- if vim.version.gt(v, {3, 2, 0}) then
+---   -- ...
+--- end
+--- ```
 ---
 --- \*vim.version()\* returns the version of the current Nvim process.
 ---
@@ -21,35 +22,36 @@
 ---
 --- Supported range specs are shown in the following table.
 --- Note: suffixed versions (1.2.3-rc1) are not matched.
----   <pre>
----   1.2.3             is 1.2.3
----   =1.2.3            is 1.2.3
----   >1.2.3            greater than 1.2.3
----   <1.2.3            before 1.2.3
----   >=1.2.3           at least 1.2.3
----   ~1.2.3            is >=1.2.3 <1.3.0       "reasonably close to 1.2.3"
----   ^1.2.3            is >=1.2.3 <2.0.0       "compatible with 1.2.3"
----   ^0.2.3            is >=0.2.3 <0.3.0       (0.x.x is special)
----   ^0.0.1            is =0.0.1               (0.0.x is special)
----   ^1.2              is >=1.2.0 <2.0.0       (like ^1.2.0)
----   ~1.2              is >=1.2.0 <1.3.0       (like ~1.2.0)
----   ^1                is >=1.0.0 <2.0.0       "compatible with 1"
----   ~1                same                    "reasonably close to 1"
----   1.x               same
----   1.*               same
----   1                 same
----   *                 any version
----   x                 same
 ---
----   1.2.3 - 2.3.4     is >=1.2.3 <=2.3.4
+--- ```
+--- 1.2.3             is 1.2.3
+--- =1.2.3            is 1.2.3
+--- >1.2.3            greater than 1.2.3
+--- <1.2.3            before 1.2.3
+--- >=1.2.3           at least 1.2.3
+--- ~1.2.3            is >=1.2.3 <1.3.0       "reasonably close to 1.2.3"
+--- ^1.2.3            is >=1.2.3 <2.0.0       "compatible with 1.2.3"
+--- ^0.2.3            is >=0.2.3 <0.3.0       (0.x.x is special)
+--- ^0.0.1            is =0.0.1               (0.0.x is special)
+--- ^1.2              is >=1.2.0 <2.0.0       (like ^1.2.0)
+--- ~1.2              is >=1.2.0 <1.3.0       (like ~1.2.0)
+--- ^1                is >=1.0.0 <2.0.0       "compatible with 1"
+--- ~1                same                    "reasonably close to 1"
+--- 1.x               same
+--- 1.*               same
+--- 1                 same
+--- *                 any version
+--- x                 same
+---
+--- 1.2.3 - 2.3.4     is >=1.2.3 <=2.3.4
 ---
----   Partial right: missing pieces treated as x (2.3 => 2.3.x).
----   1.2.3 - 2.3       is >=1.2.3 <2.4.0
----   1.2.3 - 2         is >=1.2.3 <3.0.0
+--- Partial right: missing pieces treated as x (2.3 => 2.3.x).
+--- 1.2.3 - 2.3       is >=1.2.3 <2.4.0
+--- 1.2.3 - 2         is >=1.2.3 <3.0.0
 ---
----   Partial left: missing pieces treated as 0 (1.2 => 1.2.0).
----   1.2 - 2.3.0       is 1.2.0 - 2.3.0
----   </pre>
+--- Partial left: missing pieces treated as 0 (1.2 => 1.2.0).
+--- 1.2 - 2.3.0       is 1.2.0 - 2.3.0
+--- ```
 
 local M = {}
 
@@ -237,29 +239,32 @@ function VersionRange:has(version)
 end
 
 --- Parses a semver |version-range| "spec" and returns a range object:
----   <pre>
----   {
----     from: Version
----     to: Version
----     has(v: string|Version)
----   }
----   </pre>
+---
+--- ```
+--- {
+---   from: Version
+---   to: Version
+---   has(v: string|Version)
+--- }
+--- ```
 ---
 --- `:has()` checks if a version is in the range (inclusive `from`, exclusive `to`).
 ---
 --- Example:
----   <pre>lua
----   local r = vim.version.range('1.0.0 - 2.0.0')
----   print(r:has('1.9.9'))       -- true
----   print(r:has('2.0.0'))       -- false
----   print(r:has(vim.version())) -- check against current Nvim version
----   </pre>
+---
+--- ```lua
+--- local r = vim.version.range('1.0.0 - 2.0.0')
+--- print(r:has('1.9.9'))       -- true
+--- print(r:has('2.0.0'))       -- false
+--- print(r:has(vim.version())) -- check against current Nvim version
+--- ```
 ---
 --- Or use cmp(), eq(), lt(), and gt() to compare `.to` and `.from` directly:
----   <pre>lua
----   local r = vim.version.range('1.0.0 - 2.0.0')
----   print(vim.version.gt({1,0,3}, r.from) and vim.version.lt({1,0,3}, r.to))
----   </pre>
+---
+--- ```lua
+--- local r = vim.version.range('1.0.0 - 2.0.0')
+--- print(vim.version.gt({1,0,3}, r.from) and vim.version.lt({1,0,3}, r.to))
+--- ```
 ---
 --- @see # https://github.com/npm/node-semver#ranges
 ---
@@ -345,16 +350,17 @@ end
 --- specified literally as a `{major, minor, patch}` tuple, e.g. `{1, 0, 3}`).
 ---
 --- Example:
---- <pre>lua
----   if vim.version.cmp({1,0,3}, {0,2,1}) == 0 then
----     -- ...
----   end
----   local v1 = vim.version.parse('1.0.3-pre')
----   local v2 = vim.version.parse('0.2.1')
----   if vim.version.cmp(v1, v2) == 0 then
----     -- ...
----   end
---- </pre>
+---
+--- ```lua
+--- if vim.version.cmp({1,0,3}, {0,2,1}) == 0 then
+---   -- ...
+--- end
+--- local v1 = vim.version.parse('1.0.3-pre')
+--- local v2 = vim.version.parse('0.2.1')
+--- if vim.version.cmp(v1, v2) == 0 then
+---   -- ...
+--- end
+--- ```
 ---
 --- @note Per semver, build metadata is ignored when comparing two otherwise-equivalent versions.
 ---
@@ -399,9 +405,10 @@ end
 
 --- Parses a semantic version string and returns a version object which can be used with other
 --- `vim.version` functions. For example "1.0.1-rc1+build.2" returns:
---- <pre>
----   { major = 1, minor = 0, patch = 1, prerelease = "rc1", build = "build.2" }
---- </pre>
+---
+--- ```
+--- { major = 1, minor = 0, patch = 1, prerelease = "rc1", build = "build.2" }
+--- ```
 ---
 --- @see # https://semver.org/spec/v2.0.0.html
 ---
diff --git a/scripts/gen_eval_files.lua b/scripts/gen_eval_files.lua
index 5d726315bd..1afe3d5f46 100755
--- a/scripts/gen_eval_files.lua
+++ b/scripts/gen_eval_files.lua
@@ -213,17 +213,20 @@ end
 
 --- Convert vimdoc references to markdown literals
 --- Convert vimdoc codeblocks to markdown codeblocks
+---
+--- Ensure code blocks have one empty line before the start fence and after the closing fence.
+---
 --- @param x string
 --- @return string
 local function norm_text(x)
   return (
     x:gsub('|([^ ]+)|', '`%1`')
-      :gsub('>lua', '\n```lua')
-      :gsub('>vim', '\n```vim')
-      :gsub('\n<$', '\n```')
-      :gsub('\n<\n', '\n```\n')
-      :gsub('%s+>\n', '\n```\n')
-      :gsub('\n<%s+\n?', '\n```\n')
+      :gsub('\n*>lua', '\n\n```lua')
+      :gsub('\n*>vim', '\n\n```vim')
+      :gsub('\n+<$', '\n```')
+      :gsub('\n+<\n+', '\n```\n\n')
+      :gsub('%s+>\n+', '\n```\n')
+      :gsub('\n+<%s+\n?', '\n```\n')
   )
 end
 
diff --git a/scripts/gen_vimdoc.py b/scripts/gen_vimdoc.py
index d485e68e2f..ed156e1422 100755
--- a/scripts/gen_vimdoc.py
+++ b/scripts/gen_vimdoc.py
@@ -585,13 +585,12 @@ def render_node(n, text, prefix='', indent='', width=text_width - indentation,
             text += '>{}{}\n<'.format(ensure_nl, o)
     elif n.nodeName == 'programlisting': # codeblock (```)
         o = get_text(n)
-        filename = n.attributes['filename'].value
-        if filename:
-            text += '>{}'.format(filename.lstrip('.'))
-        else:
-            text += '>'
+        text += '>'
+        if 'filename' in n.attributes:
+            filename = n.attributes['filename'].value
+            text += filename.lstrip('.')
 
-        text += '\n\n{}\n<'.format(textwrap.indent(o, ' ' * 4))
+        text += '\n{}\n<'.format(textwrap.indent(o, ' ' * 4))
     elif is_inline(n):
         text = doc_wrap(get_text(n), prefix=prefix, indent=indent, width=width)
     elif n.nodeName == 'verbatim':
@@ -768,6 +767,27 @@ def para_as_map(parent, indent='', width=text_width - indentation, fmt_vimhelp=F
 
     return chunks, xrefs
 
+def is_program_listing(para):
+    """
+    Return True if `para` contains a "programlisting" (i.e. a Markdown code
+    block ```).
+
+    Sometimes a <para> element will have only a single "programlisting" child
+    node, but othertimes it will have extra whitespace around the
+    "programlisting" node.
+
+    @param para XML <para> node
+    @return True if <para> is a programlisting
+    """
+
+    # Remove any child text nodes that are only whitespace
+    children = [
+        n for n in para.childNodes
+        if n.nodeType != n.TEXT_NODE or n.data.strip() != ''
+    ]
+
+    return len(children) == 1 and children[0].nodeName == 'programlisting'
+
 def fmt_node_as_vimhelp(parent: Element, width=text_width - indentation, indent='',
                         fmt_vimhelp=False):
     """Renders (nested) Doxygen <para> nodes as Vim :help text.
@@ -799,10 +819,7 @@ def fmt_node_as_vimhelp(parent: Element, width=text_width - indentation, indent=
         # 'programlisting' blocks are Markdown code blocks. Do not include
         # these as a separate paragraph, but append to the last non-empty line
         # in the text
-        if (
-            len(child.childNodes) == 1
-            and child.childNodes[0].nodeName == 'programlisting'
-        ):
+        if is_program_listing(child):
             while rendered_blocks and rendered_blocks[-1] == '':
                 rendered_blocks.pop()
             rendered_blocks[-1] += ' ' + para['text']
diff --git a/src/nvim/api/autocmd.c b/src/nvim/api/autocmd.c
index aa0c2695ad..2e4d2a622d 100644
--- a/src/nvim/api/autocmd.c
+++ b/src/nvim/api/autocmd.c
@@ -49,19 +49,20 @@ static int64_t next_autocmd_id = 1;
 /// Get all autocommands that match the corresponding {opts}.
 ///
 /// These examples will get autocommands matching ALL the given criteria:
-/// <pre>lua
-///   -- Matches all criteria
-///   autocommands = vim.api.nvim_get_autocmds({
-///     group = "MyGroup",
-///     event = {"BufEnter", "BufWinEnter"},
-///     pattern = {"*.c", "*.h"}
-///   })
 ///
-///   -- All commands from one group
-///   autocommands = vim.api.nvim_get_autocmds({
-///     group = "MyGroup",
-///   })
-/// </pre>
+/// ```lua
+/// -- Matches all criteria
+/// autocommands = vim.api.nvim_get_autocmds({
+///   group = "MyGroup",
+///   event = {"BufEnter", "BufWinEnter"},
+///   pattern = {"*.c", "*.h"}
+/// })
+///
+/// -- All commands from one group
+/// autocommands = vim.api.nvim_get_autocmds({
+///   group = "MyGroup",
+/// })
+/// ```
 ///
 /// NOTE: When multiple patterns or events are provided, it will find all the autocommands that
 /// match any combination of them.
@@ -344,28 +345,31 @@ cleanup:
 /// function _name_ string) or `command` (Ex command string).
 ///
 /// Example using Lua callback:
-/// <pre>lua
-///     vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
-///       pattern = {"*.c", "*.h"},
-///       callback = function(ev)
-///         print(string.format('event fired: \%s', vim.inspect(ev)))
-///       end
-///     })
-/// </pre>
+///
+/// ```lua
+/// vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
+///   pattern = {"*.c", "*.h"},
+///   callback = function(ev)
+///     print(string.format('event fired: %s', vim.inspect(ev)))
+///   end
+/// })
+/// ```
 ///
 /// Example using an Ex command as the handler:
-/// <pre>lua
-///     vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
-///       pattern = {"*.c", "*.h"},
-///       command = "echo 'Entering a C or C++ file'",
-///     })
-/// </pre>
+///
+/// ```lua
+/// vim.api.nvim_create_autocmd({"BufEnter", "BufWinEnter"}, {
+///   pattern = {"*.c", "*.h"},
+///   command = "echo 'Entering a C or C++ file'",
+/// })
+/// ```
 ///
 /// Note: `pattern` is NOT automatically expanded (unlike with |:autocmd|), thus names like "$HOME"
 /// and "~" must be expanded explicitly:
-/// <pre>lua
-///   pattern = vim.fn.expand("~") .. "/some/path/*.py"
-/// </pre>
+///
+/// ```lua
+/// pattern = vim.fn.expand("~") .. "/some/path/*.py"
+/// ```
 ///
 /// @param event (string|array) Event(s) that will trigger the handler (`callback` or `command`).
 /// @param opts Options dict:
@@ -619,11 +623,12 @@ cleanup:
 /// Create or get an autocommand group |autocmd-groups|.
 ///
 /// To get an existing group id, do:
-/// <pre>lua
-///     local id = vim.api.nvim_create_augroup("MyGroup", {
-///         clear = false
-///     })
-/// </pre>
+///
+/// ```lua
+/// local id = vim.api.nvim_create_augroup("MyGroup", {
+///     clear = false
+/// })
+/// ```
 ///
 /// @param name String: The name of the group
 /// @param opts Dictionary Parameters
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index baac694848..e8f9f809f2 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -85,11 +85,15 @@ Integer nvim_buf_line_count(Buffer buffer, Error *err)
 ///
 /// Example (Lua): capture buffer updates in a global `events` variable
 /// (use "vim.print(events)" to see its contents):
-/// <pre>lua
-///   events = {}
-///   vim.api.nvim_buf_attach(0, false, {
-///     on_lines=function(...) table.insert(events, {...}) end})
-/// </pre>
+///
+/// ```lua
+/// events = {}
+/// vim.api.nvim_buf_attach(0, false, {
+///   on_lines = function(...)
+///     table.insert(events, {...})
+///   end,
+/// })
+/// ```
 ///
 /// @see |nvim_buf_detach()|
 /// @see |api-buffer-updates-lua|
diff --git a/src/nvim/api/command.c b/src/nvim/api/command.c
index 2b09cfc4b2..808d4e0b8d 100644
--- a/src/nvim/api/command.c
+++ b/src/nvim/api/command.c
@@ -860,11 +860,12 @@ static void build_cmdline_str(char **cmdlinep, exarg_T *eap, CmdParseInfo *cmdin
 /// For Lua usage see |lua-guide-commands-create|.
 ///
 /// Example:
-/// <pre>vim
-///    :call nvim_create_user_command('SayHello', 'echo "Hello world!"', {'bang': v:true})
-///    :SayHello
-///    Hello world!
-/// </pre>
+///
+/// ```vim
+/// :call nvim_create_user_command('SayHello', 'echo "Hello world!"', {'bang': v:true})
+/// :SayHello
+/// Hello world!
+/// ```
 ///
 /// @param  name    Name of the new user command. Must begin with an uppercase letter.
 /// @param  command Replacement command to execute when this user command is executed. When called
diff --git a/src/nvim/api/extmark.c b/src/nvim/api/extmark.c
index b76a275c0d..05f62f6c7c 100644
--- a/src/nvim/api/extmark.c
+++ b/src/nvim/api/extmark.c
@@ -300,10 +300,11 @@ ArrayOf(Integer) nvim_buf_get_extmark_by_id(Buffer buffer, Integer ns_id,
 /// Region can be given as (row,col) tuples, or valid extmark ids (whose
 /// positions define the bounds). 0 and -1 are understood as (0,0) and (-1,-1)
 /// respectively, thus the following are equivalent:
-/// <pre>lua
-///   vim.api.nvim_buf_get_extmarks(0, my_ns, 0, -1, {})
-///   vim.api.nvim_buf_get_extmarks(0, my_ns, {0,0}, {-1,-1}, {})
-/// </pre>
+///
+/// ```lua
+/// vim.api.nvim_buf_get_extmarks(0, my_ns, 0, -1, {})
+/// vim.api.nvim_buf_get_extmarks(0, my_ns, {0,0}, {-1,-1}, {})
+/// ```
 ///
 /// If `end` is less than `start`, traversal works backwards. (Useful
 /// with `limit`, to get the first marks prior to a given position.)
@@ -313,20 +314,21 @@ ArrayOf(Integer) nvim_buf_get_extmark_by_id(Buffer buffer, Integer ns_id,
 /// of an extmark will be considered.
 ///
 /// Example:
-/// <pre>lua
-///   local api = vim.api
-///   local pos = api.nvim_win_get_cursor(0)
-///   local ns  = api.nvim_create_namespace('my-plugin')
-///   -- Create new extmark at line 1, column 1.
-///   local m1  = api.nvim_buf_set_extmark(0, ns, 0, 0, {})
-///   -- Create new extmark at line 3, column 1.
-///   local m2  = api.nvim_buf_set_extmark(0, ns, 2, 0, {})
-///   -- Get extmarks only from line 3.
-///   local ms  = api.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})
-///   -- Get all marks in this buffer + namespace.
-///   local all = api.nvim_buf_get_extmarks(0, ns, 0, -1, {})
-///   vim.print(ms)
-/// </pre>
+///
+/// ```lua
+/// local api = vim.api
+/// local pos = api.nvim_win_get_cursor(0)
+/// local ns  = api.nvim_create_namespace('my-plugin')
+/// -- Create new extmark at line 1, column 1.
+/// local m1  = api.nvim_buf_set_extmark(0, ns, 0, 0, {})
+/// -- Create new extmark at line 3, column 1.
+/// local m2  = api.nvim_buf_set_extmark(0, ns, 2, 0, {})
+/// -- Get extmarks only from line 3.
+/// local ms  = api.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})
+/// -- Get all marks in this buffer + namespace.
+/// local all = api.nvim_buf_get_extmarks(0, ns, 0, -1, {})
+/// vim.print(ms)
+/// ```
 ///
 /// @param buffer  Buffer handle, or 0 for current buffer
 /// @param ns_id  Namespace id from |nvim_create_namespace()| or -1 for all namespaces
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index da10ab5bd4..916409b973 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -212,10 +212,11 @@ void nvim_set_hl_ns_fast(Integer ns_id, Error *err)
 /// nvim_feedkeys().
 ///
 /// Example:
-/// <pre>vim
-///     :let key = nvim_replace_termcodes("<C-o>", v:true, v:false, v:true)
-///     :call nvim_feedkeys(key, 'n', v:false)
-/// </pre>
+///
+/// ```vim
+/// :let key = nvim_replace_termcodes("<C-o>", v:true, v:false, v:true)
+/// :call nvim_feedkeys(key, 'n', v:false)
+/// ```
 ///
 /// @param keys         to be typed
 /// @param mode         behavior flags, see |feedkeys()|
@@ -1280,10 +1281,11 @@ void nvim_unsubscribe(uint64_t channel_id, String event)
 /// "#rrggbb" hexadecimal string.
 ///
 /// Example:
-/// <pre>vim
-///     :echo nvim_get_color_by_name("Pink")
-///     :echo nvim_get_color_by_name("#cbcbcb")
-/// </pre>
+///
+/// ```vim
+/// :echo nvim_get_color_by_name("Pink")
+/// :echo nvim_get_color_by_name("#cbcbcb")
+/// ```
 ///
 /// @param name Color name or "#rrggbb" string
 /// @return 24-bit RGB value, or -1 for invalid argument.
@@ -1420,14 +1422,16 @@ ArrayOf(Dictionary) nvim_get_keymap(String mode)
 /// Empty {rhs} is |<Nop>|. |keycodes| are replaced as usual.
 ///
 /// Example:
-/// <pre>vim
-///     call nvim_set_keymap('n', ' <NL>', '', {'nowait': v:true})
-/// </pre>
+///
+/// ```vim
+/// call nvim_set_keymap('n', ' <NL>', '', {'nowait': v:true})
+/// ```
 ///
 /// is equivalent to:
-/// <pre>vim
-///     nmap <nowait> <Space><NL> <Nop>
-/// </pre>
+///
+/// ```vim
+/// nmap <nowait> <Space><NL> <Nop>
+/// ```
 ///
 /// @param channel_id
 /// @param  mode  Mode short-name (map command prefix: "n", "i", "v", "x", …)
diff --git a/src/nvim/api/win_config.c b/src/nvim/api/win_config.c
index ac27554172..6a16d06fb7 100644
--- a/src/nvim/api/win_config.c
+++ b/src/nvim/api/win_config.c
@@ -56,16 +56,19 @@
 /// this should not be used to specify arbitrary WM screen positions.
 ///
 /// Example (Lua): window-relative float
-/// <pre>lua
-///     vim.api.nvim_open_win(0, false,
-///       {relative='win', row=3, col=3, width=12, height=3})
-/// </pre>
+///
+/// ```lua
+/// vim.api.nvim_open_win(0, false,
+///   {relative='win', row=3, col=3, width=12, height=3})
+/// ```
 ///
 /// Example (Lua): buffer-relative float (travels as buffer is scrolled)
-/// <pre>lua
-///     vim.api.nvim_open_win(0, false,
-///       {relative='win', width=12, height=3, bufpos={100,10}})
-/// </pre>
+///
+/// ```lua
+/// vim.api.nvim_open_win(0, false,
+///   {relative='win', width=12, height=3, bufpos={100,10}})
+/// })
+/// ```
 ///
 /// @param buffer Buffer to display, or 0 for current buffer
 /// @param enter  Enter the window (make it the current window)
diff --git a/src/nvim/options.lua b/src/nvim/options.lua
index f0666101b8..3221e5b6e9 100644
--- a/src/nvim/options.lua
+++ b/src/nvim/options.lua
@@ -566,7 +566,7 @@ return {
         backups if you don't care about losing the file.
 
         Note that environment variables are not expanded.  If you want to use
-        $HOME you must expand it explicitly, e.g.: >
+        $HOME you must expand it explicitly, e.g.: >vim
         	:let &backupskip = escape(expand('$HOME'), '\') .. '/tmp/*'
 
         <	Note that the default also makes sure that "crontab -e" works (when a