From 8456a867f79e3fb3b5390659c5d11a1e35793372 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Sat, 18 Mar 2023 07:58:04 +0000
Subject: [PATCH] chore(build): auto-generate vimdoc

---
 doc/lazy.nvim.txt | 55 ++++++++++++++++++++++-------------------------
 1 file changed, 26 insertions(+), 29 deletions(-)

diff --git a/doc/lazy.nvim.txt b/doc/lazy.nvim.txt
index 5c36a3b..6bb0db9 100644
--- a/doc/lazy.nvim.txt
+++ b/doc/lazy.nvim.txt
@@ -149,12 +149,16 @@ PLUGIN SPEC                                  *lazy.nvim-lazy.nvim-plugin-spec*
 
   config         fun(LazyPlugin, opts:table) or true                          config is executed when the plugin loads. The
                                                                               default implementation will automatically run
-                                                                              require("plugin").setup(opts). "plugin" will default
-                                                                              to name if specified, otherwise lazy.nvim will do
-                                                                              its best to guess the correct plugin name. See also
+                                                                              require(MAIN).setup(opts). Lazy uses several
+                                                                              heuristics to determine the plugin’s MAIN module
+                                                                              automatically based on the plugin’s name. See also
                                                                               opts. To use the default implementation without opts
                                                                               set config to true.
 
+  main           string?                                                      You can specify the main module to use for config()
+                                                                              and opts(), in case it can not be determined
+                                                                              automatically. See config()
+
   build          fun(LazyPlugin) or string or a list of build commands        build is executed when a plugin is installed or
                                                                               updated. If it’s a string it will be ran as a shell
                                                                               command. When prefixed with it is a Neovim command.
@@ -309,30 +313,22 @@ EXAMPLES ~
         "nvim-neorg/neorg",
         -- lazy-load on filetype
         ft = "norg",
-        -- custom config that will be executed when loading the plugin
-        config = function()
-          require("neorg").setup()
-        end,
-      },
-    
-      -- the above could also be written as:
-      {
-        "nvim-neorg/neorg",
-        ft = "norg",
-        config = true, -- run require("neorg").setup()
-      },
-    
-      -- or set custom options:
-      {
-        "nvim-neorg/neorg",
-        ft = "norg",
-        opts = { foo = "bar" }, -- run require("neorg").setup({foo = "bar"})
+        -- options for neorg. This will automatically call `require("neorg").setup(opts)`
+        opts = {
+          load = {
+            ["core.defaults"] = {},
+          },
+        },
       },
     
       {
         "dstein64/vim-startuptime",
         -- lazy-load on a command
         cmd = "StartupTime",
+        -- init is called during startup. Configuration for vim plugins typically should be set in an init function
+        init = function()
+          vim.g.startuptime_tries = 10
+        end,
       },
     
       {
@@ -350,19 +346,20 @@ EXAMPLES ~
         end,
       },
     
+      -- if some code requires a module from an unloaded plugin, it will be automatically loaded.
+      -- So for api plugins like devicons, we can always set lazy=true
+      { "nvim-tree/nvim-web-devicons", lazy = true },
+    
       -- you can use the VeryLazy event for things that can
       -- load later and are not important for the initial UI
       { "stevearc/dressing.nvim", event = "VeryLazy" },
     
       {
-        "cshuaimin/ssr.nvim",
-        -- init is always executed during startup, but doesn't load the plugin yet.
-        init = function()
-          vim.keymap.set({ "n", "x" }, "<leader>cR", function()
-            -- this require will automatically load the plugin
-            require("ssr").open()
-          end, { desc = "Structural Replace" })
-        end,
+        "Wansmer/treesj",
+        keys = {
+          { "J", "<cmd>TSJToggle<cr>", desc = "Join Toggle" },
+        },
+        opts = { use_default_keymaps = false, max_join_length = 150 },
       },
     
       {