chore(master): release nvim-tree 1.6.0 (#2845)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -59,9 +59,9 @@ body:
 
         If not provided it is very unlikely that the nvim-tree team will be able to address your issue.
 
-        See [wiki: Clean Room Replication](https://github.com/nvim-tree/nvim-tree.lua/wiki/Troubleshooting#clean-room-replication) for instructions.
+        See [wiki: Clean Room Replication](https://github.com/nvim-tree/nvim-tree.lua/wiki/Troubleshooting#clean-room-replication) for instructions and paste the contents of your `/tmp/nvt-min.lua` here.
 
-        Please paste the contents of your `/tmp/nvt-min.lua` here."
+        Please do NOT post a configuration that uses other plugin managers such as lazy, see [wiki: Lazy Loading](https://github.com/nvim-tree/nvim-tree.lua/wiki/Installation#lazy-loading)"
       render: lua
     validations:
       required: true

.github/workflows/ci.yml

@@ -2,6 +2,8 @@ name: CI
 
 on:
   pull_request:
+  push:
+    branches: [master]
   workflow_dispatch:
 
 permissions:
@@ -11,6 +13,10 @@ jobs:
   lint:
     runs-on: ubuntu-latest
 
+    concurrency:
+      group: ${{ github.workflow }}-${{ matrix.lua_version }}-${{ github.head_ref || github.ref_name }}
+      cancel-in-progress: true
+
     strategy:
       matrix:
         lua_version: [ 5.1 ]
@@ -31,6 +37,10 @@ jobs:
   style:
     runs-on: ubuntu-latest
 
+    concurrency:
+      group: ${{ github.workflow }}-${{ matrix.stylua_version }}-${{ github.head_ref || github.ref_name }}
+      cancel-in-progress: true
+
     strategy:
       matrix:
         stylua_version: [ 0.19.1 ]
@@ -50,10 +60,14 @@ jobs:
   check:
     runs-on: ubuntu-latest
 
+    concurrency:
+      group: ${{ github.workflow }}-${{ matrix.nvim_version }}-${{ matrix.luals_version }}-${{ github.head_ref || github.ref_name }}
+      cancel-in-progress: true
+
     strategy:
       matrix:
         nvim_version: [ stable, nightly ]
-        luals_version: [ 3.7.3 ]
+        luals_version: [ 3.9.1 ]
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/luarocks-release.yml

@@ -0,0 +1,37 @@
+name: Luarocks Release
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+  workflow_dispatch:
+jobs:
+  luarocks-upload:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: LuaRocks Upload
+        uses: nvim-neorocks/luarocks-tag-release@v7
+        env:
+          LUAROCKS_API_KEY: ${{ secrets.LUAROCKS_API_KEY }}
+        with:
+          summary: A File Explorer For Neovim
+          detailed_description: |
+            Automatic updates
+
+            File type icons
+
+            Git integration
+
+            Diagnostics integration - LSP and COC
+
+            (Live) filtering
+
+            Cut, copy, paste, rename, delete, create etc.
+
+            Highly customisable
+
+            Rich API
+          license: "GPL-3.0"
+          labels: neovim
+          dependencies: |
+            nvim-web-devicons

.github/workflows/release-please.yml

@@ -3,7 +3,9 @@ on:
     branches:
       - master
   workflow_dispatch:
-
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
 name: release-please
 permissions:
   contents: write
@@ -23,9 +25,13 @@ jobs:
           git remote add gh-token "https://${{ secrets.GITHUB_TOKEN }}@github.com/google-github-actions/release-please-action.git"
           git tag -d       v${{ steps.release.outputs.major }}                                                                       || true
           git tag -d       v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}                                    || true
+          git tag -d       v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }} || true
           git push origin :v${{ steps.release.outputs.major }}                                                                       || true
           git push origin :v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}                                    || true
+          git push origin :v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }} || true
           git tag -a       v${{ steps.release.outputs.major }}                                                                       -m "Release v${{ steps.release.outputs.major }}"
           git tag -a       v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}                                    -m "Release v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}"
+          git tag -a       v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }} -m "Release v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }}"
           git push origin  v${{ steps.release.outputs.major }}
           git push origin  v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}
+          git push origin  v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}.${{ steps.release.outputs.patch }}

.github/workflows/semantic-pr-subject.yml

@@ -7,11 +7,13 @@ on:
       - edited
       - synchronize
   workflow_dispatch:
-
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
 jobs:
   semantic-pr-subject:
     runs-on: ubuntu-latest
     steps:
-      - uses: amannn/action-semantic-pull-request@v5.4.0
+      - uses: amannn/action-semantic-pull-request@v5.5.3
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,2 +1,4 @@
 /luals-out/
 /luals/
+# backup vim files
+*~

.luarc.json

@@ -1,17 +1,15 @@
 {
   "$schema": "https://raw.githubusercontent.com/sumneko/vscode-lua/master/setting/schema.json",
-  "runtime.version" : "Lua 5.1",
+  "runtime.version": "Lua 5.1",
   "workspace": {
     "library": [
-      "$VIMRUNTIME/lua/vim/lsp",
+      "$VIMRUNTIME/lua/vim",
       "${3rd}/luv/library"
     ]
   },
   "diagnostics": {
     "libraryFiles": "Disable",
-    "globals": [
+    "globals": [],
-      "vim"
-    ],
     "neededFileStatus": {
       "ambiguity-1": "Any",
       "assign-type-mismatch": "Any",
@@ -33,11 +31,19 @@
       "duplicate-index": "Any",
       "duplicate-set-field": "Any",
       "empty-block": "Any",
+      "global-element": "Any",
       "global-in-nil-env": "Any",
+      "incomplete-signature-doc": "None",
+      "inject-field": "Any",
+      "invisible": "Any",
       "lowercase-global": "Any",
+      "missing-fields": "Any",
+      "missing-global-doc": "Any",
+      "missing-local-export-doc": "None",
       "missing-parameter": "Any",
       "missing-return": "Any",
       "missing-return-value": "Any",
+      "name-style-check": "None",
       "need-check-nil": "Any",
       "newfield-call": "Any",
       "newline-call": "Any",
@@ -70,4 +76,3 @@
     }
   }
 }
-

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.0.0"
+  ".": "1.6.0"
 }

CHANGELOG.md

@@ -1,5 +1,118 @@
 # Changelog
 
+## [1.6.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.5.0...nvim-tree-v1.6.0) (2024-08-10)
+
+
+### Features
+
+* **#2225:** add renderer.hidden_display to show a summary of hidden files below the tree ([#2856](https://github.com/nvim-tree/nvim-tree.lua/issues/2856)) ([e25eb7f](https://github.com/nvim-tree/nvim-tree.lua/commit/e25eb7fa83f7614bb23d762e91d2de44fcd7103b))
+* **#2349:** add "right_align" option for renderer.icons.*_placement ([#2839](https://github.com/nvim-tree/nvim-tree.lua/issues/2839)) ([1d629a5](https://github.com/nvim-tree/nvim-tree.lua/commit/1d629a5d3f7d83d516494c221a2cfc079f43bc47))
+* **#2349:** add "right_align" option for renderer.icons.*_placement ([#2846](https://github.com/nvim-tree/nvim-tree.lua/issues/2846)) ([48d0e82](https://github.com/nvim-tree/nvim-tree.lua/commit/48d0e82f9434691cc50d970898142a8c084a49d6))
+* add renderer.highlight_hidden, renderer.icons.show.hidden and renderer.icons.hidden_placement for dotfile icons/highlights ([#2840](https://github.com/nvim-tree/nvim-tree.lua/issues/2840)) ([48a9290](https://github.com/nvim-tree/nvim-tree.lua/commit/48a92907575df1dbd7242975a04e98169cb3a115))
+
+
+### Bug Fixes
+
+* **#2859:** make sure window still exists when restoring options ([#2863](https://github.com/nvim-tree/nvim-tree.lua/issues/2863)) ([466fbed](https://github.com/nvim-tree/nvim-tree.lua/commit/466fbed3e4b61fcc23a48fe99de7bfa264a9fee8))
+
+## [1.5.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.4.0...nvim-tree-v1.5.0) (2024-07-11)
+
+
+### Features
+
+* **#2127:** add experimental.actions.open_file.relative_path to open files with a relative path rather than absolute ([#2805](https://github.com/nvim-tree/nvim-tree.lua/issues/2805)) ([869c064](https://github.com/nvim-tree/nvim-tree.lua/commit/869c064721a6c2091f22c3541e8f0ff958361771))
+* **#2598:** add api.tree.resize ([#2811](https://github.com/nvim-tree/nvim-tree.lua/issues/2811)) ([2ede0de](https://github.com/nvim-tree/nvim-tree.lua/commit/2ede0de67b47e89e2b4cb488ea3f58b8f5a8c90a))
+* **#2799:** `filesystem_watchers.ignore_dirs` and `git.disable_for_dirs` may be functions ([#2800](https://github.com/nvim-tree/nvim-tree.lua/issues/2800)) ([8b2c5c6](https://github.com/nvim-tree/nvim-tree.lua/commit/8b2c5c678be4b49dff6a2df794877000113fd77b))
+* **#2799:** filesystem_watchers.ignore_dirs and git.disable_for_dirs may be functions ([8b2c5c6](https://github.com/nvim-tree/nvim-tree.lua/commit/8b2c5c678be4b49dff6a2df794877000113fd77b))
+
+
+### Bug Fixes
+
+* **#2813:** macos: enable file renaming with changed capitalization ([#2814](https://github.com/nvim-tree/nvim-tree.lua/issues/2814)) ([abfd1d1](https://github.com/nvim-tree/nvim-tree.lua/commit/abfd1d1b6772540364743531cc0331e08a0027a9))
+* **#2819:** experimental.actions.open_file.relative_path issue following change directory ([#2820](https://github.com/nvim-tree/nvim-tree.lua/issues/2820)) ([12a9a99](https://github.com/nvim-tree/nvim-tree.lua/commit/12a9a995a455d2c2466e47140663275365a5d2fc))
+
+## [1.4.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.3.3...nvim-tree-v1.4.0) (2024-06-09)
+
+### Notice
+
+* Neovim 0.9 is now the minimum supported version; please upgrade to neovim release version 0.9 or 0.10.
+
+### Reverts
+
+* **#2781:** "refactor: replace deprecated use of vim.diagnostic.is_disabled()" ([#2784](https://github.com/nvim-tree/nvim-tree.lua/issues/2784)) ([517e4fb](https://github.com/nvim-tree/nvim-tree.lua/commit/517e4fbb9ef3c0986da7047f44b4b91a2400f93c))
+
+
+### Miscellaneous Chores
+
+* release 1.4.0 ([1cac800](https://github.com/nvim-tree/nvim-tree.lua/commit/1cac8005df6da484c97499247754afa59fef92db))
+
+## [1.3.3](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.3.2...nvim-tree-v1.3.3) (2024-05-14)
+
+
+### Bug Fixes
+
+* nil access exception with git integration when changing branches ([#2774](https://github.com/nvim-tree/nvim-tree.lua/issues/2774)) ([340d3a9](https://github.com/nvim-tree/nvim-tree.lua/commit/340d3a9795e06bdd1814228de398cd510f9bfbb0))
+
+## [1.3.2](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.3.1...nvim-tree-v1.3.2) (2024-05-12)
+
+
+### Bug Fixes
+
+* **#2758:** use nvim-webdevicons default file icon, not renderer.icons.glyphs.default, as per :help ([#2759](https://github.com/nvim-tree/nvim-tree.lua/issues/2759)) ([347e1eb](https://github.com/nvim-tree/nvim-tree.lua/commit/347e1eb35264677f66a79466bb5e3d111968e12c))
+* **#2758:** use nvim-webdevicons default for default files ([347e1eb](https://github.com/nvim-tree/nvim-tree.lua/commit/347e1eb35264677f66a79466bb5e3d111968e12c))
+* **#925:** handle newlines in file names ([#2754](https://github.com/nvim-tree/nvim-tree.lua/issues/2754)) ([64f61e4](https://github.com/nvim-tree/nvim-tree.lua/commit/64f61e4c913047a045ff90bd188dd3b54ee443cf))
+
+## [1.3.1](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.3.0...nvim-tree-v1.3.1) (2024-04-25)
+
+
+### Bug Fixes
+
+* **#2535:** TextYankPost event sends vim.v.event ([#2734](https://github.com/nvim-tree/nvim-tree.lua/issues/2734)) ([d8d3a15](https://github.com/nvim-tree/nvim-tree.lua/commit/d8d3a1590a05b2d8b5eb26e2ed1c6052b1b47a77))
+* **#2733:** escape trash path ([#2735](https://github.com/nvim-tree/nvim-tree.lua/issues/2735)) ([81eb8d5](https://github.com/nvim-tree/nvim-tree.lua/commit/81eb8d519233c105f30dc0a278607e62b20502fd))
+
+## [1.3.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.2.0...nvim-tree-v1.3.0) (2024-03-30)
+
+
+### Features
+
+* add update_focused_file.exclude  ([#2673](https://github.com/nvim-tree/nvim-tree.lua/issues/2673)) ([e20966a](https://github.com/nvim-tree/nvim-tree.lua/commit/e20966ae558524f8d6f93dc37f5d2a8605f893e2))
+
+
+### Bug Fixes
+
+* **#2658:** change SpellCap groups to reduce confusion: ExecFile->Question, ImageFile->Question, SpecialFile->Title, Symlink->Underlined; add all other highlight groups to :NvimTreeHiTest ([#2732](https://github.com/nvim-tree/nvim-tree.lua/issues/2732)) ([0aca092](https://github.com/nvim-tree/nvim-tree.lua/commit/0aca0920f44b12a8383134bcb52da9faec123608))
+* bookmark filter shows marked directory children ([#2719](https://github.com/nvim-tree/nvim-tree.lua/issues/2719)) ([2d97059](https://github.com/nvim-tree/nvim-tree.lua/commit/2d97059661c83787372c8c003e743c984ba3ac50))
+
+## [1.2.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.1.1...nvim-tree-v1.2.0) (2024-03-24)
+
+
+### Features
+
+* add api.tree.toggle_enable_filters ([#2706](https://github.com/nvim-tree/nvim-tree.lua/issues/2706)) ([f7c09bd](https://github.com/nvim-tree/nvim-tree.lua/commit/f7c09bd72e50e1795bd3afb9e2a2b157b4bfb3c3))
+
+## [1.1.1](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.1.0...nvim-tree-v1.1.1) (2024-03-15)
+
+
+### Bug Fixes
+
+* **#2395:** marks.bulk.move defaults to directory at cursor ([#2688](https://github.com/nvim-tree/nvim-tree.lua/issues/2688)) ([cfea5bd](https://github.com/nvim-tree/nvim-tree.lua/commit/cfea5bd0806aab41bef6014c6cf5a510910ddbdb))
+* **#2705:** change NvimTreeWindowPicker cterm background from Cyan to more visible DarkBlue ([#2708](https://github.com/nvim-tree/nvim-tree.lua/issues/2708)) ([1fd9c98](https://github.com/nvim-tree/nvim-tree.lua/commit/1fd9c98960463d2d5d400916c0633b2df016941d))
+* bookmark filter should include parent directory ([#2704](https://github.com/nvim-tree/nvim-tree.lua/issues/2704)) ([76b9810](https://github.com/nvim-tree/nvim-tree.lua/commit/76b98109f62caa12b2f1dff472060b2233ea2e90))
+
+## [1.1.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.0.0...nvim-tree-v1.1.0) (2024-03-14)
+
+
+### Features
+
+* **#2630:** file renames can now create directories ([#2657](https://github.com/nvim-tree/nvim-tree.lua/issues/2657)) ([efafd73](https://github.com/nvim-tree/nvim-tree.lua/commit/efafd73efa9bc8c26282aed563ba0f01c7465b06))
+* add api.fs.copy.basename, default mapping ge ([#2698](https://github.com/nvim-tree/nvim-tree.lua/issues/2698)) ([8f2a50f](https://github.com/nvim-tree/nvim-tree.lua/commit/8f2a50f1cd0c64003042364cf317c8788eaa6c8c))
+
+
+### Bug Fixes
+
+* **#2695:** git toplevel guard against missing paths ([#2696](https://github.com/nvim-tree/nvim-tree.lua/issues/2696)) ([3c4267e](https://github.com/nvim-tree/nvim-tree.lua/commit/3c4267eb5045fa86b67fe40c0c63d31efc801e77))
+* searchcount exception on invalid search regex ([#2693](https://github.com/nvim-tree/nvim-tree.lua/issues/2693)) ([041dbd1](https://github.com/nvim-tree/nvim-tree.lua/commit/041dbd18f440207ad161503a384e7c82d575db66))
+
 ## [1.0.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v0.100.0...nvim-tree-v1.0.0) (2024-02-18)
 
 

CONTRIBUTING.md

@@ -61,6 +61,15 @@ Assumes `$VIMRUNTIME` is `/usr/share/nvim/runtime`. Adjust as necessary e.g.
 VIMRUNTIME="/my/path/to/runtime" make check
 ```
 
+If `lua-language-server` is not available or `--check` doesn't function (e.g. Arch Linux 3.9.1-1) you can manually install it as per `ci.yml` e.g.
+
+```sh
+mkdir luals
+curl -L "https://github.com/LuaLS/lua-language-server/releases/download/3.9.1/lua-language-server-3.9.1-linux-x64.tar.gz" | tar zx --directory luals
+
+PATH="luals/bin:${PATH}" make check
+```
+
 # Adding New Actions
 
 To add a new action, add a file in `actions/name-of-the-action.lua`. You should export a `setup` function if some configuration is needed.
@@ -69,15 +78,43 @@ Once you did, you should run `make help-update`
 
 # Documentation
 
+## Opts
+
 When adding new options, you should declare the defaults in the main `nvim-tree.lua` file.
 
 Documentation for options should also be added to `nvim-tree-opts` in `doc/nvim-tree-lua.txt`
 
+## API
+
+When adding or changing API please update :help nvim-tree-api
+
 # Pull Request
 
-Please reference any issues in the description e.g. "resolves #1234".
+Please reference any issues in the description e.g. "resolves #1234", which will be closed upon merge.
 
 Please check "allow edits by maintainers" to allow nvim-tree developers to make small changes such as documentation tweaks.
 
-A test case to reproduce the issue is required. A ["Clean Room" Replication](https://github.com/nvim-tree/nvim-tree.lua/wiki/Troubleshooting#clean-room-replication) is preferred.
+## Subject
 
+The merge commit message will be the subject of the PR.
+
+A [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0) subject will be validated by the Semantic Pull Request Subject CI job. Reference the issue to be used in the release notes e.g.
+
+`fix(#2395): marks.bulk.move defaults to directory at cursor`
+
+Available types:
+* feat: A new feature
+* fix: A bug fix
+* docs: Documentation only changes
+* style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)
+* refactor: A code change that neither fixes a bug nor adds a feature
+* perf: A code change that improves performance
+* test: Adding missing tests or correcting existing tests
+* build: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
+* ci: Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)
+* chore: Other changes that don't modify src or test files
+* revert: Reverts a previous commit
+
+If in doubt, look at previous commits.
+
+See also [The Conventional Commits ultimate cheatsheet](https://gist.github.com/gabrielecanepa/fa6cca1a8ae96f77896fe70ddee65527)

Makefile

@@ -22,7 +22,7 @@ style-doc:
 	scripts/doc-comments.sh
 
 luals:
-	scripts/luals-check.sh
+	@scripts/luals-check.sh
 
 #
 # fixes

README.md

@@ -24,11 +24,11 @@
 
 Take a look at the [wiki](https://github.com/nvim-tree/nvim-tree.lua/wiki) for Showcases, Tips, Recipes and more.
 
-Community support: [matrix](https://matrix.to/#/#nvim-tree:matrix.org)
+Questions and general support: [Discussions](https://github.com/nvim-tree/nvim-tree.lua/discussions)
 
 ## Requirements
 
-[neovim >=0.8.0](https://github.com/neovim/neovim/wiki/Installing-Neovim)
+[neovim >=0.9.0](https://github.com/neovim/neovim/wiki/Installing-Neovim)
 
 [nvim-web-devicons](https://github.com/nvim-tree/nvim-web-devicons) is optional and used to display file icons. It requires a [patched font](https://www.nerdfonts.com/). Your terminal emulator must be configured to use that font, usually "Hack Nerd Font"
 
@@ -112,6 +112,23 @@ require("nvim-tree").setup {
 }
 ```
 
+### Highlight
+
+Run `:NvimTreeHiTest` to show all the highlights that nvim-tree uses.
+
+They can be customised before or after setup is called and will be immediately
+applied at runtime. e.g.
+
+```lua
+vim.cmd([[
+    :hi      NvimTreeExecFile    guifg=#ffa0a0
+    :hi      NvimTreeSpecialFile guifg=#ff80ff gui=underline
+    :hi      NvimTreeSymlink     guifg=Yellow  gui=italic
+    :hi link NvimTreeImageFile   Title
+]])
+```
+See [:help nvim-tree-highlight](doc/nvim-tree-lua.txt) for details.
+
 ## Commands
 
 See [:help nvim-tree-commands](doc/nvim-tree-lua.txt)

doc/nvim-tree-lua.txt

@@ -48,12 +48,18 @@ CONTENTS                                                           *nvim-tree*
   7. Mappings                                 |nvim-tree-mappings|
   7.1  Mappings: Default                        |nvim-tree-mappings-default|
   8. Highlight                                |nvim-tree-highlight|
-  8.1  Highlight Default                        |nvim-tree-highlight-default|
+  8.1  Highlight: Default                       |nvim-tree-highlight-default|
-  8.2  Highlight Overhaul                       |nvim-tree-highlight-overhaul|
+  8.2  Highlight: Overhaul                      |nvim-tree-highlight-overhaul|
   9. Events                                   |nvim-tree-events|
  10. Prompts                                  |nvim-tree-prompts|
  11. OS Specific Restrictions                 |nvim-tree-os-specific|
  12. Netrw                                    |nvim-tree-netrw|
+ 13. Legacy                                   |nvim-tree-legacy|
+ 13.1  Legacy: Opts                             |nvim-tree-legacy-opts|
+ 13.2  Legacy: Highlight                        |nvim-tree-legacy-highlight|
+ 14. Index                                    |nvim-tree-index|
+ 14.1  Index: Opts                              |nvim-tree-index-opts|
+ 14.2  Index: API                               |nvim-tree-index-api|
 
 ==============================================================================
  1. INTRODUCTION                                      *nvim-tree-introduction*
@@ -97,7 +103,7 @@ Git Integration
 
 Requirements
 
-    This file explorer requires `neovim >= 0.8.0`
+    This file explorer requires `neovim >= 0.9.0`
 
 ==============================================================================
  2. QUICKSTART                                          *nvim-tree-quickstart*
@@ -179,6 +185,7 @@ Show the mappings:  `g?`
 `f`               Live Filter: Start         |nvim-tree-api.live_filter.start()|
 `g?`              Help                       |nvim-tree-api.tree.toggle_help()|
 `gy`              Copy Absolute Path         |nvim-tree-api.fs.copy.absolute_path()|
+`ge`              Copy Basename              |nvim-tree-api.fs.copy.basename()|
 `H`               Toggle Filter: Dotfiles    |nvim-tree-api.tree.toggle_hidden_filter()|
 `I`               Toggle Filter: Git Ignore  |nvim-tree-api.tree.toggle_gitignore_filter()|
 `J`               Last Sibling               |nvim-tree-api.node.navigate.sibling.last()|
@@ -238,8 +245,15 @@ via |nvim-tree.on_attach| e.g. >
 Run |:NvimTreeHiTest| to show all the highlights that nvim-tree uses.
 
 They can be customised before or after setup is called and will be immediately
-applied at runtime.
+applied at runtime. e.g. >
 
+    vim.cmd([[
+        :hi      NvimTreeExecFile    guifg=#ffa0a0
+        :hi      NvimTreeSpecialFile guifg=#ff80ff gui=underline
+        :hi      NvimTreeSymlink     guifg=Yellow  gui=italic
+        :hi link NvimTreeImageFile   Title
+    ]])
+<
 See |nvim-tree-highlight| for details.
 
 ==============================================================================
@@ -409,11 +423,13 @@ Following is the default configuration. See |nvim-tree-opts| for details.
         root_folder_label = ":~:s?$?/..?",
         indent_width = 2,
         special_files = { "Cargo.toml", "Makefile", "README.md", "readme.md" },
+        hidden_display = "none",
         symlink_destination = true,
         highlight_git = "none",
         highlight_diagnostics = "none",
         highlight_opened_files = "none",
         highlight_modified = "none",
+        highlight_hidden = "none",
         highlight_bookmarks = "none",
         highlight_clipboard = "name",
         indent_markers = {
@@ -440,6 +456,7 @@ Following is the default configuration. See |nvim-tree-opts| for details.
           },
           git_placement = "before",
           modified_placement = "after",
+          hidden_placement = "after",
           diagnostics_placement = "signcolumn",
           bookmarks_placement = "signcolumn",
           padding = " ",
@@ -450,6 +467,7 @@ Following is the default configuration. See |nvim-tree-opts| for details.
             folder_arrow = true,
             git = true,
             modified = true,
+            hidden = false,
             diagnostics = true,
             bookmarks = true,
           },
@@ -458,6 +476,7 @@ Following is the default configuration. See |nvim-tree-opts| for details.
             symlink = "",
             bookmark = "󰆤",
             modified = "●",
+            hidden = "󰜌",
             folder = {
               arrow_closed = "",
               arrow_open = "",
@@ -486,9 +505,12 @@ Following is the default configuration. See |nvim-tree-opts| for details.
       },
       update_focused_file = {
         enable = false,
-        update_root = false,
+        update_root = {
+          enable = false,
           ignore_list = {},
         },
+        exclude = false,
+      },
       system_open = {
         cmd = "",
         args = {},
@@ -523,6 +545,7 @@ Following is the default configuration. See |nvim-tree-opts| for details.
         show_on_open_dirs = true,
       },
       filters = {
+        enable = true,
         git_ignored = true,
         dotfiles = false,
         git_clean = false,
@@ -602,7 +625,13 @@ Following is the default configuration. See |nvim-tree-opts| for details.
           default_yes = false,
         },
       },
-      experimental = {},
+      experimental = {
+        actions = {
+          open_file = {
+            relative_path = false,
+          },
+        },
+      },
       log = {
         enable = false,
         truncate = false,
@@ -665,7 +694,7 @@ Prefer startup root directory when updating root directory of the tree.
 Only relevant when `update_focused_file.update_root` is `true`
   Type: `boolean`, Default: `false`
 
-*nvim-tree.sync_root_with_cwd*  (previously `update_cwd`)
+*nvim-tree.sync_root_with_cwd*
 Changes the tree root directory on `DirChanged` and refreshes the tree.
   Type: `boolean`, Default: `false`
 
@@ -687,7 +716,7 @@ Type: `boolean`, Default: `false`
 
 File and folder sorting options.
 
-*nvim-tree.sort.sorter*  (previously `sort_by`)
+*nvim-tree.sort.sorter*
 Changes how files within the same directory are sorted.
 Can be one of `"name"`, `"case_sensitive"`, `"modification_time"`, `"extension"`,
 `"suffix"`, `"filetype"` or a function.
@@ -766,7 +795,7 @@ Show |signcolumn|. Value can be `"yes"`, `"auto"`, `"no"`.
 Width of the window: can be a `%` string, a number representing columns, a
 function or a table.
 A table indicates that the view should be dynamically sized based on the
-longest line (previously `view.adaptive_size`).
+longest line.
   Type: `string | number | table | function()` returning a number
   Default: `30`
 
@@ -814,7 +843,6 @@ Use nvim-tree in a floating window.
 
 Highlight precedence, additive:
   git < opened < modified < bookmarked < diagnostics < copied < cut
-Neovim <= 0.8 will only show the highest.
 
 *nvim-tree.renderer.add_trailing*
 Appends a trailing slash to folder names.
@@ -851,6 +879,49 @@ Number of spaces for an each tree nesting level. Minimum 1.
 A list of filenames that gets highlighted with `NvimTreeSpecialFile`.
   Type: `table`, Default: `{ "Cargo.toml", "Makefile", "README.md", "readme.md", }`
 
+*nvim-tree.renderer.hidden_display*
+Show a summary of hidden files below the tree using `NvimTreeHiddenDisplay
+  Type: `function | string`, Default: `"none"`
+
+  Possible string values are:
+    - `"none"`:   Doesn't inform anything about hidden files.
+    - `"simple"`: Shows how many hidden files are in a folder.
+    - `"all"`:    Shows how many files are hidden and the number of hidden
+                files per reason why they're hidden.
+
+  Example `"all"`:
+    If a folder has 14 hidden items for various reasons, the display might
+    show: >
+    (14 total git: 5, dotfile: 9)
+<
+  If a function is provided, it receives a table `hidden_stats` where keys are
+  reasons and values are the count of hidden files for that reason.
+
+  The `hidden_stats` argument is structured as follows, where <num> is the
+  number of hidden files related to the field: >
+    hidden_stats = {
+      bookmark = <num>,
+      buf = <num>,
+      custom = <num>,
+      dotfile = <num>,
+      git = <num>,
+      live_filter = <num>,
+    }
+<
+  Example of function that can be passed: >
+    function(hidden_stats)
+      local total_count = 0
+      for reason, count in pairs(hidden_stats) do
+        total_count = total_count + count
+      end
+
+      if total_count > 0 then
+        return "(" .. tostring(total_count) .. " hidden)"
+      end
+      return nil
+    end
+<
+
 *nvim-tree.renderer.symlink_destination*
 Whether to show the destination of the symlink.
   Type: `boolean`, Default: `true`
@@ -881,6 +952,13 @@ Requires |nvim-tree.modified.enable|
 Value can be `"none"`, `"icon"`, `"name"` or `"all"`
   Type: `string`, Default `"none"`
 
+*nvim-tree.renderer.highlight_hidden*
+Highlight icons and/or names for hidden files (dotfiles) using the
+`NvimTreeHiddenFileHL` highlight group.
+Requires |nvim-tree.hidden.enable|
+Value can be `"none"`, `"icon"`, `"name"` or `"all"`
+  Type: `string`, Default `"none"`
+
 *nvim-tree.renderer.highlight_bookmarks*
 Highlight bookmarked using the `NvimTreeBookmarkHL` group.
 Value can be `"none"`, `"icon"`, `"name"` or `"all"`
@@ -919,7 +997,13 @@ Configuration options for tree indent markers.
 Configuration options for icons.
 
 Icon order and sign column precedence:
-  git < modified < bookmarked < diagnostics
+  git < hidden < modified < bookmarked < diagnostics
+
+`renderer.icons.*_placement` options may be:
+- `"before"` : before file/folder, after the file/folders icons
+- `"after"` : after file/folder
+- `"signcolumn"` : far left, requires |nvim-tree.view.signcolumn| enabled
+- `"right_align"` : far right
 
     *nvim-tree.renderer.icons.web_devicons*
     Configure optional plugin `"nvim-tree/nvim-web-devicons"`
@@ -949,27 +1033,23 @@ Icon order and sign column precedence:
               Type: `boolean`, Default: `true`
 
     *nvim-tree.renderer.icons.git_placement*
-    Place where the git icons will be rendered.
+    Git icons placement.
-    Can be `"after"` or `"before"` filename (after the file/folders icons)
-    or `"signcolumn"` (requires |nvim-tree.view.signcolumn| enabled).
       Type: `string`, Default: `"before"`
 
     *nvim-tree.renderer.icons.diagnostics_placement*
-    Place where the diagnostics icon will be rendered.
+    Diganostic icon placement.
-    Can be `"after"` or `"before"` filename (after the file/folders icons)
-    or `"signcolumn"` (requires |nvim-tree.view.signcolumn| enabled).
       Type: `string`, Default: `"signcolumn"`
 
     *nvim-tree.renderer.icons.modified_placement*
-    Place where the modified icon will be rendered.
+    Modified icon placement.
-    Can be `"after"` or `"before"` filename (after the file/folders icons)
+      Type: `string`, Default: `"after"`
-    or `"signcolumn"` (requires |nvim-tree.view.signcolumn| enabled).
+
+    *nvim-tree.renderer.icons.hidden_placement*
+    Hidden icon placement.
       Type: `string`, Default: `"after"`
 
     *nvim-tree.renderer.icons.bookmarks_placement*
-    Place where the bookmarks icon will be rendered.
+    Bookmark icon placement.
-    Can be `"after"` or `"before"` filename (after the file/folders icons)
-    or `"signcolumn"` (requires |nvim-tree.view.signcolumn| enabled).
       Type: `string`, Default: `signcolumn`
 
     *nvim-tree.renderer.icons.padding*
@@ -982,7 +1062,7 @@ Icon order and sign column precedence:
 
     *nvim-tree.renderer.icons.show*
     Configuration options for showing icon types.
-    Left to right order: file/folder, git, modified, diagnostics, bookmarked.
+    Left to right order: file/folder, git, modified, hidden, diagnostics, bookmarked.
 
         *nvim-tree.renderer.icons.show.file*
         Show an icon before the file name.
@@ -1007,6 +1087,11 @@ Icon order and sign column precedence:
         Requires |modified.enable| `= true`
           Type: `boolean`, Default: `true`
 
+        *nvim-tree.renderer.icons.show.hidden*
+        Show a hidden icon, see |renderer.icons.hidden_placement|
+        Requires |hidden.enable| `= true`
+          Type: `boolean`, Default: `true`
+
         *nvim-tree.renderer.icons.show.diagnostics*
         Show a diagnostics status icon, see |renderer.icons.diagnostics_placement|
         Requires |diagnostics.enable| `= true`
@@ -1034,6 +1119,10 @@ Icon order and sign column precedence:
         Icon to display for modified files.
           Type: `string`, Default: `"●"`
 
+        *nvim-tree.renderer.icons.glyphs.hidden*
+        Icon to display for hidden files.
+          Type: `string`, Default: `"󰜌""`
+
         *nvim-tree.renderer.icons.glyphs.folder*
         Glyphs for directories.
         Overridden by |nvim-tree.renderer.icons.web_devicons| if available.
@@ -1086,20 +1175,26 @@ Enable this feature.
   Type: `boolean`, Default: `false`
 
 *nvim-tree.update_focused_file.update_root*
-(previously `update_focused_file.update_cwd`)
 Update the root directory of the tree if the file is not under current
 root directory. It prefers vim's cwd and `root_dirs`.
 Otherwise it falls back to the folder containing the file.
 Only relevant when `update_focused_file.enable` is `true`
+
+    *nvim-tree.update_focused_file.update_root.enable*
       Type: `boolean`, Default: `false`
 
-*nvim-tree.update_focused_file.ignore_list*
+    *nvim-tree.update_focused_file.update_root.ignore_list*
-List of buffer names and filetypes that will not update the root dir
+    List of buffer names and filetypes that will not update the root dir
-of the tree if the file isn't found under the current root directory.
+    of the tree if the file isn't found under the current root directory.
-Only relevant when `update_focused_file.update_root` and
+    Only relevant when `update_focused_file.update_root.enable` and
-`update_focused_file.enable` are `true`.
+    `update_focused_file.enable` are `true`.
       Type: {string}, Default: `{}`
 
+*nvim-tree.update_focused_file.exclude*
+A function that returns true if the file should not be focused when opening.
+Takes the `BufEnter` event as an argument. see |autocmd-events|
+  Type: {function}, Default: `false`
+
 ==============================================================================
  5.6 OPTS: SYSTEM OPEN                            *nvim-tree-opts-system-open*
 
@@ -1147,8 +1242,9 @@ Only relevant when `git.show_on_dirs` is `true`.
 
 *nvim-tree.git.disable_for_dirs*
 Disable git integration when git top-level matches these paths.
-May be relative, evaluated via |fnamemodify| `":p"`
+Strings may be relative, evaluated via |fnamemodify| `":p"`
-  Type: `table`, Default: `{}`
+Function is passed an absolute path and returns true for disable.
+  Type: `string[] | fun(path: string): boolean`, Default: `{}`
 
 *nvim-tree.git.timeout*
 Kills the git process after some time if it takes too long.
@@ -1229,7 +1325,12 @@ Only relevant when |modified.show_on_dirs| is `true`.
 
 File / folder filters that may be toggled.
 
-*nvim-tree.filters.git_ignored*  (previously `git.ignore`)
+*nvim-tree.filters.enable*
+Enable / disable all filters including live filter.
+Toggle via |nvim-tree-api.tree.toggle_enable_filters()|
+  Type: `boolean`, Default: `true`
+
+*nvim-tree.filters.git_ignored*
 Ignore files based on `.gitignore`. Requires |git.enable| `= true`
 Toggle via |nvim-tree-api.tree.toggle_gitignore_filter()|, default `I`
   Type: `boolean`, Default: `true`
@@ -1305,10 +1406,12 @@ Idle milliseconds between filesystem change and action.
   Type: `number`, Default: `50` (ms)
 
 *nvim-tree.filesystem_watchers.ignore_dirs*
-List of vim regex for absolute directory paths that will not be watched.
+List of vim regex for absolute directory paths that will not be watched or
-Backslashes must be escaped e.g. `"my-project/\\.build$"`. See |string-match|.
+function returning whether a path should be ignored.
+Strings must be backslash escaped e.g. `"my-proj/\\.build$"`. See |string-match|.
+Function is passed an absolute path.
 Useful when path is not in `.gitignore` or git integration is disabled.
-  Type: {string}, Default: `{}`
+  Type: `string[] | fun(path: string): boolean`, Default: `{}`
 
 ==============================================================================
  5.13 OPTS: ACTIONS                                   *nvim-tree-opts-actions*
@@ -1376,7 +1479,7 @@ Configuration options for opening a file from nvim-tree.
     Prevent new opened file from opening in the same window as the tree.
       Type: `boolean`, Default: `true`
 
-    *nvim-tree.actions.open_file.resize_window*  (previously `view.auto_resize`)
+    *nvim-tree.actions.open_file.resize_window*
     Resizes the tree when opening a file.
       Type: `boolean`, Default: `true`
 
@@ -1444,7 +1547,7 @@ Windows default `"trash"`     requires `trash-cli` or similar
 *nvim-tree.tab.sync*
 Configuration for syncing nvim-tree across tabs.
 
-    *nvim-tree.tab.sync.open*  (previously `nvim-tree.open_on_tab`)
+    *nvim-tree.tab.sync.open*
     Opens the tree automatically when switching tabpage or opening a new
     tabpage if the tree was previously open.
       Type: `boolean`, Default: `false`
@@ -1453,7 +1556,7 @@ Configuration for syncing nvim-tree across tabs.
     Closes the tree across all tabpages when the tree is closed.
       Type: `boolean`, Default: `false`
 
-    *nvim-tree.tab.sync.ignore*  (previously `nvim-tree.ignore_buf_on_tab_change`)
+    *nvim-tree.tab.sync.ignore*
     List of filetypes or buffer names on new tab that will prevent
     |nvim-tree.tab.sync.open| and |nvim-tree.tab.sync.close|
       Type: {string}, Default: `{}`
@@ -1493,7 +1596,7 @@ Confirmation prompts.
     Prompt before removing.
       Type: `boolean`, Default: `true`
 
-    *nvim-tree.ui.confirm.trash*  (previously `trash.require_confirm`)
+    *nvim-tree.ui.confirm.trash*
     Prompt before trashing.
       Type: `boolean`, Default: `true`
 
@@ -1508,6 +1611,12 @@ Confirmation prompts.
 Experimental features that may become default or optional functionality.
 In the event of a problem please disable the experiment and raise an issue.
 
+    *nvim-tree.experimental.actions.open_file.relative_path*
+    Buffers opened by nvim-tree will use with relative paths instead of
+    absolute.
+    Execute |:ls| to see the paths of all open buffers.
+      Type: `boolean`, Default: `false`
+
 ==============================================================================
  5.20 OPTS: LOG                                           *nvim-tree-opts-log*
 
@@ -1627,6 +1736,22 @@ tree.focus()                                      *nvim-tree-api.tree.focus()*
 tree.reload()                                    *nvim-tree-api.tree.reload()*
     Refresh the tree. Does nothing if closed.
 
+tree.resize({opts})                              *nvim-tree-api.tree.resize()*
+    Resize the tree, persisting the new size.
+    Resets to |nvim-tree.view.width| when no {opts} provided.
+    See |:NvimTreeResize|
+
+    Parameters: ~
+      • {opts} (table) optional parameters
+
+    Options: ~
+      • {width}    (table)  new |nvim-tree.view.width| value
+      • {absolute} (number) set the width
+      • {relative} (number) increase or decrease the width
+
+    Only one option is supported, in the priority order above.
+    {absolute} and {relative} do nothing when {width} is a function.
+
 tree.change_root({path})                    *nvim-tree-api.tree.change_root()*
     Change the tree's root to a path.
 
@@ -1689,6 +1814,10 @@ tree.expand_all()                            *nvim-tree-api.tree.expand_all()*
     Recursively expand all nodes in the tree.
     Folder: only the nodes underneath that folder.
 
+                                  *nvim-tree-api.tree.toggle_enable_filters()*
+tree.toggle_enable_filters()
+    Toggle |nvim-tree.filters.enable| all filters.
+
                                 *nvim-tree-api.tree.toggle_gitignore_filter()*
 tree.toggle_gitignore_filter()
     Toggle |nvim-tree.filters.git_ignored| filter.
@@ -2228,6 +2357,7 @@ You are encouraged to copy these to your own |nvim-tree.on_attach| function.
   vim.keymap.set('n', 'f',       api.live_filter.start,               opts('Live Filter: Start'))
   vim.keymap.set('n', 'g?',      api.tree.toggle_help,                opts('Help'))
   vim.keymap.set('n', 'gy',      api.fs.copy.absolute_path,           opts('Copy Absolute Path'))
+  vim.keymap.set('n', 'ge',      api.fs.copy.basename,                opts('Copy Basename'))
   vim.keymap.set('n', 'H',       api.tree.toggle_hidden_filter,       opts('Toggle Filter: Dotfiles'))
   vim.keymap.set('n', 'I',       api.tree.toggle_gitignore_filter,    opts('Toggle Filter: Git Ignore'))
   vim.keymap.set('n', 'J',       api.node.navigate.sibling.last,      opts('Last Sibling'))
@@ -2301,7 +2431,7 @@ To prevent usage of a highlight:
     `:hi! link NvimTreeExecFile NONE`
 
 ==============================================================================
- 8.1 HIGHLIGHT DEFAULT                           *nvim-tree-highlight-default*
+ 8.1 HIGHLIGHT: DEFAULT                          *nvim-tree-highlight-default*
 
 |:highlight-link| `default` or |:highlight-default| define the groups on setup:
 
@@ -2369,6 +2499,14 @@ Modified: >
     NvimTreeModifiedIcon        Type
     NvimTreeModifiedFileHL      NvimTreeModifiedIcon
     NvimTreeModifiedFolderHL    NvimTreeModifiedIcon
+
+Hidden: >
+    NvimTreeModifiedIcon        Conceal
+    NvimTreeModifiedFileHL      NvimTreeHiddenIcon
+    NvimTreeModifiedFolderHL    NvimTreeHiddenFileHL
+<
+Hidden Display: >
+    NvimTreeHiddenDisplay       Conceal
 <
 Opened: >
     NvimTreeOpenedHL            Special
@@ -2419,7 +2557,9 @@ Diagnostics Folder Highlight: >
     NvimTreeDiagnosticHintFolderHL      NvimTreeDiagnosticHintFileHL
 <
 ==============================================================================
- 8.1 HIGHLIGHT OVERHAUL                         *nvim-tree-highlight-overhaul*
+ 8.2 HIGHLIGHT: OVERHAUL                        *nvim-tree-highlight-overhaul*
+
+See |nvim-tree-legacy-highlight| for old highlight group compatibility.
 
 2024-01-20: significant highlighting changes, some breaking:
 
@@ -2444,51 +2584,14 @@ Diagnostics Folder Highlight: >
 - NvimTreeSpecialFile  PreProc   -> SpellCap
 - NvimTreeSymlink      Statement -> SpellCap
 
-Legacy highlight group are still obeyed when they are defined and the current
+Approximate pre-overhaul values for the `SpellCap` groups may be set via: >
-highlight group is not, hard linking as follows: >
 
-    NvimTreeModifiedIcon        NvimTreeModifiedFile
+    vim.cmd([[
-    NvimTreeOpenedHL            NvimTreeOpenedFile
+        :hi NvimTreeExecFile    gui=bold           guifg=#ffa0a0
-    NvimTreeBookmarkIcon        NvimTreeBookmark
+        :hi NvimTreeSymlink     gui=bold           guifg=#ffff60
-
+        :hi NvimTreeSpecialFile gui=bold,underline guifg=#ff80ff
-    NvimTreeGitDeletedIcon      NvimTreeGitDeleted
+        :hi NvimTreeImageFile   gui=bold           guifg=#ff80ff
-    NvimTreeGitDirtyIcon        NvimTreeGitDirty
+    ]])
-    NvimTreeGitIgnoredIcon      NvimTreeGitIgnored
-    NvimTreeGitMergeIcon        NvimTreeGitMerge
-    NvimTreeGitNewIcon          NvimTreeGitNew
-    NvimTreeGitRenamedIcon      NvimTreeGitRenamed
-    NvimTreeGitStagedIcon       NvimTreeGitStaged
-
-    NvimTreeGitFileDeletedHL    NvimTreeFileDeleted
-    NvimTreeGitFileDirtyHL      NvimTreeFileDirty
-    NvimTreeGitFileIgnoredHL    NvimTreeFileIgnored
-    NvimTreeGitFileMergeHL      NvimTreeFileMerge
-    NvimTreeGitFileNewHL        NvimTreeFileNew
-    NvimTreeGitFileRenamedHL    NvimTreeFileRenamed
-    NvimTreeGitFileStagedHL     NvimTreeFileStaged
-
-    NvimTreeGitFolderDeletedHL  NvimTreeFolderDeleted
-    NvimTreeGitFolderDirtyHL    NvimTreeFolderDirty
-    NvimTreeGitFolderIgnoredHL  NvimTreeFolderIgnored
-    NvimTreeGitFolderMergeHL    NvimTreeFolderMerge
-    NvimTreeGitFolderNewHL      NvimTreeFolderNew
-    NvimTreeGitFolderRenamedHL  NvimTreeFolderRenamed
-    NvimTreeGitFolderStagedHL   NvimTreeFolderStaged
-
-    NvimTreeLspDiagnosticsError                 NvimTreeDiagnosticErrorIcon
-    NvimTreeLspDiagnosticsWarning               NvimTreeDiagnosticWarnIcon
-    NvimTreeLspDiagnosticsInformation           NvimTreeDiagnosticInfoIcon
-    NvimTreeLspDiagnosticsHint                  NvimTreeDiagnosticHintIcon
-
-    NvimTreeLspDiagnosticsErrorText             NvimTreeDiagnosticErrorFileHL
-    NvimTreeLspDiagnosticsWarningText           NvimTreeDiagnosticWarnFileHL
-    NvimTreeLspDiagnosticsInformationText       NvimTreeDiagnosticInfoFileHL
-    NvimTreeLspDiagnosticsHintText              NvimTreeDiagnosticHintFileHL
-
-    NvimTreeLspDiagnosticsErrorFolderText       NvimTreeDiagnosticErrorFolderHL 
-    NvimTreeLspDiagnosticsWarningFolderText     NvimTreeDiagnosticWarnFolderHL
-    NvimTreeLspDiagnosticsInformationFolderText NvimTreeDiagnosticInfoFolderHL
-    NvimTreeLspDiagnosticsHintFolderText        NvimTreeDiagnosticHintFolderHL
 <
 ==============================================================================
  9. EVENTS                                                  *nvim-tree-events*
@@ -2631,10 +2734,6 @@ configurations for different types of prompts.
 ==============================================================================
  11. OS SPECIFIC RESTRICTIONS                          *nvim-tree-os-specific*
 
-macOS
-- Rename to different case is not possible when using a case insensitive file
-  system.
-
 Windows WSL and PowerShell
 - Trash is synchronized
 - Executable file detection is disabled as this is non-performant and can
@@ -2662,4 +2761,350 @@ keep using |netrw| without its browser features please ensure:
 |nvim-tree.disable_netrw| `= false`
 |nvim-tree.hijack_netrw| ` = true`
 
+==============================================================================
+ 13. LEGACY                                                 *nvim-tree-legacy*
+
+Breaking refactors have been made however the legacy versions will be silently
+migrated and used.
+There are no plans to remove this migration.
+
+==============================================================================
+ 13.1 LEGACY: OPTS                                     *nvim-tree-legacy-opts*
+
+Legacy options are translated to the current, making type and value changes as
+needed.
+
+`update_cwd`                         |nvim-tree.sync_root_with_cwd|
+`update_focused_file.update_cwd`     |nvim-tree.update_focused_file.update_root|
+`open_on_tab`                        |nvim-tree.tab.sync.open|
+`ignore_buf_on_tab_change`           |nvim-tree.tab.sync.ignore|
+`renderer.root_folder_modifier`      |nvim-tree.renderer.root_folder_label|
+`update_focused_file.debounce_delay` |nvim-tree.view.debounce_delay|
+`trash.require_confirm`              |nvim-tree.ui.confirm.trash|
+`view.adaptive_size`                 |nvim-tree.view.width|
+`sort_by`                            |nvim-tree.sort.sorter|
+`git.ignore`                         |nvim-tree.filters.git_ignored|
+`renderer.icons.webdev_colors`       |nvim-tree.renderer.icons.web_devicons.file.color|
+
+==============================================================================
+ 13.2 LEGACY: HIGHLIGHT                           *nvim-tree-legacy-highlight*
+
+Legacy highlight group are still obeyed when they are defined and the current
+highlight group is not, hard linking as follows: >
+
+    NvimTreeModifiedIcon        NvimTreeModifiedFile
+    NvimTreeOpenedHL            NvimTreeOpenedFile
+    NvimTreeBookmarkIcon        NvimTreeBookmark
+
+    NvimTreeGitDeletedIcon      NvimTreeGitDeleted
+    NvimTreeGitDirtyIcon        NvimTreeGitDirty
+    NvimTreeGitIgnoredIcon      NvimTreeGitIgnored
+    NvimTreeGitMergeIcon        NvimTreeGitMerge
+    NvimTreeGitNewIcon          NvimTreeGitNew
+    NvimTreeGitRenamedIcon      NvimTreeGitRenamed
+    NvimTreeGitStagedIcon       NvimTreeGitStaged
+
+    NvimTreeGitFileDeletedHL    NvimTreeFileDeleted
+    NvimTreeGitFileDirtyHL      NvimTreeFileDirty
+    NvimTreeGitFileIgnoredHL    NvimTreeFileIgnored
+    NvimTreeGitFileMergeHL      NvimTreeFileMerge
+    NvimTreeGitFileNewHL        NvimTreeFileNew
+    NvimTreeGitFileRenamedHL    NvimTreeFileRenamed
+    NvimTreeGitFileStagedHL     NvimTreeFileStaged
+
+    NvimTreeGitFolderDeletedHL  NvimTreeFolderDeleted
+    NvimTreeGitFolderDirtyHL    NvimTreeFolderDirty
+    NvimTreeGitFolderIgnoredHL  NvimTreeFolderIgnored
+    NvimTreeGitFolderMergeHL    NvimTreeFolderMerge
+    NvimTreeGitFolderNewHL      NvimTreeFolderNew
+    NvimTreeGitFolderRenamedHL  NvimTreeFolderRenamed
+    NvimTreeGitFolderStagedHL   NvimTreeFolderStaged
+
+    NvimTreeLspDiagnosticsError                 NvimTreeDiagnosticErrorIcon
+    NvimTreeLspDiagnosticsWarning               NvimTreeDiagnosticWarnIcon
+    NvimTreeLspDiagnosticsInformation           NvimTreeDiagnosticInfoIcon
+    NvimTreeLspDiagnosticsHint                  NvimTreeDiagnosticHintIcon
+
+    NvimTreeLspDiagnosticsErrorText             NvimTreeDiagnosticErrorFileHL
+    NvimTreeLspDiagnosticsWarningText           NvimTreeDiagnosticWarnFileHL
+    NvimTreeLspDiagnosticsInformationText       NvimTreeDiagnosticInfoFileHL
+    NvimTreeLspDiagnosticsHintText              NvimTreeDiagnosticHintFileHL
+
+    NvimTreeLspDiagnosticsErrorFolderText       NvimTreeDiagnosticErrorFolderHL
+    NvimTreeLspDiagnosticsWarningFolderText     NvimTreeDiagnosticWarnFolderHL
+    NvimTreeLspDiagnosticsInformationFolderText NvimTreeDiagnosticInfoFolderHL
+    NvimTreeLspDiagnosticsHintFolderText        NvimTreeDiagnosticHintFolderHL
+<
+==============================================================================
+ 14 INDEX                                                    *nvim-tree-index*
+
+==============================================================================
+ 14.1 INDEX: OPTS                                       *nvim-tree-index-opts*
+
+|nvim-tree.actions.change_dir|
+|nvim-tree.actions.change_dir.enable|
+|nvim-tree.actions.change_dir.global|
+|nvim-tree.actions.change_dir.restrict_above_cwd|
+|nvim-tree.actions.expand_all|
+|nvim-tree.actions.expand_all.exclude|
+|nvim-tree.actions.expand_all.max_folder_discovery|
+|nvim-tree.actions.file_popup|
+|nvim-tree.actions.file_popup.open_win_config|
+|nvim-tree.actions.open_file|
+|nvim-tree.actions.open_file.eject|
+|nvim-tree.actions.open_file.quit_on_open|
+|nvim-tree.actions.open_file.resize_window|
+|nvim-tree.actions.open_file.window_picker|
+|nvim-tree.actions.open_file.window_picker.chars|
+|nvim-tree.actions.open_file.window_picker.enable|
+|nvim-tree.actions.open_file.window_picker.exclude|
+|nvim-tree.actions.open_file.window_picker.picker|
+|nvim-tree.actions.remove_file.close_window|
+|nvim-tree.actions.use_system_clipboard|
+|nvim-tree.auto_reload_on_write|
+|nvim-tree.diagnostics.debounce_delay|
+|nvim-tree.diagnostics.enable|
+|nvim-tree.diagnostics.icons|
+|nvim-tree.diagnostics.severity|
+|nvim-tree.diagnostics.severity.max|
+|nvim-tree.diagnostics.severity.min|
+|nvim-tree.diagnostics.show_on_dirs|
+|nvim-tree.diagnostics.show_on_open_dirs|
+|nvim-tree.disable_netrw|
+|nvim-tree.experimental|
+|nvim-tree.experimental.actions.open_file.relative_path|
+|nvim-tree.filesystem_watchers.debounce_delay|
+|nvim-tree.filesystem_watchers.enable|
+|nvim-tree.filesystem_watchers.ignore_dirs|
+|nvim-tree.filters.custom|
+|nvim-tree.filters.dotfiles|
+|nvim-tree.filters.enable|
+|nvim-tree.filters.exclude|
+|nvim-tree.filters.git_clean|
+|nvim-tree.filters.git_ignored|
+|nvim-tree.filters.no_bookmark|
+|nvim-tree.filters.no_buffer|
+|nvim-tree.git.cygwin_support|
+|nvim-tree.git.disable_for_dirs|
+|nvim-tree.git.enable|
+|nvim-tree.git.show_on_dirs|
+|nvim-tree.git.show_on_open_dirs|
+|nvim-tree.git.timeout|
+|nvim-tree.help.sort_by|
+|nvim-tree.hijack_cursor|
+|nvim-tree.hijack_directories.auto_open|
+|nvim-tree.hijack_directories.enable|
+|nvim-tree.hijack_netrw|
+|nvim-tree.hijack_unnamed_buffer_when_opening|
+|nvim-tree.live_filter.always_show_folders|
+|nvim-tree.live_filter.prefix|
+|nvim-tree.log.enable|
+|nvim-tree.log.truncate|
+|nvim-tree.log.types|
+|nvim-tree.log.types.all|
+|nvim-tree.log.types.config|
+|nvim-tree.log.types.copy_paste|
+|nvim-tree.log.types.dev|
+|nvim-tree.log.types.diagnostics|
+|nvim-tree.log.types.git|
+|nvim-tree.log.types.profile|
+|nvim-tree.log.types.watcher|
+|nvim-tree.modified.enable|
+|nvim-tree.modified.show_on_dirs|
+|nvim-tree.modified.show_on_open_dirs|
+|nvim-tree.notify.threshold|
+|nvim-tree.on_attach|
+|nvim-tree.prefer_startup_root|
+|nvim-tree.reload_on_bufenter|
+|nvim-tree.renderer.add_trailing|
+|nvim-tree.renderer.full_name|
+|nvim-tree.renderer.group_empty|
+|nvim-tree.renderer.hidden_display|
+|nvim-tree.renderer.highlight_bookmarks|
+|nvim-tree.renderer.highlight_clipboard|
+|nvim-tree.renderer.highlight_diagnostics|
+|nvim-tree.renderer.highlight_git|
+|nvim-tree.renderer.highlight_hidden|
+|nvim-tree.renderer.highlight_modified|
+|nvim-tree.renderer.highlight_opened_files|
+|nvim-tree.renderer.icons|
+|nvim-tree.renderer.icons.bookmarks_placement|
+|nvim-tree.renderer.icons.diagnostics_placement|
+|nvim-tree.renderer.icons.git_placement|
+|nvim-tree.renderer.icons.glyphs|
+|nvim-tree.renderer.icons.glyphs.default|
+|nvim-tree.renderer.icons.glyphs.folder|
+|nvim-tree.renderer.icons.glyphs.git|
+|nvim-tree.renderer.icons.glyphs.hidden|
+|nvim-tree.renderer.icons.glyphs.modified|
+|nvim-tree.renderer.icons.glyphs.symlink|
+|nvim-tree.renderer.icons.hidden_placement|
+|nvim-tree.renderer.icons.modified_placement|
+|nvim-tree.renderer.icons.padding|
+|nvim-tree.renderer.icons.show|
+|nvim-tree.renderer.icons.show.bookmarks|
+|nvim-tree.renderer.icons.show.diagnostics|
+|nvim-tree.renderer.icons.show.file|
+|nvim-tree.renderer.icons.show.folder|
+|nvim-tree.renderer.icons.show.folder_arrow|
+|nvim-tree.renderer.icons.show.git|
+|nvim-tree.renderer.icons.show.hidden|
+|nvim-tree.renderer.icons.show.modified|
+|nvim-tree.renderer.icons.symlink_arrow|
+|nvim-tree.renderer.icons.web_devicons|
+|nvim-tree.renderer.icons.web_devicons.file|
+|nvim-tree.renderer.icons.web_devicons.file.color|
+|nvim-tree.renderer.icons.web_devicons.file.enable|
+|nvim-tree.renderer.icons.web_devicons.folder|
+|nvim-tree.renderer.icons.web_devicons.folder.color|
+|nvim-tree.renderer.icons.web_devicons.folder.enable|
+|nvim-tree.renderer.indent_markers|
+|nvim-tree.renderer.indent_markers.enable|
+|nvim-tree.renderer.indent_markers.icons|
+|nvim-tree.renderer.indent_markers.inline_arrows|
+|nvim-tree.renderer.indent_width|
+|nvim-tree.renderer.root_folder_label|
+|nvim-tree.renderer.special_files|
+|nvim-tree.renderer.symlink_destination|
+|nvim-tree.respect_buf_cwd|
+|nvim-tree.root_dirs|
+|nvim-tree.select_prompts|
+|nvim-tree.sort.files_first|
+|nvim-tree.sort.folders_first|
+|nvim-tree.sort.sorter|
+|nvim-tree.sync_root_with_cwd|
+|nvim-tree.system_open.args|
+|nvim-tree.system_open.cmd|
+|nvim-tree.tab.sync|
+|nvim-tree.tab.sync.close|
+|nvim-tree.tab.sync.ignore|
+|nvim-tree.tab.sync.open|
+|nvim-tree.trash.cmd|
+|nvim-tree.ui.confirm|
+|nvim-tree.ui.confirm.default_yes|
+|nvim-tree.ui.confirm.remove|
+|nvim-tree.ui.confirm.trash|
+|nvim-tree.update_focused_file.enable|
+|nvim-tree.update_focused_file.exclude|
+|nvim-tree.update_focused_file.update_root|
+|nvim-tree.update_focused_file.update_root.enable|
+|nvim-tree.update_focused_file.update_root.ignore_list|
+|nvim-tree.view.centralize_selection|
+|nvim-tree.view.cursorline|
+|nvim-tree.view.debounce_delay|
+|nvim-tree.view.float|
+|nvim-tree.view.float.enable|
+|nvim-tree.view.float.open_win_config|
+|nvim-tree.view.float.quit_on_focus_loss|
+|nvim-tree.view.number|
+|nvim-tree.view.preserve_window_proportions|
+|nvim-tree.view.relativenumber|
+|nvim-tree.view.side|
+|nvim-tree.view.signcolumn|
+|nvim-tree.view.width|
+|nvim-tree.view.width.max|
+|nvim-tree.view.width.min|
+|nvim-tree.view.width.padding|
+
+==============================================================================
+ 14.2 INDEX: API                                         *nvim-tree-index-api*
+
+|nvim-tree-api.commands.get()|
+|nvim-tree-api.config.mappings.default_on_attach()|
+|nvim-tree-api.config.mappings.get_keymap()|
+|nvim-tree-api.config.mappings.get_keymap_default()|
+|nvim-tree-api.diagnostics.hi_test()|
+|nvim-tree-api.events.subscribe()|
+|nvim-tree-api.fs.clear_clipboard()|
+|nvim-tree-api.fs.copy.absolute_path()|
+|nvim-tree-api.fs.copy.filename()|
+|nvim-tree-api.fs.copy.node()|
+|nvim-tree-api.fs.copy.relative_path()|
+|nvim-tree-api.fs.create()|
+|nvim-tree-api.fs.cut()|
+|nvim-tree-api.fs.paste()|
+|nvim-tree-api.fs.print_clipboard()|
+|nvim-tree-api.fs.remove()|
+|nvim-tree-api.fs.rename()|
+|nvim-tree-api.fs.rename_basename()|
+|nvim-tree-api.fs.rename_full()|
+|nvim-tree-api.fs.rename_node()|
+|nvim-tree-api.fs.rename_sub()|
+|nvim-tree-api.fs.trash()|
+|nvim-tree-api.git.reload()|
+|nvim-tree-api.live_filter.clear()|
+|nvim-tree-api.live_filter.start()|
+|nvim-tree-api.marks.bulk.delete()|
+|nvim-tree-api.marks.bulk.move()|
+|nvim-tree-api.marks.bulk.trash()|
+|nvim-tree-api.marks.clear()|
+|nvim-tree-api.marks.get()|
+|nvim-tree-api.marks.list()|
+|nvim-tree-api.marks.navigate.next()|
+|nvim-tree-api.marks.navigate.prev()|
+|nvim-tree-api.marks.navigate.select()|
+|nvim-tree-api.marks.toggle()|
+|nvim-tree-api.node.navigate.diagnostics.next()|
+|nvim-tree-api.node.navigate.diagnostics.next_recursive()|
+|nvim-tree-api.node.navigate.diagnostics.prev()|
+|nvim-tree-api.node.navigate.diagnostics.prev_recursive()|
+|nvim-tree-api.node.navigate.git.next()|
+|nvim-tree-api.node.navigate.git.next_recursive()|
+|nvim-tree-api.node.navigate.git.next_skip_gitignored()|
+|nvim-tree-api.node.navigate.git.prev()|
+|nvim-tree-api.node.navigate.git.prev_recursive()|
+|nvim-tree-api.node.navigate.git.prev_skip_gitignored()|
+|nvim-tree-api.node.navigate.opened.next()|
+|nvim-tree-api.node.navigate.opened.prev()|
+|nvim-tree-api.node.navigate.parent()|
+|nvim-tree-api.node.navigate.parent_close()|
+|nvim-tree-api.node.navigate.sibling.first()|
+|nvim-tree-api.node.navigate.sibling.last()|
+|nvim-tree-api.node.navigate.sibling.next()|
+|nvim-tree-api.node.navigate.sibling.prev()|
+|nvim-tree-api.node.open.drop()|
+|nvim-tree-api.node.open.edit()|
+|nvim-tree-api.node.open.horizontal()|
+|nvim-tree-api.node.open.no_window_picker()|
+|nvim-tree-api.node.open.preview()|
+|nvim-tree-api.node.open.preview_no_picker()|
+|nvim-tree-api.node.open.replace_tree_buffer()|
+|nvim-tree-api.node.open.tab()|
+|nvim-tree-api.node.open.tab_drop()|
+|nvim-tree-api.node.open.toggle_group_empty()|
+|nvim-tree-api.node.open.vertical()|
+|nvim-tree-api.node.run.cmd()|
+|nvim-tree-api.node.run.system()|
+|nvim-tree-api.node.show_info_popup()|
+|nvim-tree-api.tree.change_root()|
+|nvim-tree-api.tree.change_root_to_node()|
+|nvim-tree-api.tree.change_root_to_parent()|
+|nvim-tree-api.tree.close()|
+|nvim-tree-api.tree.close_in_all_tabs()|
+|nvim-tree-api.tree.close_in_this_tab()|
+|nvim-tree-api.tree.collapse_all()|
+|nvim-tree-api.tree.expand_all()|
+|nvim-tree-api.tree.find_file()|
+|nvim-tree-api.tree.focus()|
+|nvim-tree-api.tree.get_nodes()|
+|nvim-tree-api.tree.get_node_under_cursor()|
+|nvim-tree-api.tree.is_tree_buf()|
+|nvim-tree-api.tree.is_visible()|
+|nvim-tree-api.tree.open()|
+|nvim-tree-api.tree.reload()|
+|nvim-tree-api.tree.resize()|
+|nvim-tree-api.tree.search_node()|
+|nvim-tree-api.tree.toggle()|
+|nvim-tree-api.tree.toggle_custom_filter()|
+|nvim-tree-api.tree.toggle_enable_filters()|
+|nvim-tree-api.tree.toggle_git_clean_filter()|
+|nvim-tree-api.tree.toggle_gitignore_filter()|
+|nvim-tree-api.tree.toggle_help()|
+|nvim-tree-api.tree.toggle_hidden_filter()|
+|nvim-tree-api.tree.toggle_no_bookmark_filter()|
+|nvim-tree-api.tree.toggle_no_buffer_filter()|
+|nvim-tree-api.tree.winid()|
+
+==============================================================================
+
  vim:tw=78:ts=4:sw=4:et:ft=help:norl:

lua/nvim-tree.lua

@@ -9,9 +9,7 @@ local actions = require "nvim-tree.actions"
 local legacy = require "nvim-tree.legacy"
 local core = require "nvim-tree.core"
 local git = require "nvim-tree.git"
-local filters = require "nvim-tree.explorer.filters"
 local buffers = require "nvim-tree.buffers"
-local events = require "nvim-tree.events"
 local notify = require "nvim-tree.notify"
 
 local _config = {}
@@ -26,8 +24,15 @@ local M = {
 function M.change_root(path, bufnr)
   -- skip if current file is in ignore_list
   if type(bufnr) == "number" then
-    local ft = vim.api.nvim_buf_get_option(bufnr, "filetype") or ""
+    local ft
-    for _, value in pairs(_config.update_focused_file.ignore_list) do
+
+    if vim.fn.has "nvim-0.10" == 1 then
+      ft = vim.api.nvim_get_option_value("filetype", { buf = bufnr }) or ""
+    else
+      ft = vim.api.nvim_buf_get_option(bufnr, "filetype") or "" ---@diagnostic disable-line: deprecated
+    end
+
+    for _, value in pairs(_config.update_focused_file.update_root.ignore_list) do
       if utils.str_find(path, value) or utils.str_find(ft, value) then
         return
       end
@@ -78,7 +83,14 @@ end
 function M.tab_enter()
   if view.is_visible { any_tabpage = true } then
     local bufname = vim.api.nvim_buf_get_name(0)
-    local ft = vim.api.nvim_buf_get_option(0, "ft")
+
+    local ft
+    if vim.fn.has "nvim-0.10" == 1 then
+      ft = vim.api.nvim_get_option_value("filetype", { buf = 0 }) or ""
+    else
+      ft = vim.api.nvim_buf_get_option(0, "ft") ---@diagnostic disable-line: deprecated
+    end
+
     for _, filter in ipairs(M.config.tab.sync.ignore) do
       if bufname:match(filter) ~= nil or ft:match(filter) ~= nil then
         return
@@ -105,8 +117,8 @@ function M.open_on_directory()
 end
 
 function M.place_cursor_on_node()
-  local search = vim.fn.searchcount()
+  local ok, search = pcall(vim.fn.searchcount)
-  if search and search.exact_match == 1 then
+  if ok and search and search.exact_match == 1 then
     return
   end
 
@@ -149,7 +161,7 @@ function M.change_dir(name)
     actions.root.change_dir.fn(name)
   end
 
-  if _config.update_focused_file.enable then
+  if _config.update_focused_file.update_root.enable then
     actions.tree.find_file.fn()
   end
 end
@@ -197,7 +209,13 @@ local function setup_autocommands(opts)
   create_nvim_tree_autocmd("BufReadPost", {
     callback = function(data)
       -- update opened file buffers
-      if (filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == "" then
+      local explorer = core.get_explorer()
+      if not explorer then
+        return
+      end
+      if
+        (explorer.filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == ""
+      then
         utils.debounce("Buf:filter_buffer", opts.view.debounce_delay, function()
           actions.reloaders.reload_explorer()
         end)
@@ -208,7 +226,13 @@ local function setup_autocommands(opts)
   create_nvim_tree_autocmd("BufUnload", {
     callback = function(data)
       -- update opened file buffers
-      if (filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == "" then
+      local explorer = core.get_explorer()
+      if not explorer then
+        return
+      end
+      if
+        (explorer.filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= "none") and vim.bo[data.buf].buftype == ""
+      then
         utils.debounce("Buf:filter_buffer", opts.view.debounce_delay, function()
           actions.reloaders.reload_explorer()
         end)
@@ -247,7 +271,11 @@ local function setup_autocommands(opts)
   end
   if opts.update_focused_file.enable then
     create_nvim_tree_autocmd("BufEnter", {
-      callback = function()
+      callback = function(event)
+        local exclude = opts.update_focused_file.exclude
+        if type(exclude) == "function" and exclude(event) then
+          return
+        end
         utils.debounce("BufEnter:find_file", opts.view.debounce_delay, function()
           actions.tree.find_file.fn()
         end)
@@ -320,21 +348,6 @@ local function setup_autocommands(opts)
       end,
     })
   end
-
-  -- TODO #1545 remove similar check from view.resize
-  if vim.fn.has "nvim-0.9" == 1 then
-    create_nvim_tree_autocmd("WinResized", {
-      callback = function()
-        if vim.v.event and vim.v.event.windows then
-          for _, winid in ipairs(vim.v.event.windows) do
-            if vim.api.nvim_win_is_valid(winid) and utils.is_nvim_tree_buf(vim.api.nvim_win_get_buf(winid)) then
-              events._dispatch_on_tree_resize(vim.api.nvim_win_get_width(winid))
-            end
-          end
-        end
-      end,
-    })
-  end
 end
 
 local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
@@ -385,11 +398,13 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
     root_folder_label = ":~:s?$?/..?",
     indent_width = 2,
     special_files = { "Cargo.toml", "Makefile", "README.md", "readme.md" },
+    hidden_display = "none",
     symlink_destination = true,
     highlight_git = "none",
     highlight_diagnostics = "none",
     highlight_opened_files = "none",
     highlight_modified = "none",
+    highlight_hidden = "none",
     highlight_bookmarks = "none",
     highlight_clipboard = "name",
     indent_markers = {
@@ -416,6 +431,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       },
       git_placement = "before",
       modified_placement = "after",
+      hidden_placement = "after",
       diagnostics_placement = "signcolumn",
       bookmarks_placement = "signcolumn",
       padding = " ",
@@ -426,6 +442,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
         folder_arrow = true,
         git = true,
         modified = true,
+        hidden = false,
         diagnostics = true,
         bookmarks = true,
       },
@@ -434,6 +451,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
         symlink = "",
         bookmark = "󰆤",
         modified = "●",
+        hidden = "󰜌",
         folder = {
           arrow_closed = "",
           arrow_open = "",
@@ -462,9 +480,12 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
   },
   update_focused_file = {
     enable = false,
-    update_root = false,
+    update_root = {
+      enable = false,
       ignore_list = {},
     },
+    exclude = false,
+  },
   system_open = {
     cmd = "",
     args = {},
@@ -499,6 +520,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
     show_on_open_dirs = true,
   },
   filters = {
+    enable = true,
     git_ignored = true,
     dotfiles = false,
     git_clean = false,
@@ -578,7 +600,13 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       default_yes = false,
     },
   },
-  experimental = {},
+  experimental = {
+    actions = {
+      open_file = {
+        relative_path = false,
+      },
+    },
+  },
   log = {
     enable = false,
     truncate = false,
@@ -620,12 +648,22 @@ local ACCEPTED_TYPES = {
     },
   },
   renderer = {
+    hidden_display = { "function", "string" },
     group_empty = { "boolean", "function" },
     root_folder_label = { "function", "string", "boolean" },
   },
+  update_focused_file = {
+    exclude = { "function" },
+  },
+  git = {
+    disable_for_dirs = { "function" },
+  },
   filters = {
     custom = { "function" },
   },
+  filesystem_watchers = {
+    ignore_dirs = { "function" },
+  },
   actions = {
     open_file = {
       window_picker = {
@@ -644,17 +682,20 @@ local ACCEPTED_STRINGS = {
     signcolumn = { "yes", "no", "auto" },
   },
   renderer = {
+    hidden_display = { "none", "simple", "all" },
     highlight_git = { "none", "icon", "name", "all" },
     highlight_opened_files = { "none", "icon", "name", "all" },
     highlight_modified = { "none", "icon", "name", "all" },
+    highlight_hidden = { "none", "icon", "name", "all" },
     highlight_bookmarks = { "none", "icon", "name", "all" },
     highlight_diagnostics = { "none", "icon", "name", "all" },
     highlight_clipboard = { "none", "icon", "name", "all" },
     icons = {
-      git_placement = { "before", "after", "signcolumn" },
+      git_placement = { "before", "after", "signcolumn", "right_align" },
-      modified_placement = { "before", "after", "signcolumn" },
+      modified_placement = { "before", "after", "signcolumn", "right_align" },
-      diagnostics_placement = { "before", "after", "signcolumn" },
+      hidden_placement = { "before", "after", "signcolumn", "right_align" },
-      bookmarks_placement = { "before", "after", "signcolumn" },
+      diagnostics_placement = { "before", "after", "signcolumn", "right_align" },
+      bookmarks_placement = { "before", "after", "signcolumn", "right_align" },
     },
   },
   help = {
@@ -755,8 +796,8 @@ end
 
 ---@param conf table|nil
 function M.setup(conf)
-  if vim.fn.has "nvim-0.8" == 0 then
+  if vim.fn.has "nvim-0.9" == 0 then
-    notify.warn "nvim-tree.lua requires Neovim 0.8 or higher"
+    notify.warn "nvim-tree.lua requires Neovim 0.9 or higher"
     return
   end
 
@@ -799,7 +840,6 @@ function M.setup(conf)
   require("nvim-tree.view").setup(opts)
   require("nvim-tree.lib").setup(opts)
   require("nvim-tree.renderer").setup(opts)
-  require("nvim-tree.live-filter").setup(opts)
   require("nvim-tree.marks").setup(opts)
   require("nvim-tree.buffers").setup(opts)
   require("nvim-tree.help").setup(opts)

lua/nvim-tree/actions/finders/search-node.lua

@@ -1,5 +1,4 @@
 local core = require "nvim-tree.core"
-local filters = require "nvim-tree.explorer.filters"
 local find_file = require("nvim-tree.actions.finders.find-file").fn
 
 local M = {}
@@ -9,6 +8,11 @@ local M = {}
 ---@return string|nil
 local function search(search_dir, input_path)
   local realpaths_searched = {}
+  local explorer = core.get_explorer()
+
+  if not explorer then
+    return
+  end
 
   if not search_dir then
     return
@@ -19,7 +23,7 @@ local function search(search_dir, input_path)
   local function iter(dir)
     local realpath, path, name, stat, handle, _
 
-    local filter_status = filters.prepare()
+    local filter_status = explorer.filters:prepare()
 
     handle, _ = vim.loop.fs_scandir(dir)
     if not handle then
@@ -36,12 +40,13 @@ local function search(search_dir, input_path)
     while name do
       path = dir .. "/" .. name
 
+      ---@type uv.fs_stat.result|nil
       stat, _ = vim.loop.fs_stat(path)
       if not stat then
         break
       end
 
-      if not filters.should_filter(path, filter_status) then
+      if not explorer.filters:should_filter(path, stat, filter_status) then
         if string.find(path, "/" .. input_path .. "$") then
           return path
         end
@@ -68,8 +73,15 @@ function M.fn()
 
   -- temporarily set &path
   local bufnr = vim.api.nvim_get_current_buf()
-  local path_existed, path_opt = pcall(vim.api.nvim_buf_get_option, bufnr, "path")
+
-  vim.api.nvim_buf_set_option(bufnr, "path", core.get_cwd() .. "/**")
+  local path_existed, path_opt
+  if vim.fn.has "nvim-0.10" == 1 then
+    path_existed, path_opt = pcall(vim.api.nvim_get_option_value, "path", { buf = bufnr })
+    vim.api.nvim_set_option_value("path", core.get_cwd() .. "/**", { buf = bufnr })
+  else
+    path_existed, path_opt = pcall(vim.api.nvim_buf_get_option, bufnr, "path") ---@diagnostic disable-line: deprecated
+    vim.api.nvim_buf_set_option(bufnr, "path", core.get_cwd() .. "/**") ---@diagnostic disable-line: deprecated
+  end
 
   vim.ui.input({ prompt = "Search: ", completion = "file_in_path" }, function(input_path)
     if not input_path or input_path == "" then
@@ -77,9 +89,17 @@ function M.fn()
     end
     -- reset &path
     if path_existed then
-      vim.api.nvim_buf_set_option(bufnr, "path", path_opt)
+      if vim.fn.has "nvim-0.10" == 1 then
+        vim.api.nvim_set_option_value("path", path_opt, { buf = bufnr })
       else
-      vim.api.nvim_buf_set_option(bufnr, "path", nil)
+        vim.api.nvim_buf_set_option(bufnr, "path", path_opt) ---@diagnostic disable-line: deprecated
+      end
+    else
+      if vim.fn.has "nvim-0.10" == 1 then
+        vim.api.nvim_set_option_value("path", nil, { buf = bufnr })
+      else
+        vim.api.nvim_buf_set_option(bufnr, "path", nil) ---@diagnostic disable-line: deprecated
+      end
     end
 
     -- strip trailing slash

lua/nvim-tree/actions/fs/copy-paste.lua

@@ -276,17 +276,24 @@ end
 ---@param content string
 local function copy_to_clipboard(content)
   local clipboard_name
+  local reg
   if M.config.actions.use_system_clipboard == true then
-    vim.fn.setreg("+", content)
-    vim.fn.setreg('"', content)
     clipboard_name = "system"
+    reg = "+"
   else
-    vim.fn.setreg('"', content)
-    vim.fn.setreg("1", content)
     clipboard_name = "neovim"
+    reg = "1"
   end
 
-  vim.api.nvim_exec_autocmds("TextYankPost", {})
+  -- manually firing TextYankPost does not set vim.v.event
+  -- workaround: create a scratch buffer with the clipboard contents and send a yank command
+  local temp_buf = vim.api.nvim_create_buf(false, true)
+  vim.api.nvim_buf_set_text(temp_buf, 0, 0, 0, 0, { content })
+  vim.api.nvim_buf_call(temp_buf, function()
+    vim.cmd(string.format('normal! "%sy$', reg))
+  end)
+  vim.api.nvim_buf_delete(temp_buf, {})
+
   notify.info(string.format("Copied %s to %s clipboard!", content, clipboard_name))
 end
 
@@ -295,6 +302,12 @@ function M.copy_filename(node)
   copy_to_clipboard(node.name)
 end
 
+---@param node Node
+function M.copy_basename(node)
+  local basename = vim.fn.fnamemodify(node.name, ":r")
+  copy_to_clipboard(basename)
+end
+
 ---@param node Node
 function M.copy_path(node)
   local absolute_path = node.absolute_path

lua/nvim-tree/actions/fs/create-file.lua

@@ -12,7 +12,7 @@ local M = {}
 local function create_and_notify(file)
   events._dispatch_will_create_file(file)
   local ok, fd = pcall(vim.loop.fs_open, file, "w", 420)
-  if not ok then
+  if not ok or type(fd) ~= "number" then
     notify.error("Couldn't create file " .. notify.render_path(file))
     return
   end

lua/nvim-tree/actions/fs/remove-file.lua

@@ -49,9 +49,9 @@ end
 ---@param cwd string
 ---@return boolean|nil
 local function remove_dir(cwd)
-  local handle = vim.loop.fs_scandir(cwd)
+  local handle, err = vim.loop.fs_scandir(cwd)
-  if type(handle) == "string" then
+  if not handle then
-    notify.error(handle)
+    notify.error(err)
     return
   end
 

lua/nvim-tree/actions/fs/rename-file.lua

@@ -9,6 +9,16 @@ local M = {
   config = {},
 }
 
+---@param iter function iterable
+---@return integer
+local function get_num_nodes(iter)
+  local i = 0
+  for _ in iter do
+    i = i + 1
+  end
+  return i
+end
+
 local ALLOWED_MODIFIERS = {
   [":p"] = true,
   [":p:h"] = true,
@@ -20,26 +30,69 @@ local function err_fmt(from, to, reason)
   return string.format("Cannot rename %s -> %s: %s", from, to, reason)
 end
 
+local function rename_file_exists(node, to)
+  if not utils.is_macos then
+    return utils.file_exists(to)
+  end
+
+  if string.lower(node) == string.lower(to) then
+    return false
+  end
+
+  return utils.file_exists(to)
+end
+
 ---@param node Node
 ---@param to string
 function M.rename(node, to)
   local notify_from = notify.render_path(node.absolute_path)
   local notify_to = notify.render_path(to)
 
-  if utils.file_exists(to) then
+  if rename_file_exists(notify_from, notify_to) then
     notify.warn(err_fmt(notify_from, notify_to, "file already exists"))
     return
   end
 
+  -- create a folder for each path element if the folder does not exist
+  local idx = 0
+  local path_to_create = ""
+
+  local num_nodes = get_num_nodes(utils.path_split(utils.path_remove_trailing(to)))
+  local is_error = false
+  for path in utils.path_split(to) do
+    idx = idx + 1
+
+    local p = utils.path_remove_trailing(path)
+    if #path_to_create == 0 and vim.fn.has "win32" == 1 then
+      path_to_create = utils.path_join { p, path_to_create }
+    else
+      path_to_create = utils.path_join { path_to_create, p }
+    end
+
+    if idx == num_nodes then
       events._dispatch_will_rename_node(node.absolute_path, to)
       local success, err = vim.loop.fs_rename(node.absolute_path, to)
+
       if not success then
         notify.warn(err_fmt(notify_from, notify_to, err))
         return
       end
+    elseif not rename_file_exists(notify_from, path_to_create) then
+      local success = vim.loop.fs_mkdir(path_to_create, 493)
+      if not success then
+        notify.error("Could not create folder " .. notify.render_path(path_to_create))
+        is_error = true
+        break
+      end
+      is_error = false
+    end
+  end
+
+  if not is_error then
     notify.info(string.format("%s -> %s", notify_from, notify_to))
     utils.rename_loaded_buffers(node.absolute_path, to)
     events._dispatch_node_renamed(node.absolute_path, to)
+  end
 end
 
 ---@param default_modifier string|nil

lua/nvim-tree/actions/fs/trash.lua

@@ -42,7 +42,7 @@ function M.remove(node)
   -- trashes a path (file or folder)
   local function trash_path(on_exit)
     local need_sync_wait = utils.is_windows
-    local job = vim.fn.jobstart(M.config.trash.cmd .. ' "' .. node.absolute_path .. '"', {
+    local job = vim.fn.jobstart(M.config.trash.cmd .. " " .. vim.fn.shellescape(node.absolute_path), {
       detach = not need_sync_wait,
       on_exit = on_exit,
       on_stderr = on_stderr,

lua/nvim-tree/actions/node/file-popup.lua

@@ -6,6 +6,14 @@ local M = {}
 ---@return table
 local function get_formatted_lines(node)
   local stats = node.fs_stat
+  if stats == nil then
+    return {
+      "",
+      "  Can't retrieve file information",
+      "",
+    }
+  end
+
   local fpath = " fullpath: " .. node.absolute_path
   local created_at = " created:  " .. os.date("%x %X", stats.birthtime.sec)
   local modified_at = " modified: " .. os.date("%x %X", stats.mtime.sec)
@@ -48,7 +56,7 @@ end
 
 function M.close_popup()
   if current_popup ~= nil then
-    vim.api.nvim_win_close(current_popup.winnr, { force = true })
+    vim.api.nvim_win_close(current_popup.winnr, true)
     vim.cmd "augroup NvimTreeRemoveFilePopup | au! CursorMoved | augroup END"
 
     current_popup = nil

lua/nvim-tree/actions/node/open-file.lua

@@ -26,14 +26,20 @@ local function usable_win_ids()
   return vim.tbl_filter(function(id)
     local bufid = vim.api.nvim_win_get_buf(id)
     for option, v in pairs(M.window_picker.exclude) do
-      local ok, option_value = pcall(vim.api.nvim_buf_get_option, bufid, option)
+      local ok, option_value
+      if vim.fn.has "nvim-0.10" == 1 then
+        ok, option_value = pcall(vim.api.nvim_get_option_value, option, { buf = bufid })
+      else
+        ok, option_value = pcall(vim.api.nvim_buf_get_option, bufid, option) ---@diagnostic disable-line: deprecated
+      end
+
       if ok and vim.tbl_contains(v, option_value) then
         return false
       end
     end
 
     local win_config = vim.api.nvim_win_get_config(id)
-    return id ~= tree_winid and win_config.focusable and not win_config.external
+    return id ~= tree_winid and win_config.focusable and not win_config.external or false
   end, win_ids)
 end
 
@@ -83,8 +89,15 @@ local function pick_win_id()
 
   if laststatus == 3 then
     for _, win_id in ipairs(not_selectable) do
-      local ok_status, statusline = pcall(vim.api.nvim_win_get_option, win_id, "statusline")
+      local ok_status, statusline, ok_hl, winhl
-      local ok_hl, winhl = pcall(vim.api.nvim_win_get_option, win_id, "winhl")
+
+      if vim.fn.has "nvim-0.10" == 1 then
+        ok_status, statusline = pcall(vim.api.nvim_get_option_value, "statusline", { win = win_id })
+        ok_hl, winhl = pcall(vim.api.nvim_get_option_value, "winhl", { win = win_id })
+      else
+        ok_status, statusline = pcall(vim.api.nvim_win_get_option, win_id, "statusline") ---@diagnostic disable-line: deprecated
+        ok_hl, winhl = pcall(vim.api.nvim_win_get_option, win_id, "winhl") ---@diagnostic disable-line: deprecated
+      end
 
       win_opts[win_id] = {
         statusline = ok_status and statusline or "",
@@ -92,15 +105,26 @@ local function pick_win_id()
       }
 
       -- Clear statusline for windows not selectable
-      vim.api.nvim_win_set_option(win_id, "statusline", " ")
+      if vim.fn.has "nvim-0.10" == 1 then
+        vim.api.nvim_set_option_value("statusline", " ", { win = win_id })
+      else
+        vim.api.nvim_win_set_option(win_id, "statusline", " ") ---@diagnostic disable-line: deprecated
+      end
     end
   end
 
   -- Setup UI
   for _, id in ipairs(selectable) do
     local char = M.window_picker.chars:sub(i, i)
-    local ok_status, statusline = pcall(vim.api.nvim_win_get_option, id, "statusline")
+
-    local ok_hl, winhl = pcall(vim.api.nvim_win_get_option, id, "winhl")
+    local ok_status, statusline, ok_hl, winhl
+    if vim.fn.has "nvim-0.10" == 1 then
+      ok_status, statusline = pcall(vim.api.nvim_get_option_value, "statusline", { win = id })
+      ok_hl, winhl = pcall(vim.api.nvim_get_option_value, "winhl", { win = id })
+    else
+      ok_status, statusline = pcall(vim.api.nvim_win_get_option, id, "statusline") ---@diagnostic disable-line: deprecated
+      ok_hl, winhl = pcall(vim.api.nvim_win_get_option, id, "winhl") ---@diagnostic disable-line: deprecated
+    end
 
     win_opts[id] = {
       statusline = ok_status and statusline or "",
@@ -108,8 +132,13 @@ local function pick_win_id()
     }
     win_map[char] = id
 
-    vim.api.nvim_win_set_option(id, "statusline", "%=" .. char .. "%=")
+    if vim.fn.has "nvim-0.10" == 1 then
-    vim.api.nvim_win_set_option(id, "winhl", "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker")
+      vim.api.nvim_set_option_value("statusline", "%=" .. char .. "%=", { win = id })
+      vim.api.nvim_set_option_value("winhl", "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker", { win = id })
+    else
+      vim.api.nvim_win_set_option(id, "statusline", "%=" .. char .. "%=") ---@diagnostic disable-line: deprecated
+      vim.api.nvim_win_set_option(id, "winhl", "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker") ---@diagnostic disable-line: deprecated
+    end
 
     i = i + 1
     if i > #M.window_picker.chars then
@@ -128,14 +157,25 @@ local function pick_win_id()
   -- Restore window options
   for _, id in ipairs(selectable) do
     for opt, value in pairs(win_opts[id]) do
-      vim.api.nvim_win_set_option(id, opt, value)
+      if vim.fn.has "nvim-0.10" == 1 then
+        vim.api.nvim_set_option_value(opt, value, { win = id })
+      else
+        vim.api.nvim_win_set_option(id, opt, value) ---@diagnostic disable-line: deprecated
+      end
     end
   end
 
   if laststatus == 3 then
     for _, id in ipairs(not_selectable) do
+      -- Ensure window still exists at this point
+      if vim.api.nvim_win_is_valid(id) then
         for opt, value in pairs(win_opts[id]) do
-        vim.api.nvim_win_set_option(id, opt, value)
+          if vim.fn.has "nvim-0.10" == 1 then
+            vim.api.nvim_set_option_value(opt, value, { win = id })
+          else
+            vim.api.nvim_win_set_option(id, opt, value) ---@diagnostic disable-line: deprecated
+          end
+        end
       end
     end
   end
@@ -153,6 +193,9 @@ local function open_file_in_tab(filename)
   if M.quit_on_open then
     view.close()
   end
+  if M.relative_path then
+    filename = utils.path_relative(filename, vim.fn.getcwd())
+  end
   vim.cmd("tabe " .. vim.fn.fnameescape(filename))
 end
 
@@ -160,6 +203,9 @@ local function drop(filename)
   if M.quit_on_open then
     view.close()
   end
+  if M.relative_path then
+    filename = utils.path_relative(filename, vim.fn.getcwd())
+  end
   vim.cmd("drop " .. vim.fn.fnameescape(filename))
 end
 
@@ -167,6 +213,9 @@ local function tab_drop(filename)
   if M.quit_on_open then
     view.close()
   end
+  if M.relative_path then
+    filename = utils.path_relative(filename, vim.fn.getcwd())
+  end
   vim.cmd("tab :drop " .. vim.fn.fnameescape(filename))
 end
 
@@ -258,25 +307,21 @@ local function open_in_new_window(filename, mode)
     -- If `hidden` is not enabled, check if buffer in target window is
     -- modified, and create new split if it is.
     local target_bufid = vim.api.nvim_win_get_buf(target_winid)
-    if vim.api.nvim_buf_get_option(target_bufid, "modified") then
+
+    local modified
+    if vim.fn.has "nvim-0.10" == 1 then
+      modified = vim.api.nvim_get_option_value("modified", { buf = target_bufid })
+    else
+      modified = vim.api.nvim_buf_get_option(target_bufid, "modified") ---@diagnostic disable-line: deprecated
+    end
+
+    if modified then
       if not mode:match "split$" then
         mode = "vsplit"
       end
     end
   end
 
-  local fname = vim.fn.fnameescape(filename)
-  fname = utils.escape_special_chars(fname)
-
-  local cmd
-  if create_new_window then
-    cmd = string.format("%s vsplit %s", new_window_side, fname)
-  elseif mode:match "split$" then
-    cmd = string.format("%s %s", mode, fname)
-  else
-    cmd = string.format("edit %s", fname)
-  end
-
   if (mode == "preview" or mode == "preview_no_picker") and view.View.float.enable then
     -- ignore "WinLeave" autocmd on preview
     -- because the registered "WinLeave"
@@ -286,7 +331,24 @@ local function open_in_new_window(filename, mode)
     set_current_win_no_autocmd(target_winid, { "BufEnter" })
   end
 
-  pcall(vim.cmd, cmd)
+  local fname
+  if M.relative_path then
+    fname = utils.escape_special_chars(vim.fn.fnameescape(utils.path_relative(filename, vim.fn.getcwd())))
+  else
+    fname = utils.escape_special_chars(vim.fn.fnameescape(filename))
+  end
+
+  local command
+  if create_new_window then
+    -- generated from vim.api.nvim_parse_cmd("belowright vsplit foo", {})
+    command = { cmd = "vsplit", mods = { split = new_window_side }, args = { fname } }
+  elseif mode:match "split$" then
+    command = { cmd = mode, args = { fname } }
+  else
+    command = { cmd = "edit", args = { fname } }
+  end
+
+  pcall(vim.api.nvim_cmd, command, { output = false })
   lib.set_target_win()
 end
 
@@ -301,6 +363,9 @@ end
 
 local function edit_in_current_buf(filename)
   require("nvim-tree.view").abandon_current_window()
+  if M.relative_path then
+    filename = utils.path_relative(filename, vim.fn.getcwd())
+  end
   vim.cmd("keepalt keepjumps edit " .. vim.fn.fnameescape(filename))
 end
 
@@ -357,6 +422,7 @@ end
 function M.setup(opts)
   M.quit_on_open = opts.actions.open_file.quit_on_open
   M.resize_window = opts.actions.open_file.resize_window
+  M.relative_path = opts.experimental.actions.open_file.relative_path
   if opts.actions.open_file.window_picker.chars then
     opts.actions.open_file.window_picker.chars = tostring(opts.actions.open_file.window_picker.chars):upper()
   end

lua/nvim-tree/actions/tree/find-file.lua

@@ -24,18 +24,19 @@ function M.fn(opts)
   local bufnr, path
 
   -- (optional) buffer number and path
-  if type(opts.buf) == "nil" then
+  local opts_buf = opts.buf
+  if type(opts_buf) == "nil" then
     bufnr = vim.api.nvim_get_current_buf()
     path = vim.api.nvim_buf_get_name(bufnr)
-  elseif type(opts.buf) == "number" then
+  elseif type(opts_buf) == "number" then
-    if not vim.api.nvim_buf_is_valid(opts.buf) then
+    if not vim.api.nvim_buf_is_valid(opts_buf) then
       return
     end
-    bufnr = tonumber(opts.buf)
+    bufnr = opts_buf
     path = vim.api.nvim_buf_get_name(bufnr)
-  elseif type(opts.buf) == "string" then
+  elseif type(opts_buf) == "string" then
     bufnr = nil
-    path = tostring(opts.buf)
+    path = tostring(opts_buf)
   else
     return
   end
@@ -55,7 +56,7 @@ function M.fn(opts)
   end
 
   -- update root
-  if opts.update_root or M.config.update_focused_file.update_root then
+  if opts.update_root or M.config.update_focused_file.update_root.enable then
     require("nvim-tree").change_root(path, bufnr)
   end
 

lua/nvim-tree/actions/tree/init.lua

@@ -4,12 +4,14 @@ M.find_file = require "nvim-tree.actions.tree.find-file"
 M.modifiers = require "nvim-tree.actions.tree.modifiers"
 M.open = require "nvim-tree.actions.tree.open"
 M.toggle = require "nvim-tree.actions.tree.toggle"
+M.resize = require "nvim-tree.actions.tree.resize"
 
 function M.setup(opts)
   M.find_file.setup(opts)
   M.modifiers.setup(opts)
   M.open.setup(opts)
   M.toggle.setup(opts)
+  M.resize.setup(opts)
 end
 
 return M

lua/nvim-tree/actions/tree/modifiers/toggles.lua

@@ -1,8 +1,7 @@
 local lib = require "nvim-tree.lib"
 local utils = require "nvim-tree.utils"
-local filters = require "nvim-tree.explorer.filters"
 local reloaders = require "nvim-tree.actions.reloaders"
-
+local core = require "nvim-tree.core"
 local M = {}
 
 local function reload()
@@ -11,34 +10,56 @@ local function reload()
   utils.focus_node_or_parent(node)
 end
 
-function M.custom()
+local function wrap_explorer(fn)
-  filters.config.filter_custom = not filters.config.filter_custom
+  return function(...)
+    local explorer = core.get_explorer()
+    if explorer then
+      return fn(explorer, ...)
+    end
+  end
+end
+
+local function custom(explorer)
+  explorer.filters.config.filter_custom = not explorer.filters.config.filter_custom
   reload()
 end
 
-function M.git_ignored()
+local function git_ignored(explorer)
-  filters.config.filter_git_ignored = not filters.config.filter_git_ignored
+  explorer.filters.config.filter_git_ignored = not explorer.filters.config.filter_git_ignored
   reload()
 end
 
-function M.git_clean()
+local function git_clean(explorer)
-  filters.config.filter_git_clean = not filters.config.filter_git_clean
+  explorer.filters.config.filter_git_clean = not explorer.filters.config.filter_git_clean
   reload()
 end
 
-function M.no_buffer()
+local function no_buffer(explorer)
-  filters.config.filter_no_buffer = not filters.config.filter_no_buffer
+  explorer.filters.config.filter_no_buffer = not explorer.filters.config.filter_no_buffer
   reload()
 end
 
-function M.no_bookmark()
+local function no_bookmark(explorer)
-  filters.config.filter_no_bookmark = not filters.config.filter_no_bookmark
+  explorer.filters.config.filter_no_bookmark = not explorer.filters.config.filter_no_bookmark
   reload()
 end
 
-function M.dotfiles()
+local function dotfiles(explorer)
-  filters.config.filter_dotfiles = not filters.config.filter_dotfiles
+  explorer.filters.config.filter_dotfiles = not explorer.filters.config.filter_dotfiles
   reload()
 end
 
+local function enable(explorer)
+  explorer.filters.config.enable = not explorer.filters.config.enable
+  reload()
+end
+
+M.custom = wrap_explorer(custom)
+M.git_ignored = wrap_explorer(git_ignored)
+M.git_clean = wrap_explorer(git_clean)
+M.no_buffer = wrap_explorer(no_buffer)
+M.no_bookmark = wrap_explorer(no_bookmark)
+M.dotfiles = wrap_explorer(dotfiles)
+M.enable = wrap_explorer(enable)
+
 return M

lua/nvim-tree/actions/tree/resize.lua

@@ -0,0 +1,51 @@
+local view = require "nvim-tree.view"
+
+local M = {}
+
+---Resize the tree, persisting the new size.
+---@param opts ApiTreeResizeOpts|nil
+function M.fn(opts)
+  if opts == nil then
+    -- reset to config values
+    view.configure_width()
+    view.resize()
+    return
+  end
+
+  local options = opts or {}
+  local width_cfg = options.width
+
+  if width_cfg ~= nil then
+    view.configure_width(width_cfg)
+    view.resize()
+    return
+  end
+
+  if not view.is_width_determined() then
+    -- {absolute} and {relative} do nothing when {width} is a function.
+    return
+  end
+
+  local absolute = options.absolute
+  if type(absolute) == "number" then
+    view.resize(absolute)
+    return
+  end
+
+  local relative = options.relative
+  if type(relative) == "number" then
+    local relative_size = tostring(relative)
+    if relative > 0 then
+      relative_size = "+" .. relative_size
+    end
+
+    view.resize(relative_size)
+    return
+  end
+end
+
+function M.setup(opts)
+  M.config = opts or {}
+end
+
+return M

lua/nvim-tree/api.lua

@@ -1,12 +1,11 @@
 local lib = require "nvim-tree.lib"
+local core = require "nvim-tree.core"
 local view = require "nvim-tree.view"
 local utils = require "nvim-tree.utils"
 local actions = require "nvim-tree.actions"
 local appearance_diagnostics = require "nvim-tree.appearance.diagnostics"
 local events = require "nvim-tree.events"
 local help = require "nvim-tree.help"
-local live_filter = require "nvim-tree.live-filter"
-local marks = require "nvim-tree.marks"
 local marks_navigation = require "nvim-tree.marks.navigation"
 local marks_bulk_delete = require "nvim-tree.marks.bulk-delete"
 local marks_bulk_trash = require "nvim-tree.marks.bulk-trash"
@@ -43,9 +42,10 @@ local Api = {
   diagnostics = {},
 }
 
---- Do nothing when setup not called.
+--- Print error when setup not called.
 --- f function to invoke
 ---@param f function
+---@return fun(...) : any
 local function wrap(f)
   return function(...)
     if vim.g.NvimTreeSetup == 1 then
@@ -56,13 +56,13 @@ local function wrap(f)
   end
 end
 
----Inject the node as the first argument if absent.
+---Inject the node as the first argument if present otherwise do nothing.
 ---@param fn function function to invoke
 local function wrap_node(fn)
   return function(node, ...)
     node = node or lib.get_node_at_cursor()
     if node then
-      fn(node, ...)
+      return fn(node, ...)
     end
   end
 end
@@ -72,10 +72,36 @@ end
 local function wrap_node_or_nil(fn)
   return function(node, ...)
     node = node or lib.get_node_at_cursor()
-    fn(node, ...)
+    return fn(node, ...)
   end
 end
 
+---Inject the explorer as the first argument if present otherwise do nothing.
+---@param fn function function to invoke
+---@return fun(...) : any
+local function wrap_explorer(fn)
+  return function(...)
+    local explorer = core.get_explorer()
+    if explorer then
+      return fn(explorer, ...)
+    end
+  end
+end
+
+---Invoke a member's method on the singleton explorer.
+---Print error when setup not called.
+---@param explorer_member string explorer member name
+---@param member_method string method name to invoke on member
+---@return fun(...) : any
+local function wrap_explorer_member(explorer_member, member_method)
+  return wrap(function(...)
+    local explorer = core.get_explorer()
+    if explorer then
+      return explorer[explorer_member][member_method](explorer[explorer_member], ...)
+    end
+  end)
+end
+
 ---@class ApiTreeOpenOpts
 ---@field path string|nil path
 ---@field current_window boolean|nil default false
@@ -100,6 +126,13 @@ Api.tree.close_in_this_tab = wrap(view.close_this_tab_only)
 Api.tree.close_in_all_tabs = wrap(view.close_all_tabs)
 Api.tree.reload = wrap(actions.reloaders.reload_explorer)
 
+---@class ApiTreeResizeOpts
+---@field width string|function|number|table|nil
+---@field absolute number|nil
+---@field relative number|nil
+
+Api.tree.resize = wrap(actions.tree.resize.fn)
+
 Api.tree.change_root = wrap(function(...)
   require("nvim-tree").change_dir(...)
 end)
@@ -128,6 +161,7 @@ Api.tree.find_file = wrap(actions.tree.find_file.fn)
 Api.tree.search_node = wrap(actions.finders.search_node.fn)
 Api.tree.collapse_all = wrap(actions.tree.modifiers.collapse_all.fn)
 Api.tree.expand_all = wrap_node(actions.tree.modifiers.expand_all.fn)
+Api.tree.toggle_enable_filters = wrap(actions.tree.modifiers.toggles.enable)
 Api.tree.toggle_gitignore_filter = wrap(actions.tree.modifiers.toggles.git_ignored)
 Api.tree.toggle_git_clean_filter = wrap(actions.tree.modifiers.toggles.git_clean)
 Api.tree.toggle_no_buffer_filter = wrap(actions.tree.modifiers.toggles.no_buffer)
@@ -163,6 +197,7 @@ Api.fs.print_clipboard = wrap(actions.fs.copy_paste.print_clipboard)
 Api.fs.copy.node = wrap_node(actions.fs.copy_paste.copy)
 Api.fs.copy.absolute_path = wrap_node(actions.fs.copy_paste.copy_absolute_path)
 Api.fs.copy.filename = wrap_node(actions.fs.copy_paste.copy_filename)
+Api.fs.copy.basename = wrap_node(actions.fs.copy_paste.copy_basename)
 Api.fs.copy.relative_path = wrap_node(actions.fs.copy_paste.copy_path)
 
 ---@param mode string
@@ -229,16 +264,16 @@ Api.git.reload = wrap(actions.reloaders.reload_git)
 Api.events.subscribe = events.subscribe
 Api.events.Event = events.Event
 
-Api.live_filter.start = wrap(live_filter.start_filtering)
+Api.live_filter.start = wrap_explorer_member("live_filter", "start_filtering")
-Api.live_filter.clear = wrap(live_filter.clear_filter)
+Api.live_filter.clear = wrap_explorer_member("live_filter", "clear_filter")
 
-Api.marks.get = wrap_node(marks.get_mark)
+Api.marks.get = wrap_node(wrap_explorer_member("marks", "get_mark"))
-Api.marks.list = wrap(marks.get_marks)
+Api.marks.list = wrap_explorer_member("marks", "get_marks")
-Api.marks.toggle = wrap_node(marks.toggle_mark)
+Api.marks.toggle = wrap_node(wrap_explorer_member("marks", "toggle_mark"))
-Api.marks.clear = wrap(marks.clear_marks)
+Api.marks.clear = wrap_explorer_member("marks", "clear_marks")
-Api.marks.bulk.delete = wrap(marks_bulk_delete.bulk_delete)
+Api.marks.bulk.delete = wrap_explorer(marks_bulk_delete.bulk_delete)
-Api.marks.bulk.trash = wrap(marks_bulk_trash.bulk_trash)
+Api.marks.bulk.trash = wrap_explorer(marks_bulk_trash.bulk_trash)
-Api.marks.bulk.move = wrap(marks_bulk_move.bulk_move)
+Api.marks.bulk.move = wrap_explorer(marks_bulk_move.bulk_move)
 Api.marks.navigate.next = wrap(marks_navigation.next)
 Api.marks.navigate.prev = wrap(marks_navigation.prev)
 Api.marks.navigate.select = wrap(marks_navigation.select)

lua/nvim-tree/appearance/diagnostics.lua

@@ -1,5 +1,8 @@
 local appearance = require "nvim-tree.appearance"
 
+-- others with name and links less than this arbitrary value are short
+local SHORT_LEN = 50
+
 local M = {}
 
 ---@class HighlightDisplay for :NvimTreeHiTest
@@ -8,7 +11,7 @@ local M = {}
 ---@field def string :hi concrete definition after following any links
 local HighlightDisplay = {}
 
----@param group string nvim-tree highlight group
+---@param group string nvim-tree highlight group name
 ---@return HighlightDisplay
 function HighlightDisplay:new(group)
   local o = {}
@@ -39,41 +42,99 @@ function HighlightDisplay:new(group)
   return o
 end
 
+---Render one group.
+---@param bufnr number to render in
+---@param fmt string format string for group, links, def
+---@param l number line number to render at
+---@return number l next line number
 function HighlightDisplay:render(bufnr, fmt, l)
   local text = string.format(fmt, self.group, self.links, self.def)
 
   vim.api.nvim_buf_set_lines(bufnr, l, -1, true, { text })
   vim.api.nvim_buf_add_highlight(bufnr, -1, self.group, l, 0, #self.group)
+
+  return l + 1
 end
 
----Run a test similar to :so $VIMRUNTIME/syntax/hitest.vim
+---Render many groups.
----Display all nvim-tree highlight groups, their link chain and actual definition
+---@param header string before with underline line
-function M.hi_test()
+---@param displays HighlightDisplay[] highlight group
-  local displays = {}
+---@param bufnr number to render in
+---@param l number line number to start at
+---@return number l next line number
+local function render_displays(header, displays, bufnr, l)
   local max_group_len = 0
   local max_links_len = 0
 
-  -- build all highlight groups, name only
+  -- build all highlight groups, using name only
-  for _, highlight_group in ipairs(appearance.HIGHLIGHT_GROUPS) do
+  for _, display in ipairs(displays) do
-    local display = HighlightDisplay:new(highlight_group.group)
-    table.insert(displays, display)
     max_group_len = math.max(max_group_len, #display.group)
     max_links_len = math.max(max_links_len, #display.links)
   end
 
+  -- header
+  vim.api.nvim_buf_set_lines(bufnr, l, -1, true, { header, (header:gsub(".", "-")) })
+  l = l + 2
+
+  -- render and highlight
+  local fmt = string.format("%%-%d.%ds %%-%d.%ds %%s", max_group_len, max_group_len, max_links_len, max_links_len)
+  for _, display in ipairs(displays) do
+    l = display:render(bufnr, fmt, l)
+  end
+
+  return l
+end
+
+---Run a test similar to :so $VIMRUNTIME/syntax/hitest.vim
+---Display all nvim-tree and neovim highlight groups, their link chain and actual definition
+function M.hi_test()
   -- create a buffer
   local bufnr = vim.api.nvim_create_buf(false, true)
 
-  -- render and highlight
   local l = 0
-  local fmt = string.format("%%-%d.%ds %%-%d.%ds %%s", max_group_len, max_group_len, max_links_len, max_links_len)
+
-  for _, display in ipairs(displays) do
+  -- nvim-tree groups, ordered
-    display:render(bufnr, fmt, l)
+  local displays = {}
+  for _, highlight_group in ipairs(appearance.HIGHLIGHT_GROUPS) do
+    local display = HighlightDisplay:new(highlight_group.group)
+    table.insert(displays, display)
+  end
+  l = render_displays("nvim-tree", displays, bufnr, l)
+
+  vim.api.nvim_buf_set_lines(bufnr, l, -1, true, { "" })
   l = l + 1
+
+  -- built in groups, ordered opaquely by nvim
+  local displays_short, displays_long = {}, {}
+  local ok, out = pcall(vim.api.nvim_cmd, { cmd = "highlight" }, { output = true })
+  if ok then
+    for group in string.gmatch(out, "(%w*)%s+xxx") do
+      if group:find("NvimTree", 1, true) ~= 1 then
+        local display = HighlightDisplay:new(group)
+        if #display.group + #display.links > SHORT_LEN then
+          table.insert(displays_long, display)
+        else
+          table.insert(displays_short, display)
+        end
+      end
+    end
   end
 
+  -- short ones first
+  l = render_displays("other, short", displays_short, bufnr, l)
+  vim.api.nvim_buf_set_lines(bufnr, l, -1, true, { "" })
+  l = l + 1
+
+  -- long
+  render_displays("other, long", displays_long, bufnr, l)
+
   -- finalise and focus the buffer
-  vim.api.nvim_buf_set_option(bufnr, "modifiable", false)
+  if vim.fn.has "nvim-0.10" == 1 then
+    vim.api.nvim_set_option_value("modifiable", false, { buf = bufnr })
+  else
+    vim.api.nvim_buf_set_option(bufnr, "modifiable", false) ---@diagnostic disable-line: deprecated
+  end
+
   vim.cmd.buffer(bufnr)
 end
 

lua/nvim-tree/appearance/init.lua

@@ -1,5 +1,11 @@
 local M = {}
 
+---@class HighlightGroup
+---@field group string
+---@field link string|nil
+---@field def string|nil
+
+---@type HighlightGroup[]
 -- All highlight groups: linked or directly defined.
 -- Please add new groups to help and preserve order.
 -- Please avoid directly defined groups to preserve accessibility for TUI.
@@ -8,6 +14,7 @@ M.HIGHLIGHT_GROUPS = {
   -- Standard
   { group = "NvimTreeNormal", link = "Normal" },
   { group = "NvimTreeNormalFloat", link = "NormalFloat" },
+  { group = "NvimTreeNormalFloatBorder", link = "FloatBorder" },
   { group = "NvimTreeNormalNC", link = "NvimTreeNormal" },
 
   { group = "NvimTreeLineNr", link = "LineNr" },
@@ -24,10 +31,10 @@ M.HIGHLIGHT_GROUPS = {
   { group = "NvimTreeStatusLineNC", link = "StatusLineNC" },
 
   -- File Text
-  { group = "NvimTreeExecFile", link = "SpellCap" },
+  { group = "NvimTreeExecFile", link = "Question" },
-  { group = "NvimTreeImageFile", link = "SpellCap" },
+  { group = "NvimTreeImageFile", link = "Question" },
-  { group = "NvimTreeSpecialFile", link = "SpellCap" },
+  { group = "NvimTreeSpecialFile", link = "Title" },
-  { group = "NvimTreeSymlink", link = "SpellCap" },
+  { group = "NvimTreeSymlink", link = "Underlined" },
 
   -- Folder Text
   { group = "NvimTreeRootFolder", link = "Title" },
@@ -51,7 +58,7 @@ M.HIGHLIGHT_GROUPS = {
   { group = "NvimTreeIndentMarker", link = "NvimTreeFolderIcon" },
 
   -- Picker
-  { group = "NvimTreeWindowPicker", def = "guifg=#ededed guibg=#4493c8 gui=bold ctermfg=White ctermbg=Cyan" },
+  { group = "NvimTreeWindowPicker", def = "guifg=#ededed guibg=#4493c8 gui=bold ctermfg=White ctermbg=DarkBlue" },
 
   -- LiveFilter
   { group = "NvimTreeLiveFilterPrefix", link = "PreProc" },
@@ -70,6 +77,14 @@ M.HIGHLIGHT_GROUPS = {
   { group = "NvimTreeModifiedFileHL", link = "NvimTreeModifiedIcon" },
   { group = "NvimTreeModifiedFolderHL", link = "NvimTreeModifiedFileHL" },
 
+  -- Hidden
+  { group = "NvimTreeHiddenIcon", link = "Conceal" },
+  { group = "NvimTreeHiddenFileHL", link = "NvimTreeHiddenIcon" },
+  { group = "NvimTreeHiddenFolderHL", link = "NvimTreeHiddenFileHL" },
+
+  -- Hidden Display
+  { group = "NvimTreeHiddenDisplay", link = "Conceal" },
+
   -- Opened
   { group = "NvimTreeOpenedHL", link = "Special" },
 
@@ -177,15 +192,8 @@ function M.setup()
 
   -- hard link override when legacy only is present
   for from, to in pairs(M.LEGACY_LINKS) do
-    local hl_from
+    local hl_from = vim.api.nvim_get_hl(0, { name = from })
-    local hl_to
+    local hl_to = vim.api.nvim_get_hl(0, { name = to })
-    if vim.fn.has "nvim-0.9" == 1 then
-      hl_from = vim.api.nvim_get_hl(0, { name = from })
-      hl_to = vim.api.nvim_get_hl(0, { name = to })
-    else
-      hl_from = vim.api.nvim__get_hl_defs(0)[from] or {}
-      hl_to = vim.api.nvim__get_hl_defs(0)[to] or {}
-    end
     if vim.tbl_isempty(hl_from) and not vim.tbl_isempty(hl_to) then
       vim.api.nvim_command("hi link " .. from .. " " .. to)
     end

lua/nvim-tree/buffers.lua

@@ -6,7 +6,7 @@ M._modified = {}
 ---refresh M._modified
 function M.reload_modified()
   M._modified = {}
-  local bufs = vim.fn.getbufinfo { bufmodified = true, buflisted = true }
+  local bufs = vim.fn.getbufinfo { bufmodified = 1, buflisted = 1 }
   for _, buf in pairs(bufs) do
     local path = buf.name
     if path ~= "" then -- not a [No Name] buffer

lua/nvim-tree/core.lua

@@ -1,6 +1,5 @@
 local events = require "nvim-tree.events"
 local explorer = require "nvim-tree.explorer"
-local live_filter = require "nvim-tree.live-filter"
 local view = require "nvim-tree.view"
 local log = require "nvim-tree.log"
 
@@ -45,7 +44,7 @@ function M.get_nodes_starting_line()
   if view.is_root_folder_visible(M.get_cwd()) then
     offset = offset + 1
   end
-  if live_filter.filter then
+  if TreeExplorer and TreeExplorer.live_filter.filter then
     return offset + 1
   end
   return offset

lua/nvim-tree/diagnostics.lua

@@ -39,19 +39,21 @@ end
 local function from_nvim_lsp()
   local buffer_severity = {}
 
-  local is_disabled = false
+  -- is_enabled is not present in all 0.10 builds/releases, see #2781
-  if vim.fn.has "nvim-0.9" == 1 then
+  local is_enabled = false
-    is_disabled = vim.diagnostic.is_disabled()
+  if vim.fn.has "nvim-0.10" == 1 and type(vim.diagnostic.is_enabled) == "function" then
+    is_enabled = vim.diagnostic.is_enabled()
+  elseif type(vim.diagnostic.is_disabled) == "function" then ---@diagnostic disable-line: deprecated
+    is_enabled = not vim.diagnostic.is_disabled() ---@diagnostic disable-line: deprecated
   end
 
-  if not is_disabled then
+  if is_enabled then
     for _, diagnostic in ipairs(vim.diagnostic.get(nil, { severity = M.severity })) do
-      local buf = diagnostic.bufnr
+      if diagnostic.severity and diagnostic.bufnr and vim.api.nvim_buf_is_valid(diagnostic.bufnr) then
-      if vim.api.nvim_buf_is_valid(buf) then
+        local bufname = uniformize_path(vim.api.nvim_buf_get_name(diagnostic.bufnr))
-        local bufname = uniformize_path(vim.api.nvim_buf_get_name(buf))
+        if not buffer_severity[bufname] or diagnostic.severity < buffer_severity[bufname] then
-        local severity = diagnostic.severity
+          buffer_severity[bufname] = diagnostic.severity
-        local highest_severity = buffer_severity[bufname] or severity
+        end
-        buffer_severity[bufname] = math.min(highest_severity, severity)
       end
     end
   end

lua/nvim-tree/enum.lua

@@ -16,6 +16,18 @@ M.ICON_PLACEMENT = {
   signcolumn = 1,
   before = 2,
   after = 3,
+  right_align = 4,
+}
+
+---Reason for filter in filter.lua
+---@enum FILTER_REASON
+M.FILTER_REASON = {
+  none = 0, -- It's not filtered
+  git = 1,
+  buf = 2,
+  dotfile = 4,
+  custom = 8,
+  bookmark = 16,
 }
 
 return M

lua/nvim-tree/explorer/explore.lua

@@ -2,30 +2,32 @@ local utils = require "nvim-tree.utils"
 local builders = require "nvim-tree.explorer.node-builders"
 local explorer_node = require "nvim-tree.explorer.node"
 local git = require "nvim-tree.git"
-local sorters = require "nvim-tree.explorer.sorters"
-local filters = require "nvim-tree.explorer.filters"
-local live_filter = require "nvim-tree.live-filter"
 local log = require "nvim-tree.log"
 
+local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
 local Watcher = require "nvim-tree.watcher"
 
 local M = {}
 
----@param type_ string|nil
----@param cwd string
----@return any
-local function get_type_from(type_, cwd)
-  return type_ or (vim.loop.fs_stat(cwd) or {}).type
-end
-
 ---@param handle uv.uv_fs_t
 ---@param cwd string
 ---@param node Node
 ---@param git_status table
-local function populate_children(handle, cwd, node, git_status)
+---@param parent Explorer
+local function populate_children(handle, cwd, node, git_status, parent)
   local node_ignored = explorer_node.is_git_ignored(node)
   local nodes_by_path = utils.bool_record(node.nodes, "absolute_path")
-  local filter_status = filters.prepare(git_status)
+
+  local filter_status = parent.filters:prepare(git_status)
+
+  node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
+    git = 0,
+    buf = 0,
+    dotfile = 0,
+    custom = 0,
+    bookmark = 0,
+  })
+
   while true do
     local name, t = vim.loop.fs_scandir_next(handle)
     if not name then
@@ -33,18 +35,19 @@ local function populate_children(handle, cwd, node, git_status)
     end
 
     local abs = utils.path_join { cwd, name }
-
     local profile = log.profile_start("explore populate_children %s", abs)
 
-    t = get_type_from(t, abs)
+    ---@type uv.fs_stat.result|nil
-    if not filters.should_filter(abs, filter_status) and not nodes_by_path[abs] and Watcher.is_fs_event_capable(abs) then
+    local stat = vim.loop.fs_stat(abs)
+    local filter_reason = parent.filters:should_filter_as_reason(abs, stat, filter_status)
+    if filter_reason == FILTER_REASON.none and not nodes_by_path[abs] and Watcher.is_fs_event_capable(abs) then
       local child = nil
       if t == "directory" and vim.loop.fs_access(abs, "R") then
-        child = builders.folder(node, abs, name)
+        child = builders.folder(node, abs, name, stat)
       elseif t == "file" then
-        child = builders.file(node, abs, name)
+        child = builders.file(node, abs, name, stat)
       elseif t == "link" then
-        local link = builders.link(node, abs, name)
+        local link = builders.link(node, abs, name, stat)
         if link.link_to ~= nil then
           child = link
         end
@@ -54,6 +57,12 @@ local function populate_children(handle, cwd, node, git_status)
         nodes_by_path[child.absolute_path] = true
         explorer_node.update_git_status(child, node_ignored, git_status)
       end
+    else
+      for reason, value in pairs(FILTER_REASON) do
+        if filter_reason == value then
+          node.hidden_stats[reason] = node.hidden_stats[reason] + 1
+        end
+      end
     end
 
     log.profile_end(profile)
@@ -62,8 +71,9 @@ end
 
 ---@param node Node
 ---@param status table
+---@param parent Explorer
 ---@return Node[]|nil
-function M.explore(node, status)
+function M.explore(node, status, parent)
   local cwd = node.link_to or node.absolute_path
   local handle = vim.loop.fs_scandir(cwd)
   if not handle then
@@ -72,7 +82,7 @@ function M.explore(node, status)
 
   local profile = log.profile_start("explore init %s", node.absolute_path)
 
-  populate_children(handle, cwd, node, status)
+  populate_children(handle, cwd, node, status, parent)
 
   local is_root = not node.parent
   local child_folder_only = explorer_node.has_one_child_folder(node) and node.nodes[1]
@@ -80,15 +90,15 @@ function M.explore(node, status)
     local child_cwd = child_folder_only.link_to or child_folder_only.absolute_path
     local child_status = git.load_project_status(child_cwd)
     node.group_next = child_folder_only
-    local ns = M.explore(child_folder_only, child_status)
+    local ns = M.explore(child_folder_only, child_status, parent)
     node.nodes = ns or {}
 
     log.profile_end(profile)
     return ns
   end
 
-  sorters.sort(node.nodes)
+  parent.sorters:sort(node.nodes)
-  live_filter.apply_filter(node)
+  parent.live_filter:apply_filter(node)
 
   log.profile_end(profile)
   return node.nodes

lua/nvim-tree/explorer/filters.lua

@@ -1,16 +1,53 @@
 local utils = require "nvim-tree.utils"
-local marks = require "nvim-tree.marks"
+local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
 
-local M = {
+---@class Filters to handle all opts.filters and related API
+---@field config table hydrated user opts.filters
+---@field private explorer Explorer
+---@field private exclude_list string[] filters.exclude
+---@field private ignore_list string[] filters.custom string table
+---@field private custom_function (fun(absolute_path: string): boolean)|nil filters.custom function
+local Filters = {}
+
+---@param opts table user options
+---@param explorer Explorer
+---@return Filters
+function Filters:new(opts, explorer)
+  local o = {
+    explorer = explorer,
     ignore_list = {},
-  exclude_list = {},
+    exclude_list = opts.filters.exclude,
     custom_function = nil,
-}
+    config = {
+      enable = opts.filters.enable,
+      filter_custom = true,
+      filter_dotfiles = opts.filters.dotfiles,
+      filter_git_ignored = opts.filters.git_ignored,
+      filter_git_clean = opts.filters.git_clean,
+      filter_no_buffer = opts.filters.no_buffer,
+      filter_no_bookmark = opts.filters.no_bookmark,
+    },
+  }
+
+  local custom_filter = opts.filters.custom
+  if type(custom_filter) == "function" then
+    o.custom_function = custom_filter
+  else
+    if custom_filter and #custom_filter > 0 then
+      for _, filter_name in pairs(custom_filter) do
+        o.ignore_list[filter_name] = true
+      end
+    end
+  end
+  setmetatable(o, self)
+  self.__index = self
+  return o
+end
 
 ---@param path string
 ---@return boolean
-local function is_excluded(path)
+local function is_excluded(self, path)
-  for _, node in ipairs(M.exclude_list) do
+  for _, node in ipairs(self.exclude_list) do
     if path:match(node) then
       return true
     end
@@ -22,7 +59,7 @@ end
 ---@param path string Absolute path
 ---@param git_status table from prepare
 ---@return boolean
-local function git(path, git_status)
+local function git(self, path, git_status)
   if type(git_status) ~= "table" or type(git_status.files) ~= "table" or type(git_status.dirs) ~= "table" then
     return false
   end
@@ -33,12 +70,12 @@ local function git(path, git_status)
   status = status or git_status.dirs.indirect[path] and git_status.dirs.indirect[path][1]
 
   -- filter ignored; overrides clean as they are effectively dirty
-  if M.config.filter_git_ignored and status == "!!" then
+  if self.config.filter_git_ignored and status == "!!" then
     return true
   end
 
   -- filter clean
-  if M.config.filter_git_clean and not status then
+  if self.config.filter_git_clean and not status then
     return true
   end
 
@@ -49,8 +86,8 @@ end
 ---@param path string Absolute path
 ---@param bufinfo table vim.fn.getbufinfo { buflisted = 1 }
 ---@return boolean
-local function buf(path, bufinfo)
+local function buf(self, path, bufinfo)
-  if not M.config.filter_no_buffer or type(bufinfo) ~= "table" then
+  if not self.config.filter_no_buffer or type(bufinfo) ~= "table" then
     return false
   end
 
@@ -66,33 +103,63 @@ end
 
 ---@param path string
 ---@return boolean
-local function dotfile(path)
+local function dotfile(self, path)
-  return M.config.filter_dotfiles and utils.path_basename(path):sub(1, 1) == "."
+  return self.config.filter_dotfiles and utils.path_basename(path):sub(1, 1) == "."
 end
 
 ---@param path string
----@param bookmarks table<string, boolean> absolute paths bookmarked
+---@param path_type string|nil filetype of path
-local function bookmark(path, bookmarks)
+---@param bookmarks table<string, string|nil> path, filetype table of bookmarked files
-  return M.config.filter_no_bookmark and not bookmarks[path]
+local function bookmark(self, path, path_type, bookmarks)
+  if not self.config.filter_no_bookmark then
+    return false
+  end
+  -- if bookmark is empty, we should see a empty filetree
+  if next(bookmarks) == nil then
+    return true
+  end
+
+  local mark_parent = utils.path_add_trailing(path)
+  for mark, mark_type in pairs(bookmarks) do
+    if path == mark then
+      return false
+    end
+
+    if path_type == "directory" then
+      -- check if path is mark's parent
+      if vim.fn.stridx(mark, mark_parent) == 0 then
+        return false
+      end
+    end
+    if mark_type == "directory" then
+      -- check if mark is path's parent
+      local path_parent = utils.path_add_trailing(mark)
+      if vim.fn.stridx(path, path_parent) == 0 then
+        return false
+      end
+    end
+  end
+
+  return true
 end
 
 ---@param path string
 ---@return boolean
-local function custom(path)
+local function custom(self, path)
-  if not M.config.filter_custom then
+  if not self.config.filter_custom then
     return false
   end
 
   local basename = utils.path_basename(path)
 
   -- filter user's custom function
-  if M.custom_function and M.custom_function(path) then
+  if self.custom_function and self.custom_function(path) then
     return true
   end
 
   -- filter custom regexes
   local relpath = utils.path_relative(path, vim.loop.cwd())
-  for pat, _ in pairs(M.ignore_list) do
+  for pat, _ in pairs(self.ignore_list) do
     if vim.fn.match(relpath, pat) ~= -1 or vim.fn.match(basename, pat) ~= -1 then
       return true
     end
@@ -100,7 +167,7 @@ local function custom(path)
 
   local idx = path:match ".+()%.[^.]+$"
   if idx then
-    if M.ignore_list["*" .. string.sub(path, idx)] == true then
+    if self.ignore_list["*" .. string.sub(path, idx)] == true then
       return true
     end
   end
@@ -114,19 +181,22 @@ end
 --- git_status: reference
 --- bufinfo: empty unless no_buffer set: vim.fn.getbufinfo { buflisted = 1 }
 --- bookmarks: absolute paths to boolean
-function M.prepare(git_status)
+function Filters:prepare(git_status)
   local status = {
     git_status = git_status or {},
     bufinfo = {},
     bookmarks = {},
   }
 
-  if M.config.filter_no_buffer then
+  if self.config.filter_no_buffer then
     status.bufinfo = vim.fn.getbufinfo { buflisted = 1 }
   end
 
-  for _, node in pairs(marks.get_marks()) do
+  local explorer = require("nvim-tree.core").get_explorer()
-    status.bookmarks[node.absolute_path] = true
+  if explorer then
+    for _, node in pairs(explorer.marks:get_marks()) do
+      status.bookmarks[node.absolute_path] = node.type
+    end
   end
 
   return status
@@ -134,40 +204,53 @@ end
 
 ---Check if the given path should be filtered.
 ---@param path string Absolute path
+---@param fs_stat uv.fs_stat.result|nil fs_stat of file
 ---@param status table from prepare
 ---@return boolean
-function M.should_filter(path, status)
+function Filters:should_filter(path, fs_stat, status)
-  -- exclusions override all filters
+  if not self.config.enable then
-  if is_excluded(path) then
     return false
   end
 
-  return git(path, status.git_status) or buf(path, status.bufinfo) or dotfile(path) or custom(path) or bookmark(path, status.bookmarks)
+  -- exclusions override all filters
+  if is_excluded(self, path) then
+    return false
+  end
+
+  return git(self, path, status.git_status)
+    or buf(self, path, status.bufinfo)
+    or dotfile(self, path)
+    or custom(self, path)
+    or bookmark(self, path, fs_stat and fs_stat.type, status.bookmarks)
 end
 
-function M.setup(opts)
+--- Check if the given path should be filtered, and provide the reason why it was
-  M.config = {
+---@param path string Absolute path
-    filter_custom = true,
+---@param fs_stat uv.fs_stat.result|nil fs_stat of file
-    filter_dotfiles = opts.filters.dotfiles,
+---@param status table from prepare
-    filter_git_ignored = opts.filters.git_ignored,
+---@return FILTER_REASON
-    filter_git_clean = opts.filters.git_clean,
+function Filters:should_filter_as_reason(path, fs_stat, status)
-    filter_no_buffer = opts.filters.no_buffer,
+  if not self.config.enable then
-    filter_no_bookmark = opts.filters.no_bookmark,
+    return FILTER_REASON.none
-  }
+  end
 
-  M.ignore_list = {}
+  if is_excluded(self, path) then
-  M.exclude_list = opts.filters.exclude
+    return FILTER_REASON.none
+  end
 
-  local custom_filter = opts.filters.custom
+  if git(self, path, status.git_status) then
-  if type(custom_filter) == "function" then
+    return FILTER_REASON.git
-    M.custom_function = custom_filter
+  elseif buf(self, path, status.bufinfo) then
+    return FILTER_REASON.buf
+  elseif dotfile(self, path) then
+    return FILTER_REASON.dotfile
+  elseif custom(self, path) then
+    return FILTER_REASON.custom
+  elseif bookmark(self, path, fs_stat and fs_stat.type, status.bookmarks) then
+    return FILTER_REASON.bookmark
   else
-    if custom_filter and #custom_filter > 0 then
+    return FILTER_REASON.none
-      for _, filter_name in pairs(custom_filter) do
-        M.ignore_list[filter_name] = true
-      end
-    end
   end
 end
 
-return M
+return Filters

lua/nvim-tree/explorer/init.lua

@@ -1,6 +1,11 @@
 local git = require "nvim-tree.git"
+local notify = require "nvim-tree.notify"
 local watch = require "nvim-tree.explorer.watch"
 local explorer_node = require "nvim-tree.explorer.node"
+local Filters = require "nvim-tree.explorer.filters"
+local Marks = require "nvim-tree.marks"
+local LiveFilter = require "nvim-tree.explorer.live-filter"
+local Sorters = require "nvim-tree.explorer.sorters"
 
 local M = {}
 
@@ -11,22 +16,40 @@ M.reload = require("nvim-tree.explorer.reload").reload
 ---@field absolute_path string
 ---@field nodes Node[]
 ---@field open boolean
+---@field filters Filters
+---@field live_filter LiveFilter
+---@field sorters Sorter
+---@field marks Marks
 
 local Explorer = {}
 Explorer.__index = Explorer
 
----@param cwd string|nil
+---@param path string|nil
----@return Explorer
+---@return Explorer|nil
-function Explorer.new(cwd)
+function Explorer.new(path)
-  cwd = vim.loop.fs_realpath(cwd or vim.loop.cwd())
+  local err
+
+  if path then
+    path, err = vim.loop.fs_realpath(path)
+  else
+    path, err = vim.loop.cwd()
+  end
+  if not path then
+    notify.error(err)
+    return
+  end
 
   ---@class Explorer
   local explorer = setmetatable({
-    absolute_path = cwd,
+    absolute_path = path,
     nodes = {},
     open = true,
+    marks = Marks:new(),
+    sorters = Sorters:new(M.config),
   }, Explorer)
   explorer.watcher = watch.create_watcher(explorer)
+  explorer.filters = Filters:new(M.config, explorer)
+  explorer.live_filter = LiveFilter:new(M.config, explorer)
   explorer:_load(explorer)
   return explorer
 end
@@ -36,7 +59,7 @@ end
 function Explorer:_load(node)
   local cwd = node.link_to or node.absolute_path
   local git_status = git.load_project_status(cwd)
-  M.explore(node, git_status)
+  M.explore(node, git_status, self)
 end
 
 ---@param node Node
@@ -57,10 +80,9 @@ function Explorer:destroy()
 end
 
 function M.setup(opts)
+  M.config = opts
   require("nvim-tree.explorer.node").setup(opts)
   require("nvim-tree.explorer.explore").setup(opts)
-  require("nvim-tree.explorer.filters").setup(opts)
-  require("nvim-tree.explorer.sorters").setup(opts)
   require("nvim-tree.explorer.reload").setup(opts)
   require("nvim-tree.explorer.watch").setup(opts)
 end

lua/nvim-tree/explorer/live-filter.lua

@@ -2,34 +2,58 @@ local view = require "nvim-tree.view"
 local utils = require "nvim-tree.utils"
 local Iterator = require "nvim-tree.iterators.node-iterator"
 
-local M = {
+---@class LiveFilter
+---@field explorer Explorer
+---@field prefix string
+---@field always_show_folders boolean
+---@field filter string
+local LiveFilter = {}
+
+---@param opts table
+---@param explorer Explorer
+function LiveFilter:new(opts, explorer)
+  local o = {
+    explorer = explorer,
+    prefix = opts.live_filter.prefix,
+    always_show_folders = opts.live_filter.always_show_folders,
     filter = nil,
-}
+  }
+  setmetatable(o, self)
+  self.__index = self
+  return o
+end
 
 local function redraw()
   require("nvim-tree.renderer").draw()
 end
 
 ---@param node_ Node|nil
-local function reset_filter(node_)
+local function reset_filter(self, node_)
-  node_ = node_ or require("nvim-tree.core").get_explorer()
+  node_ = node_ or self.explorer
 
   if node_ == nil then
     return
   end
 
+  node_.hidden_stats = vim.tbl_deep_extend("force", node_.hidden_stats or {}, {
+    live_filter = 0,
+  })
+
   Iterator.builder(node_.nodes)
     :hidden()
     :applier(function(node)
       node.hidden = false
+      node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
+        live_filter = 0,
+      })
     end)
     :iterate()
 end
 
-local overlay_bufnr = nil
+local overlay_bufnr = 0
-local overlay_winnr = nil
+local overlay_winnr = 0
 
-local function remove_overlay()
+local function remove_overlay(self)
   if view.View.float.enable and view.View.float.quit_on_focus_loss then
     -- return to normal nvim-tree float behaviour when filter window is closed
     vim.api.nvim_create_autocmd("WinLeave", {
@@ -45,26 +69,30 @@ local function remove_overlay()
 
   vim.api.nvim_win_close(overlay_winnr, true)
   vim.api.nvim_buf_delete(overlay_bufnr, { force = true })
-  overlay_bufnr = nil
+  overlay_bufnr = 0
-  overlay_winnr = nil
+  overlay_winnr = 0
 
-  if M.filter == "" then
+  if self.filter == "" then
-    M.clear_filter()
+    self:clear_filter()
   end
 end
 
 ---@param node Node
 ---@return boolean
-local function matches(node)
+local function matches(self, node)
+  if not self.explorer.filters.config.enable then
+    return true
+  end
+
   local path = node.absolute_path
   local name = vim.fn.fnamemodify(path, ":t")
-  return vim.regex(M.filter):match_str(name) ~= nil
+  return vim.regex(self.filter):match_str(name) ~= nil
 end
 
 ---@param node_ Node|nil
-function M.apply_filter(node_)
+function LiveFilter:apply_filter(node_)
-  if not M.filter or M.filter == "" then
+  if not self.filter or self.filter == "" then
-    reset_filter(node_)
+    reset_filter(self, node_)
     return
   end
 
@@ -74,6 +102,10 @@ function M.apply_filter(node_)
     local filtered_nodes = 0
     local nodes = node.group_next and { node.group_next } or node.nodes
 
+    node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
+      live_filter = 0,
+    })
+
     if nodes then
       for _, n in pairs(nodes) do
         iterate(n)
@@ -83,31 +115,37 @@ function M.apply_filter(node_)
       end
     end
 
-    local has_nodes = nodes and (M.always_show_folders or #nodes > filtered_nodes)
+    node.hidden_stats.live_filter = filtered_nodes
-    local ok, is_match = pcall(matches, node)
+
+    local has_nodes = nodes and (self.always_show_folders or #nodes > filtered_nodes)
+    local ok, is_match = pcall(matches, self, node)
     node.hidden = not (has_nodes or (ok and is_match))
   end
 
-  iterate(node_ or require("nvim-tree.core").get_explorer())
+  iterate(node_ or self.explorer)
 end
 
-local function record_char()
+local function record_char(self)
   vim.schedule(function()
-    M.filter = vim.api.nvim_buf_get_lines(overlay_bufnr, 0, -1, false)[1]
+    self.filter = vim.api.nvim_buf_get_lines(overlay_bufnr, 0, -1, false)[1]
-    M.apply_filter()
+    self:apply_filter()
     redraw()
   end)
 end
 
-local function configure_buffer_overlay()
+local function configure_buffer_overlay(self)
   overlay_bufnr = vim.api.nvim_create_buf(false, true)
 
   vim.api.nvim_buf_attach(overlay_bufnr, true, {
-    on_lines = record_char,
+    on_lines = function()
+      return record_char(self)
+    end,
   })
 
   vim.api.nvim_create_autocmd("InsertLeave", {
-    callback = remove_overlay,
+    callback = function()
+      return remove_overlay(self)
+    end,
     once = true,
   })
 
@@ -115,17 +153,17 @@ local function configure_buffer_overlay()
 end
 
 ---@return integer
-local function calculate_overlay_win_width()
+local function calculate_overlay_win_width(self)
   local wininfo = vim.fn.getwininfo(view.get_winnr())[1]
 
   if wininfo then
-    return wininfo.width - wininfo.textoff - #M.prefix
+    return wininfo.width - wininfo.textoff - #self.prefix
   end
 
   return 20
 end
 
-local function create_overlay()
+local function create_overlay(self)
   if view.View.float.enable then
     -- don't close nvim-tree float when focus is changed to filter window
     vim.api.nvim_clear_autocmds {
@@ -135,40 +173,48 @@ local function create_overlay()
     }
   end
 
-  configure_buffer_overlay()
+  configure_buffer_overlay(self)
   overlay_winnr = vim.api.nvim_open_win(overlay_bufnr, true, {
     col = 1,
     row = 0,
     relative = "cursor",
-    width = calculate_overlay_win_width(),
+    width = calculate_overlay_win_width(self),
     height = 1,
     border = "none",
     style = "minimal",
   })
-  vim.api.nvim_buf_set_option(overlay_bufnr, "modifiable", true)
+
-  vim.api.nvim_buf_set_lines(overlay_bufnr, 0, -1, false, { M.filter })
+  if vim.fn.has "nvim-0.10" == 1 then
+    vim.api.nvim_set_option_value("modifiable", true, { buf = overlay_bufnr })
+  else
+    vim.api.nvim_buf_set_option(overlay_bufnr, "modifiable", true) ---@diagnostic disable-line: deprecated
+  end
+
+  vim.api.nvim_buf_set_lines(overlay_bufnr, 0, -1, false, { self.filter })
   vim.cmd "startinsert"
-  vim.api.nvim_win_set_cursor(overlay_winnr, { 1, #M.filter + 1 })
+  vim.api.nvim_win_set_cursor(overlay_winnr, { 1, #self.filter + 1 })
 end
 
-function M.start_filtering()
+function LiveFilter:start_filtering()
   view.View.live_filter.prev_focused_node = require("nvim-tree.lib").get_node_at_cursor()
-  M.filter = M.filter or ""
+  self.filter = self.filter or ""
 
   redraw()
   local row = require("nvim-tree.core").get_nodes_starting_line() - 1
-  local col = #M.prefix > 0 and #M.prefix - 1 or 1
+  local col = #self.prefix > 0 and #self.prefix - 1 or 1
   view.set_cursor { row, col }
   -- needs scheduling to let the cursor move before initializing the window
-  vim.schedule(create_overlay)
+  vim.schedule(function()
+    return create_overlay(self)
+  end)
 end
 
-function M.clear_filter()
+function LiveFilter:clear_filter()
   local node = require("nvim-tree.lib").get_node_at_cursor()
   local last_node = view.View.live_filter.prev_focused_node
 
-  M.filter = nil
+  self.filter = nil
-  reset_filter()
+  reset_filter(self)
   redraw()
 
   if node then
@@ -178,9 +224,4 @@ function M.clear_filter()
   end
 end
 
-function M.setup(opts)
+return LiveFilter
-  M.prefix = opts.live_filter.prefix
-  M.always_show_folders = opts.live_filter.always_show_folders
-end
-
-return M

lua/nvim-tree/explorer/node-builders.lua

@@ -6,15 +6,16 @@ local M = {}
 ---@param parent Node
 ---@param absolute_path string
 ---@param name string
+---@param fs_stat uv.fs_stat.result|nil
 ---@return Node
-function M.folder(parent, absolute_path, name)
+function M.folder(parent, absolute_path, name, fs_stat)
   local handle = vim.loop.fs_scandir(absolute_path)
   local has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
 
   local node = {
     type = "directory",
     absolute_path = absolute_path,
-    fs_stat = vim.loop.fs_stat(absolute_path),
+    fs_stat = fs_stat,
     group_next = nil, -- If node is grouped, this points to the next child dir/link node
     has_children = has_children,
     name = name,
@@ -43,8 +44,9 @@ end
 ---@param parent Node
 ---@param absolute_path string
 ---@param name string
+---@param fs_stat uv.fs_stat.result|nil
 ---@return Node
-function M.file(parent, absolute_path, name)
+function M.file(parent, absolute_path, name, fs_stat)
   local ext = string.match(name, ".?[^.]+%.(.*)") or ""
 
   return {
@@ -52,7 +54,7 @@ function M.file(parent, absolute_path, name)
     absolute_path = absolute_path,
     executable = M.is_executable(absolute_path),
     extension = ext,
-    fs_stat = vim.loop.fs_stat(absolute_path),
+    fs_stat = fs_stat,
     name = name,
     parent = parent,
   }
@@ -66,15 +68,16 @@ end
 ---@param parent Node
 ---@param absolute_path string
 ---@param name string
+---@param fs_stat uv.fs_stat.result|nil
 ---@return Node
-function M.link(parent, absolute_path, name)
+function M.link(parent, absolute_path, name, fs_stat)
   --- I dont know if this is needed, because in my understanding, there isn't hard links in windows, but just to be sure i changed it.
   local link_to = vim.loop.fs_realpath(absolute_path)
   local open, nodes, has_children
 
   local is_dir_link = (link_to ~= nil) and vim.loop.fs_stat(link_to).type == "directory"
 
-  if is_dir_link then
+  if is_dir_link and link_to then
     local handle = vim.loop.fs_scandir(link_to)
     has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
     open = false
@@ -84,7 +87,7 @@ function M.link(parent, absolute_path, name)
   local node = {
     type = "link",
     absolute_path = absolute_path,
-    fs_stat = vim.loop.fs_stat(absolute_path),
+    fs_stat = fs_stat,
     group_next = nil, -- If node is grouped, this points to the next child dir/link node
     has_children = has_children,
     link_to = link_to,

lua/nvim-tree/explorer/node.lua

@@ -29,7 +29,7 @@ end
 ---@param absolute_path string
 ---@return GitStatus
 local function get_git_status(parent_ignored, status, absolute_path)
-  local file_status = parent_ignored and "!!" or status.files and status.files[absolute_path]
+  local file_status = parent_ignored and "!!" or (status and status.files and status.files[absolute_path])
   return { file = file_status }
 end
 
@@ -128,6 +128,19 @@ function M.is_git_ignored(node)
   return node and node.git_status ~= nil and node.git_status.file == "!!"
 end
 
+---@param node Node
+---@return boolean
+function M.is_dotfile(node)
+  if node == nil then
+    return false
+  end
+  if node.is_dot or (node.name and (node.name:sub(1, 1) == ".")) or M.is_dotfile(node.parent) then
+    node.is_dot = true
+    return true
+  end
+  return false
+end
+
 ---@param node Node
 function M.node_destroy(node)
   if not node then

lua/nvim-tree/explorer/reload.lua

@@ -1,12 +1,10 @@
 local utils = require "nvim-tree.utils"
 local builders = require "nvim-tree.explorer.node-builders"
 local explorer_node = require "nvim-tree.explorer.node"
-local filters = require "nvim-tree.explorer.filters"
-local sorters = require "nvim-tree.explorer.sorters"
-local live_filter = require "nvim-tree.live-filter"
 local git = require "nvim-tree.git"
 local log = require "nvim-tree.log"
 
+local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
 local NodeIterator = require "nvim-tree.iterators.node-iterator"
 local Watcher = require "nvim-tree.watcher"
 
@@ -70,6 +68,10 @@ end
 ---@param node Node
 ---@param git_status table
 function M.reload(node, git_status)
+  local explorer = require("nvim-tree.core").get_explorer()
+  if not explorer then
+    return
+  end
   local cwd = node.link_to or node.absolute_path
   local handle = vim.loop.fs_scandir(cwd)
   if not handle then
@@ -78,37 +80,41 @@ function M.reload(node, git_status)
 
   local profile = log.profile_start("reload %s", node.absolute_path)
 
-  local filter_status = filters.prepare(git_status)
+  local filter_status = explorer.filters:prepare(git_status)
 
   if node.group_next then
     node.nodes = { node.group_next }
     node.group_next = nil
   end
 
-  local child_names = {}
+  local remain_childs = {}
 
   local node_ignored = explorer_node.is_git_ignored(node)
+  ---@type table<string, Node>
   local nodes_by_path = utils.key_by(node.nodes, "absolute_path")
+
+  -- To reset we must 'zero' everything that we use
+  node.hidden_stats = vim.tbl_deep_extend("force", node.hidden_stats or {}, {
+    git = 0,
+    buf = 0,
+    dotfile = 0,
+    custom = 0,
+    bookmark = 0,
+  })
+
   while true do
-    local name, t = vim.loop.fs_scandir_next(handle, cwd)
+    local name, t = vim.loop.fs_scandir_next(handle)
     if not name then
       break
     end
 
-    local stat
-    local function fs_stat_cached(path)
-      if stat ~= nil then
-        return stat
-      end
-
-      stat = vim.loop.fs_stat(path)
-      return stat
-    end
-
     local abs = utils.path_join { cwd, name }
-    t = t or (fs_stat_cached(abs) or {}).type
+    ---@type uv.fs_stat.result|nil
-    if not filters.should_filter(abs, filter_status) then
+    local stat = vim.loop.fs_stat(abs)
-      child_names[abs] = true
+
+    local filter_reason = explorer.filters:should_filter_as_reason(abs, stat, filter_status)
+    if filter_reason == FILTER_REASON.none then
+      remain_childs[abs] = true
 
       -- Recreate node if type changes.
       if nodes_by_path[abs] then
@@ -122,26 +128,32 @@ function M.reload(node, git_status)
       end
 
       if not nodes_by_path[abs] then
+        local new_child = nil
         if t == "directory" and vim.loop.fs_access(abs, "R") and Watcher.is_fs_event_capable(abs) then
-          local folder = builders.folder(node, abs, name)
+          new_child = builders.folder(node, abs, name, stat)
-          nodes_by_path[abs] = folder
-          table.insert(node.nodes, folder)
         elseif t == "file" then
-          local file = builders.file(node, abs, name)
+          new_child = builders.file(node, abs, name, stat)
-          nodes_by_path[abs] = file
-          table.insert(node.nodes, file)
         elseif t == "link" then
-          local link = builders.link(node, abs, name)
+          local link = builders.link(node, abs, name, stat)
           if link.link_to ~= nil then
-            nodes_by_path[abs] = link
+            new_child = link
-            table.insert(node.nodes, link)
           end
         end
+        if new_child then
+          table.insert(node.nodes, new_child)
+          nodes_by_path[abs] = new_child
+        end
       else
         local n = nodes_by_path[abs]
         if n then
-          n.executable = builders.is_executable(abs)
+          n.executable = builders.is_executable(abs) or false
-          n.fs_stat = fs_stat_cached(abs)
+          n.fs_stat = stat
+        end
+      end
+    else
+      for reason, value in pairs(FILTER_REASON) do
+        if filter_reason == value then
+          node.hidden_stats[reason] = node.hidden_stats[reason] + 1
         end
       end
     end
@@ -150,8 +162,8 @@ function M.reload(node, git_status)
   node.nodes = vim.tbl_map(
     update_status(nodes_by_path, node_ignored, git_status),
     vim.tbl_filter(function(n)
-      if child_names[n.absolute_path] then
+      if remain_childs[n.absolute_path] then
-        return child_names[n.absolute_path]
+        return remain_childs[n.absolute_path]
       else
         explorer_node.node_destroy(n)
         return false
@@ -169,8 +181,8 @@ function M.reload(node, git_status)
     return ns
   end
 
-  sorters.sort(node.nodes)
+  explorer.sorters:sort(node.nodes)
-  live_filter.apply_filter(node)
+  explorer.live_filter:apply_filter(node)
   log.profile_end(profile)
   return node.nodes
 end

lua/nvim-tree/explorer/sorters.lua

@@ -1,12 +1,27 @@
-local M = {}
-
 local C = {}
 
+---@class Sorter
+local Sorter = {}
+
+function Sorter:new(opts)
+  local o = {}
+  setmetatable(o, self)
+  self.__index = self
+  o.config = vim.deepcopy(opts.sort)
+
+  if type(o.config.sorter) == "function" then
+    o.user = o.config.sorter
+  end
+  return o
+end
+
 --- Predefined comparator, defaulting to name
 ---@param sorter string as per options
 ---@return function
-local function get_comparator(sorter)
+function Sorter:get_comparator(sorter)
-  return C[sorter] or C.name
+  return function(a, b)
+    return (C[sorter] or C.name)(a, b, self.config)
+  end
 end
 
 ---Create a shallow copy of a portion of a list.
@@ -27,17 +42,17 @@ end
 ---@param a Node
 ---@param b Node
 ---@return boolean|nil
-local function folders_or_files_first(a, b)
+local function folders_or_files_first(a, b, cfg)
-  if not (M.config.sort.folders_first or M.config.sort.files_first) then
+  if not (cfg.folders_first or cfg.files_first) then
     return
   end
 
   if not a.nodes and b.nodes then
     -- file <> folder
-    return M.config.sort.files_first
+    return cfg.files_first
   elseif a.nodes and not b.nodes then
     -- folder <> file
-    return not M.config.sort.files_first
+    return not cfg.files_first
   end
 end
 
@@ -97,8 +112,8 @@ end
 
 ---Perform a merge sort using sorter option.
 ---@param t table nodes
-function M.sort(t)
+function Sorter:sort(t)
-  if C.user then
+  if self.user then
     local t_user = {}
     local origin_index = {}
 
@@ -115,9 +130,9 @@ function M.sort(t)
       table.insert(origin_index, n)
     end
 
-    local predefined = C.user(t_user)
+    local predefined = self.user(t_user)
     if predefined then
-      split_merge(t, 1, #t, get_comparator(predefined))
+      split_merge(t, 1, #t, self:get_comparator(predefined))
       return
     end
 
@@ -142,7 +157,7 @@ function M.sort(t)
 
     split_merge(t, 1, #t, mini_comparator) -- sort by user order
   else
-    split_merge(t, 1, #t, get_comparator(M.config.sort.sorter))
+    split_merge(t, 1, #t, self:get_comparator(self.config.sorter))
   end
 end
 
@@ -150,12 +165,12 @@ end
 ---@param b Node
 ---@param ignorecase boolean|nil
 ---@return boolean
-local function node_comparator_name_ignorecase_or_not(a, b, ignorecase)
+local function node_comparator_name_ignorecase_or_not(a, b, ignorecase, cfg)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b)
+  local early_return = folders_or_files_first(a, b, cfg)
   if early_return ~= nil then
     return early_return
   end
@@ -167,20 +182,20 @@ local function node_comparator_name_ignorecase_or_not(a, b, ignorecase)
   end
 end
 
-function C.case_sensitive(a, b)
+function C.case_sensitive(a, b, cfg)
-  return node_comparator_name_ignorecase_or_not(a, b, false)
+  return node_comparator_name_ignorecase_or_not(a, b, false, cfg)
 end
 
-function C.name(a, b)
+function C.name(a, b, cfg)
-  return node_comparator_name_ignorecase_or_not(a, b, true)
+  return node_comparator_name_ignorecase_or_not(a, b, true, cfg)
 end
 
-function C.modification_time(a, b)
+function C.modification_time(a, b, cfg)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b)
+  local early_return = folders_or_files_first(a, b, cfg)
   if early_return ~= nil then
     return early_return
   end
@@ -199,17 +214,17 @@ function C.modification_time(a, b)
   return last_modified_b <= last_modified_a
 end
 
-function C.suffix(a, b)
+function C.suffix(a, b, cfg)
   if not (a and b) then
     return true
   end
 
   -- directories go first
-  local early_return = folders_or_files_first(a, b)
+  local early_return = folders_or_files_first(a, b, cfg)
   if early_return ~= nil then
     return early_return
   elseif a.nodes and b.nodes then
-    return C.name(a, b)
+    return C.name(a, b, cfg)
   end
 
   -- dotfiles go second
@@ -218,7 +233,7 @@ function C.suffix(a, b)
   elseif a.name:sub(1, 1) ~= "." and b.name:sub(1, 1) == "." then
     return false
   elseif a.name:sub(1, 1) == "." and b.name:sub(1, 1) == "." then
-    return C.name(a, b)
+    return C.name(a, b, cfg)
   end
 
   -- unsuffixed go third
@@ -230,7 +245,7 @@ function C.suffix(a, b)
   elseif a_suffix_ndx and not b_suffix_ndx then
     return false
   elseif not (a_suffix_ndx and b_suffix_ndx) then
-    return C.name(a, b)
+    return C.name(a, b, cfg)
   end
 
   -- finally, compare by suffixes
@@ -242,18 +257,18 @@ function C.suffix(a, b)
   elseif not a_suffix and b_suffix then
     return false
   elseif a_suffix:lower() == b_suffix:lower() then
-    return C.name(a, b)
+    return C.name(a, b, cfg)
   end
 
   return a_suffix:lower() < b_suffix:lower()
 end
 
-function C.extension(a, b)
+function C.extension(a, b, cfg)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b)
+  local early_return = folders_or_files_first(a, b, cfg)
   if early_return ~= nil then
     return early_return
   end
@@ -267,18 +282,18 @@ function C.extension(a, b)
   local a_ext = (a.extension or ""):lower()
   local b_ext = (b.extension or ""):lower()
   if a_ext == b_ext then
-    return C.name(a, b)
+    return C.name(a, b, cfg)
   end
 
   return a_ext < b_ext
 end
 
-function C.filetype(a, b)
+function C.filetype(a, b, cfg)
   local a_ft = vim.filetype.match { filename = a.name }
   local b_ft = vim.filetype.match { filename = b.name }
 
   -- directories first
-  local early_return = folders_or_files_first(a, b)
+  local early_return = folders_or_files_first(a, b, cfg)
   if early_return ~= nil then
     return early_return
   end
@@ -292,19 +307,10 @@ function C.filetype(a, b)
 
   -- same filetype or both nil, sort by name
   if a_ft == b_ft then
-    return C.name(a, b)
+    return C.name(a, b, cfg)
   end
 
   return a_ft < b_ft
 end
 
-function M.setup(opts)
+return Sorter
-  M.config = {}
-  M.config.sort = opts.sort
-
-  if type(M.config.sort.sorter) == "function" then
-    C.user = M.config.sort.sorter
-  end
-end
-
-return M

lua/nvim-tree/explorer/watch.lua

@@ -40,11 +40,15 @@ local function is_folder_ignored(path)
     end
   end
 
+  if type(M.config.filesystem_watchers.ignore_dirs) == "table" then
     for _, ignore_dir in ipairs(M.config.filesystem_watchers.ignore_dirs) do
       if vim.fn.match(path, ignore_dir) ~= -1 then
         return true
       end
     end
+  elseif type(M.config.filesystem_watchers.ignore_dirs) == "function" then
+    return M.config.filesystem_watchers.ignore_dirs(path)
+  end
 
   return false
 end

lua/nvim-tree/git/init.lua

@@ -136,6 +136,10 @@ end
 ---@param path string absolute
 ---@return string|nil
 function M.get_toplevel(path)
+  if not path then
+    return nil
+  end
+
   if not M.config.git.enable then
     return nil
   end
@@ -166,15 +170,21 @@ function M.get_toplevel(path)
   if not toplevel or not git_dir then
     return nil
   end
+  local toplevel_norm = vim.fn.fnamemodify(toplevel, ":p")
 
   -- ignore disabled paths
+  if type(M.config.git.disable_for_dirs) == "table" then
     for _, disabled_for_dir in ipairs(M.config.git.disable_for_dirs) do
-    local toplevel_norm = vim.fn.fnamemodify(toplevel, ":p")
       local disabled_norm = vim.fn.fnamemodify(disabled_for_dir, ":p")
       if toplevel_norm == disabled_norm then
         return nil
       end
     end
+  elseif type(M.config.git.disable_for_dirs) == "function" then
+    if M.config.git.disable_for_dirs(toplevel_norm) then
+      return nil
+    end
+  end
 
   M._toplevels_by_path[path] = toplevel
   M._git_dirs_by_toplevel[toplevel] = git_dir

lua/nvim-tree/help.lua

@@ -173,7 +173,12 @@ local function open()
 
   -- populate it
   vim.api.nvim_buf_set_lines(M.bufnr, 0, -1, false, lines)
-  vim.api.nvim_buf_set_option(M.bufnr, "modifiable", false)
+
+  if vim.fn.has "nvim-0.10" == 1 then
+    vim.api.nvim_set_option_value("modifiable", false, { buf = M.bufnr })
+  else
+    vim.api.nvim_buf_set_option(M.bufnr, "modifiable", false) ---@diagnostic disable-line: deprecated
+  end
 
   -- highlight it
   for _, h in ipairs(hl) do

lua/nvim-tree/keymap.lua

@@ -68,6 +68,7 @@ function M.default_on_attach(bufnr)
   vim.keymap.set('n', 'f',       api.live_filter.start,               opts('Live Filter: Start'))
   vim.keymap.set('n', 'g?',      api.tree.toggle_help,                opts('Help'))
   vim.keymap.set('n', 'gy',      api.fs.copy.absolute_path,           opts('Copy Absolute Path'))
+  vim.keymap.set('n', 'ge',      api.fs.copy.basename,                opts('Copy Basename'))
   vim.keymap.set('n', 'H',       api.tree.toggle_hidden_filter,       opts('Toggle Filter: Dotfiles'))
   vim.keymap.set('n', 'I',       api.tree.toggle_gitignore_filter,    opts('Toggle Filter: Git Ignore'))
   vim.keymap.set('n', 'J',       api.node.navigate.sibling.last,      opts('Last Sibling'))

lua/nvim-tree/legacy.lua

@@ -3,6 +3,7 @@ local notify = require "nvim-tree.notify"
 
 local M = {}
 
+-- silently move, please add to help nvim-tree-legacy-opts
 local function refactored(opts)
   -- 2022/06/20
   utils.move_missing_val(opts, "update_focused_file", "update_cwd", opts, "update_focused_file", "update_root", true)
@@ -51,6 +52,14 @@ local function refactored(opts)
   if type(opts.renderer) == "table" and type(opts.renderer.highlight_git) == "boolean" then
     opts.renderer.highlight_git = opts.renderer.highlight_git and "name" or "none"
   end
+
+  -- 2024/02/15
+  if type(opts.update_focused_file) == "table" then
+    if type(opts.update_focused_file.update_root) ~= "table" then
+      opts.update_focused_file.update_root = { enable = opts.update_focused_file.update_root }
+    end
+  end
+  utils.move_missing_val(opts, "update_focused_file", "ignore_list", opts, "update_focused_file.update_root", "ignore_list", true)
 end
 
 local function deprecated(opts)
@@ -61,12 +70,12 @@ end
 
 local function removed(opts)
   if opts.auto_close then
-    notify.warn "auto close feature has been removed, see note in the README (tips & reminder section)"
+    notify.warn "auto close feature has been removed: https://github.com/nvim-tree/nvim-tree.lua/wiki/Auto-Close"
     opts.auto_close = nil
   end
 
   if opts.focus_empty_on_setup then
-    notify.warn "focus_empty_on_setup has been removed and will be replaced by a new startup configuration. Please remove this option. See https://bit.ly/3yJch2T"
+    notify.warn "focus_empty_on_setup has been removed: https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup"
     opts.focus_empty_on_setup = nil
   end
 

lua/nvim-tree/lib.lua

@@ -3,6 +3,7 @@ local view = require "nvim-tree.view"
 local core = require "nvim-tree.core"
 local utils = require "nvim-tree.utils"
 local events = require "nvim-tree.events"
+local notify = require "nvim-tree.notify"
 local explorer_node = require "nvim-tree.explorer.node"
 
 ---@class LibOpenOpts
@@ -57,6 +58,7 @@ local function clone_node(node)
     name = node.name,
     open = node.open,
     type = node.type,
+    fs_stat = node.fs_stat,
   }
 
   if type(node.nodes) == "table" then
@@ -83,8 +85,7 @@ function M.get_last_group_node(node)
     node = node.group_next
   end
 
-  ---@diagnostic disable-next-line: return-type-mismatch -- it can't be nil
+  return node ---@diagnostic disable-line: return-type-mismatch -- it can't be nil
-  return node
 end
 
 ---Group empty folders
@@ -197,8 +198,15 @@ end
 local function should_hijack_current_buf()
   local bufnr = vim.api.nvim_get_current_buf()
   local bufname = vim.api.nvim_buf_get_name(bufnr)
-  local bufmodified = vim.api.nvim_buf_get_option(bufnr, "modified")
+
-  local ft = vim.api.nvim_buf_get_option(bufnr, "ft")
+  local bufmodified, ft
+  if vim.fn.has "nvim-0.10" == 1 then
+    bufmodified = vim.api.nvim_get_option_value("modified", { buf = bufnr })
+    ft = vim.api.nvim_get_option_value("ft", { buf = bufnr })
+  else
+    bufmodified = vim.api.nvim_buf_get_option(bufnr, "modified") ---@diagnostic disable-line: deprecated
+    ft = vim.api.nvim_buf_get_option(bufnr, "ft") ---@diagnostic disable-line: deprecated
+  end
 
   local should_hijack_unnamed = M.hijack_unnamed_buffer_when_opening and bufname == "" and not bufmodified and ft == ""
   local should_hijack_dir = bufname ~= "" and vim.fn.isdirectory(bufname) == 1 and M.hijack_directories.enable
@@ -242,7 +250,16 @@ function M.open(opts)
 
   M.set_target_win()
   if not core.get_explorer() or opts.path then
-    core.init(opts.path or vim.loop.cwd())
+    if opts.path then
+      core.init(opts.path)
+    else
+      local cwd, err = vim.loop.cwd()
+      if not cwd then
+        notify.error(string.format("current working directory unavailable: %s", err))
+        return
+      end
+      core.init(cwd)
+    end
   end
   if should_hijack_current_buf() then
     view.close_this_tab_only()

lua/nvim-tree/marks/bulk-delete.lua

@@ -1,4 +1,3 @@
-local marks = require "nvim-tree.marks"
 local utils = require "nvim-tree.utils"
 local remove_file = require "nvim-tree.actions.fs.remove-file"
 local notify = require "nvim-tree.notify"
@@ -10,12 +9,13 @@ local M = {
 
 --- Delete nodes; each removal will be optionally notified
 ---@param nodes Node[]
-local function do_delete(nodes)
+---@param marks Marks
+local function do_delete(marks, nodes)
   for _, node in pairs(nodes) do
     remove_file.remove(node)
   end
 
-  marks.clear_marks()
+  marks:clear_marks()
 
   if not M.config.filesystem_watchers.enable then
     require("nvim-tree.actions.reloaders").reload_explorer()
@@ -23,8 +23,15 @@ local function do_delete(nodes)
 end
 
 --- Delete marked nodes, optionally prompting
-function M.bulk_delete()
+---@param explorer Explorer
-  local nodes = marks.get_marks()
+function M.bulk_delete(explorer)
+  if not explorer then
+    return
+  end
+
+  local marks = explorer.marks
+
+  local nodes = marks:get_marks()
   if not nodes or #nodes == 0 then
     notify.warn "No bookmarksed to delete."
     return
@@ -36,11 +43,11 @@ function M.bulk_delete()
     lib.prompt(prompt_input, prompt_select, { "", "y" }, { "No", "Yes" }, "nvimtree_bulk_delete", function(item_short)
       utils.clear_prompt()
       if item_short == "y" then
-        do_delete(nodes)
+        do_delete(marks, nodes)
       end
     end)
   else
-    do_delete(nodes)
+    do_delete(marks, nodes)
   end
 end
 

lua/nvim-tree/marks/bulk-move.lua

@@ -1,22 +1,37 @@
-local marks = require "nvim-tree.marks"
 local core = require "nvim-tree.core"
 local utils = require "nvim-tree.utils"
 local rename_file = require "nvim-tree.actions.fs.rename-file"
 local notify = require "nvim-tree.notify"
+local lib = require "nvim-tree.lib"
 
 local M = {
   config = {},
 }
 
-function M.bulk_move()
+---@param explorer Explorer
-  if #marks.get_marks() == 0 then
+function M.bulk_move(explorer)
+  if not explorer then
+    return
+  end
+  local marks = explorer.marks
+
+  if #marks:get_marks() == 0 then
     notify.warn "No bookmarks to move."
     return
   end
 
+  local node_at_cursor = lib.get_node_at_cursor()
+  local default_path = core.get_cwd()
+
+  if node_at_cursor and node_at_cursor.type == "directory" then
+    default_path = node_at_cursor.absolute_path
+  elseif node_at_cursor and node_at_cursor.parent then
+    default_path = node_at_cursor.parent.absolute_path
+  end
+
   local input_opts = {
     prompt = "Move to: ",
-    default = core.get_cwd(),
+    default = default_path,
     completion = "dir",
   }
 
@@ -30,14 +45,14 @@ function M.bulk_move()
       return
     end
 
-    local nodes = marks.get_marks()
+    local nodes = marks:get_marks()
     for _, node in pairs(nodes) do
       local head = vim.fn.fnamemodify(node.absolute_path, ":t")
       local to = utils.path_join { location, head }
       rename_file.rename(node, to)
     end
 
-    marks.clear_marks()
+    marks:clear_marks()
 
     if not M.config.filesystem_watchers.enable then
       require("nvim-tree.actions.reloaders").reload_explorer()

lua/nvim-tree/marks/bulk-trash.lua

@@ -1,4 +1,3 @@
-local marks = require "nvim-tree.marks"
 local utils = require "nvim-tree.utils"
 local remove_file = require "nvim-tree.actions.fs.trash"
 local notify = require "nvim-tree.notify"
@@ -14,12 +13,17 @@ local function do_trash(nodes)
   for _, node in pairs(nodes) do
     remove_file.remove(node)
   end
-
-  marks.clear_marks()
 end
 
-function M.bulk_trash()
+---@param explorer Explorer
-  local nodes = marks.get_marks()
+function M.bulk_trash(explorer)
+  if not explorer then
+    return
+  end
+
+  local marks = explorer.marks
+
+  local nodes = marks:get_marks()
   if not nodes or #nodes == 0 then
     notify.warn "No bookmarks to trash."
     return
@@ -32,10 +36,12 @@ function M.bulk_trash()
       utils.clear_prompt()
       if item_short == "y" then
         do_trash(nodes)
+        marks:clear_marks()
       end
     end)
   else
     do_trash(nodes)
+    marks:clear_marks()
   end
 end
 

lua/nvim-tree/marks/init.lua

@@ -1,63 +1,73 @@
 local renderer = {} -- circular dependency
 
-local NvimTreeMarks = {}
+---@class Marks
+---@field private marks Node[]
+local Marks = {}
 
-local M = {}
+---@return Marks
+function Marks:new()
+  local o = {}
+  setmetatable(o, self)
+  self.__index = self
 
----@class MinimalNode
+  o.marks = {}
----@field absolute_path string
 
----@param node Node|MinimalNode
+  return o
-local function add_mark(node)
+end
-  NvimTreeMarks[node.absolute_path] = node
+
+---@private
+---@param node Node
+function Marks:add_mark(node)
+  self.marks[node.absolute_path] = node
 
   renderer.draw()
 end
 
----@param node Node|MinimalNode
+---@private
-local function remove_mark(node)
+---@param node Node
-  NvimTreeMarks[node.absolute_path] = nil
+function Marks:remove_mark(node)
+  self.marks[node.absolute_path] = nil
 
   renderer.draw()
 end
 
----@param node Node|MinimalNode
+---@param node Node
-function M.toggle_mark(node)
+function Marks:toggle_mark(node)
   if node.absolute_path == nil then
     return
   end
 
-  if M.get_mark(node) then
+  if self:get_mark(node) then
-    remove_mark(node)
+    self:remove_mark(node)
   else
-    add_mark(node)
+    self:add_mark(node)
   end
 
   renderer.draw()
 end
 
-function M.clear_marks()
+function Marks:clear_marks()
-  NvimTreeMarks = {}
+  self.marks = {}
 
   renderer.draw()
 end
 
----@param node Node|MinimalNode
+---@param node Node
----@return table|nil
+---@return Node|nil
-function M.get_mark(node)
+function Marks:get_mark(node)
-  return node and NvimTreeMarks[node.absolute_path]
+  return node and self.marks[node.absolute_path]
 end
 
----@return table
+---@return Node[]
-function M.get_marks()
+function Marks:get_marks()
   local list = {}
-  for _, node in pairs(NvimTreeMarks) do
+  for _, node in pairs(self.marks) do
     table.insert(list, node)
   end
   return list
 end
 
-function M.setup(opts)
+function Marks.setup(opts)
   renderer = require "nvim-tree.renderer"
 
   require("nvim-tree.marks.bulk-delete").setup(opts)
@@ -65,4 +75,4 @@ function M.setup(opts)
   require("nvim-tree.marks.bulk-move").setup(opts)
 end
 
-return M
+return Marks

lua/nvim-tree/marks/navigation.lua

@@ -1,6 +1,5 @@
 local Iterator = require "nvim-tree.iterators.node-iterator"
 local core = require "nvim-tree.core"
-local Marks = require "nvim-tree.marks"
 local open_file = require "nvim-tree.actions.node.open-file"
 local utils = require "nvim-tree.utils"
 local lib = require "nvim-tree.lib"
@@ -9,10 +8,15 @@ local lib = require "nvim-tree.lib"
 ---@param where string
 ---@return Node|nil
 local function get_nearest(node, where)
+  local explorer = core.get_explorer()
+  if not explorer then
+    return
+  end
+
   local first, prev, next, last = nil, nil, nil, nil
   local found = false
 
-  Iterator.builder(core.get_explorer().nodes)
+  Iterator.builder(explorer.nodes)
     :recursor(function(n)
       return n.open and n.nodes
     end)
@@ -22,7 +26,7 @@ local function get_nearest(node, where)
         return
       end
 
-      if not Marks.get_mark(n) then
+      if not explorer.marks:get_mark(n) then
         return
       end
 
@@ -84,9 +88,14 @@ M.next = navigate_to "next"
 M.prev = navigate_to "prev"
 
 function M.select()
+  local explorer = core.get_explorer()
+  if not explorer then
+    return
+  end
+
   local list = vim.tbl_map(function(n)
     return n.absolute_path
-  end, Marks.get_marks())
+  end, explorer.marks:get_marks())
 
   vim.ui.select(list, {
     prompt = "Select a file to open or a folder to focus",
@@ -94,7 +103,7 @@ function M.select()
     if not choice or choice == "" then
       return
     end
-    local node = Marks.get_mark { absolute_path = choice }
+    local node = explorer.marks:get_mark { absolute_path = choice }
     open_or_focus(node)
   end)
 end

lua/nvim-tree/node.lua

@@ -6,9 +6,10 @@
 ---@class BaseNode
 ---@field absolute_path string
 ---@field executable boolean
----@field fs_stat uv.uv_fs_t
+---@field fs_stat uv.fs_stat.result|nil
 ---@field git_status GitStatus|nil
 ---@field hidden boolean
+---@field is_dot boolean
 ---@field name string
 ---@field parent DirNode
 ---@field type string
@@ -20,6 +21,7 @@
 ---@field group_next Node|nil
 ---@field nodes Node[]
 ---@field open boolean
+---@field hidden_stats table -- Each field of this table is a key for source and value for count
 
 ---@class FileNode: BaseNode
 ---@field extension string

lua/nvim-tree/renderer/builder.lua

@@ -1,5 +1,4 @@
 local core = require "nvim-tree.core"
-local live_filter = require "nvim-tree.live-filter"
 local notify = require "nvim-tree.notify"
 local utils = require "nvim-tree.utils"
 local view = require "nvim-tree.view"
@@ -10,6 +9,7 @@ local DecoratorCut = require "nvim-tree.renderer.decorator.cut"
 local DecoratorDiagnostics = require "nvim-tree.renderer.decorator.diagnostics"
 local DecoratorGit = require "nvim-tree.renderer.decorator.git"
 local DecoratorModified = require "nvim-tree.renderer.decorator.modified"
+local DecoratorHidden = require "nvim-tree.renderer.decorator.hidden"
 local DecoratorOpened = require "nvim-tree.renderer.decorator.opened"
 
 local pad = require "nvim-tree.renderer.components.padding"
@@ -42,6 +42,8 @@ local M = {
 ---@field lines string[] includes icons etc.
 ---@field hl_args AddHighlightArgs[] line highlights
 ---@field signs string[] line signs
+---@field extmarks table[] extra marks for right icon placement
+---@field virtual_lines table[] virtual lines for hidden count display
 ---@field private root_cwd string absolute path
 ---@field private index number
 ---@field private depth number
@@ -60,6 +62,8 @@ function Builder:new()
     lines = {},
     markers = {},
     signs = {},
+    extmarks = {},
+    virtual_lines = {},
   }
   setmetatable(o, self)
   self.__index = self
@@ -228,6 +232,14 @@ function Builder:format_line(indent_markers, arrows, icon, name, node)
     add_to_end(line, M.decorators[i]:icons_after(node))
   end
 
+  local rights = {}
+  for i = #M.decorators, 1, -1 do
+    add_to_end(rights, M.decorators[i]:icons_right_align(node))
+  end
+  if #rights > 0 then
+    self.extmarks[self.index] = rights
+  end
+
   return line
 end
 
@@ -295,24 +307,16 @@ function Builder:add_highlights(node)
     table.insert(name_groups, name)
   end
 
-  -- one or many icon groups; <= 0.8 always uses highest due to lack of a practical nvim_get_hl equivalent
+  -- one or many icon groups
   if #icon_groups > 1 then
-    if vim.fn.has "nvim-0.9" == 1 then
     icon_hl_group = self:create_combined_group(icon_groups)
-    else
-      icon_hl_group = icon_groups[#icon_groups]
-    end
   else
     icon_hl_group = icon_groups[1]
   end
 
-  -- one or many name groups; <= 0.8 always uses highest due to lack of a practical nvim_get_hl equivalent
+  -- one or many name groups
   if #name_groups > 1 then
-    if vim.fn.has "nvim-0.9" == 1 then
     name_hl_group = self:create_combined_group(name_groups)
-    else
-      name_hl_group = name_groups[#name_groups]
-    end
   else
     name_hl_group = name_groups[1]
   end
@@ -349,7 +353,6 @@ function Builder:build_line(node, idx, num_children)
   self.index = self.index + 1
 
   node = require("nvim-tree.lib").get_last_group_node(node)
-
   if node.open then
     self.depth = self.depth + 1
     self:build_lines(node)
@@ -357,9 +360,36 @@ function Builder:build_line(node, idx, num_children)
   end
 end
 
+---Add virtual lines for rendering hidden count information per node
+---@private
+function Builder:add_hidden_count_string(node, idx, num_children)
+  if not node.open then
+    return
+  end
+  local hidden_count_string = M.opts.renderer.hidden_display(node.hidden_stats)
+  if hidden_count_string and hidden_count_string ~= "" then
+    local indent_markers = pad.get_indent_markers(self.depth, idx or 0, num_children or 0, node, self.markers, 1)
+    local indent_width = M.opts.renderer.indent_width
+
+    local indent_padding = string.rep(" ", indent_width)
+    local indent_string = indent_padding .. indent_markers.str
+    local line_nr = #self.lines - 1
+    self.virtual_lines[line_nr] = self.virtual_lines[line_nr] or {}
+
+    -- NOTE: We are inserting in depth order because of current traversal
+    -- if we change the traversal, we might need to sort by depth before rendering `self.virtual_lines`
+    -- to maintain proper ordering of parent and child folder hidden count info.
+    table.insert(self.virtual_lines[line_nr], {
+      { indent_string, indent_markers.hl },
+      { string.rep(indent_padding, (node.parent == nil and 0 or 1)) .. hidden_count_string, "NvimTreeHiddenDisplay" },
+    })
+  end
+end
+
 ---@private
 function Builder:get_nodes_number(nodes)
-  if not live_filter.filter then
+  local explorer = core.get_explorer()
+  if not explorer or not explorer.live_filter.filter then
     return #nodes
   end
 
@@ -386,6 +416,7 @@ function Builder:build_lines(node)
       idx = idx + 1
     end
   end
+  self:add_hidden_count_string(node)
 end
 
 ---@private
@@ -396,15 +427,16 @@ function Builder:format_root_name(root_label)
     local label = root_label(self.root_cwd)
     if type(label) == "string" then
       return label
-    else
-      return "???"
-    end
     end
+  elseif type(root_label) == "string" then
     return utils.path_remove_trailing(vim.fn.fnamemodify(self.root_cwd, root_label))
+  end
+  return "???"
 end
 
 ---@private
 function Builder:build_header()
+  local explorer = core.get_explorer()
   if view.is_root_folder_visible(core.get_cwd()) then
     local root_name = self:format_root_name(M.opts.renderer.root_folder_label)
     table.insert(self.lines, root_name)
@@ -412,8 +444,8 @@ function Builder:build_header()
     self.index = 1
   end
 
-  if live_filter.filter then
+  if explorer and explorer.live_filter.filter then
-    local filter_line = string.format("%s/%s/", M.opts.live_filter.prefix, live_filter.filter)
+    local filter_line = string.format("%s/%s/", M.opts.live_filter.prefix, explorer.live_filter.filter)
     table.insert(self.lines, filter_line)
     local prefix_length = string.len(M.opts.live_filter.prefix)
     self:insert_highlight({ "NvimTreeLiveFilterPrefix" }, 0, prefix_length)
@@ -422,15 +454,68 @@ function Builder:build_header()
   end
 end
 
+---Sanitize lines for rendering.
+---Replace newlines with literal \n
+---@private
+function Builder:sanitize_lines()
+  self.lines = vim.tbl_map(function(line)
+    return line and line:gsub("\n", "\\n") or ""
+  end, self.lines)
+end
+
 ---Build all lines with highlights and signs
 ---@return Builder
 function Builder:build()
   self:build_header()
   self:build_lines()
+  self:sanitize_lines()
   return self
 end
 
+---@param opts table
+local setup_hidden_display_function = function(opts)
+  local hidden_display = opts.renderer.hidden_display
+  -- options are already validated, so ´hidden_display´ can ONLY be `string` or `function` if type(hidden_display) == "string" then
+  if type(hidden_display) == "string" then
+    if hidden_display == "none" then
+      opts.renderer.hidden_display = function()
+        return nil
+      end
+    elseif hidden_display == "simple" then
+      opts.renderer.hidden_display = function(hidden_stats)
+        return utils.default_format_hidden_count(hidden_stats, true)
+      end
+    elseif hidden_display == "all" then
+      opts.renderer.hidden_display = function(hidden_stats)
+        return utils.default_format_hidden_count(hidden_stats, false)
+      end
+    end
+  elseif type(hidden_display) == "function" then
+    local safe_render = function(hidden_stats)
+      -- In case of missing field such as live_filter we zero it, otherwise keep field as is
+      hidden_stats = vim.tbl_deep_extend("force", {
+        live_filter = 0,
+        git = 0,
+        buf = 0,
+        dotfile = 0,
+        custom = 0,
+        bookmark = 0,
+      }, hidden_stats or {})
+
+      local ok, result = pcall(hidden_display, hidden_stats)
+      if not ok then
+        notify.warn "Problem occurred in the function ``opts.renderer.hidden_display`` see nvim-tree.renderer.hidden_display on :h nvim-tree"
+        return nil
+      end
+      return result
+    end
+
+    opts.renderer.hidden_display = safe_render
+  end
+end
+
 function Builder.setup(opts)
+  setup_hidden_display_function(opts)
   M.opts = opts
 
   -- priority order
@@ -440,6 +525,7 @@ function Builder.setup(opts)
     DecoratorDiagnostics:new(opts),
     DecoratorBookmarks:new(opts),
     DecoratorModified:new(opts),
+    DecoratorHidden:new(opts),
     DecoratorOpened:new(opts),
     DecoratorGit:new(opts),
   }

lua/nvim-tree/renderer/components/full-name.lua

@@ -67,12 +67,19 @@ local function show()
   })
 
   local ns_id = vim.api.nvim_get_namespaces()["NvimTreeHighlights"]
-  local extmarks = vim.api.nvim_buf_get_extmarks(0, ns_id, { line_nr - 1, 0 }, { line_nr - 1, -1 }, { details = 1 })
+  local extmarks = vim.api.nvim_buf_get_extmarks(0, ns_id, { line_nr - 1, 0 }, { line_nr - 1, -1 }, { details = true })
   vim.api.nvim_win_call(M.popup_win, function()
     vim.api.nvim_buf_set_lines(0, 0, -1, true, { line })
     for _, extmark in ipairs(extmarks) do
-      local hl = extmark[4]
+      -- nvim 0.10 luadoc is incorrect: vim.api.keyset.get_extmark_item is missing the extmark_id at the start
-      vim.api.nvim_buf_add_highlight(0, ns_id, hl.hl_group, 0, extmark[3], hl.end_col)
+
+      ---@cast extmark table
+      ---@type integer
+      local col = extmark[3]
+      ---@type vim.api.keyset.extmark_details
+      local details = extmark[4]
+
+      vim.api.nvim_buf_add_highlight(0, ns_id, details.hl_group, 0, col, details.end_col)
     end
     vim.cmd [[ setlocal nowrap cursorline noswapfile nobuflisted buftype=nofile bufhidden=hide ]]
   end)

lua/nvim-tree/renderer/components/icons.lua

@@ -64,9 +64,14 @@ local function get_file_icon_webdev(fname, extension)
   elseif string.match(extension, "%.(.*)") then
     -- If there are more extensions to the file, try to grab the icon for them recursively
     return get_file_icon_webdev(fname, string.match(extension, "%.(.*)"))
+  else
+    local devicons_default = M.devicons.get_default_icon()
+    if devicons_default and type(devicons_default.icon) == "string" and type(devicons_default.name) == "string" then
+      return devicons_default.icon, "DevIcon" .. devicons_default.name
     else
       return get_file_icon_default()
     end
+  end
 end
 
 local function config_file_icon()

lua/nvim-tree/renderer/components/padding.lua

@@ -19,7 +19,7 @@ local function check_siblings_for_folder(node, with_arrows)
   return false
 end
 
-local function get_padding_indent_markers(depth, idx, nodes_number, markers, with_arrows, inline_arrows, node)
+local function get_padding_indent_markers(depth, idx, nodes_number, markers, with_arrows, inline_arrows, node, early_stop)
   local base_padding = with_arrows and (not node.nodes or depth > 0) and "  " or ""
   local padding = (inline_arrows or depth == 0) and base_padding or ""
 
@@ -27,7 +27,7 @@ local function get_padding_indent_markers(depth, idx, nodes_number, markers, wit
     local has_folder_sibling = check_siblings_for_folder(node, with_arrows)
     local indent = string.rep(" ", M.config.indent_width - 1)
     markers[depth] = idx ~= nodes_number
-    for i = 1, depth do
+    for i = 1, depth - early_stop do
       local glyph
       if idx == nodes_number and i == depth then
         local bottom_width = M.config.indent_width - 2 + (with_arrows and not inline_arrows and has_folder_sibling and 2 or 0)
@@ -62,7 +62,7 @@ end
 ---@param node table
 ---@param markers table
 ---@return HighlightedString[]
-function M.get_indent_markers(depth, idx, nodes_number, node, markers)
+function M.get_indent_markers(depth, idx, nodes_number, node, markers, early_stop)
   local str = ""
 
   local show_arrows = M.config.icons.show.folder_arrow
@@ -71,7 +71,7 @@ function M.get_indent_markers(depth, idx, nodes_number, node, markers)
   local indent_width = M.config.indent_width
 
   if show_markers then
-    str = str .. get_padding_indent_markers(depth, idx, nodes_number, markers, show_arrows, inline_arrows, node)
+    str = str .. get_padding_indent_markers(depth, idx, nodes_number, markers, show_arrows, inline_arrows, node, early_stop or 0)
   else
     str = str .. string.rep(" ", depth * indent_width)
   end

lua/nvim-tree/renderer/decorator/bookmarks.lua

@@ -1,4 +1,4 @@
-local marks = require "nvim-tree.marks"
+local core = require "nvim-tree.core"
 
 local HL_POSITION = require("nvim-tree.enum").HL_POSITION
 local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
@@ -34,7 +34,7 @@ end
 ---@param node Node
 ---@return HighlightedString[]|nil icons
 function DecoratorBookmarks:calculate_icons(node)
-  if marks.get_mark(node) then
+  if core.get_explorer() and core.get_explorer().marks:get_mark(node) then
     return { self.icon }
   end
 end
@@ -43,7 +43,7 @@ end
 ---@param node Node
 ---@return string|nil group
 function DecoratorBookmarks:calculate_highlight(node)
-  if self.hl_pos ~= HL_POSITION.none and marks.get_mark(node) then
+  if self.hl_pos ~= HL_POSITION.none and core.get_explorer() and core.get_explorer().marks:get_mark(node) then
     return "NvimTreeBookmarkHL"
   end
 end

lua/nvim-tree/renderer/decorator/hidden.lua

@@ -0,0 +1,55 @@
+local HL_POSITION = require("nvim-tree.enum").HL_POSITION
+local ICON_PLACEMENT = require("nvim-tree.enum").ICON_PLACEMENT
+local explorer_node = require "nvim-tree.explorer.node"
+local Decorator = require "nvim-tree.renderer.decorator"
+
+---@class DecoratorHidden: Decorator
+---@field icon HighlightedString|nil
+local DecoratorHidden = Decorator:new()
+
+---@param opts table
+---@return DecoratorHidden
+function DecoratorHidden:new(opts)
+  local o = Decorator.new(self, {
+    enabled = true,
+    hl_pos = HL_POSITION[opts.renderer.highlight_hidden] or HL_POSITION.none,
+    icon_placement = ICON_PLACEMENT[opts.renderer.icons.hidden_placement] or ICON_PLACEMENT.none,
+  })
+  ---@cast o DecoratorHidden
+
+  if opts.renderer.icons.show.hidden then
+    o.icon = {
+      str = opts.renderer.icons.glyphs.hidden,
+      hl = { "NvimTreeHiddenIcon" },
+    }
+    o:define_sign(o.icon)
+  end
+
+  return o
+end
+
+---Hidden icon: hidden.enable, renderer.icons.show.hidden and node starts with `.` (dotfile).
+---@param node Node
+---@return HighlightedString[]|nil icons
+function DecoratorHidden:calculate_icons(node)
+  if self.enabled and explorer_node.is_dotfile(node) then
+    return { self.icon }
+  end
+end
+
+---Hidden highlight: hidden.enable, renderer.highlight_hidden and node starts with `.` (dotfile).
+---@param node Node
+---@return string|nil group
+function DecoratorHidden:calculate_highlight(node)
+  if not self.enabled or self.hl_pos == HL_POSITION.none or (not explorer_node.is_dotfile(node)) then
+    return nil
+  end
+
+  if node.nodes then
+    return "NvimTreeHiddenFolderHL"
+  else
+    return "NvimTreeHiddenFileHL"
+  end
+end
+
+return DecoratorHidden

lua/nvim-tree/renderer/decorator/init.lua

@@ -74,6 +74,17 @@ function Decorator:icons_after(node)
   return self:calculate_icons(node)
 end
 
+---Icons when ICON_PLACEMENT.right_align
+---@param node Node
+---@return HighlightedString[]|nil icons
+function Decorator:icons_right_align(node)
+  if not self.enabled or self.icon_placement ~= ICON_PLACEMENT.right_align then
+    return
+  end
+
+  return self:calculate_icons(node)
+end
+
 ---Maybe icons, optionally implemented
 ---@protected
 ---@param _ Node

lua/nvim-tree/renderer/init.lua

@@ -12,32 +12,65 @@ local M = {}
 
 local SIGN_GROUP = "NvimTreeRendererSigns"
 
-local namespace_id = vim.api.nvim_create_namespace "NvimTreeHighlights"
+local namespace_highlights_id = vim.api.nvim_create_namespace "NvimTreeHighlights"
+local namespace_extmarks_id = vim.api.nvim_create_namespace "NvimTreeExtmarks"
+local namespace_virtual_lines_id = vim.api.nvim_create_namespace "NvimTreeVirtualLines"
 
 ---@param bufnr number
 ---@param lines string[]
 ---@param hl_args AddHighlightArgs[]
 ---@param signs string[]
-local function _draw(bufnr, lines, hl_args, signs)
+local function _draw(bufnr, lines, hl_args, signs, extmarks, virtual_lines)
-  vim.api.nvim_buf_set_option(bufnr, "modifiable", true)
+  if vim.fn.has "nvim-0.10" == 1 then
+    vim.api.nvim_set_option_value("modifiable", true, { buf = bufnr })
+  else
+    vim.api.nvim_buf_set_option(bufnr, "modifiable", true) ---@diagnostic disable-line: deprecated
+  end
+
   vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
   M.render_hl(bufnr, hl_args)
-  vim.api.nvim_buf_set_option(bufnr, "modifiable", false)
+
+  if vim.fn.has "nvim-0.10" == 1 then
+    vim.api.nvim_set_option_value("modifiable", false, { buf = bufnr })
+  else
+    vim.api.nvim_buf_set_option(bufnr, "modifiable", false) ---@diagnostic disable-line: deprecated
+  end
+
   vim.fn.sign_unplace(SIGN_GROUP)
   for i, sign_name in pairs(signs) do
     vim.fn.sign_place(0, SIGN_GROUP, sign_name, bufnr, { lnum = i + 1 })
   end
+
+  vim.api.nvim_buf_clear_namespace(bufnr, namespace_extmarks_id, 0, -1)
+  for i, extname in pairs(extmarks) do
+    for _, mark in ipairs(extname) do
+      vim.api.nvim_buf_set_extmark(bufnr, namespace_extmarks_id, i, -1, {
+        virt_text = { { mark.str, mark.hl } },
+        virt_text_pos = "right_align",
+        hl_mode = "combine",
+      })
+    end
+  end
+
+  vim.api.nvim_buf_clear_namespace(bufnr, namespace_virtual_lines_id, 0, -1)
+  for line_nr, vlines in pairs(virtual_lines) do
+    vim.api.nvim_buf_set_extmark(bufnr, namespace_virtual_lines_id, line_nr, 0, {
+      virt_lines = vlines,
+      virt_lines_above = false,
+      virt_lines_leftcol = true,
+    })
+  end
 end
 
 function M.render_hl(bufnr, hl)
   if not bufnr or not vim.api.nvim_buf_is_loaded(bufnr) then
     return
   end
-  vim.api.nvim_buf_clear_namespace(bufnr, namespace_id, 0, -1)
+  vim.api.nvim_buf_clear_namespace(bufnr, namespace_highlights_id, 0, -1)
   for _, data in ipairs(hl) do
     if type(data[1]) == "table" then
       for _, group in ipairs(data[1]) do
-        vim.api.nvim_buf_add_highlight(bufnr, namespace_id, group, data[2], data[3], data[4])
+        vim.api.nvim_buf_add_highlight(bufnr, namespace_highlights_id, group, data[2], data[3], data[4])
       end
     end
   end
@@ -51,15 +84,15 @@ function M.draw()
 
   local profile = log.profile_start "draw"
 
-  local cursor = vim.api.nvim_win_get_cursor(view.get_winnr())
+  local cursor = vim.api.nvim_win_get_cursor(view.get_winnr() or 0)
   icon_component.reset_config()
 
   local builder = Builder:new():build()
 
-  _draw(bufnr, builder.lines, builder.hl_args, builder.signs)
+  _draw(bufnr, builder.lines, builder.hl_args, builder.signs, builder.extmarks, builder.virtual_lines)
 
   if cursor and #builder.lines >= cursor[1] then
-    vim.api.nvim_win_set_cursor(view.get_winnr(), cursor)
+    vim.api.nvim_win_set_cursor(view.get_winnr() or 0, cursor)
   end
 
   view.grow_from_content()

lua/nvim-tree/utils.lua

@@ -112,7 +112,10 @@ function M.find_node(nodes, fn)
     end)
     :iterate()
   i = require("nvim-tree.view").is_root_folder_visible() and i or i - 1
-  i = require("nvim-tree.live-filter").filter and i + 1 or i
+  local explorer = require("nvim-tree.core").get_explorer()
+  if explorer and explorer.live_filter.filter then
+    i = i + 1
+  end
   return node, i
 end
 
@@ -181,6 +184,26 @@ function M.get_parent_of_group(node)
   return node
 end
 
+M.default_format_hidden_count = function(hidden_count, simple)
+  local parts = {}
+  local total_count = 0
+  for reason, count in pairs(hidden_count) do
+    total_count = total_count + count
+    if count > 0 then
+      table.insert(parts, reason .. ": " .. tostring(count))
+    end
+  end
+
+  local hidden_count_string = table.concat(parts, ", ") -- if empty then is "" (empty string)
+  if simple then
+    hidden_count_string = ""
+  end
+  if total_count > 0 then
+    return "(" .. tostring(total_count) .. (simple and " hidden" or " total ") .. hidden_count_string .. ")"
+  end
+  return nil
+end
+
 --- Return visible nodes indexed by line
 ---@param nodes_all Node[]
 ---@param line_start number
@@ -226,7 +249,14 @@ function M.rename_loaded_buffers(old_path, new_path)
         vim.api.nvim_buf_set_name(buf, new_path .. buf_name:sub(#old_path + 1))
         -- to avoid the 'overwrite existing file' error message on write for
         -- normal files
-        if vim.api.nvim_buf_get_option(buf, "buftype") == "" then
+        local buftype
+        if vim.fn.has "nvim-0.10" == 1 then
+          buftype = vim.api.nvim_get_option_value("buftype", { buf = buf })
+        else
+          buftype = vim.api.nvim_buf_get_option(buf, "buftype") ---@diagnostic disable-line: deprecated
+        end
+
+        if buftype == "" then
           vim.api.nvim_buf_call(buf, function()
             vim.cmd "silent! write!"
             vim.cmd "edit"
@@ -406,6 +436,9 @@ function M.debounce(context, timeout, callback)
   end
 
   local timer = vim.loop.new_timer()
+  if not timer then
+    return
+  end
   debouncer.timer = timer
   timer:start(timeout, 0, function()
     timer_stop_close(timer)

lua/nvim-tree/view.lua

@@ -50,6 +50,7 @@ M.View = {
       "Normal:NvimTreeNormal",
       "NormalNC:NvimTreeNormalNC",
       "NormalFloat:NvimTreeNormalFloat",
+      "FloatBorder:NvimTreeNormalFloatBorder",
     }, ","),
   },
 }
@@ -108,7 +109,7 @@ local function create_buffer(bufnr)
   events._dispatch_tree_attached_post(M.get_bufnr())
 end
 
----@param size number|fun():number
+---@param size (fun():integer)|integer|string
 ---@return integer
 local function get_size(size)
   if type(size) == "number" then
@@ -121,10 +122,13 @@ local function get_size(size)
   return math.floor(vim.o.columns * percent_as_decimal)
 end
 
----@param size number|function|nil
+---@param size (fun():integer)|integer|nil
 local function get_width(size)
-  size = size or M.View.width
+  if size then
     return get_size(size)
+  else
+    return get_size(M.View.width)
+  end
 end
 
 local move_tbl = {
@@ -140,7 +144,7 @@ local function setup_tabpage(tabpage)
 end
 
 local function set_window_options_and_buffer()
-  pcall(vim.cmd, "buffer " .. M.get_bufnr())
+  pcall(vim.api.nvim_command, "buffer " .. M.get_bufnr())
   local eventignore = vim.opt.eventignore:get()
   vim.opt.eventignore = "all"
   for k, v in pairs(M.View.winopts) do
@@ -204,7 +208,7 @@ end
 ---@param tabnr integer
 local function save_tab_state(tabnr)
   local tabpage = tabnr or vim.api.nvim_get_current_tabpage()
-  M.View.cursors[tabpage] = vim.api.nvim_win_get_cursor(M.get_winnr(tabpage))
+  M.View.cursors[tabpage] = vim.api.nvim_win_get_cursor(M.get_winnr(tabpage) or 0)
 end
 
 ---@param tabpage integer
@@ -222,8 +226,8 @@ local function close(tabpage)
       if tree_win == current_win and prev_win > 0 then
         vim.api.nvim_set_current_win(vim.fn.win_getid(prev_win))
       end
-      if vim.api.nvim_win_is_valid(tree_win) then
+      if vim.api.nvim_win_is_valid(tree_win or 0) then
-        vim.api.nvim_win_close(tree_win, true)
+        vim.api.nvim_win_close(tree_win or 0, true)
       end
       events._dispatch_on_tree_close()
       return
@@ -343,13 +347,9 @@ function M.resize(size)
   end
 
   local new_size = get_width()
-  vim.api.nvim_win_set_width(M.get_winnr(), new_size)
+  vim.api.nvim_win_set_width(M.get_winnr() or 0, new_size)
 
-  -- TODO #1545 remove similar check from setup_autocommands
-  -- We let nvim handle sending resize events after 0.9
-  if vim.fn.has "nvim-0.9" == 0 then
   events._dispatch_on_tree_resize(new_size)
-  end
 
   if not M.View.preserve_window_proportions then
     vim.cmd ":wincmd ="
@@ -420,7 +420,7 @@ function M.is_visible(opts)
     return false
   end
 
-  return M.get_winnr() ~= nil and vim.api.nvim_win_is_valid(M.get_winnr())
+  return M.get_winnr() ~= nil and vim.api.nvim_win_is_valid(M.get_winnr() or 0)
 end
 
 ---@param opts table|nil
@@ -443,7 +443,9 @@ function M.focus(winnr, open_if_closed)
     M.open()
   end
 
+  if wnr then
     vim.api.nvim_set_current_win(wnr)
+  end
 end
 
 --- Retrieve the winid of the open tree.
@@ -541,11 +543,40 @@ end
 
 -- used on ColorScheme event
 function M.reset_winhl()
-  if M.get_winnr() and vim.api.nvim_win_is_valid(M.get_winnr()) then
+  local winnr = M.get_winnr()
+  if winnr and vim.api.nvim_win_is_valid(winnr) then
     vim.wo[M.get_winnr()].winhl = M.View.winopts.winhl
   end
 end
 
+---Check if width determined or calculated on-fly
+---@return boolean
+function M.is_width_determined()
+  return type(M.View.width) ~= "function"
+end
+
+---Configure width-related config
+---@param width string|function|number|table|nil
+function M.configure_width(width)
+  if type(width) == "table" then
+    M.View.adaptive_size = true
+    M.View.width = width.min or DEFAULT_MIN_WIDTH
+    M.View.max_width = width.max or DEFAULT_MAX_WIDTH
+    M.View.padding = width.padding or DEFAULT_PADDING
+  elseif width == nil then
+    if M.config.width ~= nil then
+      -- if we had input config - fallback to it
+      M.configure_width(M.config.width)
+    else
+      -- otherwise - restore initial width
+      M.View.width = M.View.initial_width
+    end
+  else
+    M.View.adaptive_size = false
+    M.View.width = width
+  end
+end
+
 function M.setup(opts)
   local options = opts.view or {}
   M.View.centralize_selection = options.centralize_selection
@@ -561,15 +592,8 @@ function M.setup(opts)
   M.View.float = options.float
   M.on_attach = opts.on_attach
 
-  if type(options.width) == "table" then
+  M.config = options
-    M.View.adaptive_size = true
+  M.configure_width(options.width)
-    M.View.width = options.width.min or DEFAULT_MIN_WIDTH
-    M.View.max_width = options.width.max or DEFAULT_MAX_WIDTH
-    M.View.padding = options.width.padding or DEFAULT_PADDING
-  else
-    M.View.adaptive_size = false
-    M.View.width = options.width
-  end
 
   M.View.initial_width = get_width()
 end

scripts/help-update.sh

@@ -21,6 +21,39 @@ sed -e "s/^  /      /" /tmp/DEFAULT_OPTS.2.lua > /tmp/DEFAULT_OPTS.6.lua
 sed -i -e "/${begin}/,/${end}/{ /${begin}/{p; r /tmp/DEFAULT_OPTS.6.lua
            }; /${end}/p; d; }" doc/nvim-tree-lua.txt
 
+
+#
+# opts index
+#
+begin="nvim-tree-index-opts\*"
+end="====================="
+
+printf '\n' > /tmp/index-opts.txt
+sed -E "
+/^ *\*(nvim-tree\..*)\*$/! d ;
+s/^.*\*(.*)\*/|\1|/g
+" doc/nvim-tree-lua.txt | sort -d >> /tmp/index-opts.txt
+printf '\n' >> /tmp/index-opts.txt
+
+sed -i -e "/${begin}/,/${end}/{ /${begin}/{p; r /tmp/index-opts.txt
+           }; /${end}/p; d; }" doc/nvim-tree-lua.txt
+
+#
+# api index
+#
+begin="nvim-tree-index-api\*"
+end="====================="
+
+printf '\n' > /tmp/index-api.txt
+sed -E "
+/\*(nvim-tree-api.*\(\))\*/! d ;
+s/^.*\*(.*)\*/|\1|/g
+" doc/nvim-tree-lua.txt | sort -d >> /tmp/index-api.txt
+printf '\n' >> /tmp/index-api.txt
+
+sed -i -e "/${begin}/,/${end}/{ /${begin}/{p; r /tmp/index-api.txt
+           }; /${end}/p; d; }" doc/nvim-tree-lua.txt
+
 #
 # DEFAULT_ON_ATTACH
 #

scripts/luals-check.sh

@@ -29,15 +29,11 @@ fi
 
 # any output is a fail
 case "${OUT}" in
-	*Diagnosis\ complete*)
+	*Diagnosis\ completed,\ no\ problems\ found*)
-		if [ -f "${DIR_OUT}/check.json" ]; then
-			cat "${DIR_OUT}/check.json"
-			exit 1
-		else
 		exit 0
-		fi
 		;;
 	*)
+		cat "${DIR_OUT}/check.json"
 		exit 1
 		;;
 esac