add padding first column

feat: add NvimTreeFilter filetype

.editorconfig

@@ -4,9 +4,21 @@ root = true
 insert_final_newline = true
 end_of_line = lf
 
-[*.lua]
-indent_style = space
-indent_size = 2
-
 [nvim-tree-lua.txt]
 max_line_length = 78
+
+# keep these in sync with .luarc.json
+#   .editorconfig is used within nvim, overriding .luarc.json
+#   .luarc.json is used by style check
+[*.lua]
+indent_style = space
+max_line_length = 140
+indent_size = 2
+
+# EmmyLuaCodeStyle specific, see
+# https://github.com/CppCXY/EmmyLuaCodeStyle/blob/master/lua.template.editorconfig
+continuation_indent = 2
+quote_style = double
+call_arg_parentheses = always
+space_before_closure_open_parenthesis = false
+align_continuous_similar_call_args = true

.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/ISSUE_TEMPLATE/nvt-min.lua

@@ -1,12 +1,12 @@
 vim.g.loaded_netrw = 1
 vim.g.loaded_netrwPlugin = 1
 
-vim.cmd [[set runtimepath=$VIMRUNTIME]]
-vim.cmd [[set packpath=/tmp/nvt-min/site]]
+vim.cmd([[set runtimepath=$VIMRUNTIME]])
+vim.cmd([[set packpath=/tmp/nvt-min/site]])
 local package_root = "/tmp/nvt-min/site/pack"
 local install_path = package_root .. "/packer/start/packer.nvim"
 local function load_plugins()
-  require("packer").startup {
+  require("packer").startup({
     {
       "wbthomason/packer.nvim",
       "nvim-tree/nvim-tree.lua",
@@ -18,21 +18,21 @@ local function load_plugins()
       compile_path = install_path .. "/plugin/packer_compiled.lua",
       display = { non_interactive = true },
     },
-  }
+  })
 end
 if vim.fn.isdirectory(install_path) == 0 then
-  print "Installing nvim-tree and dependencies."
-  vim.fn.system { "git", "clone", "--depth=1", "https://github.com/wbthomason/packer.nvim", install_path }
+  print("Installing nvim-tree and dependencies.")
+  vim.fn.system({ "git", "clone", "--depth=1", "https://github.com/wbthomason/packer.nvim", install_path })
 end
 load_plugins()
 require("packer").sync()
-vim.cmd [[autocmd User PackerComplete ++once echo "Ready!" | lua setup()]]
+vim.cmd([[autocmd User PackerComplete ++once echo "Ready!" | lua setup()]])
 vim.opt.termguicolors = true
 vim.opt.cursorline = true
 
 -- MODIFY NVIM-TREE SETTINGS THAT ARE _NECESSARY_ FOR REPRODUCING THE ISSUE
 _G.setup = function()
-  require("nvim-tree").setup {}
+  require("nvim-tree").setup({})
 end
 
 -- UNCOMMENT this block for diagnostics issues, substituting pattern and cmd as appropriate.
@@ -41,7 +41,11 @@ end
 vim.api.nvim_create_autocmd("FileType", {
   pattern = "lua",
   callback = function()
-    vim.lsp.start { cmd = { "lua-language-server" } }
+    vim.lsp.start {
+      name = "my-luals",
+      cmd = { "lua-language-server" },
+      root_dir = vim.loop.cwd(),
+    }
   end,
 })
 ]]

.github/workflows/ci.yml

@@ -2,11 +2,9 @@ name: CI
 
 on:
   pull_request:
-    branches:
-      - '*'
   push:
-    branches:
-      - master
+    branches: [master]
+  workflow_dispatch:
 
 permissions:
   contents: read
@@ -14,29 +12,68 @@ permissions:
 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 ]
+        luacheck_version: [ 1.2.0 ]
+
     steps:
-      - uses: actions/checkout@v4
+      - name: checkout
+        uses: actions/checkout@v5
 
-      - uses: leafo/gh-actions-lua@v10
+      - name: install lua ${{ matrix.lua_version }}
+        uses: leafo/gh-actions-lua@v12
         with:
-          luaVersion: "5.1"
+          luaVersion: ${{ matrix.lua_version }}
 
-      - uses: leafo/gh-actions-luarocks@v4
+      - name: install luarocks
+        uses: leafo/gh-actions-luarocks@v6
 
-      - name: luacheck
-        run: |
-          luarocks install luacheck 1.1.1
-          luacheck lua
+      - name: install luacheck ${{ matrix.luacheck_version }}
+        run: luarocks install luacheck ${{ matrix.luacheck_version }}
 
-  style:
+      - run: make lint
+
+  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.15.0 ]
+
+    env:
+      VIMRUNTIME: /home/runner/nvim-${{ matrix.nvim_version }}/share/nvim/runtime
+
     steps:
-      - uses: actions/checkout@v4
+      - name: checkout
+        uses: actions/checkout@v5
 
-      - name: stylua
-        uses: JohnnyMorganz/stylua-action@v3
+      - name: install nvim ${{ matrix.nvim_version }}
+        uses: rhysd/action-setup-vim@v1
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          version: "0.19"
-          args: --check lua
+          neovim: true
+          version: ${{ matrix.nvim_version }}
 
+      - name: install lua-language-server ${{ matrix.luals_version }}
+        run: |
+          mkdir -p luals
+          curl -L "https://github.com/LuaLS/lua-language-server/releases/download/${{ matrix.luals_version }}/lua-language-server-${{ matrix.luals_version }}-linux-x64.tar.gz" | tar zx --directory luals
+          echo "luals/bin" >> "$GITHUB_PATH"
+
+      - run: make check
+
+      - run: make help-check
+
+      - run: make style
+
+      - run: make style-doc

.github/workflows/luarocks-release.yml

@@ -0,0 +1,39 @@
+name: Luarocks Release
+
+on:
+  push:
+    tags:
+      - v*
+  workflow_dispatch:
+
+jobs:
+  luarocks-upload:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - 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

@@ -2,18 +2,21 @@ on:
   push:
     branches:
       - master
+  workflow_dispatch:
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
 name: release-please
+permissions:
+  contents: write
+  pull-requests: write
 jobs:
   release-please:
     runs-on: ubuntu-latest
     steps:
       - uses: google-github-actions/release-please-action@v4
         id: release
-        with:
-          release-type: simple
-          package-name: nvim-tree
-          command: github-release
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: tag major and minor versions
         if: ${{ steps.release.outputs.release_created }}
         run: |
@@ -22,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

@@ -6,10 +6,14 @@ on:
       - reopened
       - 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@v6.1.1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

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

.hooks/pre-commit.sh

@@ -1,4 +1,3 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
 
-stylua . --check || exit 1
-luacheck . || exit 1
+make

.luacheckrc

@@ -1,14 +1,15 @@
--- vim: ft=lua tw=80
+local M = {}
 
 -- Don't report unused self arguments of methods.
-self = false
+M.self = false
 
-ignore = {
+M.ignore = {
   "631",  -- max_line_length
 }
 
 -- Global objects defined by the C code
-globals = {
+M.globals = {
   "vim",
-  "TreeExplorer"
 }
+
+return M

.luarc.json

@@ -1,10 +1,26 @@
 {
   "$schema": "https://raw.githubusercontent.com/sumneko/vscode-lua/master/setting/schema.json",
-  "runtime.version" : "Lua 5.1",
+  "workspace": {
+    "library": [
+      "$VIMRUNTIME/lua/vim",
+      "${3rd}/luv/library"
+    ]
+  },
+  "format": {
+    "defaultConfig": {
+      "indent_style": "space",
+      "max_line_length": "140",
+      "indent_size": "2",
+      "continuation_indent": "2",
+      "quote_style": "double",
+      "call_arg_parentheses": "always",
+      "space_before_closure_open_parenthesis": "false",
+      "align_continuous_similar_call_args": "true"
+    }
+  },
   "diagnostics": {
-    "globals": [
-      "vim"
-    ],
+    "libraryFiles": "Disable",
+    "globals": [],
     "neededFileStatus": {
       "ambiguity-1": "Any",
       "assign-type-mismatch": "Any",
@@ -26,11 +42,19 @@
       "duplicate-index": "Any",
       "duplicate-set-field": "Any",
       "empty-block": "Any",
+      "global-element": "Any",
       "global-in-nil-env": "Any",
+      "incomplete-signature-doc": "Any",
+      "inject-field": "Any",
+      "invisible": "Any",
       "lowercase-global": "Any",
+      "missing-fields": "Any",
+      "missing-global-doc": "Any",
+      "missing-local-export-doc": "Any",
       "missing-parameter": "Any",
       "missing-return": "Any",
       "missing-return-value": "Any",
+      "name-style-check": "None",
       "need-check-nil": "Any",
       "newfield-call": "Any",
       "newline-call": "Any",
@@ -63,4 +87,3 @@
     }
   }
 }
-

.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.14.0"
+}

.stylua.toml

@@ -1,6 +0,0 @@
-column_width = 140
-line_endings = "Unix"
-indent_type = "Spaces"
-indent_width = 2
-quote_style = "AutoPreferDouble"
-call_parentheses = "None"

CHANGELOG.md

@@ -1,350 +1,351 @@
 # Changelog
 
-## 1.0.0 (2023-12-09)
+## [1.14.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.13.0...nvim-tree-v1.14.0) (2025-08-12)
 
 
 ### Features
 
-* **#1079:** add renderer.highlight_clipboard default name, defaults to undercurls ([#2410](https://github.com/nvim-tree/nvim-tree.lua/issues/2410)) ([a3aa3b4](https://github.com/nvim-tree/nvim-tree.lua/commit/a3aa3b47eac8b6289f028743bef4ce9eb0f6782e))
-* **#1245:** add next_diag_item and prev_diag_item actions ([80d4f28](https://github.com/nvim-tree/nvim-tree.lua/commit/80d4f2838353915cc1567f3547d535276af9ab4c))
-* **#1389:** add git.show_on_dirs ([#1390](https://github.com/nvim-tree/nvim-tree.lua/issues/1390)) ([736cc84](https://github.com/nvim-tree/nvim-tree.lua/commit/736cc843e1294f7877a1f418860650dcc8e6f1c2))
-* **#1669:** remove deprecated open_on_setup mechanisms ([#2122](https://github.com/nvim-tree/nvim-tree.lua/issues/2122)) ([48d53a5](https://github.com/nvim-tree/nvim-tree.lua/commit/48d53a5934fbd51b655d03db7dad35551838f2c9))
-* **#1804:** add api.marks.bulk.delete with default bd mapping ([#2276](https://github.com/nvim-tree/nvim-tree.lua/issues/2276)) ([bdceaf5](https://github.com/nvim-tree/nvim-tree.lua/commit/bdceaf50966f5f4a2602eb54bfe8a3e52748a42b))
-* **#1837:** add git.disable_for_dirs ([#2239](https://github.com/nvim-tree/nvim-tree.lua/issues/2239)) ([6306140](https://github.com/nvim-tree/nvim-tree.lua/commit/63061404f4686267673707c4baffed740b2cad6a))
-* **#1917:** add diagnostic highlighting and icon placement ([#2396](https://github.com/nvim-tree/nvim-tree.lua/issues/2396)) ([323f65c](https://github.com/nvim-tree/nvim-tree.lua/commit/323f65cb9c6a4eae7a0b15e136fa668aeb7fde9b))
-* **#1974:** enable experimental.git.async by default, see https://github.com/nvim-tree/nvim-tree.lua/issues/2104 ([#2158](https://github.com/nvim-tree/nvim-tree.lua/issues/2158)) ([f8bb6b4](https://github.com/nvim-tree/nvim-tree.lua/commit/f8bb6b4c76e03156fac38c45f9feea84632c65c4))
-* **#1974:** experimental.git.async see https://github.com/nvim-tree/nvim-tree.lua/issues/2104 ([#2094](https://github.com/nvim-tree/nvim-tree.lua/issues/2094)) ([0ef3d46](https://github.com/nvim-tree/nvim-tree.lua/commit/0ef3d4613f90d8e92c1407ddf397b9ee61995526))
-* **#2079:** sort_by may return predefined sort ([#2123](https://github.com/nvim-tree/nvim-tree.lua/issues/2123)) ([6ad5c26](https://github.com/nvim-tree/nvim-tree.lua/commit/6ad5c26f4d44791699c5538d9773cb141ba033e7))
-* **#2092:** add api.node.navigate.open.next, prev ([#2093](https://github.com/nvim-tree/nvim-tree.lua/issues/2093)) ([0c9bfe7](https://github.com/nvim-tree/nvim-tree.lua/commit/0c9bfe7225156c54dd7c79292d6d6468fd1cb2a6))
-* **#2148:** api.fs.rename_full ([#2461](https://github.com/nvim-tree/nvim-tree.lua/issues/2461)) ([0882354](https://github.com/nvim-tree/nvim-tree.lua/commit/08823545171eea269943c7e414cb266abffd0b1b))
-* **#2197:** git and diagnostics folder highlight groups ([#2409](https://github.com/nvim-tree/nvim-tree.lua/issues/2409)) ([b7f6600](https://github.com/nvim-tree/nvim-tree.lua/commit/b7f6600bc2b4e48e4af45f1e77d2bf170685a542))
-* **#2270:** add notify.absolute_path - show file or absolute path (default) names with notifications ([#2286](https://github.com/nvim-tree/nvim-tree.lua/issues/2286)) ([3cc698b](https://github.com/nvim-tree/nvim-tree.lua/commit/3cc698b35b0a67792c61e1726830bb9ecfc4c9f4))
-* **#2277:** skip overwrite prompt when copy/cut paste into same directory ([#2278](https://github.com/nvim-tree/nvim-tree.lua/issues/2278)) ([7aff29d](https://github.com/nvim-tree/nvim-tree.lua/commit/7aff29d755c5b3932af3ea6b69b27df4f3b64bfe))
-* **#2305:** find file refreshes up the tree when node is not present ([#2358](https://github.com/nvim-tree/nvim-tree.lua/issues/2358)) ([ace6422](https://github.com/nvim-tree/nvim-tree.lua/commit/ace64228ad5d89035fbe6f85e7f45a1f7b9e29c1))
-* **#2312:** fire `TextYankPost` event on path copy ([#2489](https://github.com/nvim-tree/nvim-tree.lua/issues/2489)) ([c2194e9](https://github.com/nvim-tree/nvim-tree.lua/commit/c2194e940cf50033bbd05d6a31d8f1b5109bd280))
-* **#2313:** sort_by -> sort.sorter, add sort.folders_first default true ([#2314](https://github.com/nvim-tree/nvim-tree.lua/issues/2314)) ([ef305a8](https://github.com/nvim-tree/nvim-tree.lua/commit/ef305a888be2b9a0627369f00ccebbad88e6e3ce))
-* **#2316:** add NvimTreeFolderArrowClosed NvimTreeFolderArrowOpen ([#2408](https://github.com/nvim-tree/nvim-tree.lua/issues/2408)) ([8f48426](https://github.com/nvim-tree/nvim-tree.lua/commit/8f48426c88cd91aa33610c96ad649f378d7bf718))
-* **#2364:** add option to sort files first ([#2366](https://github.com/nvim-tree/nvim-tree.lua/issues/2366)) ([d11d701](https://github.com/nvim-tree/nvim-tree.lua/commit/d11d701857f4a520a0ee6f4d82d3bef155976be3))
-* **#2369:** add full renderer.icons.web_devicons options for file and folder ([#2375](https://github.com/nvim-tree/nvim-tree.lua/issues/2375)) ([b144b33](https://github.com/nvim-tree/nvim-tree.lua/commit/b144b333901a8429311215c78ee0297aa899b80f))
-* **#2398:** add NvimTreeOpenedFileIcon ([#2407](https://github.com/nvim-tree/nvim-tree.lua/issues/2407)) ([33c3bc5](https://github.com/nvim-tree/nvim-tree.lua/commit/33c3bc562b2ff3c6f5324af94054fc1f21b3c9f7))
-* **#2411:** add renderer.highlight_bookmarks, renderer.icons.bookmarks_placement ([#2412](https://github.com/nvim-tree/nvim-tree.lua/issues/2412)) ([d49a284](https://github.com/nvim-tree/nvim-tree.lua/commit/d49a2842365e425971cd27ae31d73985b0ccc0bc))
-* **#2498:** delete, trash prompts default N, added ui.confirm.default_yes option to override this behaviour ([#2500](https://github.com/nvim-tree/nvim-tree.lua/issues/2500)) ([c156856](https://github.com/nvim-tree/nvim-tree.lua/commit/c1568568b3f58d5cab87cf6a2a84717afe09d11d))
-* **#2515:** add option to change grouped folders name with custom function ([#2521](https://github.com/nvim-tree/nvim-tree.lua/issues/2521)) ([a2aaf8b](https://github.com/nvim-tree/nvim-tree.lua/commit/a2aaf8b430c11af36b869cf1c0ad2f7c8ceeaf2c))
-* **#2530:** keep alt filename on node.open.replace_tree_buffer ([#2531](https://github.com/nvim-tree/nvim-tree.lua/issues/2531)) ([52a1c99](https://github.com/nvim-tree/nvim-tree.lua/commit/52a1c99bf0bedb781ce4817c6ec3ebfe3af90f81))
-* **#2544:** add api.tree.winid ([#2545](https://github.com/nvim-tree/nvim-tree.lua/issues/2545)) ([8c53482](https://github.com/nvim-tree/nvim-tree.lua/commit/8c534822a7d16c83cf69928c53e1d8a13bd2734a))
-* **actions:** expand_all 'exclude' option ([#1388](https://github.com/nvim-tree/nvim-tree.lua/issues/1388)) ([21516f4](https://github.com/nvim-tree/nvim-tree.lua/commit/21516f447baf42f6f11421a017cd69306d5d5ff3))
-* add -bar option to command definitions ([#1422](https://github.com/nvim-tree/nvim-tree.lua/issues/1422)) ([c231933](https://github.com/nvim-tree/nvim-tree.lua/commit/c231933fcdc8855c813f368e48025a368864a636))
-* add actions.open_file.eject ([#2341](https://github.com/nvim-tree/nvim-tree.lua/issues/2341)) ([4bd30f0](https://github.com/nvim-tree/nvim-tree.lua/commit/4bd30f0137e44dcf3e74cc1164efb568f78f2b02))
-* add confirmation kind to select y/n ([ba5c18d](https://github.com/nvim-tree/nvim-tree.lua/commit/ba5c18dc2b43599067d999933469098073e1941c))
-* add cwd arg to open_replacing_current_buffer ([#1348](https://github.com/nvim-tree/nvim-tree.lua/issues/1348)) ([6b7b1b3](https://github.com/nvim-tree/nvim-tree.lua/commit/6b7b1b34fa6c4851a7b06a9ce4a1a703de7fd0ed))
-* add cwd arg to open_replacing_current_buffer: retain existing valid buffer check ([6548287](https://github.com/nvim-tree/nvim-tree.lua/commit/6548287e8b84552d40d28f9e122f7eedf1f331bd))
-* add diagnostics.show_on_open_dirs git.show_on_open_dirs ([#1778](https://github.com/nvim-tree/nvim-tree.lua/issues/1778)) ([829e9f6](https://github.com/nvim-tree/nvim-tree.lua/commit/829e9f68e10a998198e17bf5b348a6947f9d3c2e))
-* add filters.git_ignored (prev git.ignore), apply "Toggle Filter:" prefix to mapping descriptions ([#2325](https://github.com/nvim-tree/nvim-tree.lua/issues/2325)) ([697bfac](https://github.com/nvim-tree/nvim-tree.lua/commit/697bfaccac4a4843449ce7a7b14adb0e7989befe))
-* add NvimTreeCursorLineNr ([#1616](https://github.com/nvim-tree/nvim-tree.lua/issues/1616)) ([7282f7d](https://github.com/nvim-tree/nvim-tree.lua/commit/7282f7de8aedf861fe0162a559fc2b214383c51c))
-* add NvimTreeFindFile!, root_dirs and prefer_startup_root ([b08003f](https://github.com/nvim-tree/nvim-tree.lua/commit/b08003f54640f2015e54dfcd39685862908bfc6a))
-* add NvimTreeNormalFloat ([#2167](https://github.com/nvim-tree/nvim-tree.lua/issues/2167)) ([98b76ff](https://github.com/nvim-tree/nvim-tree.lua/commit/98b76ff0a2f2725b6c0d1b7491ec85ca760c9f3f))
-* add NvimTreeSymlinkIcon ([#2198](https://github.com/nvim-tree/nvim-tree.lua/issues/2198)) ([736c7ff](https://github.com/nvim-tree/nvim-tree.lua/commit/736c7ff59065275f0483af4b7f07a9bc41449ad0))
-* add on_tree_resize event ([c847354](https://github.com/nvim-tree/nvim-tree.lua/commit/c84735483f20b692ffaffb2b889a8956a9a425a4))
-* add option for folder arrows to be inline with indent markers ([#1468](https://github.com/nvim-tree/nvim-tree.lua/issues/1468)) ([7fcb48c](https://github.com/nvim-tree/nvim-tree.lua/commit/7fcb48c852b9d58709169a4dc1ec634fa9ea56f9))
-* add sort_by "filetype" ([#2302](https://github.com/nvim-tree/nvim-tree.lua/issues/2302)) ([3d2fd90](https://github.com/nvim-tree/nvim-tree.lua/commit/3d2fd90b2869f2b4679d540dd0145d002d9688c3))
-* add sort_by "suffix" ([#2307](https://github.com/nvim-tree/nvim-tree.lua/issues/2307)) ([a708bd2](https://github.com/nvim-tree/nvim-tree.lua/commit/a708bd2413d467929b5019ec1bce7b1f428438bc))
-* add ui.confirm.remove and ui.confirm.trash, deprecate trash.require_confirm ([#1887](https://github.com/nvim-tree/nvim-tree.lua/issues/1887)) ([ccb6d8a](https://github.com/nvim-tree/nvim-tree.lua/commit/ccb6d8a518d32e22bf5874f90e6c22661a5d8b46))
-* add winid parameter for api.tree.open, toggle, find_file ([#2213](https://github.com/nvim-tree/nvim-tree.lua/issues/2213)) ([b1e074d](https://github.com/nvim-tree/nvim-tree.lua/commit/b1e074d2b52d45c8327b5b43a498b3d7e6c93b97))
-* allow cycling on git/diagnostic/opened files navigation ([#2506](https://github.com/nvim-tree/nvim-tree.lua/issues/2506)) ([0a99c4a](https://github.com/nvim-tree/nvim-tree.lua/commit/0a99c4a23eae8e25285a30d08439aee8da4f5c16))
-* api.marks.bulk.trash ([#2391](https://github.com/nvim-tree/nvim-tree.lua/issues/2391)) ([7f7665a](https://github.com/nvim-tree/nvim-tree.lua/commit/7f7665a17b60d80533b7a69cfad3b6875f2dd453))
-* api.node.open.preview_no_picker with default mapping <S-Tab> ([#2464](https://github.com/nvim-tree/nvim-tree.lua/issues/2464)) ([aaee4cd](https://github.com/nvim-tree/nvim-tree.lua/commit/aaee4cd896b74f85a81bed7eef2db7869960c4d0))
-* **api:** add `node.open.drop()` ([#2164](https://github.com/nvim-tree/nvim-tree.lua/issues/2164)) ([0df384b](https://github.com/nvim-tree/nvim-tree.lua/commit/0df384b6c0fa62ff1333634d56ee4df0be5d34e1))
-* **api:** add api.commands.get ([#2083](https://github.com/nvim-tree/nvim-tree.lua/issues/2083)) ([45400cd](https://github.com/nvim-tree/nvim-tree.lua/commit/45400cd7e02027937cd5e49845545e606ecf5a1f))
-* **api:** add api.config.mappings.active, api.config.mappings.default ([#1876](https://github.com/nvim-tree/nvim-tree.lua/issues/1876)) ([bac962c](https://github.com/nvim-tree/nvim-tree.lua/commit/bac962caf472a4404ed3ce1ba2fcaf32f8002951))
-* **api:** add api.config.mappings.default_on_attach ([#2037](https://github.com/nvim-tree/nvim-tree.lua/issues/2037)) ([bbb6d48](https://github.com/nvim-tree/nvim-tree.lua/commit/bbb6d4891009de7dab05ad8fc2d39f272d7a751c))
-* **api:** add api.config.mappings.get_keymap and get_keymap_default ([#2056](https://github.com/nvim-tree/nvim-tree.lua/issues/2056)) ([4f03634](https://github.com/nvim-tree/nvim-tree.lua/commit/4f036342f14378b53ac5d7c6ae8d8f6d1bf9a0f8))
-* **api:** add api.fs.clear_clipboard ([#1706](https://github.com/nvim-tree/nvim-tree.lua/issues/1706)) ([cbb5313](https://github.com/nvim-tree/nvim-tree.lua/commit/cbb5313f9044a2ccf0b3e0f85a9e6a4e0fd0dd40))
-* **api:** add api.marks.clear ([#1708](https://github.com/nvim-tree/nvim-tree.lua/issues/1708)) ([cd2f756](https://github.com/nvim-tree/nvim-tree.lua/commit/cd2f7569dbf19ae989fcc0c1906df079b8247797))
-* **api:** add api.tree.get_nodes ([e38e061](https://github.com/nvim-tree/nvim-tree.lua/commit/e38e061710c593d9b88c8ebb2c48f2842c89dc31))
-* **api:** Add new node selection action based on tab :drop command ([#2161](https://github.com/nvim-tree/nvim-tree.lua/issues/2161)) ([d68b00a](https://github.com/nvim-tree/nvim-tree.lua/commit/d68b00a63e98ee02a415e27b3f40cb802b8f1906))
-* **api:** add public API module ([#1432](https://github.com/nvim-tree/nvim-tree.lua/issues/1432)) ([e783278](https://github.com/nvim-tree/nvim-tree.lua/commit/e7832785d2abfc3b8dd67655076eeffddb3141e9))
-* **api:** add tree.is_visible, tree.is_tree_buf ([#2150](https://github.com/nvim-tree/nvim-tree.lua/issues/2150)) ([a774fa1](https://github.com/nvim-tree/nvim-tree.lua/commit/a774fa186c19945d2a594de80922da2cbb4a0139))
-* **api:** api.tree.find_file feature parity with open/toggle, convert all commands to API, document commands ([#2039](https://github.com/nvim-tree/nvim-tree.lua/issues/2039)) ([fe980ba](https://github.com/nvim-tree/nvim-tree.lua/commit/fe980baa945100d92f77fe55e2ca113cae1b1bd3))
-* **api:** api.tree.open feature parity with api.tree.toggle ([#1955](https://github.com/nvim-tree/nvim-tree.lua/issues/1955)) ([215b29b](https://github.com/nvim-tree/nvim-tree.lua/commit/215b29bfad74518442621b9d0483a621483b066b))
-* **api:** api.tree.open/toggle: add current_window option ([#1935](https://github.com/nvim-tree/nvim-tree.lua/issues/1935)) ([f1c2d6d](https://github.com/nvim-tree/nvim-tree.lua/commit/f1c2d6d3723947d822930e66cd4d3351a3c0370a))
-* **api:** rename_basename API and action ([#1791](https://github.com/nvim-tree/nvim-tree.lua/issues/1791)) ([949913f](https://github.com/nvim-tree/nvim-tree.lua/commit/949913f1860eb85024fa1967dbd89ac797777b0d))
-* automated migration from view.mappings.list to on_attach, see https://github.com/nvim-tree/nvim-tree.lua/wiki/Migrating-To-on_attach ([#1579](https://github.com/nvim-tree/nvim-tree.lua/issues/1579)) ([7495975](https://github.com/nvim-tree/nvim-tree.lua/commit/74959750f7823d6e069d3948a645f3c7a4c00638))
-* **bookmarks:** add bookmark feature ([#1412](https://github.com/nvim-tree/nvim-tree.lua/issues/1412)) ([df92f15](https://github.com/nvim-tree/nvim-tree.lua/commit/df92f1527f30d19fbf3474af2badc0636a2d70bf))
-* **copy-paste:** use vim.ui from prompting ([69aec67](https://github.com/nvim-tree/nvim-tree.lua/commit/69aec67edb046aa94c6a2a7aef7ec83bbcfb36b5))
-* **create-file:** use vim.ui.select for confirmation ([1ee6a3e](https://github.com/nvim-tree/nvim-tree.lua/commit/1ee6a3ea65764bee4ca8114652308ee48d789031)), closes [#1434](https://github.com/nvim-tree/nvim-tree.lua/issues/1434) [#1294](https://github.com/nvim-tree/nvim-tree.lua/issues/1294)
-* deprecate view.mappings, see https://github.com/nvim-tree/nvim-tree.lua/wiki/Migrating-To-on_attach ([#2143](https://github.com/nvim-tree/nvim-tree.lua/issues/2143)) ([5aa318c](https://github.com/nvim-tree/nvim-tree.lua/commit/5aa318c15934efa03d2ac86b493e89792e06c7b6))
-* **diagnostics:** add diagnostics.severity ([#1755](https://github.com/nvim-tree/nvim-tree.lua/issues/1755)) ([68a2a09](https://github.com/nvim-tree/nvim-tree.lua/commit/68a2a0971eb50f13e4d54498a2add73f131b9a85))
-* **event:** add au, global: NvimTreeRequired, NvimTreeSetup ([#1912](https://github.com/nvim-tree/nvim-tree.lua/issues/1912)) ([1f0fc8d](https://github.com/nvim-tree/nvim-tree.lua/commit/1f0fc8d6e8c7900533b78b467e37710e9c813ae8))
-* **event:** add TreeAttachedPost ([#1877](https://github.com/nvim-tree/nvim-tree.lua/issues/1877)) ([f43f311](https://github.com/nvim-tree/nvim-tree.lua/commit/f43f3110a570512a4a4ff76a1103d734f02f6b32))
-* **event:** add TreeRendered ([#2324](https://github.com/nvim-tree/nvim-tree.lua/issues/2324)) ([3b62c6b](https://github.com/nvim-tree/nvim-tree.lua/commit/3b62c6bf2c3f2973036aed609d02fd0ca9c3af35))
-* **event:** add WillCreateFile, WillRemoveFile ([#2273](https://github.com/nvim-tree/nvim-tree.lua/issues/2273)) ([c3c6544](https://github.com/nvim-tree/nvim-tree.lua/commit/c3c6544ee00333b0f1d6a13735d0dd302dba4f70))
-* **event:** add WillRenameNode ([#1821](https://github.com/nvim-tree/nvim-tree.lua/issues/1821)) ([a2c7556](https://github.com/nvim-tree/nvim-tree.lua/commit/a2c75567add11a0f76cd61f4dfc86df8cbd4b017))
-* **event:** dispatch Event.NodeRenamed on cut-paste ([#1817](https://github.com/nvim-tree/nvim-tree.lua/issues/1817)) ([e49fa4e](https://github.com/nvim-tree/nvim-tree.lua/commit/e49fa4e52900ddc218cfaa6d7e3345c97a086d40))
-* **file-popup:** add actions.file_popup.open_win_config ([a73d0d4](https://github.com/nvim-tree/nvim-tree.lua/commit/a73d0d4800d517f737d5d6d69283426b48bdf7f3))
-* focus_empty_on_setup ([0417d91](https://github.com/nvim-tree/nvim-tree.lua/commit/0417d9148b6546bf4883b6e9750f992f980afbfe))
-* **git:** add TM git status ([#2045](https://github.com/nvim-tree/nvim-tree.lua/issues/2045)) ([1830e5e](https://github.com/nvim-tree/nvim-tree.lua/commit/1830e5e8a46b32575130bf04bbe0a773999ccb73))
-* **git:** support `DA` state, fix([#1822](https://github.com/nvim-tree/nvim-tree.lua/issues/1822)): test directory capable of watching before presenting it ([#1905](https://github.com/nvim-tree/nvim-tree.lua/issues/1905)) ([3ce0a8e](https://github.com/nvim-tree/nvim-tree.lua/commit/3ce0a8e770f70a135ef969e0a640bd8d05baf42c))
-* **log:** add node inspection function ([#2541](https://github.com/nvim-tree/nvim-tree.lua/issues/2541)) ([5231562](https://github.com/nvim-tree/nvim-tree.lua/commit/5231562cafd7044c827c8b5cfd7b1391894761cc))
-* mapping and options to sort entries in help window ([#2482](https://github.com/nvim-tree/nvim-tree.lua/issues/2482)) ([78a9ca5](https://github.com/nvim-tree/nvim-tree.lua/commit/78a9ca5ed6557f29cd0ce203df44213e54bfabb9))
-* **mapping:** deprecate user mappings and add on_attach ([#1424](https://github.com/nvim-tree/nvim-tree.lua/issues/1424)) ([64cc3c1](https://github.com/nvim-tree/nvim-tree.lua/commit/64cc3c17e1a8d00d0fafcb61349b2a7d57234e53))
-* **marks:** add bulk move action ([#1419](https://github.com/nvim-tree/nvim-tree.lua/issues/1419)) ([26512c3](https://github.com/nvim-tree/nvim-tree.lua/commit/26512c369fdb8b1e2bd80d0039dffac2088f85d8))
-* **marks:** add navigation (next, previous, select) ([#1415](https://github.com/nvim-tree/nvim-tree.lua/issues/1415)) ([89becc7](https://github.com/nvim-tree/nvim-tree.lua/commit/89becc7604719a6d81e7a31e4b4221affa145e89))
-* **movement:** allow circular movement for sibling next and prev ([#1416](https://github.com/nvim-tree/nvim-tree.lua/issues/1416)) ([b32c883](https://github.com/nvim-tree/nvim-tree.lua/commit/b32c88333f8e19685da5f301bb63a30ba685d0cb))
-* notify [NvimTree] prefix is multiline only if the message is multiline ([#2453](https://github.com/nvim-tree/nvim-tree.lua/issues/2453)) ([e64a498](https://github.com/nvim-tree/nvim-tree.lua/commit/e64a498a5eb9169ff9673ef6a409005040d29c4c))
-* **notify:** add notify.threshold ([#1693](https://github.com/nvim-tree/nvim-tree.lua/issues/1693)) ([6ca6f99](https://github.com/nvim-tree/nvim-tree.lua/commit/6ca6f99e7689c68679e8f0a58b421545ff52931f))
-* **notify:** switch all print/nvim_*write statements to utils.notify ([1844713](https://github.com/nvim-tree/nvim-tree.lua/commit/18447132fce62dad87624efdb395fd6b2bebbc35))
-* paste and create always target closed folder, remove create_in_closed_folder ([#1802](https://github.com/nvim-tree/nvim-tree.lua/issues/1802)) ([7177d95](https://github.com/nvim-tree/nvim-tree.lua/commit/7177d95ac0f46bf02ff3f8375e135149a3fc79b8))
-* **picker:** allow custom function actions.open_file.window_picker.picker ([#1782](https://github.com/nvim-tree/nvim-tree.lua/issues/1782)) ([d85b671](https://github.com/nvim-tree/nvim-tree.lua/commit/d85b6718cef7f27c603cf170fb5154d90356e90b))
-* **remove-file:** use vim.ui.select ([2d629ca](https://github.com/nvim-tree/nvim-tree.lua/commit/2d629cab78e6e25374037982531aee95c6e89b10))
-* renderer.full_name includes root node ([#2502](https://github.com/nvim-tree/nvim-tree.lua/issues/2502)) ([7e3c0be](https://github.com/nvim-tree/nvim-tree.lua/commit/7e3c0bee7b246ca835d5f7453db6fa19de359bab))
-* **renderer:** add NvimTreeOpenedFolderIcon NvimTreeClosedFolderIcon ([#1768](https://github.com/nvim-tree/nvim-tree.lua/issues/1768)) ([0b319a1](https://github.com/nvim-tree/nvim-tree.lua/commit/0b319a1b284a2e75faa46107d2cda31a30e946bc))
-* **renderer:** add NvimTreeSymlinkFolderName ([#2000](https://github.com/nvim-tree/nvim-tree.lua/issues/2000)) ([f3dbddf](https://github.com/nvim-tree/nvim-tree.lua/commit/f3dbddf8b3fbd5de7c8838eafc1b3b72cd30c73e))
-* **renderer:** add renderer.indent_width ([#1505](https://github.com/nvim-tree/nvim-tree.lua/issues/1505)) ([e8bf3d7](https://github.com/nvim-tree/nvim-tree.lua/commit/e8bf3d778a74882d748f55d67af206fa8b321d99))
-* **renderer:** add renderer.root_folder_label ([#1746](https://github.com/nvim-tree/nvim-tree.lua/issues/1746)) ([99d7136](https://github.com/nvim-tree/nvim-tree.lua/commit/99d713644d44b573d076812ee5bfcaa5290aaa25))
-* **renderer:** show symlink folder destination ([ad1f3ef](https://github.com/nvim-tree/nvim-tree.lua/commit/ad1f3ef3bc86ca43ebf488569aadf6f56e448575))
-* **search-node:** use vim.ui.input ([1b667bc](https://github.com/nvim-tree/nvim-tree.lua/commit/1b667bc99e1e2cf090362579726fa2a55a4e1acc))
-* **sorters:** allow user sort_by ([3676e0b](https://github.com/nvim-tree/nvim-tree.lua/commit/3676e0b124c2a132857e2bbcf7f48f05228f1052))
-* split startup warning messages into multiple lines ([#2436](https://github.com/nvim-tree/nvim-tree.lua/issues/2436)) ([113e095](https://github.com/nvim-tree/nvim-tree.lua/commit/113e0950c88b81b01d253d8f3da17bbd0e6716bb))
-* support custom $GIT_DIR ([#2263](https://github.com/nvim-tree/nvim-tree.lua/issues/2263)) ([a6daf50](https://github.com/nvim-tree/nvim-tree.lua/commit/a6daf50b9d1aa426f557e51b37ee854b99782d3f))
-* support vim.diagnostic.is_disabled() ([#2232](https://github.com/nvim-tree/nvim-tree.lua/issues/2232)) ([8d82c4d](https://github.com/nvim-tree/nvim-tree.lua/commit/8d82c4dbe15913655b509dcf1179b2ac7c69f9c5))
-* **tab_change:** introduce new option to filter buffer by bufname or ft ([79434c2](https://github.com/nvim-tree/nvim-tree.lua/commit/79434c2b3cd86aebc652db042c17f3b433bfd47c))
-* **tabs:** add tab.sync options ([#1698](https://github.com/nvim-tree/nvim-tree.lua/issues/1698)) ([c494994](https://github.com/nvim-tree/nvim-tree.lua/commit/c49499413a875fc99ce8594cfe6474ed684e51eb))
-* **trash:** add synchronized trash support for windows ([#2335](https://github.com/nvim-tree/nvim-tree.lua/issues/2335)) ([75c0574](https://github.com/nvim-tree/nvim-tree.lua/commit/75c05742bc1f96d9606ee315b3c649973c4fb1cd))
-* **trash:** use vim.ui.select for confirmation ([7cffe14](https://github.com/nvim-tree/nvim-tree.lua/commit/7cffe14743279a7fa05dcd21a09a575e777c55f6))
-* use IEC binary size prefixes ([#2483](https://github.com/nvim-tree/nvim-tree.lua/issues/2483)) ([83b6995](https://github.com/nvim-tree/nvim-tree.lua/commit/83b699533b279af6d207d6c3860d4301556d65b4))
-* use virtual title in notifications if title is not supported ([#2439](https://github.com/nvim-tree/nvim-tree.lua/issues/2439)) ([85abe29](https://github.com/nvim-tree/nvim-tree.lua/commit/85abe2939620fe63b73ec97d3e2e0c7f2ec4fe23))
-* validate all option types ([#2414](https://github.com/nvim-tree/nvim-tree.lua/issues/2414)) ([ea14741](https://github.com/nvim-tree/nvim-tree.lua/commit/ea147418e07e1ca7a867c753c906d27c39863273))
-* validate some option string values ([#2404](https://github.com/nvim-tree/nvim-tree.lua/issues/2404)) ([51f0236](https://github.com/nvim-tree/nvim-tree.lua/commit/51f02366deed1f21153c564b546fed813acfd6d8))
-* **view:** add filters.git_clean, filters.no_buffer ([#1784](https://github.com/nvim-tree/nvim-tree.lua/issues/1784)) ([c5dc80c](https://github.com/nvim-tree/nvim-tree.lua/commit/c5dc80c36b6855cb30bff8e743838b9da97219b3))
-* **view:** add float.quit_on_focus_loss, float respects actions.open_file.quit_on_open ([#1621](https://github.com/nvim-tree/nvim-tree.lua/issues/1621)) ([79f631b](https://github.com/nvim-tree/nvim-tree.lua/commit/79f631bc1d52b387f4ae59fad1291d894afa97f5))
-* **view:** add view.cursorline ([#1859](https://github.com/nvim-tree/nvim-tree.lua/issues/1859)) ([9ad93b6](https://github.com/nvim-tree/nvim-tree.lua/commit/9ad93b6ac062acca6d50563bf3984b287e10f721))
-* **view:** add view.width.min/max replacing adaptive_size, allowing upper bound ([#1915](https://github.com/nvim-tree/nvim-tree.lua/issues/1915)) ([96506fe](https://github.com/nvim-tree/nvim-tree.lua/commit/96506fee49542f3aedab76368d400a147fea344e))
-* **view:** add view.width.padding ([#1941](https://github.com/nvim-tree/nvim-tree.lua/issues/1941)) ([e05ed6a](https://github.com/nvim-tree/nvim-tree.lua/commit/e05ed6a60ff4fa70063f74edbf07ef8365eaabae))
-* **view:** allow function for view.float.open_win_config ([#1538](https://github.com/nvim-tree/nvim-tree.lua/issues/1538)) ([c3ea264](https://github.com/nvim-tree/nvim-tree.lua/commit/c3ea264947671f44d836af5b7587e12c4b4611f9))
-* **view:** always enable cursorline, users may change this behaviour via Event.TreeOpen ([#1814](https://github.com/nvim-tree/nvim-tree.lua/issues/1814)) ([69a07d1](https://github.com/nvim-tree/nvim-tree.lua/commit/69a07d169ae8c1de90904bd5fb9e1dd27eff6d30))
-* **view:** deprecate open_on_setup.* in favour of https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup ([#1951](https://github.com/nvim-tree/nvim-tree.lua/issues/1951)) ([fb775b3](https://github.com/nvim-tree/nvim-tree.lua/commit/fb775b335389590f96ba22097b6a36a7c2f161ab))
-* **view:** float.quit_on_focus_loss documentation clarification ([4a01f90](https://github.com/nvim-tree/nvim-tree.lua/commit/4a01f90d111d8a85a79502478f6f4e9ef13df74d))
-* **view:** Floating nvim tree window [#1377](https://github.com/nvim-tree/nvim-tree.lua/issues/1377) ([#1462](https://github.com/nvim-tree/nvim-tree.lua/issues/1462)) ([7323c81](https://github.com/nvim-tree/nvim-tree.lua/commit/7323c81bd6209c247248244b12682cc345630301))
-* **view:** floating window's optional adaptive size specification ([#1559](https://github.com/nvim-tree/nvim-tree.lua/issues/1559)) ([757951b](https://github.com/nvim-tree/nvim-tree.lua/commit/757951ba6b3ee6b0f502c4bd4a23c53b382305c2))
-* **view:** indicate modified buffers ([#1835](https://github.com/nvim-tree/nvim-tree.lua/issues/1835)) ([dcc344c](https://github.com/nvim-tree/nvim-tree.lua/commit/dcc344cc72a617ff01db950aedfd3b3430ba5b59))
-* **watcher:** add filesystem_watchers.ignore_dirs ([#1705](https://github.com/nvim-tree/nvim-tree.lua/issues/1705)) ([ed9db63](https://github.com/nvim-tree/nvim-tree.lua/commit/ed9db632a89ff2712c48e32774d68a715553510f))
-* **watcher:** debounce FS watchers ([e401a4c](https://github.com/nvim-tree/nvim-tree.lua/commit/e401a4c9570f433053604fd9d98833376d5982fe))
-* **watcher:** partial git refresh ([#1373](https://github.com/nvim-tree/nvim-tree.lua/issues/1373)) ([7a795d7](https://github.com/nvim-tree/nvim-tree.lua/commit/7a795d78fa2a102de197e81b85f5b1e6b5f366a3))
-* **watcher:** tear down watcher on failue, warning the user ([#1707](https://github.com/nvim-tree/nvim-tree.lua/issues/1707)) ([a0f3e99](https://github.com/nvim-tree/nvim-tree.lua/commit/a0f3e99b2dc46b441c1a1db09eaf6338f1c5298a))
+* **#2685:** highlight git new tracked with NvimTreeGitFileNewHL ([#3176](https://github.com/nvim-tree/nvim-tree.lua/issues/3176)) ([0a52012](https://github.com/nvim-tree/nvim-tree.lua/commit/0a52012d611f3c1492b8d2aba363fabf734de91d))
+* **#2789:** add optional function expand_until to api.tree.expand_all and api.node.expand ([#3166](https://github.com/nvim-tree/nvim-tree.lua/issues/3166)) ([1b876db](https://github.com/nvim-tree/nvim-tree.lua/commit/1b876db04903b93c78c97fd3f3dd85d59eeef5ff))
+* **#2826:** allow only one window with nvim-tree buffer per tab ([#3174](https://github.com/nvim-tree/nvim-tree.lua/issues/3174)) ([dd2364d](https://github.com/nvim-tree/nvim-tree.lua/commit/dd2364d6802f7f57a98acb8b545ed484c6697626))
+* **#3157:** add view.cursorlineopt ([#3158](https://github.com/nvim-tree/nvim-tree.lua/issues/3158)) ([8eb5e0b](https://github.com/nvim-tree/nvim-tree.lua/commit/8eb5e0bfd1c4da6efc03ab0c1ccf463dbaae831e))
 
 
 ### Bug Fixes
 
-* **#1270:** ensure explorer exists at startup before propagating FS changes ([55aa006](https://github.com/nvim-tree/nvim-tree.lua/commit/55aa0062b974e1fc29b4462c745271ae40009eda))
-* **#1270:** open_on_setup_file does not override open_on_setup, hijack_directories does not override startup behaviour ([#1618](https://github.com/nvim-tree/nvim-tree.lua/issues/1618)) ([c5536db](https://github.com/nvim-tree/nvim-tree.lua/commit/c5536db0b7a9e13709af16a0ffe1ab20137f8a48))
-* **#1354:** add missing :hi NvimTreeFileIgnored ([#1358](https://github.com/nvim-tree/nvim-tree.lua/issues/1358)) ([1fc0eee](https://github.com/nvim-tree/nvim-tree.lua/commit/1fc0eee9465f764bd3c8fab1900efe13318b28c9))
-* **#1356:** view.close switch_buf_if_last_buf prefers alt buf ([#1357](https://github.com/nvim-tree/nvim-tree.lua/issues/1357)) ([d9aaa2f](https://github.com/nvim-tree/nvim-tree.lua/commit/d9aaa2f985c69ae1452e067e33e8a11ec84196a1))
-* **#1366:** warn when trash cmd missing ([#1378](https://github.com/nvim-tree/nvim-tree.lua/issues/1378)) ([7285898](https://github.com/nvim-tree/nvim-tree.lua/commit/72858986f9de019dc0e151c76090de29954081f0))
-* **#1406:** allow nvim-tree.renderer.icons.show.folder_arrow ([fd562ed](https://github.com/nvim-tree/nvim-tree.lua/commit/fd562ede63c6dac8938276f901e1e6d46ac8b293))
-* **#1479:** apply remove_keymaps to default mappings ([cfc4692](https://github.com/nvim-tree/nvim-tree.lua/commit/cfc4692a3fd5e5afa7321b878eb8364e7617d7b7))
-* **#1480:** break symlink cycle on find-file, search-node ([#1482](https://github.com/nvim-tree/nvim-tree.lua/issues/1482)) ([261a5c3](https://github.com/nvim-tree/nvim-tree.lua/commit/261a5c380c000e23c4a23dcd55b984c856cdb113))
-* **#1484:** better error handling in git utils get_toplevel ([ff6e796](https://github.com/nvim-tree/nvim-tree.lua/commit/ff6e7966f39a897ac4d1358f4d022cfecdc88ff1))
-* **#1494:** git showUntracked value and log ([#1504](https://github.com/nvim-tree/nvim-tree.lua/issues/1504)) ([09a5126](https://github.com/nvim-tree/nvim-tree.lua/commit/09a51266bca28dd87febd63c66bdbd74f7764a63))
-* **#1500:** focusing directories with a trailing slash in their path doesn't work ([#1501](https://github.com/nvim-tree/nvim-tree.lua/issues/1501)) ([b314b3a](https://github.com/nvim-tree/nvim-tree.lua/commit/b314b3a6992f07f7af5c58521d1e219b032d309e))
-* **#1503:** focus last win before close ([#1509](https://github.com/nvim-tree/nvim-tree.lua/issues/1509)) ([d9edddb](https://github.com/nvim-tree/nvim-tree.lua/commit/d9edddb84931ca73c350922d76f6c6825b694248))
-* **#1514:** inverted git navigation keymaps ([#1515](https://github.com/nvim-tree/nvim-tree.lua/issues/1515)) ([9fd7b7a](https://github.com/nvim-tree/nvim-tree.lua/commit/9fd7b7ae2920cc349644b5d45785e2a655ffdfe9))
-* **#1518:** sort_by=modification_time not reordering on refresh. ([#1519](https://github.com/nvim-tree/nvim-tree.lua/issues/1519)) ([049cdd3](https://github.com/nvim-tree/nvim-tree.lua/commit/049cdd3073faab064d93f7d6397c9d292d8a3cab))
-* **#1520:** file type changes are not detected. ([#1521](https://github.com/nvim-tree/nvim-tree.lua/issues/1521)) ([c5fba1e](https://github.com/nvim-tree/nvim-tree.lua/commit/c5fba1ec1861525a8d2d9773f7983ecf77b588dc))
-* **#1529:** ensure tree window exists before closing ([#1537](https://github.com/nvim-tree/nvim-tree.lua/issues/1537)) ([e3353c4](https://github.com/nvim-tree/nvim-tree.lua/commit/e3353c4cb40baef335e1a21d8b9c21b9cde919be))
-* **#1533:** make `toggle_mark` ignore non-togglable nodes. ([#1534](https://github.com/nvim-tree/nvim-tree.lua/issues/1534)) ([90dcf42](https://github.com/nvim-tree/nvim-tree.lua/commit/90dcf42bba4b9c07e1d590592035fdec5d8e07d8))
-* **#1539:** Fix closing nvim-tree float when file is removed ([#1546](https://github.com/nvim-tree/nvim-tree.lua/issues/1546)) ([07f59e7](https://github.com/nvim-tree/nvim-tree.lua/commit/07f59e7450c767c674cc53f5930b2d73af60b9c1))
-* **#1540:** watcher ignore directories with name exactly '.git' ([259efee](https://github.com/nvim-tree/nvim-tree.lua/commit/259efeee62c7fb51abf299c2570cacbf4806e98a))
-* **#1543:** Do not resize nvim-tree window if float is enabled ([#1556](https://github.com/nvim-tree/nvim-tree.lua/issues/1556)) ([ce5d0a6](https://github.com/nvim-tree/nvim-tree.lua/commit/ce5d0a6b7ddfec622554943d2ebcc739b1d74567))
-* **#1545:** dispatch Event.Resize on all window resizes, requires nvim 0.9+ ([#2238](https://github.com/nvim-tree/nvim-tree.lua/issues/2238)) ([0345117](https://github.com/nvim-tree/nvim-tree.lua/commit/034511714bacfadc5008e49f73fcef67e5613840))
-* **#1547:** pass explicit system arguments to for git toplevel and untracked actions ([9914780](https://github.com/nvim-tree/nvim-tree.lua/commit/9914780cbabdffe3cd030867f0bc34c6e51bcb95))
-* **#1551:** handle git status TT as staged ([c272c88](https://github.com/nvim-tree/nvim-tree.lua/commit/c272c88dafa5d2e8bf0554f4d687396f843714c5))
-* **#1553:** set correct side on vim open directory ([#1594](https://github.com/nvim-tree/nvim-tree.lua/issues/1594)) ([5cb87c0](https://github.com/nvim-tree/nvim-tree.lua/commit/5cb87c037d92b71a3a6f2bc342e2a38456b8870e))
-* **#1555:** incorrect exe highlight in Windows filesystem from WSL ([#1557](https://github.com/nvim-tree/nvim-tree.lua/issues/1557)) ([4a725c0](https://github.com/nvim-tree/nvim-tree.lua/commit/4a725c0ca501d81002aad77418f1edafdd01a0ba))
-* **#1564:** reset &bufhidden when opening an existing (maybe previewed) buffer ([#1573](https://github.com/nvim-tree/nvim-tree.lua/issues/1573)) ([e282420](https://github.com/nvim-tree/nvim-tree.lua/commit/e282420111929e2af2efca6f3fe31f95985d4a5b))
-* **#1568:** show relative path of symlink destination ([#1569](https://github.com/nvim-tree/nvim-tree.lua/issues/1569)) ([951e10a](https://github.com/nvim-tree/nvim-tree.lua/commit/951e10a64e0b03069f0f50ddc79d6a8ed8d23dec))
-* **#1615:** focus created file when command line prompt requires confirmation ([#1622](https://github.com/nvim-tree/nvim-tree.lua/issues/1622)) ([be2b4f5](https://github.com/nvim-tree/nvim-tree.lua/commit/be2b4f58e66ec48a8597246331c0c76f85171b4d))
-* **#1626:** obey splitright/below when splitting existing windows ([#1641](https://github.com/nvim-tree/nvim-tree.lua/issues/1641)) ([c4ac723](https://github.com/nvim-tree/nvim-tree.lua/commit/c4ac723a833b6d78b8a6403ad37efd56a67ee0c4))
-* **#1628:** quit_on_open e:  do not open in the tree's window ([#1637](https://github.com/nvim-tree/nvim-tree.lua/issues/1637)) ([b01e7be](https://github.com/nvim-tree/nvim-tree.lua/commit/b01e7beaa6f0dbbf5df775cf4ecc829a23f0be54))
-* **#1629:** nvim start with file named *NvimTree* opens tree instead of buffer ([#1634](https://github.com/nvim-tree/nvim-tree.lua/issues/1634)) ([c66cbdf](https://github.com/nvim-tree/nvim-tree.lua/commit/c66cbdfc25ce115db50cfe3dca8b96a8a1e9b931))
-* **#1632:** autocenter: avoid use of feedkeys ([#1632](https://github.com/nvim-tree/nvim-tree.lua/issues/1632)) ([187388b](https://github.com/nvim-tree/nvim-tree.lua/commit/187388b7f5ea7b38888c9af9c02cb2f9040aea1f))
-* **#1639:** ensure tree autocommands match filetype as well as name ([#1640](https://github.com/nvim-tree/nvim-tree.lua/issues/1640)) ([48992fd](https://github.com/nvim-tree/nvim-tree.lua/commit/48992fd3e82fa0f2ca22679f909823d8b37171d4))
-* **#1643:** preview on floating window ([#1648](https://github.com/nvim-tree/nvim-tree.lua/issues/1648)) ([c995ce0](https://github.com/nvim-tree/nvim-tree.lua/commit/c995ce087875ec5d4df51520b1e9cb09a4b51725))
-* **#1664:** respect hijack_directories.enable on startup when not open_on_setup ([#1665](https://github.com/nvim-tree/nvim-tree.lua/issues/1665)) ([4e24505](https://github.com/nvim-tree/nvim-tree.lua/commit/4e24505e2b30c4a8c35a3dfb4f564f14f6d9bfd4))
-* **#1668:** revert all startup behaviour changes back to 540055b ([3a2f68b](https://github.com/nvim-tree/nvim-tree.lua/commit/3a2f68b9d53fdf360beba222022868c527ae4d8a))
-* **#1668:** update issue link ([2b97063](https://github.com/nvim-tree/nvim-tree.lua/commit/2b970635d1ef531355a380258372411576ecad4d))
-* **#1671:** split with no window picker will always find an available window ([#1677](https://github.com/nvim-tree/nvim-tree.lua/issues/1677)) ([dd90bfa](https://github.com/nvim-tree/nvim-tree.lua/commit/dd90bfa155be7fa5371a32cb8b95d4f76d379161))
-* **#1675:** open-file sanity check mode ([e94f517](https://github.com/nvim-tree/nvim-tree.lua/commit/e94f5177983c033aad340b5351bf65ef1fa9737a))
-* **#1679:** renderer.full_name correctly shows for one character outside ([#1688](https://github.com/nvim-tree/nvim-tree.lua/issues/1688)) ([fba9751](https://github.com/nvim-tree/nvim-tree.lua/commit/fba97517bb570702be98718c9f841ae9b359133e))
-* **#1697:** remove notify plugin auto-detection ([#2135](https://github.com/nvim-tree/nvim-tree.lua/issues/2135)) ([68f485b](https://github.com/nvim-tree/nvim-tree.lua/commit/68f485b4542abd3912299b40b9ff39a834365567))
-* **#1711:** open in a new window when no window picker and no available window ([#1715](https://github.com/nvim-tree/nvim-tree.lua/issues/1715)) ([33ce8e3](https://github.com/nvim-tree/nvim-tree.lua/commit/33ce8e3c733a9fd949dabb96896eef3e24d01e54))
-* **#1712:** invalid window ID on colorscheme ([#1714](https://github.com/nvim-tree/nvim-tree.lua/issues/1714)) ([ada2c64](https://github.com/nvim-tree/nvim-tree.lua/commit/ada2c6441d0844cc1995b5def24fd3e90cfa8032))
-* **#1716:** focus file/directory when created in a sub-directory, don't dispatch FolderCreated on file creation ([#1722](https://github.com/nvim-tree/nvim-tree.lua/issues/1722)) ([bdc4ec6](https://github.com/nvim-tree/nvim-tree.lua/commit/bdc4ec6abd3e6c78eb5dea5f8b94c2698c3aad51))
-* **#1720:** .git watch only FETCH_HEAD, HEAD, HEAD.lock, config, index ([#1732](https://github.com/nvim-tree/nvim-tree.lua/issues/1732)) ([bcb2a5a](https://github.com/nvim-tree/nvim-tree.lua/commit/bcb2a5a80ddfe44dd9f4361800a54baafd7f6f18))
-* **#1723:** find_file for externally created new file results in folder unable to be opened ([be2ccd4](https://github.com/nvim-tree/nvim-tree.lua/commit/be2ccd4b1a6077b53f8bfabf1e5c1775ca6dfbdc))
-* **#1728:** escape cwd changes to prevent environment variable expansion ([#1729](https://github.com/nvim-tree/nvim-tree.lua/issues/1729)) ([e204a7d](https://github.com/nvim-tree/nvim-tree.lua/commit/e204a7d819a9a065d5b1cdc6f59d2d2777d14a0f))
-* **#1731 #1723 #1716:** handle all external file system changes ([#1757](https://github.com/nvim-tree/nvim-tree.lua/issues/1757)) ([b17358f](https://github.com/nvim-tree/nvim-tree.lua/commit/b17358ff4d822deeb42b97919065800f8f91cb55))
-* **#1740:** Error while running :NvimTreeCollapseKeepBuffers ([#1741](https://github.com/nvim-tree/nvim-tree.lua/issues/1741)) ([cf90837](https://github.com/nvim-tree/nvim-tree.lua/commit/cf908370fb046641e3aaaa6a6177c1b5d165f186))
-* **#1785:** retain focused node on filter toggles ([#2202](https://github.com/nvim-tree/nvim-tree.lua/issues/2202)) ([d5d6950](https://github.com/nvim-tree/nvim-tree.lua/commit/d5d6950a0d0cc2692dfce9a1251b42f4da69136f))
-* **#1804:** do not refresh watched nodes that have been destroyed (deleted) ([d949af7](https://github.com/nvim-tree/nvim-tree.lua/commit/d949af7245c04018e0b5ed3409c4e82c1303d2ea))
-* **#1815:** don't schedule find_file calls, debounce update_focused_file with 15ms default ([#1820](https://github.com/nvim-tree/nvim-tree.lua/issues/1820)) ([623cecb](https://github.com/nvim-tree/nvim-tree.lua/commit/623cecb809c6ec35b8ddd47a57732ee2c57446f5))
-* **#1815:** don't schedule find_file calls, debounce update_focused_file with 15ms default ([#1828](https://github.com/nvim-tree/nvim-tree.lua/issues/1828)) ([87409bb](https://github.com/nvim-tree/nvim-tree.lua/commit/87409bb4afd0093193e1364faa47327fbfdfca87))
-* **#1824:** Don't modify jumplist when `edit_in_place`. ([#1825](https://github.com/nvim-tree/nvim-tree.lua/issues/1825)) ([e8ea62c](https://github.com/nvim-tree/nvim-tree.lua/commit/e8ea62c198f6e91197072350c119e8cc8e7f963a))
-* **#1831:** improve fs_scandir error handling, add profiling ([89c79cb](https://github.com/nvim-tree/nvim-tree.lua/commit/89c79cb33bc4867ccf9ee4810697da76ac59fdba))
-* **#1831:** remove error messages that were previously unreachable and add no value ([547db6e](https://github.com/nvim-tree/nvim-tree.lua/commit/547db6e9297ca9b0da95965d1760461b33b44687))
-* **#1831:** remove instrumentation ([#1968](https://github.com/nvim-tree/nvim-tree.lua/issues/1968)) ([e0166d1](https://github.com/nvim-tree/nvim-tree.lua/commit/e0166d146923fdf5df9e26b47fc164ef30ccb548))
-* **#1831:** remove instrumentation ([#1969](https://github.com/nvim-tree/nvim-tree.lua/issues/1969)) ([7eb33d2](https://github.com/nvim-tree/nvim-tree.lua/commit/7eb33d2a6d5d574a43159da90e0eac2445367393))
-* **#1831:** remove windows executable functionality due to occasional vim freeze and performance concerns ([#1868](https://github.com/nvim-tree/nvim-tree.lua/issues/1868)) ([3c4958a](https://github.com/nvim-tree/nvim-tree.lua/commit/3c4958ab3dd0e5fa470fb50b6b9cc6df48229a2e))
-* **#1833:** do not find file when view is not visible on the current tab ([#1845](https://github.com/nvim-tree/nvim-tree.lua/issues/1845)) ([9e4c395](https://github.com/nvim-tree/nvim-tree.lua/commit/9e4c39572f631bb60ee15cb9d46e1daa9927a45e))
-* **#1836:** add view.debounce_delay ([#1871](https://github.com/nvim-tree/nvim-tree.lua/issues/1871)) ([951b6e7](https://github.com/nvim-tree/nvim-tree.lua/commit/951b6e7e55da8aee9566cc0b17c11f9451cec349))
-* **#1841:** do not refresh on buffer events when highlight_opened_files is none ([4fc74ca](https://github.com/nvim-tree/nvim-tree.lua/commit/4fc74ca32157ecb275e62647fbe9cff0b8e9b9c8))
-* **#1841:** do not refresh on buffer events when not a file buffer ([#1843](https://github.com/nvim-tree/nvim-tree.lua/issues/1843)) ([e14c289](https://github.com/nvim-tree/nvim-tree.lua/commit/e14c2895b4f36a22001f7773244041c173dcf867))
-* **#1858:** deprecation warning for config.mappings.active and default ([#2084](https://github.com/nvim-tree/nvim-tree.lua/issues/2084)) ([886d852](https://github.com/nvim-tree/nvim-tree.lua/commit/886d852f6e8b73ae0ed6793bb09601b22d1f2fee))
-* **#1858:** fire TreeAttachedPost event following on_attach call ([f0a1c6a](https://github.com/nvim-tree/nvim-tree.lua/commit/f0a1c6ae2eeaefcb693dc1a319150c52e64397b0))
-* **#1878:** nvim frozen on no name buffer when modified.enable ([#1879](https://github.com/nvim-tree/nvim-tree.lua/issues/1879)) ([cdbd7da](https://github.com/nvim-tree/nvim-tree.lua/commit/cdbd7daf29db09e58a4ddc181c1be91c07184f4e))
-* **#1916:** suppress EPERM watcher failures on windows ([#1919](https://github.com/nvim-tree/nvim-tree.lua/issues/1919)) ([1b13a49](https://github.com/nvim-tree/nvim-tree.lua/commit/1b13a49f913b58a5f1792ea81c13947a7988db8e))
-* **#1923:** handle empty git icons ([#1952](https://github.com/nvim-tree/nvim-tree.lua/issues/1952)) ([8505b6e](https://github.com/nvim-tree/nvim-tree.lua/commit/8505b6ecd828e8fccb00ea59e789999311391210))
-* **#1923:** handle empty git icons ([#1987](https://github.com/nvim-tree/nvim-tree.lua/issues/1987)) ([ba1778e](https://github.com/nvim-tree/nvim-tree.lua/commit/ba1778e061f25814bc5940be886a7f41d7d7736e))
-* **#1931:** do not execute git status in git ignored directories ([#2326](https://github.com/nvim-tree/nvim-tree.lua/issues/2326)) ([273c170](https://github.com/nvim-tree/nvim-tree.lua/commit/273c1700eb68c27dce4e518efafc8144fd7ce4ab))
-* **#1940:** NvimTreeFindFileToggle focus tree ([9e87ee2](https://github.com/nvim-tree/nvim-tree.lua/commit/9e87ee2d6e86f37ff09cb74ec7dcf2ac984a01e9))
-* **#1942:** nvim-tree window options do not trigger OptionSet event ([#1945](https://github.com/nvim-tree/nvim-tree.lua/issues/1945)) ([55028e3](https://github.com/nvim-tree/nvim-tree.lua/commit/55028e30d7f897711c6469ea93a316f0f12223d4))
-* **#1946:** only change vim's global cwd on startup when opening the tree ([#1947](https://github.com/nvim-tree/nvim-tree.lua/issues/1947)) ([8567841](https://github.com/nvim-tree/nvim-tree.lua/commit/8567841b87a664e47118b178190acc364d6730f9))
-* **#1950:** disable most API until nvim-tree setup has been called ([#2125](https://github.com/nvim-tree/nvim-tree.lua/issues/2125)) ([56cdb58](https://github.com/nvim-tree/nvim-tree.lua/commit/56cdb5827d7c79611ccbe10ae6a720ee11fbde65))
-* **#1961:** cycle detection on refresh, preventing infinite loop ([#1996](https://github.com/nvim-tree/nvim-tree.lua/issues/1996)) ([4222bb8](https://github.com/nvim-tree/nvim-tree.lua/commit/4222bb875d86a2a53069c75c4833e27f58e26d90))
-* **#1961:** harden profiling functions ([#1986](https://github.com/nvim-tree/nvim-tree.lua/issues/1986)) ([b712b82](https://github.com/nvim-tree/nvim-tree.lua/commit/b712b82b0ca4eb402ced2d83f8082366989e43e0))
-* **#1961:** stop unnecessary find file refreshes, avoid find file refresh cycles ([#2010](https://github.com/nvim-tree/nvim-tree.lua/issues/2010)) ([9c97e64](https://github.com/nvim-tree/nvim-tree.lua/commit/9c97e6449b0b0269bd44e1fd4857184dfa57bb4c))
-* **#1970:** additional log function gating for efficiency when not logging ([#1971](https://github.com/nvim-tree/nvim-tree.lua/issues/1971)) ([02fdc26](https://github.com/nvim-tree/nvim-tree.lua/commit/02fdc262eba188198a7deb2117b3b996e6763d65))
-* **#1970:** disable git integration after 5 timeouts ([#1990](https://github.com/nvim-tree/nvim-tree.lua/issues/1990)) ([36e29c3](https://github.com/nvim-tree/nvim-tree.lua/commit/36e29c3a95ae606449f6616a0d8ab7247af807dc))
-* **#1976:** support non-standard `$GIT_DIR` ([#2012](https://github.com/nvim-tree/nvim-tree.lua/issues/2012)) ([517dee6](https://github.com/nvim-tree/nvim-tree.lua/commit/517dee64c150821efdc1d5adcd4285fdf9c30371))
-* **#1989:** cut/paste over open buffer ([#2279](https://github.com/nvim-tree/nvim-tree.lua/issues/2279)) ([4af5722](https://github.com/nvim-tree/nvim-tree.lua/commit/4af572246ce49883e2a52c49203a19984454f2e0))
-* **#1993:** always fire TreeOpen event ([#1994](https://github.com/nvim-tree/nvim-tree.lua/issues/1994)) ([8b8d457](https://github.com/nvim-tree/nvim-tree.lua/commit/8b8d457e07d279976a9baac6bbff5aa036afdc5f))
-* **#2003:** obey user split command for modified buffers when hidden not set ([#2008](https://github.com/nvim-tree/nvim-tree.lua/issues/2008)) ([04f99f1](https://github.com/nvim-tree/nvim-tree.lua/commit/04f99f14b5f662df722badf78c3cae7b17dc4571))
-* **#2004:** relative path detection handles regex magic ([#2005](https://github.com/nvim-tree/nvim-tree.lua/issues/2005)) ([66c15af](https://github.com/nvim-tree/nvim-tree.lua/commit/66c15afd13da5f86de52b82f38cd9d3f418d0dc3))
-* **#2024:** help handles empty mapping description ([59bcb01](https://github.com/nvim-tree/nvim-tree.lua/commit/59bcb01d3bf58b810b9c48db56e558f3857110ad))
-* **#2024:** revert removal of deprecated nvim-tree.config nvim_tree_callback ([362ecbe](https://github.com/nvim-tree/nvim-tree.lua/commit/362ecbeed69fae91a287004619decadcb6f7c113))
-* **#2057:** update focused file on new terminal ([#2060](https://github.com/nvim-tree/nvim-tree.lua/issues/2060)) ([31d8e24](https://github.com/nvim-tree/nvim-tree.lua/commit/31d8e2446025f619bbabe5289815a9f464a2d144))
-* **#2078:** :NvimTreeFindFile focuses tree ([#2080](https://github.com/nvim-tree/nvim-tree.lua/issues/2080)) ([6319ad9](https://github.com/nvim-tree/nvim-tree.lua/commit/6319ad94050c4489951ad34b6535c134a3efa455))
-* **#2081:** do not change root for inexistent files ([#2082](https://github.com/nvim-tree/nvim-tree.lua/issues/2082)) ([6515a1e](https://github.com/nvim-tree/nvim-tree.lua/commit/6515a1e1a9c0187e4fa81998a02732bf681a9103))
-* **#2086:** "Rename: Omit Filename" not removing file name ([#2087](https://github.com/nvim-tree/nvim-tree.lua/issues/2087)) ([a38f9a5](https://github.com/nvim-tree/nvim-tree.lua/commit/a38f9a55a4b55b0aa18af7abfde2c17a30959bdf))
-* **#2088:** actions change dir enable false does not update tree root ([#2095](https://github.com/nvim-tree/nvim-tree.lua/issues/2095)) ([3e9509e](https://github.com/nvim-tree/nvim-tree.lua/commit/3e9509ec1b86f2352af85dd87ed77200488471b6))
-* **#2104:** remove experimental.git.async, always used ([#2234](https://github.com/nvim-tree/nvim-tree.lua/issues/2234)) ([164eb10](https://github.com/nvim-tree/nvim-tree.lua/commit/164eb10cbd7363cbedbad768be0f98e8595c322d))
-* **#2109:** floating help window ([#2120](https://github.com/nvim-tree/nvim-tree.lua/issues/2120)) ([0a144ba](https://github.com/nvim-tree/nvim-tree.lua/commit/0a144ba50af3ef585d3d5170efea64f3d465219c))
-* **#2114:** remove deprecated non-API from lib, events ([#2121](https://github.com/nvim-tree/nvim-tree.lua/issues/2121)) ([920d5c8](https://github.com/nvim-tree/nvim-tree.lua/commit/920d5c8f7e4afebfc8e9a25ab36f7da915908838))
-* **#2126:** custom window pickers may create windows ([#2140](https://github.com/nvim-tree/nvim-tree.lua/issues/2140)) ([8f392fa](https://github.com/nvim-tree/nvim-tree.lua/commit/8f392fa763b7ee80a48c714b630acaf6d1fe1854))
-* **#2132:** focus file after rename and paste ([#2151](https://github.com/nvim-tree/nvim-tree.lua/issues/2151)) ([061a05b](https://github.com/nvim-tree/nvim-tree.lua/commit/061a05bfd91475a1001f2c972e5331b166e2a437))
-* **#2133:** harden hide_root_folder deprecation ([#2134](https://github.com/nvim-tree/nvim-tree.lua/issues/2134)) ([b601b5a](https://github.com/nvim-tree/nvim-tree.lua/commit/b601b5aa25627f68d3d73ba9269b49e4f04ce126))
-* **#2139:** API functions not passing arguments ([#2141](https://github.com/nvim-tree/nvim-tree.lua/issues/2141)) ([a8a4834](https://github.com/nvim-tree/nvim-tree.lua/commit/a8a4834e1af9fb85710bc1307298a45fae4e561c))
-* **#2154:** `find_file` doesn't work when `group_empty` option is enabled ([#2100](https://github.com/nvim-tree/nvim-tree.lua/issues/2100)) ([d8b154c](https://github.com/nvim-tree/nvim-tree.lua/commit/d8b154c5f0981886fc2b0f1e52d6172e7fdd13e4))
-* **#2154:** selection incorrect after find-file when renderer.group_empty ([#2437](https://github.com/nvim-tree/nvim-tree.lua/issues/2437)) ([d8e495b](https://github.com/nvim-tree/nvim-tree.lua/commit/d8e495b2354058276cad6dd32e3efdd1d02f4da6))
-* **#2157:** use stdpath cache for nvim-tree-on-attach.lua ([#2159](https://github.com/nvim-tree/nvim-tree.lua/issues/2159)) ([13c7146](https://github.com/nvim-tree/nvim-tree.lua/commit/13c714681f44fb712ccc2519030a33c4ad925f3f))
-* **#2175:** check number of actions.open_file.window_picker.chars before picking window ([#2177](https://github.com/nvim-tree/nvim-tree.lua/issues/2177)) ([9c60947](https://github.com/nvim-tree/nvim-tree.lua/commit/9c60947926e5fb8a04f9fb8d798a1a7ff9126992))
-* **#2191:** edit: disregard floating windows ([#2209](https://github.com/nvim-tree/nvim-tree.lua/issues/2209)) ([89816ac](https://github.com/nvim-tree/nvim-tree.lua/commit/89816ace70642e9d3db0dab3dc68918f8979ec31))
-* **#2191:** edit: disregard floating windows ([#2212](https://github.com/nvim-tree/nvim-tree.lua/issues/2212)) ([b657405](https://github.com/nvim-tree/nvim-tree.lua/commit/b6574056b52f18cbb987910c72c30f295a80318b))
-* **#2240:** disable watchers following EMFILE ([#2268](https://github.com/nvim-tree/nvim-tree.lua/issues/2268)) ([d4f6d33](https://github.com/nvim-tree/nvim-tree.lua/commit/d4f6d33496ef09018ab96e48e4f4a852d3334caf))
-* **#2293:** remove unnecessary git status during find file ([#2294](https://github.com/nvim-tree/nvim-tree.lua/issues/2294)) ([1fe3228](https://github.com/nvim-tree/nvim-tree.lua/commit/1fe32286db79719dd6e52236f82c5b52df3ccaa9))
-* **#2301:** do not show git status on grouped dirs when show_on_open_dirs ([#2303](https://github.com/nvim-tree/nvim-tree.lua/issues/2303)) ([d17389c](https://github.com/nvim-tree/nvim-tree.lua/commit/d17389ce53929cf9a1e209727121e4388dc3e013))
-* **#2301:** various git folder status fixes ([#2373](https://github.com/nvim-tree/nvim-tree.lua/issues/2373)) ([4e36850](https://github.com/nvim-tree/nvim-tree.lua/commit/4e36850811e219faf649fa68682c7699ca36007d))
-* **#2327:** set parent folder git ignore status following file update ([#2328](https://github.com/nvim-tree/nvim-tree.lua/issues/2328)) ([c1466f9](https://github.com/nvim-tree/nvim-tree.lua/commit/c1466f991a3c4cbf77f44282e3baddd4b7432f8c))
-* **#2343:** tree is now correctly abandoned upon an in-place open with eject=false ([#2344](https://github.com/nvim-tree/nvim-tree.lua/issues/2344)) ([0a89dcb](https://github.com/nvim-tree/nvim-tree.lua/commit/0a89dcb464b433d2d7b97a8f15d0b608c718dc13))
-* **#2352:** windows: escape special filename characters on edit ([#2374](https://github.com/nvim-tree/nvim-tree.lua/issues/2374)) ([7c4c7e4](https://github.com/nvim-tree/nvim-tree.lua/commit/7c4c7e4e984db6ec012b0e3df11791a118d638aa))
-* **#2370:** Better "y/N" prompts ([#2377](https://github.com/nvim-tree/nvim-tree.lua/issues/2377)) ([920868d](https://github.com/nvim-tree/nvim-tree.lua/commit/920868dba13466586897a8f40220eca6b2caac41))
-* **#2382:** git watcher handles worktrees and submodules, via --absolute-git-dir when it is available ([#2389](https://github.com/nvim-tree/nvim-tree.lua/issues/2389)) ([28c3980](https://github.com/nvim-tree/nvim-tree.lua/commit/28c3980b25e50e9ede39df55427151cb11be46f9))
-* **#2386:** kill git zombies ([#2401](https://github.com/nvim-tree/nvim-tree.lua/issues/2401)) ([5897b36](https://github.com/nvim-tree/nvim-tree.lua/commit/5897b3622f033b1f3ea6adf8eb1c165e9f20554f))
-* **#2392:** bookmarks icon placement when group_empty ([#2402](https://github.com/nvim-tree/nvim-tree.lua/issues/2402)) ([b856d0a](https://github.com/nvim-tree/nvim-tree.lua/commit/b856d0a0c3238e49d6385d830ea8c7785b1eccc8))
-* **#2440:** `view.width.padding` may be a number or function returning a number ([#2442](https://github.com/nvim-tree/nvim-tree.lua/issues/2442)) ([e153d9f](https://github.com/nvim-tree/nvim-tree.lua/commit/e153d9f5991ef275df46161a5100949847229538))
-* **#2450:** apply NvimTreeImageFile for webp and jxl files ([#2451](https://github.com/nvim-tree/nvim-tree.lua/issues/2451)) ([94e572e](https://github.com/nvim-tree/nvim-tree.lua/commit/94e572e14190c47378f3afe9b60865ace7fa933e))
-* **#2459:** disable cygwin git support by default, see :help nvim-tree.git.cygwin_support to enable ([#2486](https://github.com/nvim-tree/nvim-tree.lua/issues/2486)) ([db8145c](https://github.com/nvim-tree/nvim-tree.lua/commit/db8145c27d7a1489b5a0d4fcdd6291d0fbd55a09))
-* **#2467:** remove newline in git paths when using cygwin_support ([#2478](https://github.com/nvim-tree/nvim-tree.lua/issues/2478)) ([7c5c074](https://github.com/nvim-tree/nvim-tree.lua/commit/7c5c0743541e8ffb8874fee732adcc400fa652f4))
-* **#2468:** always apply filters to subdirectories ([#2537](https://github.com/nvim-tree/nvim-tree.lua/issues/2537)) ([fb89297](https://github.com/nvim-tree/nvim-tree.lua/commit/fb892973477e131042d737c9fc822c7c2ace5076))
-* **#2473:** remove problematic <S-Tab> default mapping ([#2475](https://github.com/nvim-tree/nvim-tree.lua/issues/2475)) ([40b9b88](https://github.com/nvim-tree/nvim-tree.lua/commit/40b9b887d090d5da89a84689b4ca0304a9649f62))
-* **#2495:** skip API action if node == nil ([#2499](https://github.com/nvim-tree/nvim-tree.lua/issues/2499)) ([7630cf4](https://github.com/nvim-tree/nvim-tree.lua/commit/7630cf4a92b69cc22347894c81cc03966b2a7bcf))
-* **#2507:** icon in message after rename-file ([#2510](https://github.com/nvim-tree/nvim-tree.lua/issues/2510)) ([20a0707](https://github.com/nvim-tree/nvim-tree.lua/commit/20a0707e0ffa301eb7ef682664f37e2955354f7a))
-* **#2512:** file creation in empty folder without root_folder_label ([#2514](https://github.com/nvim-tree/nvim-tree.lua/issues/2514)) ([4ee6366](https://github.com/nvim-tree/nvim-tree.lua/commit/4ee6366ff1fc5d66231516ed05beffb50004261b))
-* **#2516:** diagnostics icon highlight group matches the documentation: NvimTreeLspDiagnosticsInfo -> Information ([#2518](https://github.com/nvim-tree/nvim-tree.lua/issues/2518)) ([46e1f77](https://github.com/nvim-tree/nvim-tree.lua/commit/46e1f776f0a714099b9160604fbb62fba2540376))
-* **#2523:** live filter overlay width calculation ([#2524](https://github.com/nvim-tree/nvim-tree.lua/issues/2524)) ([80cfead](https://github.com/nvim-tree/nvim-tree.lua/commit/80cfeadf179d5cba76f0f502c71dbcff1b515cd8))
-* **#549:** add more profiling ~tree init ([95ed588](https://github.com/nvim-tree/nvim-tree.lua/commit/95ed5882114ab481e93362aa74c0f3c65dc4aade))
-* `api.node.open.preview` should toggle directories ([#2099](https://github.com/nvim-tree/nvim-tree.lua/issues/2099)) ([7ad1c20](https://github.com/nvim-tree/nvim-tree.lua/commit/7ad1c204c4113b5ce4cc9244ff93a406db810a64))
-* **actions:** change_dir to wrong directory ([#1398](https://github.com/nvim-tree/nvim-tree.lua/issues/1398)) ([269820e](https://github.com/nvim-tree/nvim-tree.lua/commit/269820e800f6652fac3e0ff66a1463121f2f0ff4))
-* **actions:** close_node doesn't close for grouped node ([#1385](https://github.com/nvim-tree/nvim-tree.lua/issues/1385)) ([ec09b80](https://github.com/nvim-tree/nvim-tree.lua/commit/ec09b80c7bbf8a34c82b6de5f0a67ff78cbc8ae0))
-* **actions:** create file should defer more to focus ([0fa2ec1](https://github.com/nvim-tree/nvim-tree.lua/commit/0fa2ec1950a5ef20b692781f18ad9185987bb705))
-* **actions:** dispatching filter should not match for "live" keyword ([0f96e32](https://github.com/nvim-tree/nvim-tree.lua/commit/0f96e32326a842798b6b8e638a91464521e4ef71)), closes [#1420](https://github.com/nvim-tree/nvim-tree.lua/issues/1420)
-* add legacy options safety ([f742b86](https://github.com/nvim-tree/nvim-tree.lua/commit/f742b86852948f11dcca5735d2af17b75dafee5f))
-* **api:** copy is a table, copy -> copy.name ([a044818](https://github.com/nvim-tree/nvim-tree.lua/commit/a0448184af1fe374779d103ab0aed47431ab75e8)), closes [#1461](https://github.com/nvim-tree/nvim-tree.lua/issues/1461)
-* **api:** use copy.node instead of copy.name ([e95bfbf](https://github.com/nvim-tree/nvim-tree.lua/commit/e95bfbfc2d1c5bd2684c4607e4bc1b27399416e7)), closes [#1461](https://github.com/nvim-tree/nvim-tree.lua/issues/1461)
-* **change-dir:** cd command concatenation ([eb6dde4](https://github.com/nvim-tree/nvim-tree.lua/commit/eb6dde4733a27c87b42d74f962e62f33730365c6))
-* **ci:** stylua action version number ([43fd138](https://github.com/nvim-tree/nvim-tree.lua/commit/43fd13854423666c53439536892a5fbc4a66044c))
-* cleanup live filter scratch buffers ([#2522](https://github.com/nvim-tree/nvim-tree.lua/issues/2522)) ([74ddb8f](https://github.com/nvim-tree/nvim-tree.lua/commit/74ddb8f2bb5d0a0f4952afb4356ed954f18d5e9e))
-* close view before hijacking current window ([28c4bb0](https://github.com/nvim-tree/nvim-tree.lua/commit/28c4bb01f64a4f806c66781375b47767225ec94c))
-* **colorscheme:** update winhl on colorscheme change ([65c2ba8](https://github.com/nvim-tree/nvim-tree.lua/commit/65c2ba895213c3641fc58dd33bc7a44423a6cdbe)), closes [#1696](https://github.com/nvim-tree/nvim-tree.lua/issues/1696)
-* **copy-paste:** fix message on clipboard clear ([#1838](https://github.com/nvim-tree/nvim-tree.lua/issues/1838)) ([e0cfbbb](https://github.com/nvim-tree/nvim-tree.lua/commit/e0cfbbb93dc66ea51a148f206a49e82ae6bb0368))
-* count unicode codepoints instead of bytes ([#1445](https://github.com/nvim-tree/nvim-tree.lua/issues/1445)) ([1e3c578](https://github.com/nvim-tree/nvim-tree.lua/commit/1e3c578eebc854029a7bd6d67dd20a67e3edc38b))
-* **create-file:** pass file in parameter ([1018a83](https://github.com/nvim-tree/nvim-tree.lua/commit/1018a83e10c112efc38b11123d74f9f6c9ea16b6))
-* **create-file:** when node is nil, create the file at root ([e632ac7](https://github.com/nvim-tree/nvim-tree.lua/commit/e632ac7c8116ed0ed2e865b4b3e0a17a78de8081)), closes [#1467](https://github.com/nvim-tree/nvim-tree.lua/issues/1467)
-* **diagnostics:** coc obey diagnostics.severity ([#2072](https://github.com/nvim-tree/nvim-tree.lua/issues/2072)) ([874b7be](https://github.com/nvim-tree/nvim-tree.lua/commit/874b7be5d053f1b31f545099d6fcbe8ae81e9e03))
-* **diagnostics:** do not show on file/dir with same prefix ([fee6801](https://github.com/nvim-tree/nvim-tree.lua/commit/fee68013931b1a208118498d8f7f77858c5f26e0))
-* **diagnostics:** do not show on file/dir with same prefix ([#1832](https://github.com/nvim-tree/nvim-tree.lua/issues/1832)) ([3000797](https://github.com/nvim-tree/nvim-tree.lua/commit/3000797e53bab88b9e427655c6164ad1216f68be))
-* **dispatch:** dispatch help toggle when its not shown ([95c57e0](https://github.com/nvim-tree/nvim-tree.lua/commit/95c57e034a1921dc1e0dab2f43f8ff87596e0979)), closes [#1411](https://github.com/nvim-tree/nvim-tree.lua/issues/1411)
-* **doc:** duplicate help tag in README ([#2066](https://github.com/nvim-tree/nvim-tree.lua/issues/2066)) ([a50723e](https://github.com/nvim-tree/nvim-tree.lua/commit/a50723e35f57f89fb67019127a16d90f16edfef8))
-* **docs:** typos ([#1470](https://github.com/nvim-tree/nvim-tree.lua/issues/1470)) ([2928f8f](https://github.com/nvim-tree/nvim-tree.lua/commit/2928f8fe31bacc287a988e02b7fe930f19c6a972))
-* ensure startup warnings are visible with a multiline message, to work around https://github.com/neovim/neovim/issues/17832 planned for fix in nvim 0.10 ([#2387](https://github.com/nvim-tree/nvim-tree.lua/issues/2387)) ([807dc05](https://github.com/nvim-tree/nvim-tree.lua/commit/807dc051560afda30956320ed718def878f655f0))
-* error when deleting opened file from floating window ([#2503](https://github.com/nvim-tree/nvim-tree.lua/issues/2503)) ([24bb0ed](https://github.com/nvim-tree/nvim-tree.lua/commit/24bb0ed806f0984906fc65940b31cd0107229946))
-* **executable:** prevent nil extensions in executable check ([630305c](https://github.com/nvim-tree/nvim-tree.lua/commit/630305c233b815464d57bc253444610eb327d255)), closes [#1444](https://github.com/nvim-tree/nvim-tree.lua/issues/1444)
-* expand and collapse whole folder groups ([#2380](https://github.com/nvim-tree/nvim-tree.lua/issues/2380)) ([0074120](https://github.com/nvim-tree/nvim-tree.lua/commit/00741206c2df9c4b538055def19b99790f0c95c8))
-* **explorer:** reload `executable` stat ([#1427](https://github.com/nvim-tree/nvim-tree.lua/issues/1427)) ([b754eb8](https://github.com/nvim-tree/nvim-tree.lua/commit/b754eb8359837900044ea414d2edeff495e6bdb1))
-* **file rename:** edit buffer when renaming to reset filetype ([90bf140](https://github.com/nvim-tree/nvim-tree.lua/commit/90bf14014e8b31c1a96c23a9583bf89028da13e2))
-* **find-file:** do not recurse on closed nodes ([9d3602e](https://github.com/nvim-tree/nvim-tree.lua/commit/9d3602e8eab27ffb88cb89f2a938a127acd86c42))
-* focus visible parent on collapse all ([#2261](https://github.com/nvim-tree/nvim-tree.lua/issues/2261)) ([f873625](https://github.com/nvim-tree/nvim-tree.lua/commit/f873625d0636889af4cd47a01e486beb865db205))
-* fs_watcher not started for .git folders (windows) ([#2265](https://github.com/nvim-tree/nvim-tree.lua/issues/2265)) ([f5804ce](https://github.com/nvim-tree/nvim-tree.lua/commit/f5804ce94e06966e0fc1aba9c697c178fc7cb210))
-* **fs:** create file failure when reloading watch path for node ([3d58a9b](https://github.com/nvim-tree/nvim-tree.lua/commit/3d58a9b2cfd7146e2f38b101bbc860e4c80a0ceb)), closes [#1633](https://github.com/nvim-tree/nvim-tree.lua/issues/1633)
-* **get-node-from-path:** group dirs should be returned before nodes ([4bd919a](https://github.com/nvim-tree/nvim-tree.lua/commit/4bd919a75f37c7127ccfc746fc59a71068db3ceb))
-* git highlight for new staged files ([#2534](https://github.com/nvim-tree/nvim-tree.lua/issues/2534)) ([8f9169a](https://github.com/nvim-tree/nvim-tree.lua/commit/8f9169a05931041aad1a0719e82eb02cea528881))
-* **git:** fix inverted condition logic introduced in [#1433](https://github.com/nvim-tree/nvim-tree.lua/issues/1433) ([#1443](https://github.com/nvim-tree/nvim-tree.lua/issues/1443)) ([c964fa2](https://github.com/nvim-tree/nvim-tree.lua/commit/c964fa24d0e6cc7d77d46e29c03f6f004af1578c))
-* **git:** git folder fixes and improvements ([#1809](https://github.com/nvim-tree/nvim-tree.lua/issues/1809)) ([29788cc](https://github.com/nvim-tree/nvim-tree.lua/commit/29788cc32a153e42b2fe48344d315da8367fc6fa))
-* **git:** git rename not showing up for the renamed file ([#1783](https://github.com/nvim-tree/nvim-tree.lua/issues/1783)) ([f8489c9](https://github.com/nvim-tree/nvim-tree.lua/commit/f8489c992998e1e1b45aec65bdb9615e5cd59a61))
-* **git:** prevent execution of git commands when git integration is disabled ([#1433](https://github.com/nvim-tree/nvim-tree.lua/issues/1433)) ([203bb7e](https://github.com/nvim-tree/nvim-tree.lua/commit/203bb7e176fc0d00fddceabf12bebfe87bb8da02))
-* harden git status updates ([#2533](https://github.com/nvim-tree/nvim-tree.lua/issues/2533)) ([633811c](https://github.com/nvim-tree/nvim-tree.lua/commit/633811c53d3b7856cab8e96b91c6a5d2cf9eb8ae))
-* harden tree root cwd fetch ([#2557](https://github.com/nvim-tree/nvim-tree.lua/issues/2557)) ([5e4475d](https://github.com/nvim-tree/nvim-tree.lua/commit/5e4475d8bf7a3646164e01d9b65ef68369b17e3c))
-* help window header is minimum width ([#2149](https://github.com/nvim-tree/nvim-tree.lua/issues/2149)) ([5b53732](https://github.com/nvim-tree/nvim-tree.lua/commit/5b5373254f572de1fb65a7046fbd61bbffe6da05))
-* **help:** clear git signs before draw ([b81ab19](https://github.com/nvim-tree/nvim-tree.lua/commit/b81ab199a513f0c5c099f7be3f230ce796f5ad12))
-* Implicit current buf on centralize selection ([#1792](https://github.com/nvim-tree/nvim-tree.lua/issues/1792)) ([0cd8ac4](https://github.com/nvim-tree/nvim-tree.lua/commit/0cd8ac4751c39440a1c28c6be4704f3597807d29))
-* info size suffix and formatting ([#2492](https://github.com/nvim-tree/nvim-tree.lua/issues/2492)) ([a31dfad](https://github.com/nvim-tree/nvim-tree.lua/commit/a31dfada1d0d177f88bc0b7e27365b08446788bb))
-* inverted diagnostic navigation keymaps ([81eb718](https://github.com/nvim-tree/nvim-tree.lua/commit/81eb718394e489d2aebbffa730d2517d72ec7f9c))
-* **iterators:** the index does not increase ([#1399](https://github.com/nvim-tree/nvim-tree.lua/issues/1399)) ([418fc97](https://github.com/nvim-tree/nvim-tree.lua/commit/418fc971fc22a501cbc09b5f7425129b7c95130d))
-* **keymaps:** get_keymaps takes remove_keymaps as parameter ([9bbf95e](https://github.com/nvim-tree/nvim-tree.lua/commit/9bbf95e61691feb6696880701cdb1b6cafa97d41))
-* **keypress:** use <cmd> instead of `:` to avoid triggering CmdLineEnter ([7087af8](https://github.com/nvim-tree/nvim-tree.lua/commit/7087af83f3a003913ed280eb3bdffe3a46a601c6)), closes [#1417](https://github.com/nvim-tree/nvim-tree.lua/issues/1417)
-* nerd font 3 bookmark icon ([#2203](https://github.com/nvim-tree/nvim-tree.lua/issues/2203)) ([498e879](https://github.com/nvim-tree/nvim-tree.lua/commit/498e8793bbe73ab5235b3ee8f0aee32f5d01649f))
-* **notify:** log file notice info->debug ([cc18122](https://github.com/nvim-tree/nvim-tree.lua/commit/cc18122be1c53e6736f4f7a75a32429b3bbca2a0))
-* **notify:** remove unused varargs, log file notice debug->info ([a65063c](https://github.com/nvim-tree/nvim-tree.lua/commit/a65063cb0a67c0794da9aa6fc8ac0e64f614daf7))
-* **open-file:** focus file if already opened ([4900d66](https://github.com/nvim-tree/nvim-tree.lua/commit/4900d66370988108dbe0f57cb8a2fc090878f73d))
-* **open-file:** vim.op -> vim.opt ([2edbe75](https://github.com/nvim-tree/nvim-tree.lua/commit/2edbe759cd45d4a7a3ae0c6e05f5b54860775f98))
-* **paste:** allow pasting into empty root directory ([1837751](https://github.com/nvim-tree/nvim-tree.lua/commit/1837751efb5fcfc584cb0ee900f09ff911cd6c0b)), closes [#1736](https://github.com/nvim-tree/nvim-tree.lua/issues/1736)
-* **paste:** paste into empty root directory ([059e4ca](https://github.com/nvim-tree/nvim-tree.lua/commit/059e4cadd658229ff7a5f9b56064be87f52cc6cd))
-* **perf:** explorer was creating new table for each new entry ([665813b](https://github.com/nvim-tree/nvim-tree.lua/commit/665813b9e6e247c633346b861e08f03e44e3ac91))
-* prompt uses first character of response - allow "yy" ([#2357](https://github.com/nvim-tree/nvim-tree.lua/issues/2357)) ([904f95c](https://github.com/nvim-tree/nvim-tree.lua/commit/904f95cd9db31d1800998fa428e78e418a50181d))
-* **prompt:** add select_prompts to suit UI decorator plugins such as dressing and telescope ([ac8d259](https://github.com/nvim-tree/nvim-tree.lua/commit/ac8d259badf915cd9aaad406503d116230296c44))
-* reload tree on `BufEnter` if cwd is different ([#2527](https://github.com/nvim-tree/nvim-tree.lua/issues/2527)) ([874ae6e](https://github.com/nvim-tree/nvim-tree.lua/commit/874ae6e9445a5eb5ba430e5fd10212450a261ad7))
-* remove redundant file existence check in create file operation ([#1936](https://github.com/nvim-tree/nvim-tree.lua/issues/1936)) ([16f2806](https://github.com/nvim-tree/nvim-tree.lua/commit/16f2806d5968157fd6f76542c9ac358c684a3a03))
-* remove unnecessary conditions ([#1614](https://github.com/nvim-tree/nvim-tree.lua/issues/1614)) ([45d386a](https://github.com/nvim-tree/nvim-tree.lua/commit/45d386a3591f87390390c0d718a81e05895465ca))
-* **renderer:** indent markers + folder arrows should offset ([8632ac2](https://github.com/nvim-tree/nvim-tree.lua/commit/8632ac273979d5ec22ecee9c23aba18a73345584)), closes [#1421](https://github.com/nvim-tree/nvim-tree.lua/issues/1421)
-* **renderer:** indent markers with arrows ([9a02ded](https://github.com/nvim-tree/nvim-tree.lua/commit/9a02dedd92fad67b04b2a3fee2de20555956b089))
-* **renderer:** padding indent with folders only ([449b5bd](https://github.com/nvim-tree/nvim-tree.lua/commit/449b5bd0cbe08192ded83b2bce8cbec4764da63d))
-* replace vim.* "requires" with explicit calls to vim functions ([#1701](https://github.com/nvim-tree/nvim-tree.lua/issues/1701)) ([8cc3696](https://github.com/nvim-tree/nvim-tree.lua/commit/8cc369695b3a0ae3ddf9538bc1f87bbf8cdbecca))
-* restore eventignore ([#1612](https://github.com/nvim-tree/nvim-tree.lua/issues/1612)) ([11b5248](https://github.com/nvim-tree/nvim-tree.lua/commit/11b524899fc4d9a79e1b5632bd84dcc5b06da3aa))
-* schedule notifications to avoid UI freeze on startup ([#2432](https://github.com/nvim-tree/nvim-tree.lua/issues/2432)) ([ce3495b](https://github.com/nvim-tree/nvim-tree.lua/commit/ce3495bd4c9a7d8e8a64fac9cc3c252dac19a994))
-* **scripts:** default mappings should put a comma at the end of each line ([08ab346](https://github.com/nvim-tree/nvim-tree.lua/commit/08ab346f0312433b3f10a4a10f4b69d98138d38f))
-* sort_by "extension" falls back to name ([#2306](https://github.com/nvim-tree/nvim-tree.lua/issues/2306)) ([04b2c1e](https://github.com/nvim-tree/nvim-tree.lua/commit/04b2c1e08c32cf1620b9404d8417f415b6ec7aad))
-* **styling:** empty line ([4aef454](https://github.com/nvim-tree/nvim-tree.lua/commit/4aef454cd29bc69ae7d6c4737ba8570149d92f4f))
-* **system-open:** use notify for system-open failures and tidy messages ([9d241e5](https://github.com/nvim-tree/nvim-tree.lua/commit/9d241e5f5889cf8d37c3a8054b3e55157549c283))
-* trash.cmd defaults to 'trash' on macos and windows, document option ([#2336](https://github.com/nvim-tree/nvim-tree.lua/issues/2336)) ([0a54dcb](https://github.com/nvim-tree/nvim-tree.lua/commit/0a54dcb76b02f3a4e2da370c7a3f6f2b7b43ef01))
-* **trash:** do not run trash command when trash is not executable ([cbbc799](https://github.com/nvim-tree/nvim-tree.lua/commit/cbbc799e6c5784fba9b6a842000caaebf07fa122))
-* type annotations for utils.is_nvim_tree_buf ([#2180](https://github.com/nvim-tree/nvim-tree.lua/issues/2180)) ([270c955](https://github.com/nvim-tree/nvim-tree.lua/commit/270c95556cad96d18ca547d86ae65927334b108b))
-* typo on clipboard notify ([#2032](https://github.com/nvim-tree/nvim-tree.lua/issues/2032)) ([6117582](https://github.com/nvim-tree/nvim-tree.lua/commit/6117582578d2e5b81212f04db4ad206836bcd24a))
-* use pcall to prevent live-filter regex errors ([#1689](https://github.com/nvim-tree/nvim-tree.lua/issues/1689)) ([3845039](https://github.com/nvim-tree/nvim-tree.lua/commit/3845039c1a47ad0759a1ec7deb6f2ffb4421d175))
-* **view:** do not close window when NvimTree buffer is replaced ([#1391](https://github.com/nvim-tree/nvim-tree.lua/issues/1391)) ([40e515d](https://github.com/nvim-tree/nvim-tree.lua/commit/40e515df87e164454b4df12b7c97a805dd8d2bb8))
-* **view:** file filter and info popup above floating view ([d753a1d](https://github.com/nvim-tree/nvim-tree.lua/commit/d753a1da9a58339f1751db96d37e9b318be91825))
-* **view:** prevent buffer override when actions.open_file.quit_on_open ([e82a921](https://github.com/nvim-tree/nvim-tree.lua/commit/e82a921baab36e9220b31c315b3dc816d6b892c9))
-* **view:** refresh opened files highlight on buffer read, unload  ([#1827](https://github.com/nvim-tree/nvim-tree.lua/issues/1827)) ([18272f8](https://github.com/nvim-tree/nvim-tree.lua/commit/18272f8df3aac2f59dfa31b268c62e0611fbc6c3))
-* **watcher:** failure on watcher teardown message ([#1726](https://github.com/nvim-tree/nvim-tree.lua/issues/1726)) ([6d6a446](https://github.com/nvim-tree/nvim-tree.lua/commit/6d6a44626d4dec58bb61bd40d5bd63d69818c540))
-* **watcher:** only purge on subsequent setup calls, add git_purge log ([899ed45](https://github.com/nvim-tree/nvim-tree.lua/commit/899ed45602090ec9f61a2ed69d218d246e7e035a))
-* **watchers:** disable watchers on kernel filesystems ([ac90664](https://github.com/nvim-tree/nvim-tree.lua/commit/ac906640011df013ca3dd19b6dc71a4fec67cf85)), closes [#1465](https://github.com/nvim-tree/nvim-tree.lua/issues/1465)
-* window picker can't be correctly rendered when cmdheight = 0 ([#1349](https://github.com/nvim-tree/nvim-tree.lua/issues/1349)) ([79258f1](https://github.com/nvim-tree/nvim-tree.lua/commit/79258f1d670277016523e13c0a88daa25070879f))
-* **wipe:** wipe all nvim-tree rogue buffers ([ec530e7](https://github.com/nvim-tree/nvim-tree.lua/commit/ec530e73beec547e04efb11a4f17c912d750c626)), closes [#1438](https://github.com/nvim-tree/nvim-tree.lua/issues/1438)
+* **#3077:** deleting a directory containing symlinked directory will delete the contents of the linked directory ([#3168](https://github.com/nvim-tree/nvim-tree.lua/issues/3168)) ([10db694](https://github.com/nvim-tree/nvim-tree.lua/commit/10db6943cb40625941a35235eeb385ffdfbf827a))
+* **#3157:** add view.cursorlineopt ([8eb5e0b](https://github.com/nvim-tree/nvim-tree.lua/commit/8eb5e0bfd1c4da6efc03ab0c1ccf463dbaae831e))
+* **#3172:** live filter exception ([#3173](https://github.com/nvim-tree/nvim-tree.lua/issues/3173)) ([0a7fcdf](https://github.com/nvim-tree/nvim-tree.lua/commit/0a7fcdf3f8ba208f4260988a198c77ec11748339))
+* invalid window id for popup info window ([#3147](https://github.com/nvim-tree/nvim-tree.lua/issues/3147)) ([d54a187](https://github.com/nvim-tree/nvim-tree.lua/commit/d54a1875a91e1a705795ea26074795210b92ce7f))
+* **picker:** exclude full_name window id from the choice ([#3165](https://github.com/nvim-tree/nvim-tree.lua/issues/3165)) ([543ed3c](https://github.com/nvim-tree/nvim-tree.lua/commit/543ed3cac212dc3993ef9f042f6c0812e34ddd43))
+* window picker ignore hidden window ([#3145](https://github.com/nvim-tree/nvim-tree.lua/issues/3145)) ([d87b41c](https://github.com/nvim-tree/nvim-tree.lua/commit/d87b41ca537e2131622d48a6c25ccf2fbe0e5d62))
+
+
+### Performance Improvements
+
+* **#3171:** cache toplevel for untracked ([#3185](https://github.com/nvim-tree/nvim-tree.lua/issues/3185)) ([4425136](https://github.com/nvim-tree/nvim-tree.lua/commit/442513648c6936e754c3308a1c58591a399493e5))
+* **#3171:** use vim.system() instead of vim.fn.system() to execute git toplevel ([#3175](https://github.com/nvim-tree/nvim-tree.lua/issues/3175)) ([9a05b9e](https://github.com/nvim-tree/nvim-tree.lua/commit/9a05b9e9f928856ca23dbf876fab372003180c3f))
+
+
+### Reverts
+
+* **#3180, #3177:** invalid group or tabpage ([#3181](https://github.com/nvim-tree/nvim-tree.lua/issues/3181)) ([9b289ab](https://github.com/nvim-tree/nvim-tree.lua/commit/9b289abd6998e30fd24cbc9919e0b0cbed6364ce))
+* **#3180, #3177:** resolve live filter failures ([#3183](https://github.com/nvim-tree/nvim-tree.lua/issues/3183)) ([a4699c0](https://github.com/nvim-tree/nvim-tree.lua/commit/a4699c0904103e7767334f6da05f5c2ea5514845))
+
+## [1.13.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.12.0...nvim-tree-v1.13.0) (2025-06-14)
+
+
+### Features
+
+* **#3113:** add renderer.icons.folder_arrow_padding ([#3114](https://github.com/nvim-tree/nvim-tree.lua/issues/3114)) ([ea5097a](https://github.com/nvim-tree/nvim-tree.lua/commit/ea5097a1e2702b4827cb7380e7fa0bd6da87699c))
+* **#3132:** add api.node.expand and api.node.collapse ([#3133](https://github.com/nvim-tree/nvim-tree.lua/issues/3133)) ([ae59561](https://github.com/nvim-tree/nvim-tree.lua/commit/ae595611fb2225f2041996c042aa4e4b8663b41e))
+
+
+### Bug Fixes
+
+* "Invalid buffer id" on closing nvim-tree window ([#3129](https://github.com/nvim-tree/nvim-tree.lua/issues/3129)) ([25d16aa](https://github.com/nvim-tree/nvim-tree.lua/commit/25d16aab7d29ca940a9feb92e6bb734697417009))
+* **#2746:** background and right aligned icons in floating windows ([#3128](https://github.com/nvim-tree/nvim-tree.lua/issues/3128)) ([cbc3165](https://github.com/nvim-tree/nvim-tree.lua/commit/cbc3165e08893bb499da035c6f6f9d1512b57664))
+* **#3117:** allow changing filename's casing ([bd54d1d](https://github.com/nvim-tree/nvim-tree.lua/commit/bd54d1d33c20d8630703b9842480291588dbad07))
+* **#3117:** windows: change file/dir case ([#3135](https://github.com/nvim-tree/nvim-tree.lua/issues/3135)) ([bd54d1d](https://github.com/nvim-tree/nvim-tree.lua/commit/bd54d1d33c20d8630703b9842480291588dbad07))
+* **#3122:** remove redundant vim.validate ([#3123](https://github.com/nvim-tree/nvim-tree.lua/issues/3123)) ([e7d1b7d](https://github.com/nvim-tree/nvim-tree.lua/commit/e7d1b7dadc62fe2eccc17d814354b0a5688621ce))
+* **#3124:** fix icon padding for "right_align" placements, notably for dotfiles ([#3125](https://github.com/nvim-tree/nvim-tree.lua/issues/3125)) ([e4cd856](https://github.com/nvim-tree/nvim-tree.lua/commit/e4cd856ebf4fec51db10c69d63e43224b701cbce))
+* **#3124:** prevent empty icons_right_align response from breaking padding ([e4cd856](https://github.com/nvim-tree/nvim-tree.lua/commit/e4cd856ebf4fec51db10c69d63e43224b701cbce))
+* **#3134:** setting one glyph to "" no longer disables others ([#3136](https://github.com/nvim-tree/nvim-tree.lua/issues/3136)) ([ebcaccd](https://github.com/nvim-tree/nvim-tree.lua/commit/ebcaccda1c575fa19a8087445276e6671e2b9b37))
+* **#3143:** actions.open_file.window_picker.exclude applies when not using window picker ([#3144](https://github.com/nvim-tree/nvim-tree.lua/issues/3144)) ([05d8172](https://github.com/nvim-tree/nvim-tree.lua/commit/05d8172ebf9cdb2d140cf25b75625374fbc3df7f))
+* fixes [#3134](https://github.com/nvim-tree/nvim-tree.lua/issues/3134) ([ebcaccd](https://github.com/nvim-tree/nvim-tree.lua/commit/ebcaccda1c575fa19a8087445276e6671e2b9b37))
+* invalid buffer issue ([25d16aa](https://github.com/nvim-tree/nvim-tree.lua/commit/25d16aab7d29ca940a9feb92e6bb734697417009))
+
+## [1.12.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.11.0...nvim-tree-v1.12.0) (2025-04-20)
+
+
+### Features
+
+* add TreePreOpen event ([#3105](https://github.com/nvim-tree/nvim-tree.lua/issues/3105)) ([c24c047](https://github.com/nvim-tree/nvim-tree.lua/commit/c24c0470d9de277fbebecd718f33561ed7c90298))
+
+
+### Bug Fixes
+
+* **#3101:** when renderer.highlight_opened_files = "none" do not reload on BufUnload and BufReadPost ([#3102](https://github.com/nvim-tree/nvim-tree.lua/issues/3102)) ([5bea2b3](https://github.com/nvim-tree/nvim-tree.lua/commit/5bea2b37523a31288e0fcab42f3be5c1bd4516bb))
+* explicitly set `border` to `"none"` in full name float ([#3094](https://github.com/nvim-tree/nvim-tree.lua/issues/3094)) ([c3c1935](https://github.com/nvim-tree/nvim-tree.lua/commit/c3c193594213c5e2f89ec5d7729cad805f76b256))
+* reliably dispatch exactly one TreeOpen and TreeClose events ([#3107](https://github.com/nvim-tree/nvim-tree.lua/issues/3107)) ([3a63717](https://github.com/nvim-tree/nvim-tree.lua/commit/3a63717d3d332d8f39aaf65be7a0e4c2265af021))
+
+## [1.11.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.10.0...nvim-tree-v1.11.0) (2025-02-22)
+
+
+### Features
+
+* **#1984:** add quit_on_open and focus opts to various api.node.open functions ([#3054](https://github.com/nvim-tree/nvim-tree.lua/issues/3054)) ([3281f33](https://github.com/nvim-tree/nvim-tree.lua/commit/3281f331f7f0bef13eb00fb2d5a9d28b2f6155a2))
+* **#3037:** add API node.buffer.delete, node.buffer.wipe ([#3040](https://github.com/nvim-tree/nvim-tree.lua/issues/3040)) ([fee1da8](https://github.com/nvim-tree/nvim-tree.lua/commit/fee1da88972f5972a8296813f6c00d7598325ebd))
+
+
+### Bug Fixes
+
+* **#3045:** wipe scratch buffers for full name and show info popups ([#3050](https://github.com/nvim-tree/nvim-tree.lua/issues/3050)) ([fca0b67](https://github.com/nvim-tree/nvim-tree.lua/commit/fca0b67c0b5a31727fb33addc4d9c100736a2894))
+* **#3059:** test for presence of new 0.11 API vim.hl.range ([#3060](https://github.com/nvim-tree/nvim-tree.lua/issues/3060)) ([70825f2](https://github.com/nvim-tree/nvim-tree.lua/commit/70825f23db61ecd900c4cfea169bffe931926a9d))
+* arithmetic on nil value error on first git project open ([#3064](https://github.com/nvim-tree/nvim-tree.lua/issues/3064)) ([8052310](https://github.com/nvim-tree/nvim-tree.lua/commit/80523101f0ae48b7f1990e907b685a3d79776c01))
+* stl and stlnc fillchars are hidden in window picker ([b699143](https://github.com/nvim-tree/nvim-tree.lua/commit/b69914325a945ee5157f0d21047210b42af5776e))
+* window picker: hide fillchars: stl and stlnc ([#3066](https://github.com/nvim-tree/nvim-tree.lua/issues/3066)) ([b699143](https://github.com/nvim-tree/nvim-tree.lua/commit/b69914325a945ee5157f0d21047210b42af5776e))
+
+## [1.10.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.9.0...nvim-tree-v1.10.0) (2025-01-13)
+
+
+### Features
+
+* **api:** add node.open.vertical_no_picker, node.open.horizontal_no_picker ([#3031](https://github.com/nvim-tree/nvim-tree.lua/issues/3031)) ([68fc4c2](https://github.com/nvim-tree/nvim-tree.lua/commit/68fc4c20f5803444277022c681785c5edd11916d))
+
+
+### Bug Fixes
+
+* **#3015:** dynamic width no longer truncates on right_align icons ([#3022](https://github.com/nvim-tree/nvim-tree.lua/issues/3022)) ([f7b76cd](https://github.com/nvim-tree/nvim-tree.lua/commit/f7b76cd1a75615c8d6254fc58bedd2a7304eb7d8))
+* **#3018:** error when focusing nvim-tree when in terminal mode ([#3019](https://github.com/nvim-tree/nvim-tree.lua/issues/3019)) ([db8d7ac](https://github.com/nvim-tree/nvim-tree.lua/commit/db8d7ac1f524fc6f808764b29fa695c51e014aa6))
+* **#3041:** use vim.diagnostic.get for updating diagnostics ([#3042](https://github.com/nvim-tree/nvim-tree.lua/issues/3042)) ([aae0185](https://github.com/nvim-tree/nvim-tree.lua/commit/aae01853ddbd790d1efd6ff04ff96cf38c02c95f))
+* Can't re-enter normal mode from terminal mode ([db8d7ac](https://github.com/nvim-tree/nvim-tree.lua/commit/db8d7ac1f524fc6f808764b29fa695c51e014aa6))
+* hijack directory "BufEnter", "BufNewFile" events are nested ([#3044](https://github.com/nvim-tree/nvim-tree.lua/issues/3044)) ([39bc630](https://github.com/nvim-tree/nvim-tree.lua/commit/39bc63081605c1d4b974131ebecaea11e8a8595f))
+* view.width functions may return strings ([#3020](https://github.com/nvim-tree/nvim-tree.lua/issues/3020)) ([6b4be1d](https://github.com/nvim-tree/nvim-tree.lua/commit/6b4be1dc0cd4d5d5b8e8b56b510a75016e99746f))
+
+## [1.9.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.8.0...nvim-tree-v1.9.0) (2024-12-07)
+
+
+### Features
+
+* **#2948:** add custom decorators, :help nvim-tree-decorators ([#2996](https://github.com/nvim-tree/nvim-tree.lua/issues/2996)) ([7a4ff1a](https://github.com/nvim-tree/nvim-tree.lua/commit/7a4ff1a516fe92a5ed6b79d7ce31ea4d8f341a72))
+
+
+### Bug Fixes
+
+* **#2954:** more efficient LSP updates, increase diagnostics.debounce_delay from 50ms to 500ms ([#3007](https://github.com/nvim-tree/nvim-tree.lua/issues/3007)) ([1f3ffd6](https://github.com/nvim-tree/nvim-tree.lua/commit/1f3ffd6af145af2a4930a61c50f763264922c3fe))
+* **#2990:** Do not check if buffer is buflisted in diagnostics.update() ([#2998](https://github.com/nvim-tree/nvim-tree.lua/issues/2998)) ([28eac28](https://github.com/nvim-tree/nvim-tree.lua/commit/28eac2801b201f301449e976d7a9e8cfde053ba3))
+* **#3009:** nvim < 0.10 apply view options locally ([#3010](https://github.com/nvim-tree/nvim-tree.lua/issues/3010)) ([ca7c4c3](https://github.com/nvim-tree/nvim-tree.lua/commit/ca7c4c33cac2ad66ec69d45e465379716ef0cc97))
+* **api:** correct argument types in `wrap_node` and `wrap_node_or_nil` ([#3006](https://github.com/nvim-tree/nvim-tree.lua/issues/3006)) ([f7c65e1](https://github.com/nvim-tree/nvim-tree.lua/commit/f7c65e11d695a084ca10b93df659bb7e68b71f9f))
+
+## [1.8.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.7.1...nvim-tree-v1.8.0) (2024-11-09)
+
+
+### Features
+
+* **#2819:** add actions.open_file.relative_path, default enabled, following successful experiment ([#2995](https://github.com/nvim-tree/nvim-tree.lua/issues/2995)) ([2ee1c5e](https://github.com/nvim-tree/nvim-tree.lua/commit/2ee1c5e17fdfbf5013af31b1410e4a5f28f4cadd))
+* **#2938:** add default filesystem_watchers.ignore_dirs = { "/.ccls-cache", "/build", "/node_modules", "/target", } ([#2940](https://github.com/nvim-tree/nvim-tree.lua/issues/2940)) ([010ae03](https://github.com/nvim-tree/nvim-tree.lua/commit/010ae0365aafd6275c478d932515d2e8e897b7bb))
+
+
+### Bug Fixes
+
+* **#2945:** stack overflow on api.git.reload or fugitive event with watchers disabled ([#2949](https://github.com/nvim-tree/nvim-tree.lua/issues/2949)) ([5ad8762](https://github.com/nvim-tree/nvim-tree.lua/commit/5ad87620ec9d1190d15c88171a3f0122bc16b0fe))
+* **#2947:** root is never a dotfile, so that it doesn't propagate to children ([#2958](https://github.com/nvim-tree/nvim-tree.lua/issues/2958)) ([f5f6789](https://github.com/nvim-tree/nvim-tree.lua/commit/f5f67892996b280ae78b1b0a2d07c4fa29ae0905))
+* **#2951:** highlights incorrect following cancelled pick ([#2952](https://github.com/nvim-tree/nvim-tree.lua/issues/2952)) ([1c9553a](https://github.com/nvim-tree/nvim-tree.lua/commit/1c9553a19f70df3dcb171546a3d5e034531ef093))
+* **#2954:** resolve occasional tree flashing on diagnostics, set tree buffer options in deterministic order ([#2980](https://github.com/nvim-tree/nvim-tree.lua/issues/2980)) ([82ab19e](https://github.com/nvim-tree/nvim-tree.lua/commit/82ab19ebf79c1839d7351f2fed213d1af13a598e))
+* **#2961:** windows: escape brackets and parentheses when opening file ([#2962](https://github.com/nvim-tree/nvim-tree.lua/issues/2962)) ([63c7ad9](https://github.com/nvim-tree/nvim-tree.lua/commit/63c7ad9037fb7334682dd0b3a177cee25c5c8a0f))
+* **#2969:** After a rename, the node loses selection ([#2974](https://github.com/nvim-tree/nvim-tree.lua/issues/2974)) ([1403933](https://github.com/nvim-tree/nvim-tree.lua/commit/14039337a563f4efd72831888f332a15585f0ea1))
+* **#2972:** error on :colorscheme ([#2973](https://github.com/nvim-tree/nvim-tree.lua/issues/2973)) ([6e5a204](https://github.com/nvim-tree/nvim-tree.lua/commit/6e5a204ca659bb8f2a564df75df2739edec03cb0))
+* **#2976:** use vim.loop to preserve neovim 0.9 compatibility ([#2977](https://github.com/nvim-tree/nvim-tree.lua/issues/2977)) ([00dff48](https://github.com/nvim-tree/nvim-tree.lua/commit/00dff482f9a8fb806a54fd980359adc6cd45d435))
+* **#2978:** grouped folder not showing closed icon ([#2979](https://github.com/nvim-tree/nvim-tree.lua/issues/2979)) ([120ba58](https://github.com/nvim-tree/nvim-tree.lua/commit/120ba58254835d412bbc91cffe847e9be835fadd))
+* **#2981:** windows: root changed when navigating with LSP ([#2982](https://github.com/nvim-tree/nvim-tree.lua/issues/2982)) ([c22124b](https://github.com/nvim-tree/nvim-tree.lua/commit/c22124b37409bee6d1a0da77f4f3a1526f7a204d))
+* symlink file icons rendered when renderer.icons.show.file = false, folder.symlink* was incorrectly rendered as folder.default|open ([#2983](https://github.com/nvim-tree/nvim-tree.lua/issues/2983)) ([2156bc0](https://github.com/nvim-tree/nvim-tree.lua/commit/2156bc08c982d3c4b4cfc2b8fd7faeff58a88e10))
+
+## [1.7.1](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.7.0...nvim-tree-v1.7.1) (2024-09-30)
+
+
+### Bug Fixes
+
+* **#2794:** sshfs compatibility ([#2922](https://github.com/nvim-tree/nvim-tree.lua/issues/2922)) ([9650e73](https://github.com/nvim-tree/nvim-tree.lua/commit/9650e735baad0d39505f4cb4867a60f02858536a))
+* **#2928:** nil explorer in parent move action ([#2929](https://github.com/nvim-tree/nvim-tree.lua/issues/2929)) ([0429f28](https://github.com/nvim-tree/nvim-tree.lua/commit/0429f286b350c65118d66b646775bf187936fa47))
+* **#2930:** empty groups expanded on reload ([#2935](https://github.com/nvim-tree/nvim-tree.lua/issues/2935)) ([4520c03](https://github.com/nvim-tree/nvim-tree.lua/commit/4520c0355cc561830ee2cf90dc37a2a75abf7995))
+* invalid explorer on open ([#2927](https://github.com/nvim-tree/nvim-tree.lua/issues/2927)) ([59a8a6a](https://github.com/nvim-tree/nvim-tree.lua/commit/59a8a6ae5e9d3eae99d08ab655d12fd51d5d17f3))
+
+
+### Reverts
+
+* **#2794:** sshfs compatibility ([#2920](https://github.com/nvim-tree/nvim-tree.lua/issues/2920)) ([8405ecf](https://github.com/nvim-tree/nvim-tree.lua/commit/8405ecfbd6bb08a94ffc9c68fef211eea56e8a3b))
+
+## [1.7.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.6.1...nvim-tree-v1.7.0) (2024-09-21)
+
+
+### Features
+
+* **#2430:** use vim.ui.open as default system_open, for neovim 0.10+ ([#2912](https://github.com/nvim-tree/nvim-tree.lua/issues/2912)) ([03f737e](https://github.com/nvim-tree/nvim-tree.lua/commit/03f737e5744a2b3ebb4b086f7636a3399224ec0c))
+* help closes on <Esc> and api.tree.toggle_help mappings ([#2909](https://github.com/nvim-tree/nvim-tree.lua/issues/2909)) ([b652dbd](https://github.com/nvim-tree/nvim-tree.lua/commit/b652dbd0e0489c5fbb81fbededf0d99029cd2f38))
+
+
+### Bug Fixes
+
+* **#2862:** windows path replaces backslashes with forward slashes ([#2903](https://github.com/nvim-tree/nvim-tree.lua/issues/2903)) ([45a93d9](https://github.com/nvim-tree/nvim-tree.lua/commit/45a93d99794fff3064141d5b3a50db98ce352697))
+* **#2906:** resource leak on populate children ([#2907](https://github.com/nvim-tree/nvim-tree.lua/issues/2907)) ([a4dd5ad](https://github.com/nvim-tree/nvim-tree.lua/commit/a4dd5ad5c8f9349142291d24e0e6466995594b9a))
+* **#2917:** fix root copy paths: Y, ge, gy, y ([#2918](https://github.com/nvim-tree/nvim-tree.lua/issues/2918)) ([b18ce8b](https://github.com/nvim-tree/nvim-tree.lua/commit/b18ce8be8f162eee0bc37addcfe17d7d019fcec7))
+* safely close last tree window ([#2913](https://github.com/nvim-tree/nvim-tree.lua/issues/2913)) ([bd48816](https://github.com/nvim-tree/nvim-tree.lua/commit/bd4881660bf0ddfa6acb21259f856ba3dcb26a93))
+* safely close tree window with pcall and debug logging ([bd48816](https://github.com/nvim-tree/nvim-tree.lua/commit/bd4881660bf0ddfa6acb21259f856ba3dcb26a93))
+
+## [1.6.1](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v1.6.0...nvim-tree-v1.6.1) (2024-09-09)
+
+
+### Bug Fixes
+
+* **#2794:** sshfs compatibility ([#2893](https://github.com/nvim-tree/nvim-tree.lua/issues/2893)) ([2d6e64d](https://github.com/nvim-tree/nvim-tree.lua/commit/2d6e64dd8c45a86f312552b7a47eef2c8623a25c))
+* **#2868:** windows: do not visit unenumerable directories such as Application Data ([#2874](https://github.com/nvim-tree/nvim-tree.lua/issues/2874)) ([2104786](https://github.com/nvim-tree/nvim-tree.lua/commit/210478677cb9d672c4265deb0e9b59d58b675bd4))
+* **#2878:** nowrapscan prevents move from root ([#2880](https://github.com/nvim-tree/nvim-tree.lua/issues/2880)) ([4234095](https://github.com/nvim-tree/nvim-tree.lua/commit/42340952af598a08ab80579d067b6da72a9e6d29))
+* **#2879:** remove unnecessary tree window width setting to prevent unnecessary :wincmd = ([#2881](https://github.com/nvim-tree/nvim-tree.lua/issues/2881)) ([d43ab67](https://github.com/nvim-tree/nvim-tree.lua/commit/d43ab67d0eb4317961c5e9d15fffe908519debe0))
+
+## [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)
+
+
+### Features
+
+* **#2654:** filters.custom may be a function ([#2655](https://github.com/nvim-tree/nvim-tree.lua/issues/2655)) ([4a87b8b](https://github.com/nvim-tree/nvim-tree.lua/commit/4a87b8b46b4a30107971871df3cb7f4c30fdd5d0))
+
+
+### Miscellaneous Chores
+
+* release 1.0.0 ([#2678](https://github.com/nvim-tree/nvim-tree.lua/issues/2678)) ([d16246a](https://github.com/nvim-tree/nvim-tree.lua/commit/d16246a7575538f77e9246520449b99333c469f7))
+
+## [0.100.0](https://github.com/nvim-tree/nvim-tree.lua/compare/nvim-tree-v0.99.0...nvim-tree-v0.100.0) (2024-02-11)
+
+
+### Features
+
+* **#1389:** api: recursive node navigation for git and diagnostics ([#2525](https://github.com/nvim-tree/nvim-tree.lua/issues/2525)) ([5d13cc8](https://github.com/nvim-tree/nvim-tree.lua/commit/5d13cc8205bce4963866f73c50f6fdc18a515ffe))
+* **#2415:** add :NvimTreeHiTest ([#2664](https://github.com/nvim-tree/nvim-tree.lua/issues/2664)) ([b278fc2](https://github.com/nvim-tree/nvim-tree.lua/commit/b278fc25ae0fc95e4808eb5618f07fc2522fd2b3))
+* **#2415:** colour and highlight overhaul, see :help nvim-tree-highlight-overhaul ([#2455](https://github.com/nvim-tree/nvim-tree.lua/issues/2455)) ([e9c5abe](https://github.com/nvim-tree/nvim-tree.lua/commit/e9c5abe073a973f54d3ca10bfe30f253569f4405))
+* add node.open.toggle_group_empty, default mapping L ([#2647](https://github.com/nvim-tree/nvim-tree.lua/issues/2647)) ([8cbb1db](https://github.com/nvim-tree/nvim-tree.lua/commit/8cbb1db8e90b62fc56f379992e622e9f919792ce))
+
+
+### Bug Fixes
+
+* **#2415:** disambiguate highlight groups, see :help nvim-tree-highlight-overhaul ([#2639](https://github.com/nvim-tree/nvim-tree.lua/issues/2639)) ([d9cb432](https://github.com/nvim-tree/nvim-tree.lua/commit/d9cb432d2c8d8fa9267ddbd7535d76fe4df89360))
+* **#2415:** fix NvimTreeIndentMarker highlight group: FileIcon->FolderIcon ([e9ac136](https://github.com/nvim-tree/nvim-tree.lua/commit/e9ac136a3ab996aa8e4253253521dcf2cb66b81b))
+* **#2415:** highlight help header and mappings ([#2669](https://github.com/nvim-tree/nvim-tree.lua/issues/2669)) ([39e6fef](https://github.com/nvim-tree/nvim-tree.lua/commit/39e6fef85ac3bb29532b877aa7c9c34911c661af))
+* **#2415:** nvim 0.8 highlight overhaul support, limited to only show highest highlight precedence ([#2642](https://github.com/nvim-tree/nvim-tree.lua/issues/2642)) ([f39f7b6](https://github.com/nvim-tree/nvim-tree.lua/commit/f39f7b6fcd3865ac2146de4cb4045286308f2935))
+* **#2415:** NvimTreeIndentMarker highlight group: FileIcon->FolderIcon ([#2656](https://github.com/nvim-tree/nvim-tree.lua/issues/2656)) ([e9ac136](https://github.com/nvim-tree/nvim-tree.lua/commit/e9ac136a3ab996aa8e4253253521dcf2cb66b81b))
+* **#2624:** open file from docked floating window ([#2627](https://github.com/nvim-tree/nvim-tree.lua/issues/2627)) ([f24afa2](https://github.com/nvim-tree/nvim-tree.lua/commit/f24afa2cef551122b8bd53bb2e4a7df42343ce2e))
+* **#2632:** occasional error stack when locating nvim-tree window ([#2633](https://github.com/nvim-tree/nvim-tree.lua/issues/2633)) ([48b1d86](https://github.com/nvim-tree/nvim-tree.lua/commit/48b1d8638fa3726236ae22e0e48a74ac8ea6592a))
+* **#2637:** show buffer modified icons and highlights ([#2638](https://github.com/nvim-tree/nvim-tree.lua/issues/2638)) ([7bdb220](https://github.com/nvim-tree/nvim-tree.lua/commit/7bdb220d0fe604a77361e92cdbc7af1b8a412126))
+* **#2643:** correctly apply linked highlight groups in tree window ([#2653](https://github.com/nvim-tree/nvim-tree.lua/issues/2653)) ([fbee8a6](https://github.com/nvim-tree/nvim-tree.lua/commit/fbee8a69a46f558d29ab84e96301425b0501c668))
+* allow highlight overrides for DEFAULT_DEFS: NvimTreeFolderIcon, NvimTreeWindowPicker ([#2636](https://github.com/nvim-tree/nvim-tree.lua/issues/2636)) ([74525ac](https://github.com/nvim-tree/nvim-tree.lua/commit/74525ac04760bf0d9fec2bf51474d2b05f36048e))
+* bad column offset when using full_name ([#2629](https://github.com/nvim-tree/nvim-tree.lua/issues/2629)) ([75ff64e](https://github.com/nvim-tree/nvim-tree.lua/commit/75ff64e6663fc3b23c72dca32b2f838acefe7c8a))
+* passing nil as window handle in view.get_winnr ([48b1d86](https://github.com/nvim-tree/nvim-tree.lua/commit/48b1d8638fa3726236ae22e0e48a74ac8ea6592a))
+
+## 0.99.0 (2024-01-01)
+
+
+### Features
+
+* **#1850:** add "no bookmark" filter ([#2571](https://github.com/nvim-tree/nvim-tree.lua/issues/2571)) ([8f92e1e](https://github.com/nvim-tree/nvim-tree.lua/commit/8f92e1edd399f839a23776dcc6eee4ba18030370))
+* add kind param to vim.ui.select function calls ([#2602](https://github.com/nvim-tree/nvim-tree.lua/issues/2602)) ([dc839a7](https://github.com/nvim-tree/nvim-tree.lua/commit/dc839a72a6496ce22ebd3dd959115cf97c1b20a0))
+* add option to skip gitignored files on git navigation ([#2583](https://github.com/nvim-tree/nvim-tree.lua/issues/2583)) ([50f30bc](https://github.com/nvim-tree/nvim-tree.lua/commit/50f30bcd8c62ac4a83d133d738f268279f2c2ce2))
+
+
+### Bug Fixes
+
+* **#2519:** Diagnostics Not Updated When Tree Not Visible ([#2597](https://github.com/nvim-tree/nvim-tree.lua/issues/2597)) ([96a783f](https://github.com/nvim-tree/nvim-tree.lua/commit/96a783fbd606a458bcce2ef8041240a8b94510ce))
+* **#2609:** help toggle ([#2611](https://github.com/nvim-tree/nvim-tree.lua/issues/2611)) ([fac4900](https://github.com/nvim-tree/nvim-tree.lua/commit/fac4900bd18a9fa15be3d104645d9bdef7b3dcec))
+* hijack_cursor on update focused file and vim search ([#2600](https://github.com/nvim-tree/nvim-tree.lua/issues/2600)) ([02ae523](https://github.com/nvim-tree/nvim-tree.lua/commit/02ae52357ba4da77a4c120390791584a81d15340))

CONTRIBUTING.md

@@ -2,37 +2,177 @@
 
 Thank you for contributing.
 
-See [Development](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development) for environment setup, tips and tools.
+See [wiki: Development](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development) for environment setup, tips and tools.
 
-## Styling and formatting
+<!-- 
+https://github.com/jonschlinkert/markdown-toc
+markdown-toc --maxdepth=2 -i CONTRIBUTING.md
+-->
 
-Code is formatted using luacheck, and linted using stylua.
-You can install these with:
+<!-- toc -->
 
-```bash
-luarocks install luacheck
-cargo install stylua
+- [Tools](#tools)
+- [Quality](#quality)
+  * [lint](#lint)
+  * [style](#style)
+  * [check](#check)
+- [Diagnostics](#diagnostics)
+- [Backwards Compatibility](#backwards-compatibility)
+- [Adding New Actions](#adding-new-actions)
+- [Documentation](#documentation)
+  * [Opts](#opts)
+  * [API](#api)
+- [Windows](#windows)
+- [Pull Request](#pull-request)
+  * [Subject](#subject)
+
+<!-- tocstop -->
+
+# Tools
+
+Following are used during CI and strongly recommended during local development.
+
+Language server: [luals](https://luals.github.io)
+
+Lint: [luacheck](https://github.com/lunarmodules/luacheck/)
+
+Style Fixing: [EmmyLuaCodeStyle](https://github.com/CppCXY/EmmyLuaCodeStyle): `CodeCheck`
+
+nvim-tree.lua migrated from stylua to EmmyLuaCodeStyle ~2024/10. `vim.lsp.buf.format()` may be used as it is the default formatter for luals, using an embedded [EmmyLuaCodeStyle](https://github.com/CppCXY/EmmyLuaCodeStyle)
+
+You can install them via you OS package manager e.g. `pacman`, `brew` or other via other package managers such as `cargo` or `luarocks`
+
+# Quality
+
+The following quality checks are mandatory and are performed during CI. They run on the entire `lua` directory and return 1 on any failure.
+
+You can run them all via `make` or `make all`
+
+You can setup git hooks to run all checks by running `scripts/setup-hooks.sh`
+
+## lint
+
+1. Runs luacheck quietly using `.luacheck` settings
+
+```sh
+make lint
 ```
 
-You can setup the git hooks by running `scripts/setup-hooks.sh`.
+## style
 
-## Adding new actions
+1. Runs lua language server `codestyle-check` only, using `.luarc.json` settings
+1. Runs `scripts/doc-comments.sh` to validate annotated documentation
+
+```sh
+make style
+```
+
+You can automatically fix style issues using `CodeCheck`:
+
+```sh
+make style-fix
+```
+
+## check
+
+1. Runs the checks that the LSP lua language server runs inside nvim using `.luarc.json` via `scripts/luals-check.sh`
+
+```sh
+make check
+```
+
+Assumes `$VIMRUNTIME` is `/usr/share/nvim/runtime`. Adjust as necessary e.g.
+
+```sh
+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
+```
+
+# Diagnostics
+
+Diagnostics issues may not be suppressed. See [luals](https://luals.github.io) documentation for details on how to structure the code and comments.
+
+Suppressions are permitted only in the following cases:
+
+- Backwards compatibility shims
+- neovim API metadata incorrect, awaiting upstream fix
+- classic class framework
+
+# Backwards Compatibility
+
+Whenever new neovim API is introduced, please ensure that it is available in older versions. See `:help deprecated.txt` and `$VIMRUNTIME/lua/vim/_meta/api.lua`
+
+See `nvim-tree.setup` for the oldest supported version of neovim. If the API is not availble in that version, a backwards compatibility shim must be used e.g.
+
+```lua
+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
+```
+
+# 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.
-Once you did, you should run the `scripts/update-help.sh`.
 
-## Documentation
+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.
-Once you did, you should run the `scripts/update-help.sh`.
 
 Documentation for options should also be added to `nvim-tree-opts` in `doc/nvim-tree-lua.txt`
 
-## Pull Request
+## API
 
-Please reference any issues in the description e.g. "resolves #1234".
+When adding or changing API please update :help nvim-tree-api
+
+# Windows
+
+Please note that nvim-tree team members do not have access to nor expertise with Windows.
+
+You will need to be an active participant during development and raise a PR to resolve any issues that may arise.
+
+Please ensure that windows specific features and fixes are behind the appropriate feature flag, see [wiki: OS Feature Flags](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development#os-feature-flags)
+
+# Pull Request
+
+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

@@ -0,0 +1,48 @@
+all: lint style check
+
+#
+# mandatory checks
+#
+lint: luacheck
+
+style: style-check style-doc
+
+check: luals
+
+#
+# subtasks
+#
+luacheck:
+	luacheck --codes --quiet lua --exclude-files "**/_meta/**"
+
+# --diagnosis-as-error does not function for workspace, hence we post-process the output
+style-check:
+	@scripts/luals-check.sh codestyle-check
+
+style-doc:
+	scripts/doc-comments.sh
+
+luals:
+	@scripts/luals-check.sh
+
+#
+# fixes
+#
+style-fix:
+	CodeFormat format --config .editorconfig --workspace lua
+
+#
+# utility
+#
+help-update:
+	scripts/help-update.sh
+
+#
+# CI
+#
+help-check: help-update
+	git diff --exit-code doc/nvim-tree-lua.txt
+
+
+.PHONY: all lint style check luacheck style-check style-doc luals style-fix help-update help-check
+

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"
 
@@ -38,6 +38,8 @@ Please install via your preferred package manager. See [Installation](https://gi
 
 `nvim-tree/nvim-tree.lua`
 
+Major or minor versions may be specified via tags: `v<MAJOR>` e.g. `v1` or `v<MAJOR>.<MINOR>` e.g. `v1.23`
+
 `nvim-tree/nvim-web-devicons` optional, for file icons
 
 Disabling [netrw](https://neovim.io/doc/user/pi_netrw.html) is strongly advised, see [:help nvim-tree-netrw](doc/nvim-tree-lua.txt)
@@ -53,7 +55,7 @@ Setup the plugin in your `init.lua`
 vim.g.loaded_netrw = 1
 vim.g.loaded_netrwPlugin = 1
 
--- set termguicolors to enable highlight groups
+-- optionally enable 24-bit colour
 vim.opt.termguicolors = true
 
 -- empty setup using defaults
@@ -110,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)
@@ -143,13 +162,13 @@ nvim-tree exposes a public API. This is non breaking, with additions made as nec
 
 See wiki [Recipes](https://github.com/nvim-tree/nvim-tree.lua/wiki/Recipes) and [Tips](https://github.com/nvim-tree/nvim-tree.lua/wiki/Tips) for ideas and inspiration.
 
-Please raise a [feature request](https://github.com/nvim-tree/nvim-tree.lua/issues/new?assignees=&labels=feature+request&template=feature_request.md&title=) if the API is insufficient for your needs. [Contributions](#Contributing) are always welcome.
+Please raise a [feature request](https://github.com/nvim-tree/nvim-tree.lua/issues/new?assignees=&labels=feature+request&template=feature_request.md&title=) if the API is insufficient for your needs. Contributions are always welcome, see below.
 
 You may also subscribe to events that nvim-tree will dispatch in a variety of situations, see [:help nvim-tree-events](doc/nvim-tree-lua.txt)
 
 ## Contributing
 
-PRs are always welcome. See [wiki](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development) to get started.
+PRs are always welcome. See [CONTRIBUTING](CONTRIBUTING.md) and [wiki: Development](https://github.com/nvim-tree/nvim-tree.lua/wiki/Development) to get started.
 
 See [bug](https://github.com/nvim-tree/nvim-tree.lua/issues?q=is%3Aissue+is%3Aopen+label%3Abug) and [PR Please](https://github.com/nvim-tree/nvim-tree.lua/issues?q=is%3Aopen+is%3Aissue+label%3A%22PR+please%22) issues if you are looking for some work to get you started.
 

lua/nvim-tree.lua

@@ -1,20 +1,9 @@
-local lib = require "nvim-tree.lib"
-local log = require "nvim-tree.log"
-local colors = require "nvim-tree.colors"
-local renderer = require "nvim-tree.renderer"
-local view = require "nvim-tree.view"
-local commands = require "nvim-tree.commands"
-local utils = require "nvim-tree.utils"
-local change_dir = require "nvim-tree.actions.root.change-dir"
-local legacy = require "nvim-tree.legacy"
-local core = require "nvim-tree.core"
-local reloaders = require "nvim-tree.actions.reloaders.reloaders"
-local git = require "nvim-tree.git"
-local filters = require "nvim-tree.explorer.filters"
-local modified = require "nvim-tree.modified"
-local find_file = require "nvim-tree.actions.tree.find-file"
-local events = require "nvim-tree.events"
-local notify = require "nvim-tree.notify"
+local log = require("nvim-tree.log")
+local view = require("nvim-tree.view")
+local utils = require("nvim-tree.utils")
+local actions = require("nvim-tree.actions")
+local core = require("nvim-tree.core")
+local notify = require("nvim-tree.notify")
 
 local _config = {}
 
@@ -28,8 +17,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 ""
-    for _, value in pairs(_config.update_focused_file.ignore_list) do
+    local ft
+
+    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
@@ -51,7 +47,7 @@ function M.change_root(path, bufnr)
   -- test if in vim_cwd
   if utils.path_relative(path, vim_cwd) ~= path then
     if vim_cwd ~= cwd then
-      change_dir.fn(vim_cwd)
+      actions.root.change_dir.fn(vim_cwd)
     end
     return
   end
@@ -62,56 +58,43 @@ function M.change_root(path, bufnr)
 
   -- otherwise test M.init_root
   if _config.prefer_startup_root and utils.path_relative(path, M.init_root) ~= path then
-    change_dir.fn(M.init_root)
+    actions.root.change_dir.fn(M.init_root)
     return
   end
   -- otherwise root_dirs
   for _, dir in pairs(_config.root_dirs) do
     dir = vim.fn.fnamemodify(dir, ":p")
     if utils.path_relative(path, dir) ~= path then
-      change_dir.fn(dir)
+      actions.root.change_dir.fn(dir)
       return
     end
   end
   -- finally fall back to the folder containing the file
-  change_dir.fn(vim.fn.fnamemodify(path, ":p:h"))
-end
-
----@param cwd string|nil
-function M.open_replacing_current_buffer(cwd)
-  if view.is_visible() then
-    return
-  end
-
-  local buf = vim.api.nvim_get_current_buf()
-  local bufname = vim.api.nvim_buf_get_name(buf)
-  if bufname == "" or vim.loop.fs_stat(bufname) == nil then
-    return
-  end
-
-  if cwd == "" or cwd == nil then
-    cwd = vim.fn.fnamemodify(bufname, ":p:h")
-  end
-
-  if not core.get_explorer() or cwd ~= core.get_cwd() then
-    core.init(cwd)
-  end
-  view.open_in_win { hijack_current_buf = false, resize = false }
-  require("nvim-tree.renderer").draw()
-  require("nvim-tree.actions.finders.find-file").fn(bufname)
+  actions.root.change_dir.fn(vim.fn.fnamemodify(path, ":p:h"))
 end
 
 function M.tab_enter()
-  if view.is_visible { any_tabpage = true } then
+  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
       end
     end
-    view.open { focus_tree = false }
-    require("nvim-tree.renderer").draw()
+    view.open({ focus_tree = false })
+
+    local explorer = core.get_explorer()
+    if explorer then
+      explorer.renderer:draw()
+    end
   end
 end
 
@@ -127,35 +110,7 @@ function M.open_on_directory()
     return
   end
 
-  change_dir.force_dirchange(bufname, true)
-end
-
-function M.reset_highlight()
-  colors.setup()
-  view.reset_winhl()
-  renderer.render_hl(view.get_bufnr())
-end
-
-local prev_line
-function M.place_cursor_on_node()
-  local l = vim.api.nvim_win_get_cursor(0)[1]
-  if l == prev_line then
-    return
-  end
-  prev_line = l
-
-  local node = lib.get_node_at_cursor()
-  if not node or node.name == ".." then
-    return
-  end
-
-  local line = vim.api.nvim_get_current_line()
-  local cursor = vim.api.nvim_win_get_cursor(0)
-  local idx = vim.fn.stridx(line, node.name)
-
-  if idx >= 0 then
-    vim.api.nvim_win_set_cursor(0, { cursor[1], idx })
-  end
+  actions.root.change_dir.force_dirchange(bufname, true)
 end
 
 ---@return table
@@ -167,8 +122,8 @@ end
 ---@param hijack_netrw boolean
 local function manage_netrw(disable_netrw, hijack_netrw)
   if hijack_netrw then
-    vim.cmd "silent! autocmd! FileExplorer *"
-    vim.cmd "autocmd VimEnter * ++once silent! autocmd! FileExplorer *"
+    vim.cmd("silent! autocmd! FileExplorer *")
+    vim.cmd("autocmd VimEnter * ++once silent! autocmd! FileExplorer *")
   end
   if disable_netrw then
     vim.g.loaded_netrw = 1
@@ -179,11 +134,11 @@ end
 ---@param name string|nil
 function M.change_dir(name)
   if name then
-    change_dir.fn(name)
+    actions.root.change_dir.fn(name)
   end
 
-  if _config.update_focused_file.enable then
-    find_file.fn()
+  if _config.update_focused_file.update_root.enable then
+    actions.tree.find_file.fn()
   end
 end
 
@@ -195,9 +150,6 @@ local function setup_autocommands(opts)
     vim.api.nvim_create_autocmd(name, vim.tbl_extend("force", default_opts, custom_opts))
   end
 
-  -- reset highlights when colorscheme is changed
-  create_nvim_tree_autocmd("ColorScheme", { callback = M.reset_highlight })
-
   -- prevent new opened file from opening in the same window as nvim-tree
   create_nvim_tree_autocmd("BufWipeout", {
     pattern = "NvimTree_*",
@@ -213,58 +165,9 @@ local function setup_autocommands(opts)
     end,
   })
 
-  create_nvim_tree_autocmd("BufWritePost", {
-    callback = function()
-      if opts.auto_reload_on_write and not opts.filesystem_watchers.enable then
-        reloaders.reload_explorer()
-      end
-    end,
-  })
-
-  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
-        utils.debounce("Buf:filter_buffer", opts.view.debounce_delay, function()
-          reloaders.reload_explorer()
-        end)
-      end
-    end,
-  })
-
-  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
-        utils.debounce("Buf:filter_buffer", opts.view.debounce_delay, function()
-          reloaders.reload_explorer(nil, data.buf)
-        end)
-      end
-    end,
-  })
-
-  create_nvim_tree_autocmd("User", {
-    pattern = { "FugitiveChanged", "NeogitStatusRefreshed" },
-    callback = function()
-      if not opts.filesystem_watchers.enable and opts.git.enable then
-        reloaders.reload_git()
-      end
-    end,
-  })
-
   if opts.tab.sync.open then
     create_nvim_tree_autocmd("TabEnter", { callback = vim.schedule_wrap(M.tab_enter) })
   end
-  if opts.hijack_cursor then
-    create_nvim_tree_autocmd("CursorMoved", {
-      pattern = "NvimTree_*",
-      callback = function()
-        if utils.is_nvim_tree_buf(0) then
-          M.place_cursor_on_node()
-        end
-      end,
-    })
-  end
   if opts.sync_root_with_cwd then
     create_nvim_tree_autocmd("DirChanged", {
       callback = function()
@@ -274,36 +177,33 @@ 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()
-          find_file.fn()
+          actions.tree.find_file.fn()
         end)
       end,
     })
   end
 
   if opts.hijack_directories.enable then
-    create_nvim_tree_autocmd({ "BufEnter", "BufNewFile" }, { callback = M.open_on_directory })
+    create_nvim_tree_autocmd({ "BufEnter", "BufNewFile" }, { callback = M.open_on_directory, nested = true })
   end
 
-  create_nvim_tree_autocmd("BufEnter", {
-    pattern = "NvimTree_*",
-    callback = function()
-      if utils.is_nvim_tree_buf(0) then
-        if vim.fn.getcwd() ~= core.get_cwd() or (opts.reload_on_bufenter and not opts.filesystem_watchers.enable) then
-          reloaders.reload_explorer()
-        end
-      end
-    end,
-  })
-
   if opts.view.centralize_selection then
     create_nvim_tree_autocmd("BufEnter", {
       pattern = "NvimTree_*",
       callback = function()
         vim.schedule(function()
           vim.api.nvim_buf_call(0, function()
-            vim.cmd [[norm! zz]]
+            local is_term_mode = vim.api.nvim_get_mode().mode == "t"
+            if is_term_mode then
+              return
+            end
+            vim.cmd([[norm! zz]])
           end)
         end)
       end,
@@ -312,16 +212,16 @@ local function setup_autocommands(opts)
 
   if opts.diagnostics.enable then
     create_nvim_tree_autocmd("DiagnosticChanged", {
-      callback = function()
+      callback = function(ev)
         log.line("diagnostics", "DiagnosticChanged")
-        require("nvim-tree.diagnostics").update()
+        require("nvim-tree.diagnostics").update_lsp(ev)
       end,
     })
     create_nvim_tree_autocmd("User", {
       pattern = "CocDiagnosticChange",
       callback = function()
         log.line("diagnostics", "CocDiagnosticChange")
-        require("nvim-tree.diagnostics").update()
+        require("nvim-tree.diagnostics").update_coc()
       end,
     })
   end
@@ -337,32 +237,20 @@ local function setup_autocommands(opts)
     })
   end
 
-  if opts.modified.enable then
-    create_nvim_tree_autocmd({ "BufModifiedSet", "BufWritePost" }, {
-      callback = function()
-        utils.debounce("Buf:modified", opts.view.debounce_delay, function()
-          modified.reload()
-          reloaders.reload_explorer()
-        end)
-      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
+  -- Handles event dispatch when tree is closed by `:q`
+  create_nvim_tree_autocmd("WinClosed", {
+    pattern = "*",
+    ---@param ev vim.api.keyset.create_autocmd.callback_args
+    callback = function(ev)
+      if not vim.api.nvim_buf_is_valid(ev.buf) then
+        return
       end
+      if vim.api.nvim_get_option_value("filetype", { buf = ev.buf }) == "NvimTree" then
+        require("nvim-tree.events")._dispatch_on_tree_close()
       end
     end,
   })
 end
-end
 
 local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
   on_attach = "default",
@@ -385,6 +273,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
   view = {
     centralize_selection = false,
     cursorline = true,
+    cursorlineopt = "both",
     debounce_delay = 15,
     side = "left",
     preserve_window_proportions = false,
@@ -412,11 +301,14 @@ 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 = false,
-    highlight_diagnostics = false,
+    decorators = { "Git", "Open", "Hidden", "Modified", "Bookmark", "Diagnostics", "Copied", "Cut", },
+    highlight_git = "none",
+    highlight_diagnostics = "none",
     highlight_opened_files = "none",
     highlight_modified = "none",
+    highlight_hidden = "none",
     highlight_bookmarks = "none",
     highlight_clipboard = "name",
     indent_markers = {
@@ -443,9 +335,13 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       },
       git_placement = "before",
       modified_placement = "after",
+      hidden_placement = "after",
       diagnostics_placement = "signcolumn",
       bookmarks_placement = "signcolumn",
-      padding = " ",
+      padding = {
+        icon = " ",
+        folder_arrow = " ",
+      },
       symlink_arrow = " ➛ ",
       show = {
         file = true,
@@ -453,6 +349,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
         folder_arrow = true,
         git = true,
         modified = true,
+        hidden = false,
         diagnostics = true,
         bookmarks = true,
       },
@@ -461,6 +358,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
         symlink = "",
         bookmark = "󰆤",
         modified = "●",
+        hidden = "󰜌",
         folder = {
           arrow_closed = "",
           arrow_open = "",
@@ -489,9 +387,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 = {},
@@ -508,7 +409,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
     enable = false,
     show_on_dirs = false,
     show_on_open_dirs = true,
-    debounce_delay = 50,
+    debounce_delay = 500,
     severity = {
       min = vim.diagnostic.severity.HINT,
       max = vim.diagnostic.severity.ERROR,
@@ -519,6 +420,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       warning = "",
       error = "",
     },
+    diagnostic_opts = false,
   },
   modified = {
     enable = false,
@@ -526,10 +428,12 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
     show_on_open_dirs = true,
   },
   filters = {
+    enable = true,
     git_ignored = true,
     dotfiles = false,
     git_clean = false,
     no_buffer = false,
+    no_bookmark = false,
     custom = {},
     exclude = {},
   },
@@ -540,7 +444,12 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
   filesystem_watchers = {
     enable = true,
     debounce_delay = 50,
-    ignore_dirs = {},
+    ignore_dirs = {
+      "/.ccls-cache",
+      "/build",
+      "/node_modules",
+      "/target",
+    },
   },
   actions = {
     use_system_clipboard = true,
@@ -566,6 +475,7 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       quit_on_open = false,
       eject = true,
       resize_window = true,
+      relative_path = true,
       window_picker = {
         enable = true,
         picker = "default",
@@ -604,7 +514,8 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       default_yes = false,
     },
   },
-  experimental = {},
+  experimental = {
+  },
   log = {
     enable = false,
     truncate = false,
@@ -646,9 +557,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 = {
@@ -667,15 +591,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" },
-      modified_placement = { "before", "after", "signcolumn" },
-      diagnostics_placement = { "before", "after", "signcolumn" },
-      bookmarks_placement = { "before", "after", "signcolumn" },
+      git_placement = { "before", "after", "signcolumn", "right_align" },
+      modified_placement = { "before", "after", "signcolumn", "right_align" },
+      hidden_placement = { "before", "after", "signcolumn", "right_align" },
+      diagnostics_placement = { "before", "after", "signcolumn", "right_align" },
+      bookmarks_placement = { "before", "after", "signcolumn", "right_align" },
     },
   },
   help = {
@@ -765,19 +694,22 @@ local function localise_default_opts()
 end
 
 function M.purge_all_state()
-  require("nvim-tree.watcher").purge_watchers()
   view.close_all_tabs()
   view.abandon_all_windows()
-  if core.get_explorer() ~= nil then
-    git.purge_state()
+  local explorer = core.get_explorer()
+  if explorer then
+    require("nvim-tree.git").purge_state()
+    explorer:destroy()
     core.reset_explorer()
   end
+  -- purge orphaned that were not destroyed by their nodes
+  require("nvim-tree.watcher").purge_watchers()
 end
 
 ---@param conf table|nil
 function M.setup(conf)
-  if vim.fn.has "nvim-0.8" == 0 then
-    notify.warn "nvim-tree.lua requires Neovim 0.8 or higher"
+  if vim.fn.has("nvim-0.9") == 0 then
+    notify.warn("nvim-tree.lua requires Neovim 0.9 or higher")
     return
   end
 
@@ -785,7 +717,7 @@ function M.setup(conf)
 
   localise_default_opts()
 
-  legacy.migrate_legacy_options(conf or {})
+  require("nvim-tree.legacy").migrate_legacy_options(conf or {})
 
   validate_options(conf)
 
@@ -805,35 +737,31 @@ function M.setup(conf)
   require("nvim-tree.notify").setup(opts)
   require("nvim-tree.log").setup(opts)
 
-  if log.enabled "config" then
+  if log.enabled("config") then
     log.line("config", "default config + user")
     log.raw("config", "%s\n", vim.inspect(opts))
   end
 
   require("nvim-tree.actions").setup(opts)
   require("nvim-tree.keymap").setup(opts)
-  require("nvim-tree.colors").setup()
+  require("nvim-tree.appearance").setup()
   require("nvim-tree.diagnostics").setup(opts)
-  require("nvim-tree.explorer").setup(opts)
+  require("nvim-tree.explorer"):setup(opts)
+  require("nvim-tree.explorer.watch").setup(opts)
   require("nvim-tree.git").setup(opts)
   require("nvim-tree.git.utils").setup(opts)
   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.modified").setup(opts)
+  require("nvim-tree.renderer.components").setup(opts)
+  require("nvim-tree.buffers").setup(opts)
   require("nvim-tree.help").setup(opts)
   require("nvim-tree.watcher").setup(opts)
-  if M.config.renderer.icons.show.file and pcall(require, "nvim-web-devicons") then
-    require("nvim-web-devicons").setup()
-  end
 
   setup_autocommands(opts)
 
   if vim.g.NvimTreeSetup ~= 1 then
     -- first call to setup
-    commands.setup()
+    require("nvim-tree.commands").setup()
   else
     -- subsequent calls to setup
     M.purge_all_state()

lua/nvim-tree/_meta/api.lua

@@ -0,0 +1,51 @@
+---@meta
+error("Cannot require a meta file")
+
+--
+-- Nodes
+--
+
+---Base Node, Abstract
+---@class (exact) nvim_tree.api.Node
+---@field type "file" | "directory" | "link" uv.fs_stat.result.type
+---@field absolute_path string
+---@field executable boolean
+---@field fs_stat uv.fs_stat.result?
+---@field git_status GitNodeStatus?
+---@field hidden boolean
+---@field name string
+---@field parent nvim_tree.api.DirectoryNode?
+---@field diag_severity lsp.DiagnosticSeverity?
+
+---File
+---@class (exact) nvim_tree.api.FileNode: nvim_tree.api.Node
+---@field extension string
+
+---Directory
+---@class (exact) nvim_tree.api.DirectoryNode: nvim_tree.api.Node
+---@field has_children boolean
+---@field nodes nvim_tree.api.Node[]
+---@field open boolean
+
+---Root Directory
+---@class (exact) nvim_tree.api.RootNode: nvim_tree.api.DirectoryNode
+
+---Link mixin
+---@class (exact) nvim_tree.api.LinkNode
+---@field link_to string
+---@field fs_stat_target uv.fs_stat.result
+
+---File Link
+---@class (exact) nvim_tree.api.FileLinkNode: nvim_tree.api.FileNode, nvim_tree.api.LinkNode
+
+---DirectoryLink
+---@class (exact) nvim_tree.api.DirectoryLinkNode: nvim_tree.api.DirectoryNode, nvim_tree.api.LinkNode
+
+--
+-- Various Types
+--
+
+---A string for rendering, with optional highlight groups to apply to it
+---@class (exact) nvim_tree.api.HighlightedString
+---@field str string
+---@field hl string[]

lua/nvim-tree/_meta/api_decorator.lua

@@ -0,0 +1,54 @@
+---@meta
+error("Cannot require a meta file")
+
+local nvim_tree = { api = { decorator = {} } }
+
+---Highlight group range as per nvim-tree.renderer.highlight_*
+---@alias nvim_tree.api.decorator.HighlightRange "none" | "icon" | "name" | "all"
+
+---Icon position as per renderer.icons.*_placement
+---@alias nvim_tree.api.decorator.IconPlacement "none" | "before" | "after" | "signcolumn" | "right_align"
+
+---Names of builtin decorators or your decorator classes. Builtins are ordered lowest to highest priority.
+---@alias nvim_tree.api.decorator.Name "Git" | "Opened" | "Hidden" | "Modified" | "Bookmarks" | "Diagnostics" | "Copied" | "Cut" | nvim_tree.api.decorator.UserDecorator
+
+---Custom decorator, see :help nvim-tree-decorators
+---
+---@class (exact) nvim_tree.api.decorator.UserDecorator
+---@field protected enabled boolean
+---@field protected highlight_range nvim_tree.api.decorator.HighlightRange
+---@field protected icon_placement nvim_tree.api.decorator.IconPlacement
+nvim_tree.api.decorator.UserDecorator = {}
+
+---Create your decorator class
+---
+function nvim_tree.api.decorator.UserDecorator:extend() end
+
+---Abstract: no-args constructor must be implemented and will be called once per tree render.
+---Must set all fields.
+---
+function nvim_tree.api.decorator.UserDecorator:new() end
+
+---Abstract: optionally implement to set the node's icon
+---
+---@param node nvim_tree.api.Node
+---@return nvim_tree.api.HighlightedString? icon_node
+function nvim_tree.api.decorator.UserDecorator:icon_node(node) end
+
+---Abstract: optionally implement to provide icons and the highlight groups for your icon_placement.
+---
+---@param node nvim_tree.api.Node
+---@return nvim_tree.api.HighlightedString[]? icons
+function nvim_tree.api.decorator.UserDecorator:icons(node) end
+
+---Abstract: optionally implement to provide one highlight group to apply to your highlight_range.
+---
+---@param node nvim_tree.api.Node
+---@return string? highlight_group
+function nvim_tree.api.decorator.UserDecorator:highlight_group(node) end
+
+---Define a sign. This should be called in the constructor.
+---
+---@protected
+---@param icon nvim_tree.api.HighlightedString?
+function nvim_tree.api.decorator.UserDecorator:define_sign(icon) end

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

@@ -1,10 +1,10 @@
-local log = require "nvim-tree.log"
-local view = require "nvim-tree.view"
-local utils = require "nvim-tree.utils"
-local renderer = require "nvim-tree.renderer"
-local reload = require "nvim-tree.explorer.reload"
-local core = require "nvim-tree.core"
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local log = require("nvim-tree.log")
+local view = require("nvim-tree.view")
+local utils = require("nvim-tree.utils")
+local core = require("nvim-tree.core")
+
+local DirectoryNode = require("nvim-tree.node.directory")
+local Iterator = require("nvim-tree.iterators.node-iterator")
 
 local M = {}
 
@@ -13,7 +13,8 @@ local running = {}
 ---Find a path in the tree, expand it and focus it
 ---@param path string relative or absolute
 function M.fn(path)
-  if not core.get_explorer() or not view.is_visible() then
+  local explorer = core.get_explorer()
+  if not explorer or not view.is_visible() then
     return
   end
 
@@ -31,8 +32,8 @@ function M.fn(path)
   local profile = log.profile_start("find file %s", path_real)
 
   -- refresh the contents of all parents, expanding groups as needed
-  if utils.get_node_from_path(path_real) == nil then
-    reload.refresh_parent_nodes_for_path(vim.fn.fnamemodify(path_real, ":h"))
+  if explorer:get_node_from_path(path_real) == nil then
+    explorer:refresh_parent_nodes_for_path(vim.fn.fnamemodify(path_real, ":h"))
   end
 
   local line = core.get_nodes_starting_line()
@@ -59,25 +60,33 @@ function M.fn(path)
       local link_match = node.link_to and vim.startswith(path_real, node.link_to .. utils.path_separator)
 
       if abs_match or link_match then
-        if not node.group_next then
-          node.open = true
+        local dir = node:as(DirectoryNode)
+        if dir then
+          if not dir.group_next then
+            dir.open = true
           end
-        if #node.nodes == 0 then
-          core.get_explorer():expand(node)
-          if node.group_next and incremented_line then
+          if #dir.nodes == 0 then
+            core.get_explorer():expand(dir)
+            if dir.group_next and incremented_line then
               line = line - 1
             end
           end
         end
+      end
     end)
     :recursor(function(node)
+      node = node and node:as(DirectoryNode)
+      if node then
         return node.group_next and { node.group_next } or (node.open and #node.nodes > 0 and node.nodes)
+      else
+        return nil
+      end
     end)
     :iterate()
 
   if found and view.is_visible() then
-    renderer.draw()
-    view.set_cursor { line, 0 }
+    explorer.renderer:draw()
+    view.set_cursor({ line, 0 })
   end
 
   running[path_real] = false

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

@@ -0,0 +1,6 @@
+local M = {}
+
+M.find_file = require("nvim-tree.actions.finders.find-file")
+M.search_node = require("nvim-tree.actions.finders.search-node")
+
+return M

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 core = require("nvim-tree.core")
 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/clipboard.lua

@@ -0,0 +1,391 @@
+local lib = require("nvim-tree.lib")
+local log = require("nvim-tree.log")
+local utils = require("nvim-tree.utils")
+local core = require("nvim-tree.core")
+local events = require("nvim-tree.events")
+local notify = require("nvim-tree.notify")
+
+local find_file = require("nvim-tree.actions.finders.find-file").fn
+
+local Class = require("nvim-tree.classic")
+local DirectoryNode = require("nvim-tree.node.directory")
+
+---@alias ClipboardAction "copy" | "cut"
+---@alias ClipboardData table<ClipboardAction, Node[]>
+
+---@alias ClipboardActionFn fun(source: string, dest: string): boolean, string?
+
+---@class (exact) Clipboard: Class
+---@field private explorer Explorer
+---@field private data ClipboardData
+---@field private clipboard_name string
+---@field private reg string
+local Clipboard = Class:extend()
+
+---@class Clipboard
+---@overload fun(args: ClipboardArgs): Clipboard
+
+---@class (exact) ClipboardArgs
+---@field explorer Explorer
+
+---@protected
+---@param args ClipboardArgs
+function Clipboard:new(args)
+  self.explorer = args.explorer
+
+  self.data = {
+    copy = {},
+    cut = {},
+  }
+
+  self.clipboard_name = self.explorer.opts.actions.use_system_clipboard and "system" or "neovim"
+  self.reg = self.explorer.opts.actions.use_system_clipboard and "+" or "1"
+end
+
+---@param source string
+---@param destination string
+---@return boolean
+---@return string|nil
+local function do_copy(source, destination)
+  local source_stats, err = vim.loop.fs_stat(source)
+
+  if not source_stats then
+    log.line("copy_paste", "do_copy fs_stat '%s' failed '%s'", source, err)
+    return false, err
+  end
+
+  log.line("copy_paste", "do_copy %s '%s' -> '%s'", source_stats.type, source, destination)
+
+  if source == destination then
+    log.line("copy_paste", "do_copy source and destination are the same, exiting early")
+    return true
+  end
+
+  if source_stats.type == "file" then
+    local success
+    success, err = vim.loop.fs_copyfile(source, destination)
+    if not success then
+      log.line("copy_paste", "do_copy fs_copyfile failed '%s'", err)
+      return false, err
+    end
+    return true
+  elseif source_stats.type == "directory" then
+    local handle
+    handle, err = vim.loop.fs_scandir(source)
+    if type(handle) == "string" then
+      return false, handle
+    elseif not handle then
+      log.line("copy_paste", "do_copy fs_scandir '%s' failed '%s'", source, err)
+      return false, err
+    end
+
+    local success
+    success, err = vim.loop.fs_mkdir(destination, source_stats.mode)
+    if not success then
+      log.line("copy_paste", "do_copy fs_mkdir '%s' failed '%s'", destination, err)
+      return false, err
+    end
+
+    while true do
+      local name, _ = vim.loop.fs_scandir_next(handle)
+      if not name then
+        break
+      end
+
+      local new_name = utils.path_join({ source, name })
+      local new_destination = utils.path_join({ destination, name })
+      success, err = do_copy(new_name, new_destination)
+      if not success then
+        return false, err
+      end
+    end
+  else
+    err = string.format("'%s' illegal file type '%s'", source, source_stats.type)
+    log.line("copy_paste", "do_copy %s", err)
+    return false, err
+  end
+
+  return true
+end
+
+---@param source string
+---@param dest string
+---@param action ClipboardAction
+---@param action_fn ClipboardActionFn
+---@return boolean|nil -- success
+---@return string|nil -- error message
+local function do_single_paste(source, dest, action, action_fn)
+  local notify_source = notify.render_path(source)
+
+  log.line("copy_paste", "do_single_paste '%s' -> '%s'", source, dest)
+
+  local dest_stats, err, err_name = vim.loop.fs_stat(dest)
+  if not dest_stats and err_name ~= "ENOENT" then
+    notify.error("Could not " .. action .. " " .. notify_source .. " - " .. (err or "???"))
+    return false, err
+  end
+
+  local function on_process()
+    local success, error = action_fn(source, dest)
+    if not success then
+      notify.error("Could not " .. action .. " " .. notify_source .. " - " .. (error or "???"))
+      return false, error
+    end
+
+    find_file(utils.path_remove_trailing(dest))
+  end
+
+  if dest_stats then
+    local input_opts = {
+      prompt = "Rename to ",
+      default = dest,
+      completion = "dir",
+    }
+
+    if source == dest then
+      vim.ui.input(input_opts, function(new_dest)
+        utils.clear_prompt()
+        if new_dest then
+          do_single_paste(source, new_dest, action, action_fn)
+        end
+      end)
+    else
+      local prompt_select = "Overwrite " .. dest .. " ?"
+      local prompt_input = prompt_select .. " R(ename)/y/n: "
+      lib.prompt(prompt_input, prompt_select, { "", "y", "n" }, { "Rename", "Yes", "No" }, "nvimtree_overwrite_rename", function(item_short)
+        utils.clear_prompt()
+        if item_short == "y" then
+          on_process()
+        elseif item_short == "" or item_short == "r" then
+          vim.ui.input(input_opts, function(new_dest)
+            utils.clear_prompt()
+            if new_dest then
+              do_single_paste(source, new_dest, action, action_fn)
+            end
+          end)
+        end
+      end)
+    end
+  else
+    on_process()
+  end
+end
+
+---@param node Node
+---@param clip ClipboardData
+local function toggle(node, clip)
+  if node.name == ".." then
+    return
+  end
+  local notify_node = notify.render_path(node.absolute_path)
+
+  if utils.array_remove(clip, node) then
+    notify.info(notify_node .. " removed from clipboard.")
+    return
+  end
+
+  table.insert(clip, node)
+  notify.info(notify_node .. " added to clipboard.")
+end
+
+---Clear copied and cut
+function Clipboard:clear_clipboard()
+  self.data.copy = {}
+  self.data.cut = {}
+  notify.info("Clipboard has been emptied.")
+  self.explorer.renderer:draw()
+end
+
+---Copy one node
+---@param node Node
+function Clipboard:copy(node)
+  utils.array_remove(self.data.cut, node)
+  toggle(node, self.data.copy)
+  self.explorer.renderer:draw()
+end
+
+---Cut one node
+---@param node Node
+function Clipboard:cut(node)
+  utils.array_remove(self.data.copy, node)
+  toggle(node, self.data.cut)
+  self.explorer.renderer:draw()
+end
+
+---Paste cut or cop
+---@private
+---@param node Node
+---@param action ClipboardAction
+---@param action_fn ClipboardActionFn
+function Clipboard:do_paste(node, action, action_fn)
+  if node.name == ".." then
+    node = self.explorer
+  else
+    local dir = node:as(DirectoryNode)
+    if dir then
+      node = dir:last_group_node()
+    end
+  end
+  local clip = self.data[action]
+  if #clip == 0 then
+    return
+  end
+
+  local destination = node.absolute_path
+  local stats, err, err_name = vim.loop.fs_stat(destination)
+  if not stats and err_name ~= "ENOENT" then
+    log.line("copy_paste", "do_paste fs_stat '%s' failed '%s'", destination, err)
+    notify.error("Could not " .. action .. " " .. notify.render_path(destination) .. " - " .. (err or "???"))
+    return
+  end
+  local is_dir = stats and stats.type == "directory"
+  if not is_dir then
+    destination = vim.fn.fnamemodify(destination, ":p:h")
+  end
+
+  for _, _node in ipairs(clip) do
+    local dest = utils.path_join({ destination, _node.name })
+    do_single_paste(_node.absolute_path, dest, action, action_fn)
+  end
+
+  self.data[action] = {}
+  if not self.explorer.opts.filesystem_watchers.enable then
+    self.explorer:reload_explorer()
+  end
+end
+
+---@param source string
+---@param destination string
+---@return boolean
+---@return string?
+local function do_cut(source, destination)
+  log.line("copy_paste", "do_cut '%s' -> '%s'", source, destination)
+
+  if source == destination then
+    log.line("copy_paste", "do_cut source and destination are the same, exiting early")
+    return true
+  end
+
+  events._dispatch_will_rename_node(source, destination)
+  local success, errmsg = vim.loop.fs_rename(source, destination)
+  if not success then
+    log.line("copy_paste", "do_cut fs_rename failed '%s'", errmsg)
+    return false, errmsg
+  end
+  utils.rename_loaded_buffers(source, destination)
+  events._dispatch_node_renamed(source, destination)
+  return true
+end
+
+---Paste cut (if present) or copy (if present)
+---@param node Node
+function Clipboard:paste(node)
+  if self.data.cut[1] ~= nil then
+    self:do_paste(node, "cut", do_cut)
+  elseif self.data.copy[1] ~= nil then
+    self:do_paste(node, "copy", do_copy)
+  end
+end
+
+function Clipboard:print_clipboard()
+  local content = {}
+  if #self.data.cut > 0 then
+    table.insert(content, "Cut")
+    for _, node in pairs(self.data.cut) do
+      table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
+    end
+  end
+  if #self.data.copy > 0 then
+    table.insert(content, "Copy")
+    for _, node in pairs(self.data.copy) do
+      table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
+    end
+  end
+
+  notify.info(table.concat(content, "\n") .. "\n")
+end
+
+---@param content string
+function Clipboard:copy_to_reg(content)
+  -- 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$', self.reg))
+  end)
+  vim.api.nvim_buf_delete(temp_buf, {})
+
+  notify.info(string.format("Copied %s to %s clipboard!", content, self.clipboard_name))
+end
+
+---@param node Node
+function Clipboard:copy_filename(node)
+  if node.name == ".." then
+    -- root
+    self:copy_to_reg(vim.fn.fnamemodify(self.explorer.absolute_path, ":t"))
+  else
+    -- node
+    self:copy_to_reg(node.name)
+  end
+end
+
+---@param node Node
+function Clipboard:copy_basename(node)
+  if node.name == ".." then
+    -- root
+    self:copy_to_reg(vim.fn.fnamemodify(self.explorer.absolute_path, ":t:r"))
+  else
+    -- node
+    self:copy_to_reg(vim.fn.fnamemodify(node.name, ":r"))
+  end
+end
+
+---@param node Node
+function Clipboard:copy_path(node)
+  if node.name == ".." then
+    -- root
+    self:copy_to_reg(utils.path_add_trailing(""))
+  else
+    -- node
+    local absolute_path = node.absolute_path
+    local cwd = core.get_cwd()
+    if cwd == nil then
+      return
+    end
+
+    local relative_path = utils.path_relative(absolute_path, cwd)
+    if node:is(DirectoryNode) then
+      self:copy_to_reg(utils.path_add_trailing(relative_path))
+    else
+      self:copy_to_reg(relative_path)
+    end
+  end
+end
+
+---@param node Node
+function Clipboard:copy_absolute_path(node)
+  if node.name == ".." then
+    node = self.explorer
+  end
+
+  local absolute_path = node.absolute_path
+  local content = node.nodes ~= nil and utils.path_add_trailing(absolute_path) or absolute_path
+  self:copy_to_reg(content)
+end
+
+---Node is cut. Will not be copied.
+---@param node Node
+---@return boolean
+function Clipboard:is_cut(node)
+  return vim.tbl_contains(self.data.cut, node)
+end
+
+---Node is copied. Will not be cut.
+---@param node Node
+---@return boolean
+function Clipboard:is_copied(node)
+  return vim.tbl_contains(self.data.copy, node)
+end
+
+return Clipboard

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

@@ -1,350 +0,0 @@
-local lib = require "nvim-tree.lib"
-local log = require "nvim-tree.log"
-local utils = require "nvim-tree.utils"
-local core = require "nvim-tree.core"
-local events = require "nvim-tree.events"
-local notify = require "nvim-tree.notify"
-local renderer = require "nvim-tree.renderer"
-local reloaders = require "nvim-tree.actions.reloaders.reloaders"
-
-local HL_POSITION = require("nvim-tree.enum").HL_POSITION
-
-local find_file = require("nvim-tree.actions.finders.find-file").fn
-
-local M = {
-  config = {},
-}
-
-local clipboard = {
-  cut = {},
-  copy = {},
-}
-
----@param source string
----@param destination string
----@return boolean
----@return string|nil
-local function do_copy(source, destination)
-  local source_stats, handle
-  local success, errmsg
-
-  source_stats, errmsg = vim.loop.fs_stat(source)
-  if not source_stats then
-    log.line("copy_paste", "do_copy fs_stat '%s' failed '%s'", source, errmsg)
-    return false, errmsg
-  end
-
-  log.line("copy_paste", "do_copy %s '%s' -> '%s'", source_stats.type, source, destination)
-
-  if source == destination then
-    log.line("copy_paste", "do_copy source and destination are the same, exiting early")
-    return true
-  end
-
-  if source_stats.type == "file" then
-    success, errmsg = vim.loop.fs_copyfile(source, destination)
-    if not success then
-      log.line("copy_paste", "do_copy fs_copyfile failed '%s'", errmsg)
-      return false, errmsg
-    end
-    return true
-  elseif source_stats.type == "directory" then
-    handle, errmsg = vim.loop.fs_scandir(source)
-    if type(handle) == "string" then
-      return false, handle
-    elseif not handle then
-      log.line("copy_paste", "do_copy fs_scandir '%s' failed '%s'", source, errmsg)
-      return false, errmsg
-    end
-
-    success, errmsg = vim.loop.fs_mkdir(destination, source_stats.mode)
-    if not success then
-      log.line("copy_paste", "do_copy fs_mkdir '%s' failed '%s'", destination, errmsg)
-      return false, errmsg
-    end
-
-    while true do
-      local name, _ = vim.loop.fs_scandir_next(handle)
-      if not name then
-        break
-      end
-
-      local new_name = utils.path_join { source, name }
-      local new_destination = utils.path_join { destination, name }
-      success, errmsg = do_copy(new_name, new_destination)
-      if not success then
-        return false, errmsg
-      end
-    end
-  else
-    errmsg = string.format("'%s' illegal file type '%s'", source, source_stats.type)
-    log.line("copy_paste", "do_copy %s", errmsg)
-    return false, errmsg
-  end
-
-  return true
-end
-
----@param source string
----@param dest string
----@param action_type string
----@param action_fn fun(source: string, dest: string)
----@return boolean|nil -- success
----@return string|nil -- error message
-local function do_single_paste(source, dest, action_type, action_fn)
-  local dest_stats
-  local success, errmsg, errcode
-  local notify_source = notify.render_path(source)
-
-  log.line("copy_paste", "do_single_paste '%s' -> '%s'", source, dest)
-
-  dest_stats, errmsg, errcode = vim.loop.fs_stat(dest)
-  if not dest_stats and errcode ~= "ENOENT" then
-    notify.error("Could not " .. action_type .. " " .. notify_source .. " - " .. (errmsg or "???"))
-    return false, errmsg
-  end
-
-  local function on_process()
-    success, errmsg = action_fn(source, dest)
-    if not success then
-      notify.error("Could not " .. action_type .. " " .. notify_source .. " - " .. (errmsg or "???"))
-      return false, errmsg
-    end
-
-    find_file(utils.path_remove_trailing(dest))
-  end
-
-  if dest_stats then
-    local input_opts = {
-      prompt = "Rename to ",
-      default = dest,
-      completion = "dir",
-    }
-
-    if source == dest then
-      vim.ui.input(input_opts, function(new_dest)
-        utils.clear_prompt()
-        if new_dest then
-          do_single_paste(source, new_dest, action_type, action_fn)
-        end
-      end)
-    else
-      local prompt_select = "Overwrite " .. dest .. " ?"
-      local prompt_input = prompt_select .. " R(ename)/y/n: "
-      lib.prompt(prompt_input, prompt_select, { "", "y", "n" }, { "Rename", "Yes", "No" }, function(item_short)
-        utils.clear_prompt()
-        if item_short == "y" then
-          on_process()
-        elseif item_short == "" or item_short == "r" then
-          vim.ui.input(input_opts, function(new_dest)
-            utils.clear_prompt()
-            if new_dest then
-              do_single_paste(source, new_dest, action_type, action_fn)
-            end
-          end)
-        end
-      end)
-    end
-  else
-    on_process()
-  end
-end
-
----@param node Node
----@param clip table
-local function toggle(node, clip)
-  if node.name == ".." then
-    return
-  end
-  local notify_node = notify.render_path(node.absolute_path)
-
-  if utils.array_remove(clip, node) then
-    notify.info(notify_node .. " removed from clipboard.")
-    return
-  end
-
-  table.insert(clip, node)
-  notify.info(notify_node .. " added to clipboard.")
-end
-
-function M.clear_clipboard()
-  clipboard.cut = {}
-  clipboard.copy = {}
-  notify.info "Clipboard has been emptied."
-  renderer.draw()
-end
-
----@param node Node
-function M.copy(node)
-  utils.array_remove(clipboard.cut, node)
-  toggle(node, clipboard.copy)
-  renderer.draw()
-end
-
----@param node Node
-function M.cut(node)
-  utils.array_remove(clipboard.copy, node)
-  toggle(node, clipboard.cut)
-  renderer.draw()
-end
-
----@param node Node
----@param action_type string
----@param action_fn fun(source: string, dest: string)
-local function do_paste(node, action_type, action_fn)
-  node = lib.get_last_group_node(node)
-  local explorer = core.get_explorer()
-  if node.name == ".." and explorer then
-    node = explorer
-  end
-  local clip = clipboard[action_type]
-  if #clip == 0 then
-    return
-  end
-
-  local destination = node.absolute_path
-  local stats, errmsg, errcode = vim.loop.fs_stat(destination)
-  if not stats and errcode ~= "ENOENT" then
-    log.line("copy_paste", "do_paste fs_stat '%s' failed '%s'", destination, errmsg)
-    notify.error("Could not " .. action_type .. " " .. notify.render_path(destination) .. " - " .. (errmsg or "???"))
-    return
-  end
-  local is_dir = stats and stats.type == "directory"
-  if not is_dir then
-    destination = vim.fn.fnamemodify(destination, ":p:h")
-  end
-
-  for _, _node in ipairs(clip) do
-    local dest = utils.path_join { destination, _node.name }
-    do_single_paste(_node.absolute_path, dest, action_type, action_fn)
-  end
-
-  clipboard[action_type] = {}
-  if not M.config.filesystem_watchers.enable then
-    reloaders.reload_explorer()
-  end
-end
-
----@param source string
----@param destination string
----@return boolean
----@return string?
-local function do_cut(source, destination)
-  log.line("copy_paste", "do_cut '%s' -> '%s'", source, destination)
-
-  if source == destination then
-    log.line("copy_paste", "do_cut source and destination are the same, exiting early")
-    return true
-  end
-
-  events._dispatch_will_rename_node(source, destination)
-  local success, errmsg = vim.loop.fs_rename(source, destination)
-  if not success then
-    log.line("copy_paste", "do_cut fs_rename failed '%s'", errmsg)
-    return false, errmsg
-  end
-  utils.rename_loaded_buffers(source, destination)
-  events._dispatch_node_renamed(source, destination)
-  return true
-end
-
----@param node Node
-function M.paste(node)
-  if clipboard.cut[1] ~= nil then
-    do_paste(node, "cut", do_cut)
-  else
-    do_paste(node, "copy", do_copy)
-  end
-end
-
-function M.print_clipboard()
-  local content = {}
-  if #clipboard.cut > 0 then
-    table.insert(content, "Cut")
-    for _, node in pairs(clipboard.cut) do
-      table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
-    end
-  end
-  if #clipboard.copy > 0 then
-    table.insert(content, "Copy")
-    for _, node in pairs(clipboard.copy) do
-      table.insert(content, " * " .. (notify.render_path(node.absolute_path)))
-    end
-  end
-
-  notify.info(table.concat(content, "\n") .. "\n")
-end
-
----@param content string
-local function copy_to_clipboard(content)
-  local clipboard_name
-  if M.config.actions.use_system_clipboard == true then
-    vim.fn.setreg("+", content)
-    vim.fn.setreg('"', content)
-    clipboard_name = "system"
-  else
-    vim.fn.setreg('"', content)
-    vim.fn.setreg("1", content)
-    clipboard_name = "neovim"
-  end
-
-  vim.api.nvim_exec_autocmds("TextYankPost", {})
-  notify.info(string.format("Copied %s to %s clipboard!", content, clipboard_name))
-end
-
----@param node Node
-function M.copy_filename(node)
-  copy_to_clipboard(node.name)
-end
-
----@param node Node
-function M.copy_path(node)
-  local absolute_path = node.absolute_path
-  local cwd = core.get_cwd()
-  if cwd == nil then
-    return
-  end
-
-  local relative_path = utils.path_relative(absolute_path, cwd)
-  local content = node.nodes ~= nil and utils.path_add_trailing(relative_path) or relative_path
-  copy_to_clipboard(content)
-end
-
----@param node Node
-function M.copy_absolute_path(node)
-  local absolute_path = node.absolute_path
-  local content = node.nodes ~= nil and utils.path_add_trailing(absolute_path) or absolute_path
-  copy_to_clipboard(content)
-end
-
---- Clipboard text highlight group and position when highlight_clipboard.
----@param node Node
----@return HL_POSITION position none when clipboard empty
----@return string|nil group only when node present in clipboard
-function M.get_highlight(node)
-  if M.hl_pos == HL_POSITION.none then
-    return HL_POSITION.none, nil
-  end
-
-  for _, n in ipairs(clipboard.cut) do
-    if node == n then
-      return M.hl_pos, "NvimTreeCutHL"
-    end
-  end
-
-  for _, n in ipairs(clipboard.copy) do
-    if node == n then
-      return M.hl_pos, "NvimTreeCopiedHL"
-    end
-  end
-
-  return HL_POSITION.none, nil
-end
-
-function M.setup(opts)
-  M.config.filesystem_watchers = opts.filesystem_watchers
-  M.config.actions = opts.actions
-  M.hl_pos = HL_POSITION[opts.renderer.highlight_clipboard] or HL_POSITION.none
-end
-
-return M

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

@@ -1,18 +1,20 @@
-local utils = require "nvim-tree.utils"
-local events = require "nvim-tree.events"
-local lib = require "nvim-tree.lib"
-local core = require "nvim-tree.core"
-local notify = require "nvim-tree.notify"
+local utils = require("nvim-tree.utils")
+local events = require("nvim-tree.events")
+local core = require("nvim-tree.core")
+local notify = require("nvim-tree.notify")
 
 local find_file = require("nvim-tree.actions.finders.find-file").fn
 
+local FileNode = require("nvim-tree.node.file")
+local DirectoryNode = require("nvim-tree.node.directory")
+
 local M = {}
 
 ---@param file string
 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
@@ -30,34 +32,21 @@ local function get_num_nodes(iter)
   return i
 end
 
----@param node Node
----@return string
-local function get_containing_folder(node)
-  if node.nodes ~= nil then
-    return utils.path_add_trailing(node.absolute_path)
-  end
-  local node_name_size = #(node.name or "")
-  return node.absolute_path:sub(0, -node_name_size - 1)
-end
-
----@param node Node|nil
+---@param node Node?
 function M.fn(node)
-  local cwd = core.get_cwd()
-  if cwd == nil then
+  node = node or core.get_explorer()
+  if not node then
     return
   end
 
-  node = node and lib.get_last_group_node(node)
-  if not node or node.name == ".." then
-    node = {
-      absolute_path = cwd,
-      name = "",
-      nodes = core.get_explorer().nodes,
-      open = true,
-    }
+  local dir = node:is(FileNode) and node.parent or node:as(DirectoryNode)
+  if not dir then
+    return
   end
 
-  local containing_folder = get_containing_folder(node)
+  dir = dir:last_group_node()
+
+  local containing_folder = utils.path_add_trailing(dir.absolute_path)
 
   local input_opts = {
     prompt = "Create file ",
@@ -72,7 +61,7 @@ function M.fn(node)
     end
 
     if utils.file_exists(new_file_path) then
-      notify.warn "Cannot create: file already exists"
+      notify.warn("Cannot create: file already exists")
       return
     end
 
@@ -87,10 +76,10 @@ function M.fn(node)
     for path in utils.path_split(new_file_path) 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 }
+      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 }
+        path_to_create = utils.path_join({ path_to_create, p })
       end
       if is_last_path_file and idx == num_nodes then
         create_and_notify(path_to_create)

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

@@ -0,0 +1,14 @@
+local M = {}
+
+M.create_file = require("nvim-tree.actions.fs.create-file")
+M.remove_file = require("nvim-tree.actions.fs.remove-file")
+M.rename_file = require("nvim-tree.actions.fs.rename-file")
+M.trash = require("nvim-tree.actions.fs.trash")
+
+function M.setup(opts)
+  M.remove_file.setup(opts)
+  M.rename_file.setup(opts)
+  M.trash.setup(opts)
+end
+
+return M

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

@@ -1,8 +1,12 @@
-local utils = require "nvim-tree.utils"
-local events = require "nvim-tree.events"
-local view = require "nvim-tree.view"
-local lib = require "nvim-tree.lib"
-local notify = require "nvim-tree.notify"
+local core = require("nvim-tree.core")
+local utils = require("nvim-tree.utils")
+local events = require("nvim-tree.events")
+local view = require("nvim-tree.view")
+local lib = require("nvim-tree.lib")
+local notify = require("nvim-tree.notify")
+
+local DirectoryLinkNode = require("nvim-tree.node.directory-link")
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {
   config = {},
@@ -26,13 +30,13 @@ end
 
 ---@param absolute_path string
 local function clear_buffer(absolute_path)
-  local bufs = vim.fn.getbufinfo { bufloaded = 1, buflisted = 1 }
+  local bufs = vim.fn.getbufinfo({ bufloaded = 1, buflisted = 1 })
   for _, buf in pairs(bufs) do
     if buf.name == absolute_path then
       local tree_winnr = vim.api.nvim_get_current_win()
       if buf.hidden == 0 and (#bufs > 1 or view.View.float.enable) then
         vim.api.nvim_set_current_win(buf.windows[1])
-        vim.cmd ":bn"
+        vim.cmd(":bn")
       end
       vim.api.nvim_buf_delete(buf.bufnr, { force = true })
       if not view.View.float.quit_on_focus_loss then
@@ -49,20 +53,32 @@ end
 ---@param cwd string
 ---@return boolean|nil
 local function remove_dir(cwd)
-  local handle = vim.loop.fs_scandir(cwd)
-  if type(handle) == "string" then
-    notify.error(handle)
+  local handle, err = vim.loop.fs_scandir(cwd)
+  if not handle then
+    notify.error(err)
     return
   end
 
   while true do
-    local name, t = vim.loop.fs_scandir_next(handle)
+    local name, _ = vim.loop.fs_scandir_next(handle)
     if not name then
       break
     end
 
-    local new_cwd = utils.path_join { cwd, name }
-    if t == "directory" then
+    local new_cwd = utils.path_join({ cwd, name })
+
+    -- Type must come from fs_stat and not fs_scandir_next to maintain sshfs compatibility
+    local stat = vim.loop.fs_stat(new_cwd)
+    -- TODO remove once 0.12 is the minimum neovim version
+    -- path incorrectly specified as an integer, fixed upstream for neovim 0.12 https://github.com/neovim/neovim/pull/33872
+    ---@diagnostic disable-next-line: param-type-mismatch
+    local lstat = vim.loop.fs_lstat(new_cwd)
+
+    local type = stat and stat.type or nil
+    -- Checks if file is a link file to ensure deletion of the symlink instead of the file it points to
+    local ltype = lstat and lstat.type or nil
+
+    if type == "directory" and ltype ~= "link" then
       local success = remove_dir(new_cwd)
       if not success then
         return false
@@ -83,7 +99,7 @@ end
 ---@param node Node
 function M.remove(node)
   local notify_node = notify.render_path(node.absolute_path)
-  if node.nodes ~= nil and not node.link_to then
+  if node:is(DirectoryNode) and not node:is(DirectoryLinkNode) then
     local success = remove_dir(node.absolute_path)
     if not success then
       notify.error("Could not remove " .. notify_node)
@@ -111,8 +127,9 @@ function M.fn(node)
 
   local function do_remove()
     M.remove(node)
-    if not M.config.filesystem_watchers.enable then
-      require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+    local explorer = core.get_explorer()
+    if not M.config.filesystem_watchers.enable and explorer then
+      explorer:reload_explorer()
     end
   end
 
@@ -130,7 +147,7 @@ function M.fn(node)
       items_long = { "No", "Yes" }
     end
 
-    lib.prompt(prompt_input, prompt_select, items_short, items_long, function(item_short)
+    lib.prompt(prompt_input, prompt_select, items_short, items_long, "nvimtree_remove", function(item_short)
       utils.clear_prompt()
       if item_short == "y" or item_short == (M.config.ui.confirm.default_yes and "") then
         do_remove()

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

@@ -1,14 +1,26 @@
-local lib = require "nvim-tree.lib"
-local utils = require "nvim-tree.utils"
-local events = require "nvim-tree.events"
-local notify = require "nvim-tree.notify"
+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 find_file = require("nvim-tree.actions.finders.find-file").fn
 
+local DirectoryNode = require("nvim-tree.node.directory")
+
 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,27 +32,70 @@ 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
 ---@return fun(node: Node, modifier: string)
@@ -48,11 +103,15 @@ function M.fn(default_modifier)
   default_modifier = default_modifier or ":t"
 
   return function(node, modifier)
-    if type(node) ~= "table" then
-      node = lib.get_node_at_cursor()
+    local explorer = core.get_explorer()
+    if not explorer then
+      return
     end
 
-    if node == nil then
+    if type(node) ~= "table" then
+      node = explorer:get_node_at_cursor()
+    end
+    if not node then
       return
     end
 
@@ -66,7 +125,10 @@ function M.fn(default_modifier)
       return
     end
 
-    node = lib.get_last_group_node(node)
+    local dir = node:as(DirectoryNode)
+    if dir then
+      node = dir:last_group_node()
+    end
     if node.name == ".." then
       return
     end
@@ -100,12 +162,14 @@ function M.fn(default_modifier)
         return
       end
 
-      M.rename(node, prepend .. new_file_path .. append)
+      local full_new_path = prepend .. new_file_path .. append
+
+      M.rename(node, full_new_path)
       if not M.config.filesystem_watchers.enable then
-        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+        explorer:reload_explorer()
       end
 
-      find_file(utils.path_remove_trailing(new_file_path))
+      find_file(utils.path_remove_trailing(full_new_path))
     end)
   end
 end

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

@@ -1,22 +1,26 @@
-local lib = require "nvim-tree.lib"
-local notify = require "nvim-tree.notify"
+local core = require("nvim-tree.core")
+local lib = require("nvim-tree.lib")
+local notify = require("nvim-tree.notify")
+
+local DirectoryLinkNode = require("nvim-tree.node.directory-link")
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {
   config = {},
 }
 
-local utils = require "nvim-tree.utils"
-local events = require "nvim-tree.events"
+local utils = require("nvim-tree.utils")
+local events = require("nvim-tree.events")
 
 ---@param absolute_path string
 local function clear_buffer(absolute_path)
-  local bufs = vim.fn.getbufinfo { bufloaded = 1, buflisted = 1 }
+  local bufs = vim.fn.getbufinfo({ bufloaded = 1, buflisted = 1 })
   for _, buf in pairs(bufs) do
     if buf.name == absolute_path then
       if buf.hidden == 0 and #bufs > 1 then
         local winnr = vim.api.nvim_get_current_win()
         vim.api.nvim_set_current_win(buf.windows[1])
-        vim.cmd ":bn"
+        vim.cmd(":bn")
         vim.api.nvim_set_current_win(winnr)
       end
       vim.api.nvim_buf_delete(buf.bufnr, {})
@@ -41,25 +45,27 @@ 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,
     })
     if need_sync_wait then
-      vim.fn.jobwait { job }
+      vim.fn.jobwait({ job })
     end
   end
 
-  if node.nodes ~= nil and not node.link_to then
+  local explorer = core.get_explorer()
+
+  if node:is(DirectoryNode) and not node:is(DirectoryLinkNode) then
     trash_path(function(_, rc)
       if rc ~= 0 then
         notify.warn("trash failed: " .. err_msg .. "; please see :help nvim-tree.trash")
         return
       end
       events._dispatch_folder_removed(node.absolute_path)
-      if not M.config.filesystem_watchers.enable then
-        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+      if not M.config.filesystem_watchers.enable and explorer then
+        explorer:reload_explorer()
       end
     end)
   else
@@ -71,8 +77,8 @@ function M.remove(node)
       end
       events._dispatch_file_removed(node.absolute_path)
       clear_buffer(node.absolute_path)
-      if not M.config.filesystem_watchers.enable then
-        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+      if not M.config.filesystem_watchers.enable and explorer then
+        explorer:reload_explorer()
       end
     end)
   end
@@ -102,7 +108,7 @@ function M.fn(node)
       items_long = { "No", "Yes" }
     end
 
-    lib.prompt(prompt_input, prompt_select, items_short, items_long, function(item_short)
+    lib.prompt(prompt_input, prompt_select, items_short, items_long, "nvimtree_trash", function(item_short)
       utils.clear_prompt()
       if item_short == "y" or item_short == (M.config.ui.confirm.default_yes and "") then
         do_trash()

lua/nvim-tree/actions/init.lua

@@ -1,18 +1,17 @@
 local M = {}
 
+M.finders = require("nvim-tree.actions.finders")
+M.fs = require("nvim-tree.actions.fs")
+M.moves = require("nvim-tree.actions.moves")
+M.node = require("nvim-tree.actions.node")
+M.root = require("nvim-tree.actions.root")
+M.tree = require("nvim-tree.actions.tree")
+
 function M.setup(opts)
-  require("nvim-tree.actions.fs.trash").setup(opts)
-  require("nvim-tree.actions.node.system-open").setup(opts)
-  require("nvim-tree.actions.node.file-popup").setup(opts)
-  require("nvim-tree.actions.node.open-file").setup(opts)
-  require("nvim-tree.actions.root.change-dir").setup(opts)
-  require("nvim-tree.actions.fs.rename-file").setup(opts)
-  require("nvim-tree.actions.fs.remove-file").setup(opts)
-  require("nvim-tree.actions.fs.copy-paste").setup(opts)
-  require("nvim-tree.actions.tree-modifiers.expand-all").setup(opts)
-  require("nvim-tree.actions.tree.find-file").setup(opts)
-  require("nvim-tree.actions.tree.open").setup(opts)
-  require("nvim-tree.actions.tree.toggle").setup(opts)
+  M.fs.setup(opts)
+  M.node.setup(opts)
+  M.root.setup(opts)
+  M.tree.setup(opts)
 end
 
 return M

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

@@ -0,0 +1,7 @@
+local M = {}
+
+M.item = require("nvim-tree.actions.moves.item")
+M.parent = require("nvim-tree.actions.moves.parent")
+M.sibling = require("nvim-tree.actions.moves.sibling")
+
+return M

lua/nvim-tree/actions/moves/item.lua

@@ -1,21 +1,48 @@
-local utils = require "nvim-tree.utils"
-local view = require "nvim-tree.view"
-local core = require "nvim-tree.core"
-local lib = require "nvim-tree.lib"
-local explorer_node = require "nvim-tree.explorer.node"
+local view = require("nvim-tree.view")
+local core = require("nvim-tree.core")
+local diagnostics = require("nvim-tree.diagnostics")
+
+local FileNode = require("nvim-tree.node.file")
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {}
+local MAX_DEPTH = 100
 
----@param where string
----@param what string
----@return fun()
-function M.fn(where, what)
-  return function()
-    local node_cur = lib.get_node_at_cursor()
+---Return the status of the node or nil if no status, depending on the type of
+---status.
+---@param node Node to inspect
+---@param what string? type of status
+---@param skip_gitignored boolean? default false
+---@return boolean
+local function status_is_valid(node, what, skip_gitignored)
+  if what == "git" then
+    local git_xy = node:get_git_xy()
+    return git_xy ~= nil and (not skip_gitignored or git_xy[1] ~= "!!")
+  elseif what == "diag" then
+    local diag_status = diagnostics.get_diag_status(node)
+    return diag_status ~= nil and diag_status.value ~= nil
+  elseif what == "opened" then
+    return vim.fn.bufloaded(node.absolute_path) ~= 0
+  end
+
+  return false
+end
+
+---Move to the next node that has a valid status. If none found, don't move.
+---@param explorer Explorer
+---@param where string? where to move (forwards or backwards)
+---@param what string? type of status
+---@param skip_gitignored boolean? default false
+local function move(explorer, where, what, skip_gitignored)
   local first_node_line = core.get_nodes_starting_line()
-    local nodes_by_line = utils.get_nodes_by_line(core.get_explorer().nodes, first_node_line)
+  local nodes_by_line = explorer:get_nodes_by_line(first_node_line)
   local iter_start, iter_end, iter_step, cur, first, nex
 
+  local cursor = explorer:get_cursor_position()
+  if cursor and cursor[1] < first_node_line then
+    cur = cursor[1]
+  end
+
   if where == "next" then
     iter_start, iter_end, iter_step = first_node_line, #nodes_by_line, 1
   elseif where == "prev" then
@@ -24,21 +51,13 @@ function M.fn(where, what)
 
   for line = iter_start, iter_end, iter_step do
     local node = nodes_by_line[line]
-      local valid = false
-
-      if what == "git" then
-        valid = explorer_node.get_git_status(node) ~= nil
-      elseif what == "diag" then
-        valid = node.diag_status ~= nil
-      elseif what == "opened" then
-        valid = vim.fn.bufloaded(node.absolute_path) ~= 0
-      end
+    local valid = status_is_valid(node, what, skip_gitignored)
 
     if not first and valid then
       first = line
     end
 
-      if node == node_cur then
+    if cursor and line == cursor[1] then
       cur = line
     elseif valid and cur then
       nex = line
@@ -47,9 +66,179 @@ function M.fn(where, what)
   end
 
   if nex then
-      view.set_cursor { nex, 0 }
+    view.set_cursor({ nex, 0 })
   elseif vim.o.wrapscan and first then
-      view.set_cursor { first, 0 }
+    view.set_cursor({ first, 0 })
+  end
+end
+
+---@param node DirectoryNode
+local function expand_node(node)
+  if not node.open then
+    -- Expand the node.
+    -- Should never collapse since we checked open.
+    node:expand_or_collapse(false)
+  end
+end
+
+--- Move to the next node recursively.
+---@param explorer Explorer
+---@param what string? type of status
+---@param skip_gitignored? boolean default false
+local function move_next_recursive(explorer, what, skip_gitignored)
+  -- If the current node:
+  -- * is a directory
+  -- * and is not the root node
+  -- * and has a git/diag status
+  -- * and is not opened
+  -- expand it.
+  local node_init = explorer:get_node_at_cursor()
+  if not node_init then
+    return
+  end
+  local valid = false
+  if node_init.name ~= ".." then -- root node cannot have a status
+    valid = status_is_valid(node_init, what, skip_gitignored)
+  end
+  local node_dir = node_init:as(DirectoryNode)
+  if node_dir and valid and not node_dir.open then
+    node_dir:expand_or_collapse(false)
+  end
+
+  move(explorer, "next", what, skip_gitignored)
+
+  local node_cur = explorer:get_node_at_cursor()
+  if not node_cur then
+    return
+  end
+
+  -- If we haven't moved at all at this point, return.
+  if node_init == node_cur then
+    return
+  end
+
+  -- i is used to limit iterations.
+  local i = 0
+  local dir_cur = node_cur:as(DirectoryNode)
+  while dir_cur and i < MAX_DEPTH do
+    expand_node(dir_cur)
+
+    move(explorer, "next", what, skip_gitignored)
+
+    -- Save current node.
+    node_cur = explorer:get_node_at_cursor()
+    dir_cur = node_cur and node_cur:as(DirectoryNode)
+
+    i = i + 1
+  end
+end
+
+--- Move to the previous node recursively.
+---
+--- move_prev_recursive:
+---
+--- 1) Save current as node_init.
+--  2) Call a non-recursive prev.
+--- 3) If current node is node_init's parent, call move_prev_recursive.
+--- 4) Else:
+--- 4.1) If current node is nil, is node_init (we didn't move), or is a file, return.
+--- 4.2) The current file is a directory, expand it.
+--- 4.3) Find node_init in current window, and move to it (if not found, return).
+---      If node_init is the root node (name = ".."), directly move to position 1.
+--- 4.4) Call a non-recursive prev.
+--- 4.5) Save the current node and start back from 4.1.
+---
+---@param explorer Explorer
+---@param what string? type of status
+---@param skip_gitignored boolean? default false
+local function move_prev_recursive(explorer, what, skip_gitignored)
+  local node_init, node_cur
+
+  -- 1)
+  node_init = explorer:get_node_at_cursor()
+  if node_init == nil then
+    return
+  end
+
+  -- 2)
+  move(explorer, "prev", what, skip_gitignored)
+
+  node_cur = explorer:get_node_at_cursor()
+  if node_cur == node_init.parent then
+    -- 3)
+    move_prev_recursive(explorer, what, skip_gitignored)
+  else
+    -- i is used to limit iterations.
+    local i = 0
+    while i < MAX_DEPTH do
+      -- 4.1)
+      if
+        node_cur == nil
+        or node_cur == node_init -- we didn't move
+        or node_cur:is(FileNode) -- node is a file
+      then
+        return
+      end
+
+      -- 4.2)
+      local node_dir = node_cur:as(DirectoryNode)
+      if node_dir then
+        expand_node(node_dir)
+      end
+
+      -- 4.3)
+      if node_init.name == ".." then -- root node
+        view.set_cursor({ 1, 0 })    -- move to root node (position 1)
+      else
+        local node_init_line = explorer:find_node_line(node_init)
+        if node_init_line < 0 then
+          return
+        end
+        view.set_cursor({ node_init_line, 0 })
+      end
+
+      -- 4.4)
+      move(explorer, "prev", what, skip_gitignored)
+
+      -- 4.5)
+      node_cur = explorer:get_node_at_cursor()
+
+      i = i + 1
+    end
+  end
+end
+
+---@class NavigationItemOpts
+---@field where string?
+---@field what string?
+---@field skip_gitignored boolean?
+---@field recurse boolean?
+
+---@param opts NavigationItemOpts
+---@return fun()
+function M.fn(opts)
+  return function()
+    local explorer = core.get_explorer()
+    if not explorer then
+      return
+    end
+
+    local recurse = false
+
+    -- recurse only valid for git and diag moves.
+    if (opts.what == "git" or opts.what == "diag") and opts.recurse ~= nil then
+      recurse = opts.recurse
+    end
+
+    if not recurse then
+      move(explorer, opts.where, opts.what, opts.skip_gitignored)
+      return
+    end
+
+    if opts.where == "next" then
+      move_next_recursive(explorer, opts.what, opts.skip_gitignored)
+    elseif opts.where == "prev" then
+      move_prev_recursive(explorer, opts.what, opts.skip_gitignored)
     end
   end
 end

lua/nvim-tree/actions/moves/parent.lua

@@ -1,8 +1,5 @@
-local renderer = require "nvim-tree.renderer"
-local view = require "nvim-tree.view"
-local utils = require "nvim-tree.utils"
-local core = require "nvim-tree.core"
-local lib = require "nvim-tree.lib"
+local view = require("nvim-tree.view")
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {}
 
@@ -11,27 +8,33 @@ local M = {}
 function M.fn(should_close)
   should_close = should_close or false
 
+  ---@param node Node
   return function(node)
-    node = lib.get_last_group_node(node)
-    if should_close and node.open then
-      node.open = false
-      return renderer.draw()
+    local dir = node:as(DirectoryNode)
+    if dir then
+      dir = dir:last_group_node()
+      if should_close and dir.open then
+        dir.open = false
+        dir.explorer.renderer:draw()
+        return
+      end
     end
 
-    local parent = utils.get_parent_of_group(node).parent
+    local parent = (node:get_parent_of_group() or node).parent
 
     if not parent or not parent.parent then
-      return view.set_cursor { 1, 0 }
+      view.set_cursor({ 1, 0 })
+      return
     end
 
-    local _, line = utils.find_node(core.get_explorer().nodes, function(n)
+    local _, line = parent.explorer:find_node(function(n)
       return n.absolute_path == parent.absolute_path
     end)
 
-    view.set_cursor { line + 1, 0 }
+    view.set_cursor({ line + 1, 0 })
     if should_close then
       parent.open = false
-      renderer.draw()
+      parent.explorer.renderer:draw()
     end
   end
 end

lua/nvim-tree/actions/moves/sibling.lua

@@ -1,6 +1,5 @@
-local utils = require "nvim-tree.utils"
-local core = require "nvim-tree.core"
-local Iterator = require "nvim-tree.iterators.node-iterator"
+local core = require("nvim-tree.core")
+local Iterator = require("nvim-tree.iterators.node-iterator")
 
 local M = {}
 
@@ -12,10 +11,15 @@ function M.fn(direction)
       return
     end
 
+    local explorer = core.get_explorer()
+    if not explorer then
+      return
+    end
+
     local first, last, next, prev = nil, nil, nil, nil
     local found = false
-    local parent = node.parent or core.get_explorer()
-    Iterator.builder(parent.nodes)
+    local parent = node.parent or explorer
+    Iterator.builder(parent and parent.nodes or {})
       :recursor(function()
         return nil
       end)
@@ -45,7 +49,7 @@ function M.fn(direction)
     end
 
     if target_node then
-      utils.focus_file(target_node.absolute_path)
+      explorer:focus_node_or_parent(target_node)
     end
   end
 end

lua/nvim-tree/actions/node/buffer.lua

@@ -0,0 +1,58 @@
+-- Copyright 2019 Yazdani Kiyan under MIT License
+local notify = require("nvim-tree.notify")
+
+local M = {}
+
+---@param node Node
+---@param opts ApiNodeDeleteWipeBufferOpts|nil
+---@return nil
+function M.delete(node, opts)
+  M.delete_buffer("delete", node.absolute_path, opts)
+end
+
+---@param node Node
+---@param opts ApiNodeDeleteWipeBufferOpts|nil
+---@return nil
+function M.wipe(node, opts)
+  M.delete_buffer("wipe", node.absolute_path, opts)
+end
+
+---@alias ApiNodeDeleteWipeBufferMode '"delete"'|'"wipe"'
+
+---@param mode ApiNodeDeleteWipeBufferMode
+---@param filename string
+---@param opts ApiNodeDeleteWipeBufferOpts|nil
+---@return nil
+function M.delete_buffer(mode, filename, opts)
+  if type(mode) ~= "string" then
+    mode = "delete"
+  end
+
+  local buf_fn = vim.cmd.bdelete
+  if mode == "wipe" then
+    buf_fn = vim.cmd.bwipe
+  end
+
+  opts = opts or { force = false }
+
+  local notify_node = notify.render_path(filename)
+
+  -- check if buffer for file at cursor exists and if it is loaded
+  local bufnr_at_filename = vim.fn.bufnr(filename)
+  if bufnr_at_filename == -1 or vim.fn.getbufinfo(bufnr_at_filename)[1].loaded == 0 then
+    notify.info("No loaded buffer coincides with " .. notify_node)
+    return
+  end
+
+  local force = opts.force
+  -- check if buffer is modified
+  local buf_modified = vim.fn.getbufinfo(bufnr_at_filename)[1].changed
+  if not force and buf_modified == 1 then
+    notify.error("Buffer for file " .. notify_node .. " is modified")
+    return
+  end
+
+  buf_fn({ filename, bang = force })
+end
+
+return M

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

@@ -1,4 +1,4 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
 
 local M = {}
 
@@ -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)
@@ -42,14 +50,17 @@ local function setup_window(node)
     file_path = node.absolute_path,
   }
   local bufnr = vim.api.nvim_create_buf(false, true)
+  vim.bo[bufnr].bufhidden = "wipe"
   vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
   vim.api.nvim_win_set_buf(winnr, bufnr)
 end
 
 function M.close_popup()
   if current_popup ~= nil then
-    vim.api.nvim_win_close(current_popup.winnr, { force = true })
-    vim.cmd "augroup NvimTreeRemoveFilePopup | au! CursorMoved | augroup END"
+    if vim.api.nvim_win_is_valid(current_popup.winnr) then
+      vim.api.nvim_win_close(current_popup.winnr, true)
+    end
+    vim.cmd("augroup NvimTreeRemoveFilePopup | au! CursorMoved | augroup END")
 
     current_popup = nil
   end

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

@@ -0,0 +1,15 @@
+local M = {}
+
+M.file_popup = require("nvim-tree.actions.node.file-popup")
+M.open_file = require("nvim-tree.actions.node.open-file")
+M.run_command = require("nvim-tree.actions.node.run-command")
+M.system_open = require("nvim-tree.actions.node.system-open")
+M.buffer = require("nvim-tree.actions.node.buffer")
+
+function M.setup(opts)
+  require("nvim-tree.actions.node.system-open").setup(opts)
+  require("nvim-tree.actions.node.file-popup").setup(opts)
+  require("nvim-tree.actions.node.open-file").setup(opts)
+end
+
+return M

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

@@ -1,8 +1,9 @@
 -- Copyright 2019 Yazdani Kiyan under MIT License
-local lib = require "nvim-tree.lib"
-local notify = require "nvim-tree.notify"
-local utils = require "nvim-tree.utils"
-local view = require "nvim-tree.view"
+local lib = require("nvim-tree.lib")
+local notify = require("nvim-tree.notify")
+local utils = require("nvim-tree.utils")
+local full_name = require("nvim-tree.renderer.components.full-name")
+local view = require("nvim-tree.view")
 
 local M = {}
 
@@ -26,28 +27,28 @@ 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 id ~= full_name.popup_win
+      and win_config.focusable
+      and not win_config.hide
+      and not win_config.external
+      or false
   end, win_ids)
 end
 
----Find the first window in the tab that is not NvimTree.
----@return integer -1 if none available
-local function first_win_id()
-  local selectable = usable_win_ids()
-  if #selectable > 0 then
-    return selectable[1]
-  else
-    return -1
-  end
-end
-
 ---Get user to pick a window in the tab that is not NvimTree.
 ---@return integer|nil -- If a valid window was picked, return its id. If an
 ---       invalid window was picked / user canceled, return nil. If there are
@@ -69,10 +70,19 @@ local function pick_win_id()
   end
 
   local i = 1
-  local win_opts = {}
+  local win_opts_selectable = {}
+  local win_opts_unselectable = {}
   local win_map = {}
   local laststatus = vim.o.laststatus
   vim.o.laststatus = 2
+  local fillchars = vim.opt.fillchars:get()
+  local stl = fillchars.stl
+  local stlnc = fillchars.stlnc
+  fillchars.stl = nil
+  fillchars.stlnc = nil
+  vim.opt.fillchars = fillchars
+  fillchars.stl = stl
+  fillchars.stlnc = stlnc
 
   local tabpage = vim.api.nvim_get_current_tabpage()
   local win_ids = vim.api.nvim_tabpage_list_wins(tabpage)
@@ -83,33 +93,53 @@ 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_hl, winhl = pcall(vim.api.nvim_win_get_option, win_id, "winhl")
+      local ok_status, statusline
 
-      win_opts[win_id] = {
+      if vim.fn.has("nvim-0.10") == 1 then
+        ok_status, statusline = pcall(vim.api.nvim_get_option_value, "statusline", { win = win_id })
+      else
+        ok_status, statusline = pcall(vim.api.nvim_win_get_option, win_id, "statusline") ---@diagnostic disable-line: deprecated
+      end
+
+      win_opts_unselectable[win_id] = {
         statusline = ok_status and statusline or "",
-        winhl = ok_hl and winhl or "",
       }
 
       -- 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")
 
-    win_opts[id] = {
+    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_selectable[id] = {
       statusline = ok_status and statusline or "",
       winhl = ok_hl and winhl or "",
     }
     win_map[char] = id
 
-    vim.api.nvim_win_set_option(id, "statusline", "%=" .. char .. "%=")
-    vim.api.nvim_win_set_option(id, "winhl", "StatusLine:NvimTreeWindowPicker,StatusLineNC:NvimTreeWindowPicker")
+    if vim.fn.has("nvim-0.10") == 1 then
+      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
@@ -117,9 +147,9 @@ local function pick_win_id()
     end
   end
 
-  vim.cmd "redraw"
+  vim.cmd("redraw")
   if vim.opt.cmdheight._value ~= 0 then
-    print "Pick window: "
+    print("Pick window: ")
   end
   local _, resp = pcall(get_user_input_char)
   resp = (resp or ""):upper()
@@ -127,20 +157,32 @@ 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)
+    for opt, value in pairs(win_opts_selectable[id]) do
+      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
-      for opt, value in pairs(win_opts[id]) do
-        vim.api.nvim_win_set_option(id, opt, value)
+      -- Ensure window still exists at this point
+      if vim.api.nvim_win_is_valid(id) then
+        for opt, value in pairs(win_opts_unselectable[id]) do
+          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
 
   vim.o.laststatus = laststatus
+  vim.opt.fillchars = fillchars
 
   if not vim.tbl_contains(vim.split(M.window_picker.chars, ""), resp) then
     return
@@ -153,13 +195,27 @@ local function open_file_in_tab(filename)
   if M.quit_on_open then
     view.close()
   end
-  vim.cmd("tabe " .. vim.fn.fnameescape(filename))
+  if M.relative_path then
+    filename = utils.path_relative(filename, vim.fn.getcwd())
+  end
+  vim.cmd.tabnew()
+  vim.bo.bufhidden = "wipe"
+  -- Following vim.fn.tabnew the # buffer may be set to the tree buffer. There is no way to clear the # buffer via vim.fn.setreg as it requires a valid buffer. Clear # by setting it to a new temporary scratch buffer.
+  if utils.is_nvim_tree_buf(vim.fn.bufnr("#")) then
+    local tmpbuf = vim.api.nvim_create_buf(false, true)
+    vim.fn.setreg("#", tmpbuf)
+    vim.api.nvim_buf_delete(tmpbuf, { force = true })
+  end
+  vim.cmd.edit(vim.fn.fnameescape(filename))
 end
 
 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 +223,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
 
@@ -188,12 +247,16 @@ end
 
 local function get_target_winid(mode)
   local target_winid
-  if not M.window_picker.enable or mode == "edit_no_picker" or mode == "preview_no_picker" then
+  if not M.window_picker.enable or string.find(mode, "no_picker") then
     target_winid = lib.target_winid
-
-    -- first available window
-    if not vim.tbl_contains(vim.api.nvim_tabpage_list_wins(0), target_winid) then
-      target_winid = first_win_id()
+    local usable_wins = usable_win_ids()
+    -- first available usable window
+    if not vim.tbl_contains(usable_wins, target_winid) then
+      if #usable_wins > 0 then
+        target_winid = usable_wins[1]
+      else
+        target_winid = -1
+      end
     end
   else
     -- pick a window
@@ -233,6 +296,11 @@ local function open_in_new_window(filename, mode)
     return
   end
 
+  local position = string.find(mode, "no_picker")
+  if position then
+    mode = string.sub(mode, 0, position - 2)
+  end
+
   -- non-floating, non-nvim-tree windows
   local win_ids = vim.tbl_filter(function(id)
     local config = vim.api.nvim_win_get_config(id)
@@ -251,32 +319,28 @@ local function open_in_new_window(filename, mode)
 
     -- No need to split, as we created a new window.
     create_new_window = false
-    if mode:match "split$" then
+    if mode:match("split$") then
       mode = "edit"
     end
   elseif not vim.o.hidden then
     -- 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
-      if not mode:match "split$" 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 +350,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,11 +382,15 @@ 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
 
 ---@param mode string
 ---@param filename string
+---@return nil
 function M.fn(mode, filename)
   if type(mode) ~= "string" then
     mode = ""
@@ -357,6 +442,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.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/node/run-command.lua

@@ -1,5 +1,5 @@
-local utils = require "nvim-tree.utils"
-local core = require "nvim-tree.core"
+local utils = require("nvim-tree.utils")
+local core = require("nvim-tree.core")
 
 local M = {}
 

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

@@ -1,12 +1,12 @@
-local notify = require "nvim-tree.notify"
-local utils = require "nvim-tree.utils"
+local notify = require("nvim-tree.notify")
+local utils = require("nvim-tree.utils")
 
 local M = {}
 
 ---@param node Node
-function M.fn(node)
+local function user(node)
   if #M.config.system_open.cmd == 0 then
-    require("nvim-tree.utils").notify.warn "Cannot open file with system application. Unrecognized platform."
+    require("nvim-tree.utils").notify.warn("Cannot open file with system application. Unrecognized platform.")
     return
   end
 
@@ -49,10 +49,30 @@ function M.fn(node)
   vim.loop.unref(process.handle)
 end
 
+---@param node Node
+local function native(node)
+  local _, err = vim.ui.open(node.link_to or node.absolute_path)
+
+  -- err only provided on opener executable not found hence logging path is not useful
+  if err then
+    notify.warn(err)
+  end
+end
+
+---@param node Node
+function M.fn(node)
+  M.open(node)
+end
+
+-- TODO #2430 always use native once 0.10 is the minimum neovim version
 function M.setup(opts)
   M.config = {}
   M.config.system_open = opts.system_open or {}
 
+  if vim.fn.has("nvim-0.10") == 1 and #M.config.system_open.cmd == 0 then
+    M.open = native
+  else
+    M.open = user
     if #M.config.system_open.cmd == 0 then
       if utils.is_windows then
         M.config.system_open = {
@@ -66,5 +86,6 @@ function M.setup(opts)
       end
     end
   end
+end
 
 return M

lua/nvim-tree/actions/reloaders/reloaders.lua

@@ -1,74 +0,0 @@
-local git = require "nvim-tree.git"
-local view = require "nvim-tree.view"
-local renderer = require "nvim-tree.renderer"
-local explorer_module = require "nvim-tree.explorer"
-local core = require "nvim-tree.core"
-local explorer_node = require "nvim-tree.explorer.node"
-local Iterator = require "nvim-tree.iterators.node-iterator"
-
-local M = {}
-
----@param node Explorer|nil
----@param projects table
----@param unloaded_bufnr number|nil
-local function refresh_nodes(node, projects, unloaded_bufnr)
-  Iterator.builder({ node })
-    :applier(function(n)
-      if n.nodes then
-        local toplevel = git.get_toplevel(n.cwd or n.link_to or n.absolute_path)
-        explorer_module.reload(n, projects[toplevel] or {}, unloaded_bufnr)
-      end
-    end)
-    :recursor(function(n)
-      return n.group_next and { n.group_next } or (n.open and n.nodes)
-    end)
-    :iterate()
-end
-
----@param parent_node Node|nil
----@param projects table
-function M.reload_node_status(parent_node, projects)
-  if parent_node == nil then
-    return
-  end
-
-  local toplevel = git.get_toplevel(parent_node.absolute_path)
-  local status = projects[toplevel] or {}
-  for _, node in ipairs(parent_node.nodes) do
-    explorer_node.update_git_status(node, explorer_node.is_git_ignored(parent_node), status)
-    if node.nodes and #node.nodes > 0 then
-      M.reload_node_status(node, projects)
-    end
-  end
-end
-
-local event_running = false
----@param _ table|nil unused node passed by action
----@param unloaded_bufnr number|nil optional bufnr recently unloaded via BufUnload event
-function M.reload_explorer(_, unloaded_bufnr)
-  if event_running or not core.get_explorer() or vim.v.exiting ~= vim.NIL then
-    return
-  end
-  event_running = true
-
-  local projects = git.reload()
-  refresh_nodes(core.get_explorer(), projects, unloaded_bufnr)
-  if view.is_visible() then
-    renderer.draw(unloaded_bufnr)
-  end
-  event_running = false
-end
-
-function M.reload_git()
-  if not core.get_explorer() or not git.config.git.enable or event_running then
-    return
-  end
-  event_running = true
-
-  local projects = git.reload()
-  M.reload_node_status(core.get_explorer(), projects)
-  renderer.draw()
-  event_running = false
-end
-
-return M

lua/nvim-tree/actions/root/change-dir.lua

@@ -1,6 +1,6 @@
-local log = require "nvim-tree.log"
-local utils = require "nvim-tree.utils"
-local core = require "nvim-tree.core"
+local log = require("nvim-tree.log")
+local utils = require("nvim-tree.utils")
+local core = require("nvim-tree.core")
 
 local M = {
   current_tab = vim.api.nvim_get_current_tabpage(),
@@ -25,7 +25,7 @@ end
 ---@param new_tabpage integer
 ---@return boolean
 local function is_window_event(new_tabpage)
-  local is_event_scope_window = vim.v.event.scope == "window" or vim.v.event.changed_window
+  local is_event_scope_window = vim.v.event.scope == "window" or vim.v.event.changed_window or false
   return is_event_scope_window and new_tabpage == M.current_tab
 end
 
@@ -91,7 +91,10 @@ M.force_dirchange = add_profiling_to(function(foldername, should_open_view)
   if should_open_view then
     require("nvim-tree.lib").open()
   else
-    require("nvim-tree.renderer").draw()
+    local explorer = core.get_explorer()
+    if explorer then
+      explorer.renderer:draw()
+    end
   end
 end)
 

lua/nvim-tree/actions/root/dir-up.lua

@@ -1,12 +1,12 @@
-local utils = require "nvim-tree.utils"
-local core = require "nvim-tree.core"
+local utils = require("nvim-tree.utils")
+local core = require("nvim-tree.core")
 
 local M = {}
 
 ---@param node Node
 function M.fn(node)
   if not node or node.name == ".." then
-    require("nvim-tree.actions.root.change-dir").fn ".."
+    require("nvim-tree.actions.root.change-dir").fn("..")
   else
     local cwd = core.get_cwd()
     if cwd == nil then

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

@@ -0,0 +1,10 @@
+local M = {}
+
+M.change_dir = require("nvim-tree.actions.root.change-dir")
+M.dir_up = require("nvim-tree.actions.root.dir-up")
+
+function M.setup(opts)
+  M.change_dir.setup(opts)
+end
+
+return M

lua/nvim-tree/actions/tree-modifiers/collapse-all.lua

@@ -1,53 +0,0 @@
-local renderer = require "nvim-tree.renderer"
-local utils = require "nvim-tree.utils"
-local core = require "nvim-tree.core"
-local lib = require "nvim-tree.lib"
-local Iterator = require "nvim-tree.iterators.node-iterator"
-
-local M = {}
-
----@return fun(path: string): boolean
-local function buf_match()
-  local buffer_paths = vim.tbl_map(function(buffer)
-    return vim.api.nvim_buf_get_name(buffer)
-  end, vim.api.nvim_list_bufs())
-
-  return function(path)
-    for _, buffer_path in ipairs(buffer_paths) do
-      local matches = utils.str_find(buffer_path, path)
-      if matches then
-        return true
-      end
-    end
-    return false
-  end
-end
-
----@param keep_buffers boolean
-function M.fn(keep_buffers)
-  local node = lib.get_node_at_cursor()
-  local explorer = core.get_explorer()
-
-  if explorer == nil then
-    return
-  end
-
-  local matches = buf_match()
-
-  Iterator.builder(explorer.nodes)
-    :hidden()
-    :applier(function(n)
-      if n.nodes ~= nil then
-        n.open = keep_buffers == true and matches(n.absolute_path)
-      end
-    end)
-    :recursor(function(n)
-      return n.group_next and { n.group_next } or n.nodes
-    end)
-    :iterate()
-
-  renderer.draw()
-  utils.focus_node_or_parent(node)
-end
-
-return M

lua/nvim-tree/actions/tree-modifiers/expand-all.lua

@@ -1,80 +0,0 @@
-local core = require "nvim-tree.core"
-local renderer = require "nvim-tree.renderer"
-local Iterator = require "nvim-tree.iterators.node-iterator"
-local notify = require "nvim-tree.notify"
-local lib = require "nvim-tree.lib"
-
-local M = {}
-
----@param list string[]
----@return table
-local function to_lookup_table(list)
-  local table = {}
-  for _, element in ipairs(list) do
-    table[element] = true
-  end
-
-  return table
-end
-
----@param node Node
-local function expand(node)
-  node = lib.get_last_group_node(node)
-  node.open = true
-  if #node.nodes == 0 then
-    core.get_explorer():expand(node)
-  end
-end
-
----@param expansion_count integer
----@param node Node
----@return boolean
-local function should_expand(expansion_count, node)
-  local should_halt = expansion_count >= M.MAX_FOLDER_DISCOVERY
-  local should_exclude = M.EXCLUDE[node.name]
-  return not should_halt and node.nodes and not node.open and not should_exclude
-end
-
-local function gen_iterator()
-  local expansion_count = 0
-
-  return function(parent)
-    if parent.parent and parent.nodes and not parent.open then
-      expansion_count = expansion_count + 1
-      expand(parent)
-    end
-
-    Iterator.builder(parent.nodes)
-      :hidden()
-      :applier(function(node)
-        if should_expand(expansion_count, node) then
-          expansion_count = expansion_count + 1
-          expand(node)
-        end
-      end)
-      :recursor(function(node)
-        return expansion_count < M.MAX_FOLDER_DISCOVERY and (node.group_next and { node.group_next } or (node.open and node.nodes))
-      end)
-      :iterate()
-
-    if expansion_count >= M.MAX_FOLDER_DISCOVERY then
-      return true
-    end
-  end
-end
-
----@param base_node table
-function M.fn(base_node)
-  local node = base_node.nodes and base_node or core.get_explorer()
-  if gen_iterator()(node) then
-    notify.warn("expansion iteration was halted after " .. M.MAX_FOLDER_DISCOVERY .. " discovered folders")
-  end
-  renderer.draw()
-end
-
-function M.setup(opts)
-  M.MAX_FOLDER_DISCOVERY = opts.actions.expand_all.max_folder_discovery
-  M.EXCLUDE = to_lookup_table(opts.actions.expand_all.exclude)
-end
-
-return M

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

@@ -1,39 +0,0 @@
-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.reloaders"
-
-local M = {}
-
-local function reload()
-  local node = lib.get_node_at_cursor()
-  reloaders.reload_explorer()
-  utils.focus_node_or_parent(node)
-end
-
-function M.custom()
-  filters.config.filter_custom = not filters.config.filter_custom
-  reload()
-end
-
-function M.git_ignored()
-  filters.config.filter_git_ignored = not filters.config.filter_git_ignored
-  reload()
-end
-
-function M.git_clean()
-  filters.config.filter_git_clean = not filters.config.filter_git_clean
-  reload()
-end
-
-function M.no_buffer()
-  filters.config.filter_no_buffer = not filters.config.filter_no_buffer
-  reload()
-end
-
-function M.dotfiles()
-  filters.config.filter_dotfiles = not filters.config.filter_dotfiles
-  reload()
-end
-
-return M

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

@@ -1,7 +1,7 @@
-local core = require "nvim-tree.core"
-local lib = require "nvim-tree.lib"
-local view = require "nvim-tree.view"
-local finders_find_file = require "nvim-tree.actions.finders.find-file"
+local core = require("nvim-tree.core")
+local lib = require("nvim-tree.lib")
+local view = require("nvim-tree.view")
+local finders_find_file = require("nvim-tree.actions.finders.find-file")
 
 local M = {}
 
@@ -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
-    if not vim.api.nvim_buf_is_valid(opts.buf) then
+  elseif type(opts_buf) == "number" 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
@@ -48,14 +49,14 @@ function M.fn(opts)
     end
   elseif opts.open then
     -- open
-    lib.open { current_window = opts.current_window, winid = opts.winid }
+    lib.open({ current_window = opts.current_window, winid = opts.winid })
     if not opts.focus then
-      vim.cmd "noautocmd wincmd p"
+      vim.cmd("noautocmd wincmd p")
     end
   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

@@ -0,0 +1,17 @@
+local M = {}
+
+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/collapse.lua

@@ -0,0 +1,81 @@
+local utils = require("nvim-tree.utils")
+local core = require("nvim-tree.core")
+local Iterator = require("nvim-tree.iterators.node-iterator")
+
+local FileNode = require("nvim-tree.node.file")
+local DirectoryNode = require("nvim-tree.node.directory")
+
+local M = {}
+
+---@return fun(path: string): boolean
+local function buf_match()
+  local buffer_paths = vim.tbl_map(function(buffer)
+    return vim.api.nvim_buf_get_name(buffer)
+  end, vim.api.nvim_list_bufs())
+
+  return function(path)
+    for _, buffer_path in ipairs(buffer_paths) do
+      local matches = utils.str_find(buffer_path, path)
+      if matches then
+        return true
+      end
+    end
+    return false
+  end
+end
+
+---Collapse a node, root if nil
+---@param node Node?
+---@param opts ApiCollapseOpts
+local function collapse(node, opts)
+  local explorer = core.get_explorer()
+  if not explorer then
+    return
+  end
+
+  node = node or explorer
+
+  local node_at_cursor = explorer:get_node_at_cursor()
+  if not node_at_cursor then
+    return
+  end
+
+  local matches = buf_match()
+
+  Iterator.builder({ node:is(FileNode) and node.parent or node:as(DirectoryNode) })
+    :hidden()
+    :applier(function(n)
+      local dir = n:as(DirectoryNode)
+      if dir then
+        dir.open = opts.keep_buffers == true and matches(dir.absolute_path)
+      end
+    end)
+    :recursor(function(n)
+      return n.group_next and { n.group_next } or n.nodes
+    end)
+    :iterate()
+
+  explorer.renderer:draw()
+  explorer:focus_node_or_parent(node_at_cursor)
+end
+
+
+---@param opts ApiCollapseOpts|boolean|nil legacy -> opts.keep_buffers
+function M.all(opts)
+  -- legacy arguments
+  if type(opts) == "boolean" then
+    opts = {
+      keep_buffers = opts,
+    }
+  end
+
+  collapse(nil, opts or {})
+end
+
+---@param node Node
+---@param opts ApiCollapseOpts?
+function M.node(node, opts)
+  collapse(node, opts or {})
+end
+
+return M

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

@@ -0,0 +1,166 @@
+local core = require("nvim-tree.core")
+local Iterator = require("nvim-tree.iterators.node-iterator")
+local notify = require("nvim-tree.notify")
+
+local FileNode = require("nvim-tree.node.file")
+local DirectoryNode = require("nvim-tree.node.directory")
+
+local M = {}
+
+---@param list string[]
+---@return table
+local function to_lookup_table(list)
+  local table = {}
+  for _, element in ipairs(list) do
+    table[element] = true
+  end
+
+  return table
+end
+
+---@param node DirectoryNode
+local function expand(node)
+  node = node:last_group_node()
+  node.open = true
+  if #node.nodes == 0 then
+    core.get_explorer():expand(node)
+  end
+end
+
+---@param should_descend fun(expansion_count: integer, node: Node): boolean
+---@return fun(expansion_count: integer, node: Node): boolean
+local function limit_folder_discovery(should_descend)
+  return function(expansion_count, node)
+    local should_halt = expansion_count >= M.MAX_FOLDER_DISCOVERY
+    if should_halt then
+      notify.warn("expansion iteration was halted after " .. M.MAX_FOLDER_DISCOVERY .. " discovered folders")
+      return false
+    end
+
+    return should_descend(expansion_count, node)
+  end
+end
+
+---@param _ integer expansion_count
+---@param node Node
+---@return boolean
+local function descend_until_empty(_, node)
+
+  local dir = node:as(DirectoryNode)
+  if not dir then
+    return false
+  end
+
+  local should_exclude = M.EXCLUDE[dir.name]
+  return not should_exclude
+end
+
+---@param expansion_count integer
+---@param node Node
+---@param should_descend fun(expansion_count: integer, node: Node): boolean
+---@return boolean
+local function should_expand(expansion_count, node, should_descend)
+  local dir = node:as(DirectoryNode)
+  if not dir then
+    return false
+  end
+
+  if not dir.open and should_descend(expansion_count, node) then
+    if #node.nodes == 0 then
+      core.get_explorer():expand(dir) -- populate node.group_next
+    end
+
+    if dir.group_next then
+      local expand_next = should_expand(expansion_count, dir.group_next, should_descend)
+      if expand_next then
+        dir.open = true
+      end
+      return expand_next
+    else
+      return true
+    end
+  end
+  return false
+end
+
+
+---@param should_descend fun(expansion_count: integer, node: Node): boolean
+---@return fun(node): any
+local function gen_iterator(should_descend)
+  local expansion_count = 0
+
+  return function(parent)
+    if parent.parent and parent.nodes and not parent.open then
+      expansion_count = expansion_count + 1
+      expand(parent)
+    end
+
+    Iterator.builder(parent.nodes)
+      :hidden()
+      :applier(function(node)
+        if should_expand(expansion_count, node, should_descend) then
+          expansion_count = expansion_count + 1
+          node = node:as(DirectoryNode)
+          if node then
+            expand(node)
+          end
+        end
+      end)
+      :recursor(function(node)
+        if not should_descend(expansion_count, node) then
+          return nil
+        end
+
+        if node.group_next then
+          return { node.group_next }
+        end
+
+        if node.open and node.nodes then
+          return node.nodes
+        end
+
+        return nil
+      end)
+      :iterate()
+  end
+end
+
+---@param node Node?
+---@param expand_opts ApiTreeExpandOpts?
+local function expand_node(node, expand_opts)
+  if not node then
+    return
+  end
+  local descend_until = limit_folder_discovery((expand_opts and expand_opts.expand_until) or descend_until_empty)
+  gen_iterator(descend_until)(node)
+
+  local explorer = core.get_explorer()
+  if explorer then
+    explorer.renderer:draw()
+  end
+end
+
+---Expand the directory node or the root
+---@param node Node
+---@param expand_opts ApiTreeExpandOpts?
+function M.all(node, expand_opts)
+  expand_node(node and node:as(DirectoryNode) or core.get_explorer(), expand_opts)
+end
+
+---Expand the directory node or parent node
+---@param node Node
+---@param expand_opts ApiTreeExpandOpts?
+function M.node(node, expand_opts)
+  if not node then
+    return
+  end
+
+  expand_node(node:is(FileNode) and node.parent or node:as(DirectoryNode), expand_opts)
+end
+
+function M.setup(opts)
+  M.MAX_FOLDER_DISCOVERY = opts.actions.expand_all.max_folder_discovery
+  M.EXCLUDE = to_lookup_table(opts.actions.expand_all.exclude)
+end
+
+return M

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

@@ -0,0 +1,10 @@
+local M = {}
+
+M.collapse = require("nvim-tree.actions.tree.modifiers.collapse")
+M.expand = require("nvim-tree.actions.tree.modifiers.expand")
+
+function M.setup(opts)
+  M.expand.setup(opts)
+end
+
+return M

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

@@ -1,6 +1,6 @@
-local lib = require "nvim-tree.lib"
-local view = require "nvim-tree.view"
-local finders_find_file = require "nvim-tree.actions.finders.find-file"
+local lib = require("nvim-tree.lib")
+local view = require("nvim-tree.view")
+local finders_find_file = require("nvim-tree.actions.finders.find-file")
 
 local M = {}
 
@@ -29,11 +29,11 @@ function M.fn(opts)
     view.focus()
   else
     -- open
-    lib.open {
+    lib.open({
       path = opts.path,
       current_window = opts.current_window,
       winid = opts.winid,
-    }
+    })
   end
 
   -- find file

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/actions/tree/toggle.lua

@@ -1,6 +1,6 @@
-local lib = require "nvim-tree.lib"
-local view = require "nvim-tree.view"
-local finders_find_file = require "nvim-tree.actions.finders.find-file"
+local lib = require("nvim-tree.lib")
+local view = require("nvim-tree.view")
+local finders_find_file = require("nvim-tree.actions.finders.find-file")
 
 local M = {}
 
@@ -45,11 +45,11 @@ function M.fn(opts, no_focus, cwd, bang)
     view.close()
   else
     -- open
-    lib.open {
+    lib.open({
       path = opts.path,
       current_window = opts.current_window,
       winid = opts.winid,
-    }
+    })
 
     -- find file
     if M.config.update_focused_file.enable or opts.find_file then
@@ -64,7 +64,7 @@ function M.fn(opts, no_focus, cwd, bang)
 
     -- restore focus
     if not opts.focus then
-      vim.cmd "noautocmd wincmd p"
+      vim.cmd("noautocmd wincmd p")
     end
   end
 end

lua/nvim-tree/api.lua

@@ -1,4 +1,17 @@
-local notify = require "nvim-tree.notify"
+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_hi_test = require("nvim-tree.appearance.hi-test")
+local events = require("nvim-tree.events")
+local help = require("nvim-tree.help")
+local keymap = require("nvim-tree.keymap")
+local notify = require("nvim-tree.notify")
+
+local DirectoryNode = require("nvim-tree.node.directory")
+local FileLinkNode = require("nvim-tree.node.file-link")
+local RootNode = require("nvim-tree.node.root")
+local UserDecorator = require("nvim-tree.renderer.decorator.user")
 
 local Api = {
   tree = {},
@@ -11,6 +24,7 @@ local Api = {
     },
     run = {},
     open = {},
+    buffer = {},
   },
   events = {},
   marks = {
@@ -26,41 +40,88 @@ local Api = {
     mappings = {},
   },
   commands = {},
+  diagnostics = {},
+  decorator = {},
 }
 
---- Do nothing when setup not called.
---- f function to invoke
----@param f function
-local function wrap(f)
+---Print error when setup not called.
+---@param fn fun(...): any
+---@return fun(...): any
+local function wrap(fn)
   return function(...)
     if vim.g.NvimTreeSetup == 1 then
-      return f(...)
+      return fn(...)
     else
-      notify.error "nvim-tree setup not called"
+      notify.error("nvim-tree setup not called")
     end
   end
 end
 
----Inject the node as the first argument if absent.
----@param fn function function to invoke
+---Invoke a method on the singleton explorer.
+---Print error when setup not called.
+---@param explorer_method string explorer method name
+---@return fun(...): any
+local function wrap_explorer(explorer_method)
+  return wrap(function(...)
+    local explorer = core.get_explorer()
+    if explorer then
+      return explorer[explorer_method](explorer, ...)
+    end
+  end)
+end
+
+---Inject the node as the first argument if present otherwise do nothing.
+---@param fn fun(node: Node, ...): any
+---@return fun(node: Node?, ...): any
 local function wrap_node(fn)
   return function(node, ...)
-    node = node or require("nvim-tree.lib").get_node_at_cursor()
+    node = node or wrap_explorer("get_node_at_cursor")()
     if node then
-      fn(node, ...)
+      return fn(node, ...)
     end
   end
 end
 
 ---Inject the node or nil as the first argument if absent.
----@param fn function function to invoke
+---@param fn fun(node: Node?, ...): any
+---@return fun(node: Node?, ...): any
 local function wrap_node_or_nil(fn)
   return function(node, ...)
-    node = node or require("nvim-tree.lib").get_node_at_cursor()
-    fn(node, ...)
+    node = node or wrap_explorer("get_node_at_cursor")()
+    return fn(node, ...)
   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
+---@param ... any passed to method
+---@return fun(...): any
+local function wrap_explorer_member_args(explorer_member, member_method, ...)
+  local method_args = ...
+  return wrap(function(...)
+    local explorer = core.get_explorer()
+    if explorer then
+      return explorer[explorer_member][member_method](explorer[explorer_member], method_args, ...)
+    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
@@ -68,7 +129,8 @@ end
 ---@field find_file boolean|nil default false
 ---@field update_root boolean|nil default false
 
-Api.tree.open = wrap(require("nvim-tree.actions.tree.open").fn)
+Api.tree.open = wrap(actions.tree.open.fn)
+Api.tree.focus = Api.tree.open
 
 ---@class ApiTreeToggleOpts
 ---@field path string|nil
@@ -78,37 +140,37 @@ Api.tree.open = wrap(require("nvim-tree.actions.tree.open").fn)
 ---@field update_root boolean|nil default false
 ---@field focus boolean|nil default true
 
-Api.tree.toggle = wrap(require("nvim-tree.actions.tree.toggle").fn)
+Api.tree.toggle = wrap(actions.tree.toggle.fn)
+Api.tree.close = wrap(view.close)
+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_explorer("reload_explorer")
 
-Api.tree.close = wrap(require("nvim-tree.view").close)
+---@class ApiTreeResizeOpts
+---@field width string|function|number|table|nil
+---@field absolute number|nil
+---@field relative number|nil
 
-Api.tree.close_in_this_tab = wrap(require("nvim-tree.view").close_this_tab_only)
-
-Api.tree.close_in_all_tabs = wrap(require("nvim-tree.view").close_all_tabs)
-
-Api.tree.focus = wrap(function()
-  Api.tree.open()
-end)
-
-Api.tree.reload = wrap(require("nvim-tree.actions.reloaders.reloaders").reload_explorer)
+Api.tree.resize = wrap(actions.tree.resize.fn)
 
 Api.tree.change_root = wrap(function(...)
   require("nvim-tree").change_dir(...)
 end)
 
 Api.tree.change_root_to_node = wrap_node(function(node)
-  if node.name == ".." then
-    require("nvim-tree.actions.root.change-dir").fn ".."
-  elseif node.nodes ~= nil then
-    require("nvim-tree.actions.root.change-dir").fn(require("nvim-tree.lib").get_last_group_node(node).absolute_path)
+  if node.name == ".." or node:is(RootNode) then
+    actions.root.change_dir.fn("..")
+  else
+    node = node:as(DirectoryNode)
+    if node then
+      actions.root.change_dir.fn(node:last_group_node().absolute_path)
+    end
   end
 end)
 
-Api.tree.change_root_to_parent = wrap_node(require("nvim-tree.actions.root.dir-up").fn)
-
-Api.tree.get_node_under_cursor = wrap(require("nvim-tree.lib").get_node_at_cursor)
-
-Api.tree.get_nodes = wrap(require("nvim-tree.lib").get_nodes)
+Api.tree.change_root_to_parent = wrap_node(actions.root.dir_up.fn)
+Api.tree.get_node_under_cursor = wrap_explorer("get_node_at_cursor")
+Api.tree.get_nodes = wrap_explorer("get_nodes")
 
 ---@class ApiTreeFindFileOpts
 ---@field buf string|number|nil
@@ -118,138 +180,191 @@ Api.tree.get_nodes = wrap(require("nvim-tree.lib").get_nodes)
 ---@field update_root boolean|nil default false
 ---@field focus boolean|nil default false
 
-Api.tree.find_file = wrap(require("nvim-tree.actions.tree.find-file").fn)
+Api.tree.find_file = wrap(actions.tree.find_file.fn)
+Api.tree.search_node = wrap(actions.finders.search_node.fn)
 
-Api.tree.search_node = wrap(require("nvim-tree.actions.finders.search-node").fn)
+---@class ApiCollapseOpts
+---@field keep_buffers boolean|nil default false
 
-Api.tree.collapse_all = wrap(require("nvim-tree.actions.tree-modifiers.collapse-all").fn)
+Api.tree.collapse_all = wrap(actions.tree.modifiers.collapse.all)
 
-Api.tree.expand_all = wrap_node(require("nvim-tree.actions.tree-modifiers.expand-all").fn)
+---@class ApiTreeExpandOpts
+---@field expand_until (fun(expansion_count: integer, node: Node): boolean)|nil
 
-Api.tree.toggle_gitignore_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").git_ignored)
-
-Api.tree.toggle_git_clean_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").git_clean)
-
-Api.tree.toggle_no_buffer_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").no_buffer)
-
-Api.tree.toggle_custom_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").custom)
-
-Api.tree.toggle_hidden_filter = wrap(require("nvim-tree.actions.tree-modifiers.toggles").dotfiles)
-
-Api.tree.toggle_help = wrap(require("nvim-tree.help").toggle)
-
-Api.tree.is_tree_buf = wrap(require("nvim-tree.utils").is_nvim_tree_buf)
+Api.tree.expand_all = wrap_node(actions.tree.modifiers.expand.all)
+Api.tree.toggle_enable_filters = wrap_explorer_member("filters", "toggle")
+Api.tree.toggle_gitignore_filter = wrap_explorer_member_args("filters", "toggle", "git_ignored")
+Api.tree.toggle_git_clean_filter = wrap_explorer_member_args("filters", "toggle", "git_clean")
+Api.tree.toggle_no_buffer_filter = wrap_explorer_member_args("filters", "toggle", "no_buffer")
+Api.tree.toggle_custom_filter = wrap_explorer_member_args("filters", "toggle", "custom")
+Api.tree.toggle_hidden_filter = wrap_explorer_member_args("filters", "toggle", "dotfiles")
+Api.tree.toggle_no_bookmark_filter = wrap_explorer_member_args("filters", "toggle", "no_bookmark")
+Api.tree.toggle_help = wrap(help.toggle)
+Api.tree.is_tree_buf = wrap(utils.is_nvim_tree_buf)
 
 ---@class ApiTreeIsVisibleOpts
 ---@field tabpage number|nil
 ---@field any_tabpage boolean|nil default false
 
-Api.tree.is_visible = wrap(require("nvim-tree.view").is_visible)
+Api.tree.is_visible = wrap(view.is_visible)
 
 ---@class ApiTreeWinIdOpts
 ---@field tabpage number|nil default nil
 
-Api.tree.winid = wrap(require("nvim-tree.view").winid)
+Api.tree.winid = wrap(view.winid)
 
-Api.fs.create = wrap_node_or_nil(require("nvim-tree.actions.fs.create-file").fn)
-Api.fs.remove = wrap_node(require("nvim-tree.actions.fs.remove-file").fn)
-Api.fs.trash = wrap_node(require("nvim-tree.actions.fs.trash").fn)
-Api.fs.rename_node = wrap_node(require("nvim-tree.actions.fs.rename-file").fn ":t")
-Api.fs.rename = wrap_node(require("nvim-tree.actions.fs.rename-file").fn ":t")
-Api.fs.rename_sub = wrap_node(require("nvim-tree.actions.fs.rename-file").fn ":p:h")
-Api.fs.rename_basename = wrap_node(require("nvim-tree.actions.fs.rename-file").fn ":t:r")
-Api.fs.rename_full = wrap_node(require("nvim-tree.actions.fs.rename-file").fn ":p")
-Api.fs.cut = wrap_node(require("nvim-tree.actions.fs.copy-paste").cut)
-Api.fs.paste = wrap_node(require("nvim-tree.actions.fs.copy-paste").paste)
-Api.fs.clear_clipboard = wrap(require("nvim-tree.actions.fs.copy-paste").clear_clipboard)
-Api.fs.print_clipboard = wrap(require("nvim-tree.actions.fs.copy-paste").print_clipboard)
-Api.fs.copy.node = wrap_node(require("nvim-tree.actions.fs.copy-paste").copy)
-Api.fs.copy.absolute_path = wrap_node(require("nvim-tree.actions.fs.copy-paste").copy_absolute_path)
-Api.fs.copy.filename = wrap_node(require("nvim-tree.actions.fs.copy-paste").copy_filename)
-Api.fs.copy.relative_path = wrap_node(require("nvim-tree.actions.fs.copy-paste").copy_path)
+Api.fs.create = wrap_node_or_nil(actions.fs.create_file.fn)
+Api.fs.remove = wrap_node(actions.fs.remove_file.fn)
+Api.fs.trash = wrap_node(actions.fs.trash.fn)
+Api.fs.rename_node = wrap_node(actions.fs.rename_file.fn(":t"))
+Api.fs.rename = wrap_node(actions.fs.rename_file.fn(":t"))
+Api.fs.rename_sub = wrap_node(actions.fs.rename_file.fn(":p:h"))
+Api.fs.rename_basename = wrap_node(actions.fs.rename_file.fn(":t:r"))
+Api.fs.rename_full = wrap_node(actions.fs.rename_file.fn(":p"))
+Api.fs.cut = wrap_node(wrap_explorer_member("clipboard", "cut"))
+Api.fs.paste = wrap_node(wrap_explorer_member("clipboard", "paste"))
+Api.fs.clear_clipboard = wrap_explorer_member("clipboard", "clear_clipboard")
+Api.fs.print_clipboard = wrap_explorer_member("clipboard", "print_clipboard")
+Api.fs.copy.node = wrap_node(wrap_explorer_member("clipboard", "copy"))
+Api.fs.copy.absolute_path = wrap_node(wrap_explorer_member("clipboard", "copy_absolute_path"))
+Api.fs.copy.filename = wrap_node(wrap_explorer_member("clipboard", "copy_filename"))
+Api.fs.copy.basename = wrap_node(wrap_explorer_member("clipboard", "copy_basename"))
+Api.fs.copy.relative_path = wrap_node(wrap_explorer_member("clipboard", "copy_path"))
+---
+---@class NodeEditOpts
+---@field quit_on_open boolean|nil default false
+---@field focus boolean|nil default true
 
 ---@param mode string
----@param node table
-local function edit(mode, node)
-  local path = node.absolute_path
-  if node.link_to and not node.nodes then
-    path = node.link_to
+---@param node Node
+---@param edit_opts NodeEditOpts?
+local function edit(mode, node, edit_opts)
+  local file_link = node:as(FileLinkNode)
+  local path = file_link and file_link.link_to or node.absolute_path
+  local cur_tabpage = vim.api.nvim_get_current_tabpage()
+
+  actions.node.open_file.fn(mode, path)
+
+  edit_opts = edit_opts or {}
+
+  local mode_unsupported_quit_on_open = mode == "drop" or mode == "tab_drop" or mode == "edit_in_place"
+  if not mode_unsupported_quit_on_open and edit_opts.quit_on_open then
+    view.close(cur_tabpage)
+  end
+
+  local mode_unsupported_focus = mode == "drop" or mode == "tab_drop" or mode == "edit_in_place"
+  local focus = edit_opts.focus == nil or edit_opts.focus == true
+  if not mode_unsupported_focus and not focus then
+    -- if mode == "tabnew" a new tab will be opened and we need to focus back to the previous tab
+    if mode == "tabnew" then
+      vim.cmd(":tabprev")
+    end
+    view.focus()
   end
-  require("nvim-tree.actions.node.open-file").fn(mode, path)
 end
 
 ---@param mode string
----@return fun(node: table)
-local function open_or_expand_or_dir_up(mode)
-  return function(node)
-    if node.name == ".." then
-      require("nvim-tree.actions.root.change-dir").fn ".."
-    elseif node.nodes then
-      require("nvim-tree.lib").expand_or_collapse(node)
-    else
-      edit(mode, node)
+---@param toggle_group boolean?
+---@return fun(node: Node, edit_opts: NodeEditOpts?)
+local function open_or_expand_or_dir_up(mode, toggle_group)
+  ---@param node Node
+  ---@param edit_opts NodeEditOpts?
+  return function(node, edit_opts)
+    local root = node:as(RootNode)
+    local dir = node:as(DirectoryNode)
+
+    if root or node.name == ".." then
+      actions.root.change_dir.fn("..")
+    elseif dir then
+      dir:expand_or_collapse(toggle_group)
+    elseif not toggle_group then
+      edit(mode, node, edit_opts)
     end
   end
 end
 
-Api.node.open.edit = wrap_node(open_or_expand_or_dir_up "edit")
-Api.node.open.drop = wrap_node(open_or_expand_or_dir_up "drop")
-Api.node.open.tab_drop = wrap_node(open_or_expand_or_dir_up "tab_drop")
-Api.node.open.replace_tree_buffer = wrap_node(open_or_expand_or_dir_up "edit_in_place")
-Api.node.open.no_window_picker = wrap_node(open_or_expand_or_dir_up "edit_no_picker")
-Api.node.open.vertical = wrap_node(open_or_expand_or_dir_up "vsplit")
-Api.node.open.horizontal = wrap_node(open_or_expand_or_dir_up "split")
-Api.node.open.tab = wrap_node(open_or_expand_or_dir_up "tabnew")
-Api.node.open.preview = wrap_node(open_or_expand_or_dir_up "preview")
-Api.node.open.preview_no_picker = wrap_node(open_or_expand_or_dir_up "preview_no_picker")
+Api.node.open.edit = wrap_node(open_or_expand_or_dir_up("edit"))
+Api.node.open.drop = wrap_node(open_or_expand_or_dir_up("drop"))
+Api.node.open.tab_drop = wrap_node(open_or_expand_or_dir_up("tab_drop"))
+Api.node.open.replace_tree_buffer = wrap_node(open_or_expand_or_dir_up("edit_in_place"))
+Api.node.open.no_window_picker = wrap_node(open_or_expand_or_dir_up("edit_no_picker"))
+Api.node.open.vertical = wrap_node(open_or_expand_or_dir_up("vsplit"))
+Api.node.open.vertical_no_picker = wrap_node(open_or_expand_or_dir_up("vsplit_no_picker"))
+Api.node.open.horizontal = wrap_node(open_or_expand_or_dir_up("split"))
+Api.node.open.horizontal_no_picker = wrap_node(open_or_expand_or_dir_up("split_no_picker"))
+Api.node.open.tab = wrap_node(open_or_expand_or_dir_up("tabnew"))
+Api.node.open.toggle_group_empty = wrap_node(open_or_expand_or_dir_up("toggle_group_empty", true))
+Api.node.open.preview = wrap_node(open_or_expand_or_dir_up("preview"))
+Api.node.open.preview_no_picker = wrap_node(open_or_expand_or_dir_up("preview_no_picker"))
 
-Api.node.show_info_popup = wrap_node(require("nvim-tree.actions.node.file-popup").toggle_file_info)
-Api.node.run.cmd = wrap_node(require("nvim-tree.actions.node.run-command").run_file_command)
-Api.node.run.system = wrap_node(require("nvim-tree.actions.node.system-open").fn)
-Api.node.navigate.sibling.next = wrap_node(require("nvim-tree.actions.moves.sibling").fn "next")
-Api.node.navigate.sibling.prev = wrap_node(require("nvim-tree.actions.moves.sibling").fn "prev")
-Api.node.navigate.sibling.first = wrap_node(require("nvim-tree.actions.moves.sibling").fn "first")
-Api.node.navigate.sibling.last = wrap_node(require("nvim-tree.actions.moves.sibling").fn "last")
-Api.node.navigate.parent = wrap_node(require("nvim-tree.actions.moves.parent").fn(false))
-Api.node.navigate.parent_close = wrap_node(require("nvim-tree.actions.moves.parent").fn(true))
-Api.node.navigate.git.next = wrap_node(require("nvim-tree.actions.moves.item").fn("next", "git"))
-Api.node.navigate.git.prev = wrap_node(require("nvim-tree.actions.moves.item").fn("prev", "git"))
-Api.node.navigate.diagnostics.next = wrap_node(require("nvim-tree.actions.moves.item").fn("next", "diag"))
-Api.node.navigate.diagnostics.prev = wrap_node(require("nvim-tree.actions.moves.item").fn("prev", "diag"))
-Api.node.navigate.opened.next = wrap_node(require("nvim-tree.actions.moves.item").fn("next", "opened"))
-Api.node.navigate.opened.prev = wrap_node(require("nvim-tree.actions.moves.item").fn("prev", "opened"))
+Api.node.show_info_popup = wrap_node(actions.node.file_popup.toggle_file_info)
+Api.node.run.cmd = wrap_node(actions.node.run_command.run_file_command)
+Api.node.run.system = wrap_node(actions.node.system_open.fn)
 
-Api.git.reload = wrap(require("nvim-tree.actions.reloaders.reloaders").reload_git)
+Api.node.navigate.sibling.next = wrap_node(actions.moves.sibling.fn("next"))
+Api.node.navigate.sibling.prev = wrap_node(actions.moves.sibling.fn("prev"))
+Api.node.navigate.sibling.first = wrap_node(actions.moves.sibling.fn("first"))
+Api.node.navigate.sibling.last = wrap_node(actions.moves.sibling.fn("last"))
+Api.node.navigate.parent = wrap_node(actions.moves.parent.fn(false))
+Api.node.navigate.parent_close = wrap_node(actions.moves.parent.fn(true))
+Api.node.navigate.git.next = wrap_node(actions.moves.item.fn({ where = "next", what = "git" }))
+Api.node.navigate.git.next_skip_gitignored = wrap_node(actions.moves.item.fn({ where = "next", what = "git", skip_gitignored = true }))
+Api.node.navigate.git.next_recursive = wrap_node(actions.moves.item.fn({ where = "next", what = "git", recurse = true }))
+Api.node.navigate.git.prev = wrap_node(actions.moves.item.fn({ where = "prev", what = "git" }))
+Api.node.navigate.git.prev_skip_gitignored = wrap_node(actions.moves.item.fn({ where = "prev", what = "git", skip_gitignored = true }))
+Api.node.navigate.git.prev_recursive = wrap_node(actions.moves.item.fn({ where = "prev", what = "git", recurse = true }))
+Api.node.navigate.diagnostics.next = wrap_node(actions.moves.item.fn({ where = "next", what = "diag" }))
+Api.node.navigate.diagnostics.next_recursive = wrap_node(actions.moves.item.fn({ where = "next", what = "diag", recurse = true }))
+Api.node.navigate.diagnostics.prev = wrap_node(actions.moves.item.fn({ where = "prev", what = "diag" }))
+Api.node.navigate.diagnostics.prev_recursive = wrap_node(actions.moves.item.fn({ where = "prev", what = "diag", recurse = true }))
+Api.node.navigate.opened.next = wrap_node(actions.moves.item.fn({ where = "next", what = "opened" }))
+Api.node.navigate.opened.prev = wrap_node(actions.moves.item.fn({ where = "prev", what = "opened" }))
 
-Api.events.subscribe = require("nvim-tree.events").subscribe
-Api.events.Event = require("nvim-tree.events").Event
+Api.node.expand = wrap_node(actions.tree.modifiers.expand.node)
+Api.node.collapse = wrap_node(actions.tree.modifiers.collapse.node)
 
-Api.live_filter.start = wrap(require("nvim-tree.live-filter").start_filtering)
-Api.live_filter.clear = wrap(require("nvim-tree.live-filter").clear_filter)
+---@class ApiNodeDeleteWipeBufferOpts
+---@field force boolean|nil default false
 
-Api.marks.get = wrap_node(require("nvim-tree.marks").get_mark)
-Api.marks.list = wrap(require("nvim-tree.marks").get_marks)
-Api.marks.toggle = wrap_node(require("nvim-tree.marks").toggle_mark)
-Api.marks.clear = wrap(require("nvim-tree.marks").clear_marks)
-Api.marks.bulk.delete = wrap(require("nvim-tree.marks.bulk-delete").bulk_delete)
-Api.marks.bulk.trash = wrap(require("nvim-tree.marks.bulk-trash").bulk_trash)
-Api.marks.bulk.move = wrap(require("nvim-tree.marks.bulk-move").bulk_move)
-Api.marks.navigate.next = wrap(require("nvim-tree.marks.navigation").next)
-Api.marks.navigate.prev = wrap(require("nvim-tree.marks.navigation").prev)
-Api.marks.navigate.select = wrap(require("nvim-tree.marks.navigation").select)
-
-Api.config.mappings.default_on_attach = require("nvim-tree.keymap").default_on_attach
-
-Api.config.mappings.get_keymap = wrap(function()
-  return require("nvim-tree.keymap").get_keymap()
+Api.node.buffer.delete = wrap_node(function(node, opts)
+  actions.node.buffer.delete(node, opts)
+end)
+Api.node.buffer.wipe = wrap_node(function(node, opts)
+  actions.node.buffer.wipe(node, opts)
 end)
 
-Api.config.mappings.get_keymap_default = wrap(function()
-  return require("nvim-tree.keymap").get_keymap_default()
-end)
+Api.git.reload = wrap_explorer("reload_git")
+
+Api.events.subscribe = events.subscribe
+Api.events.Event = events.Event
+
+Api.live_filter.start = wrap_explorer_member("live_filter", "start_filtering")
+Api.live_filter.clear = wrap_explorer_member("live_filter", "clear_filter")
+
+Api.marks.get = wrap_node(wrap_explorer_member("marks", "get"))
+Api.marks.list = wrap_explorer_member("marks", "list")
+Api.marks.toggle = wrap_node(wrap_explorer_member("marks", "toggle"))
+Api.marks.clear = wrap_explorer_member("marks", "clear")
+Api.marks.bulk.delete = wrap_explorer_member("marks", "bulk_delete")
+Api.marks.bulk.trash = wrap_explorer_member("marks", "bulk_trash")
+Api.marks.bulk.move = wrap_explorer_member("marks", "bulk_move")
+Api.marks.navigate.next = wrap_explorer_member("marks", "navigate_next")
+Api.marks.navigate.prev = wrap_explorer_member("marks", "navigate_prev")
+Api.marks.navigate.select = wrap_explorer_member("marks", "navigate_select")
+
+Api.config.mappings.get_keymap = wrap(keymap.get_keymap)
+Api.config.mappings.get_keymap_default = wrap(keymap.get_keymap_default)
+Api.config.mappings.default_on_attach = keymap.default_on_attach
+
+Api.diagnostics.hi_test = wrap(appearance_hi_test)
 
 Api.commands.get = wrap(function()
   return require("nvim-tree.commands").get()
 end)
 
+---Create a decorator class by calling :extend()
+---See :help nvim-tree-decorators
+---@type nvim_tree.api.decorator.UserDecorator
+Api.decorator.UserDecorator = UserDecorator --[[@as nvim_tree.api.decorator.UserDecorator]]
+
 return Api

lua/nvim-tree/appearance/hi-test.lua

@@ -0,0 +1,147 @@
+local appearance = require("nvim-tree.appearance")
+
+local Class = require("nvim-tree.classic")
+
+-- others with name and links less than this arbitrary value are short
+local SHORT_LEN = 50
+
+local namespace_hi_test_id = vim.api.nvim_create_namespace("NvimTreeHiTest")
+
+---@class (exact) HighlightDisplay: Class for :NvimTreeHiTest
+---@field group string nvim-tree highlight group name
+---@field links string link chain to a concretely defined group
+---@field def string :hi concrete definition after following any links
+local HighlightDisplay = Class:extend()
+
+---@class HighlightDisplay
+---@overload fun(args: HighlightDisplayArgs): HighlightDisplay
+
+---@class (exact) HighlightDisplayArgs
+---@field group string nvim-tree highlight group name
+
+---@protected
+---@param args HighlightDisplayArgs
+function HighlightDisplay:new(args)
+  self.group = args.group
+
+  local concrete = self.group
+
+  -- maybe follow links
+  local links = {}
+  local link = vim.api.nvim_get_hl(0, { name = self.group }).link
+  while link do
+    table.insert(links, link)
+    concrete = link
+    link = vim.api.nvim_get_hl(0, { name = link }).link
+  end
+  self.links = table.concat(links, " ")
+
+  -- concrete definition
+  local ok, res = pcall(vim.api.nvim_cmd, { cmd = "highlight", args = { concrete } }, { output = true })
+  if ok and type(res) == "string" then
+    self.def = res:gsub(".*xxx *", "")
+  else
+    self.def = ""
+  end
+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 })
+
+  if vim.fn.has("nvim-0.11") == 1 and vim.hl and vim.hl.range then
+    vim.hl.range(bufnr, namespace_hi_test_id, self.group, { l, 0 }, { l, #self.group, }, {})
+  else
+    vim.api.nvim_buf_add_highlight(bufnr, -1, self.group, l, 0, #self.group) ---@diagnostic disable-line: deprecated
+  end
+
+  return l + 1
+end
+
+---Render many groups.
+---@param header string before with underline line
+---@param displays HighlightDisplay[] highlight group
+---@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, using name only
+  for _, display in ipairs(displays) do
+    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
+return function()
+  -- create a buffer
+  local bufnr = vim.api.nvim_create_buf(false, true)
+
+  local l = 0
+
+  -- nvim-tree groups, ordered
+  local displays = {}
+  for _, highlight_group in ipairs(appearance.HIGHLIGHT_GROUPS) do
+    local display = HighlightDisplay({ group = 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({ group = 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
+  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

@@ -0,0 +1,210 @@
+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.
+M.HIGHLIGHT_GROUPS = {
+
+  -- Standard
+  { group = "NvimTreeNormal",                  link = "Normal" },
+  { group = "NvimTreeNormalFloat",             link = "NormalFloat" },
+  { group = "NvimTreeNormalFloatBorder",       link = "FloatBorder" },
+  { group = "NvimTreeNormalNC",                link = "NvimTreeNormal" },
+
+  { group = "NvimTreeLineNr",                  link = "LineNr" },
+  { group = "NvimTreeWinSeparator",            link = "WinSeparator" },
+  { group = "NvimTreeEndOfBuffer",             link = "EndOfBuffer" },
+  { group = "NvimTreePopup",                   link = "Normal" },
+  { group = "NvimTreeSignColumn",              link = "NvimTreeNormal" },
+
+  { group = "NvimTreeCursorColumn",            link = "CursorColumn" },
+  { group = "NvimTreeCursorLine",              link = "CursorLine" },
+  { group = "NvimTreeCursorLineNr",            link = "CursorLineNr" },
+
+  { group = "NvimTreeStatusLine",              link = "StatusLine" },
+  { group = "NvimTreeStatusLineNC",            link = "StatusLineNC" },
+
+  -- File Text
+  { group = "NvimTreeExecFile",                link = "Question" },
+  { group = "NvimTreeImageFile",               link = "Question" },
+  { group = "NvimTreeSpecialFile",             link = "Title" },
+  { group = "NvimTreeSymlink",                 link = "Underlined" },
+
+  -- Folder Text
+  { group = "NvimTreeRootFolder",              link = "Title" },
+  { group = "NvimTreeFolderName",              link = "Directory" },
+  { group = "NvimTreeEmptyFolderName",         link = "Directory" },
+  { group = "NvimTreeOpenedFolderName",        link = "Directory" },
+  { group = "NvimTreeSymlinkFolderName",       link = "Directory" },
+
+  -- File Icons
+  { group = "NvimTreeFileIcon",                link = "NvimTreeNormal" },
+  { group = "NvimTreeSymlinkIcon",             link = "NvimTreeNormal" },
+
+  -- Folder Icons
+  { group = "NvimTreeFolderIcon",              def = "guifg=#8094b4 ctermfg=Blue" },
+  { group = "NvimTreeOpenedFolderIcon",        link = "NvimTreeFolderIcon" },
+  { group = "NvimTreeClosedFolderIcon",        link = "NvimTreeFolderIcon" },
+  { group = "NvimTreeFolderArrowClosed",       link = "NvimTreeIndentMarker" },
+  { group = "NvimTreeFolderArrowOpen",         link = "NvimTreeIndentMarker" },
+
+  -- Indent
+  { group = "NvimTreeIndentMarker",            link = "NvimTreeFolderIcon" },
+
+  -- Picker
+  { group = "NvimTreeWindowPicker",            def = "guifg=#ededed guibg=#4493c8 gui=bold ctermfg=White ctermbg=DarkBlue" },
+
+  -- LiveFilter
+  { group = "NvimTreeLiveFilterPrefix",        link = "PreProc" },
+  { group = "NvimTreeLiveFilterValue",         link = "ModeMsg" },
+
+  -- Clipboard
+  { group = "NvimTreeCutHL",                   link = "SpellBad" },
+  { group = "NvimTreeCopiedHL",                link = "SpellRare" },
+
+  -- Bookmark
+  { group = "NvimTreeBookmarkIcon",            link = "NvimTreeFolderIcon" },
+  { group = "NvimTreeBookmarkHL",              link = "SpellLocal" },
+
+  -- Modified
+  { group = "NvimTreeModifiedIcon",            link = "Type" },
+  { 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" },
+
+  -- Git Icon
+  { group = "NvimTreeGitDeletedIcon",          link = "Statement" },
+  { group = "NvimTreeGitDirtyIcon",            link = "Statement" },
+  { group = "NvimTreeGitIgnoredIcon",          link = "Comment" },
+  { group = "NvimTreeGitMergeIcon",            link = "Constant" },
+  { group = "NvimTreeGitNewIcon",              link = "PreProc" },
+  { group = "NvimTreeGitRenamedIcon",          link = "PreProc" },
+  { group = "NvimTreeGitStagedIcon",           link = "Constant" },
+
+  -- Git File Highlight
+  { group = "NvimTreeGitFileDeletedHL",        link = "NvimTreeGitDeletedIcon" },
+  { group = "NvimTreeGitFileDirtyHL",          link = "NvimTreeGitDirtyIcon" },
+  { group = "NvimTreeGitFileIgnoredHL",        link = "NvimTreeGitIgnoredIcon" },
+  { group = "NvimTreeGitFileMergeHL",          link = "NvimTreeGitMergeIcon" },
+  { group = "NvimTreeGitFileNewHL",            link = "NvimTreeGitNewIcon" },
+  { group = "NvimTreeGitFileRenamedHL",        link = "NvimTreeGitRenamedIcon" },
+  { group = "NvimTreeGitFileStagedHL",         link = "NvimTreeGitStagedIcon" },
+
+  -- Git Folder Highlight
+  { group = "NvimTreeGitFolderDeletedHL",      link = "NvimTreeGitFileDeletedHL" },
+  { group = "NvimTreeGitFolderDirtyHL",        link = "NvimTreeGitFileDirtyHL" },
+  { group = "NvimTreeGitFolderIgnoredHL",      link = "NvimTreeGitFileIgnoredHL" },
+  { group = "NvimTreeGitFolderMergeHL",        link = "NvimTreeGitFileMergeHL" },
+  { group = "NvimTreeGitFolderNewHL",          link = "NvimTreeGitFileNewHL" },
+  { group = "NvimTreeGitFolderRenamedHL",      link = "NvimTreeGitFileRenamedHL" },
+  { group = "NvimTreeGitFolderStagedHL",       link = "NvimTreeGitFileStagedHL" },
+
+  -- Diagnostics Icon
+  { group = "NvimTreeDiagnosticErrorIcon",     link = "DiagnosticError" },
+  { group = "NvimTreeDiagnosticWarnIcon",      link = "DiagnosticWarn" },
+  { group = "NvimTreeDiagnosticInfoIcon",      link = "DiagnosticInfo" },
+  { group = "NvimTreeDiagnosticHintIcon",      link = "DiagnosticHint" },
+
+  -- Diagnostics File Highlight
+  { group = "NvimTreeDiagnosticErrorFileHL",   link = "DiagnosticUnderlineError" },
+  { group = "NvimTreeDiagnosticWarnFileHL",    link = "DiagnosticUnderlineWarn" },
+  { group = "NvimTreeDiagnosticInfoFileHL",    link = "DiagnosticUnderlineInfo" },
+  { group = "NvimTreeDiagnosticHintFileHL",    link = "DiagnosticUnderlineHint" },
+
+  -- Diagnostics Folder Highlight
+  { group = "NvimTreeDiagnosticErrorFolderHL", link = "NvimTreeDiagnosticErrorFileHL" },
+  { group = "NvimTreeDiagnosticWarnFolderHL",  link = "NvimTreeDiagnosticWarnFileHL" },
+  { group = "NvimTreeDiagnosticInfoFolderHL",  link = "NvimTreeDiagnosticInfoFileHL" },
+  { group = "NvimTreeDiagnosticHintFolderHL",  link = "NvimTreeDiagnosticHintFileHL" },
+}
+
+-- nvim-tree highlight groups to legacy
+M.LEGACY_LINKS = {
+  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",
+
+  NvimTreeDiagnosticErrorIcon = "NvimTreeLspDiagnosticsError",
+  NvimTreeDiagnosticWarnIcon = "NvimTreeLspDiagnosticsWarning",
+  NvimTreeDiagnosticInfoIcon = "NvimTreeLspDiagnosticsInformation",
+  NvimTreeDiagnosticHintIcon = "NvimTreeLspDiagnosticsHint",
+
+  NvimTreeDiagnosticErrorFileHL = "NvimTreeLspDiagnosticsErrorText",
+  NvimTreeDiagnosticWarnFileHL = "NvimTreeLspDiagnosticsWarningText",
+  NvimTreeDiagnosticInfoFileHL = "NvimTreeLspDiagnosticsInformationText",
+  NvimTreeDiagnosticHintFileHL = "NvimTreeLspDiagnosticsHintText",
+
+  NvimTreeDiagnosticErrorFolderHL = "NvimTreeLspDiagnosticsErrorFolderText",
+  NvimTreeDiagnosticWarnFolderHL = "NvimTreeLspDiagnosticsWarningFolderText",
+  NvimTreeDiagnosticInfoFolderHL = "NvimTreeLspDiagnosticsInformationFolderText",
+  NvimTreeDiagnosticHintFolderHL = "NvimTreeLspDiagnosticsHintFolderText",
+}
+
+function M.setup()
+  -- non-linked
+  for _, g in ipairs(M.HIGHLIGHT_GROUPS) do
+    if g.def then
+      vim.api.nvim_command("hi def " .. g.group .. " " .. g.def)
+    end
+  end
+
+  -- hard link override when legacy only is present
+  for from, to in pairs(M.LEGACY_LINKS) do
+    local hl_from = vim.api.nvim_get_hl(0, { name = from })
+    local hl_to = vim.api.nvim_get_hl(0, { name = to })
+    if vim.tbl_isempty(hl_from) and not vim.tbl_isempty(hl_to) then
+      vim.api.nvim_command("hi link " .. from .. " " .. to)
+    end
+  end
+
+  -- default links
+  for _, g in ipairs(M.HIGHLIGHT_GROUPS) do
+    if g.link then
+      vim.api.nvim_command("hi def link " .. g.group .. " " .. g.link)
+    end
+  end
+end
+
+return M

lua/nvim-tree/buffers.lua

@@ -0,0 +1,65 @@
+local DirectoryNode = require("nvim-tree.node.directory")
+
+local M = {}
+
+---@type table<string, boolean> record of which file is modified
+M._modified = {}
+
+---refresh M._modified
+function M.reload_modified()
+  M._modified = {}
+  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
+      -- mark all the parent as modified as well
+      while M._modified[path] ~= true do
+        -- no need to keep going if already recorded
+        -- This also prevents an infinite loop
+        M._modified[path] = true
+        path = vim.fn.fnamemodify(path, ":h")
+      end
+    end
+  end
+end
+
+---@param node Node
+---@return boolean
+function M.is_modified(node)
+  if not M.config.modified.enable then
+    return false
+  end
+
+  if not M._modified[node.absolute_path] then
+    return false
+  end
+
+  local dir = node:as(DirectoryNode)
+  if dir then
+    if not M.config.modified.show_on_dirs then
+      return false
+    end
+
+    if dir.open and not M.config.modified.show_on_open_dirs then
+      return false
+    end
+  end
+
+  return true
+end
+
+---A buffer exists for the node's absolute path
+---@param node Node
+---@return boolean
+function M.is_opened(node)
+  return node and vim.fn.bufloaded(node.absolute_path) > 0
+end
+
+---@param opts table
+function M.setup(opts)
+  M.config = {
+    modified = opts.modified,
+  }
+end
+
+return M

lua/nvim-tree/classic.lua

@@ -0,0 +1,91 @@
+--
+-- classic
+--
+-- Copyright (c) 2014, rxi
+--
+-- This module is free software; you can redistribute it and/or modify it under
+-- the terms of the MIT license. See LICENSE for details.
+--
+-- https://github.com/rxi/classic
+--
+
+---@class (exact) Class
+---@field super Class
+---@field private implements table<Class, boolean>
+local Class = {}
+Class.__index = Class ---@diagnostic disable-line: inject-field
+
+---Default constructor
+---@protected
+function Class:new(...) --luacheck: ignore 212
+end
+
+---Extend a class, setting .super
+function Class:extend()
+  local cls = {}
+  for k, v in pairs(self) do
+    if k:find("__") == 1 then
+      cls[k] = v
+    end
+  end
+  cls.__index = cls
+  cls.super = self
+  setmetatable(cls, self)
+  return cls
+end
+
+---Implement the functions of a mixin
+---Add the mixin to .implements
+---@param mixin Class
+function Class:implement(mixin)
+  if not rawget(self, "implements") then
+    -- set on the class itself instead of parents
+    rawset(self, "implements", {})
+  end
+  self.implements[mixin] = true
+  for k, v in pairs(mixin) do
+    if self[k] == nil and type(v) == "function" then
+      self[k] = v
+    end
+  end
+end
+
+---Object is an instance of class or implements a mixin
+---@generic T
+---@param class T
+---@return boolean
+function Class:is(class)
+  local mt = getmetatable(self)
+  while mt do
+    if mt == class then
+      return true
+    end
+    if mt.implements and mt.implements[class] then
+      return true
+    end
+    mt = getmetatable(mt)
+  end
+  return false
+end
+
+---Return object if :is otherwise nil
+---@generic T
+---@param class T
+---@return T|nil
+function Class:as(class)
+  return self:is(class) and self or nil
+end
+
+---Constructor to create instance, call :new and return
+function Class:__call(...)
+  local obj = setmetatable({}, self)
+  obj:new(...)
+  return obj
+end
+
+-- avoid unused param warnings in abstract methods
+---@param ... any
+function Class:nop(...) --luacheck: ignore 212
+end
+
+return Class

lua/nvim-tree/colors.lua

@@ -1,130 +0,0 @@
-local M = {}
-
-local function get_color_from_hl(hl_name, fallback)
-  local id = vim.api.nvim_get_hl_id_by_name(hl_name)
-  if not id then
-    return fallback
-  end
-
-  local foreground = vim.fn.synIDattr(vim.fn.synIDtrans(id), "fg")
-  if not foreground or foreground == "" then
-    return fallback
-  end
-
-  return foreground
-end
-
-local function get_colors()
-  return {
-    red = vim.g.terminal_color_1 or get_color_from_hl("Keyword", "Red"),
-    green = vim.g.terminal_color_2 or get_color_from_hl("Character", "Green"),
-    yellow = vim.g.terminal_color_3 or get_color_from_hl("PreProc", "Yellow"),
-    blue = vim.g.terminal_color_4 or get_color_from_hl("Include", "Blue"),
-    purple = vim.g.terminal_color_5 or get_color_from_hl("Define", "Purple"),
-    cyan = vim.g.terminal_color_6 or get_color_from_hl("Conditional", "Cyan"),
-    dark_red = vim.g.terminal_color_9 or get_color_from_hl("Keyword", "DarkRed"),
-    orange = vim.g.terminal_color_11 or get_color_from_hl("Number", "Orange"),
-  }
-end
-
-local function get_hl_groups()
-  local colors = get_colors()
-
-  return {
-    IndentMarker = { fg = "#8094b4" },
-    Symlink = { gui = "bold", fg = colors.cyan },
-    FolderIcon = { fg = "#8094b4" },
-    RootFolder = { fg = colors.purple },
-
-    ExecFile = { gui = "bold", fg = colors.green },
-    SpecialFile = { gui = "bold,underline", fg = colors.yellow },
-    ImageFile = { gui = "bold", fg = colors.purple },
-    OpenedFile = { gui = "bold", fg = colors.green },
-    ModifiedFile = { fg = colors.green },
-
-    GitDirty = { fg = colors.dark_red },
-    GitDeleted = { fg = colors.dark_red },
-    GitStaged = { fg = colors.green },
-    GitMerge = { fg = colors.orange },
-    GitRenamed = { fg = colors.purple },
-    GitNew = { fg = colors.yellow },
-
-    WindowPicker = { gui = "bold", fg = "#ededed", bg = "#4493c8" },
-    LiveFilterPrefix = { gui = "bold", fg = colors.purple },
-    LiveFilterValue = { gui = "bold", fg = "#fff" },
-
-    Bookmark = { fg = colors.green },
-  }
-end
-
-local function get_links()
-  return {
-    FolderName = "Directory",
-    EmptyFolderName = "Directory",
-    OpenedFolderName = "Directory",
-    SymlinkFolderName = "Directory",
-    OpenedFolderIcon = "NvimTreeFolderIcon",
-    ClosedFolderIcon = "NvimTreeFolderIcon",
-    OpenedFileIcon = "NvimTreeOpenedFile",
-    Normal = "Normal",
-    NormalFloat = "NormalFloat",
-    NormalNC = "NvimTreeNormal",
-    EndOfBuffer = "EndOfBuffer",
-    CursorLineNr = "CursorLineNr",
-    LineNr = "LineNr",
-    CursorLine = "CursorLine",
-    WinSeparator = "WinSeparator",
-    CursorColumn = "CursorColumn",
-    FileDirty = "NvimTreeGitDirty",
-    FileNew = "NvimTreeGitNew",
-    FileRenamed = "NvimTreeGitRenamed",
-    FileMerge = "NvimTreeGitMerge",
-    FileStaged = "NvimTreeGitStaged",
-    FileDeleted = "NvimTreeGitDeleted",
-    FileIgnored = "NvimTreeGitIgnored",
-    FolderDirty = "NvimTreeFileDirty",
-    FolderNew = "NvimTreeFileNew",
-    FolderRenamed = "NvimTreeFileRenamed",
-    FolderMerge = "NvimTreeFileMerge",
-    FolderStaged = "NvimTreeFileStaged",
-    FolderDeleted = "NvimTreeFileDeleted",
-    FolderIgnored = "NvimTreeFileIgnored",
-    LspDiagnosticsError = "DiagnosticError",
-    LspDiagnosticsWarning = "DiagnosticWarn",
-    LspDiagnosticsInformation = "DiagnosticInfo",
-    LspDiagnosticsHint = "DiagnosticHint",
-    LspDiagnosticsErrorText = "NvimTreeLspDiagnosticsError",
-    LspDiagnosticsWarningText = "NvimTreeLspDiagnosticsWarning",
-    LspDiagnosticsInformationText = "NvimTreeLspDiagnosticsInformation",
-    LspDiagnosticsHintText = "NvimTreeLspDiagnosticsHintFile",
-    LspDiagnosticsErrorFolderText = "NvimTreeLspDiagnosticsErrorText",
-    LspDiagnosticsWarningFolderText = "NvimTreeLspDiagnosticsWarningText",
-    LspDiagnosticsInformationFolderText = "NvimTreeLspDiagnosticsInformationText",
-    LspDiagnosticsHintFolderText = "NvimTreeLspDiagnosticsHintFileText",
-    Popup = "Normal",
-    GitIgnored = "Comment",
-    StatusLine = "StatusLine",
-    StatusLineNC = "StatusLineNC",
-    SignColumn = "NvimTreeNormal",
-    CutHL = "SpellBad",
-    CopiedHL = "SpellRare",
-    BookmarkHL = "SpellLocal",
-  }
-end
-
-function M.setup()
-  local highlight_groups = get_hl_groups()
-  for k, d in pairs(highlight_groups) do
-    local gui = d.gui and " gui=" .. d.gui or ""
-    local fg = d.fg and " guifg=" .. d.fg or ""
-    local bg = d.bg and " guibg=" .. d.bg or ""
-    vim.api.nvim_command("hi def NvimTree" .. k .. gui .. fg .. bg)
-  end
-
-  local links = get_links()
-  for k, d in pairs(links) do
-    vim.api.nvim_command("hi def link NvimTree" .. k .. " " .. d)
-  end
-end
-
-return M

lua/nvim-tree/commands.lua

@@ -1,5 +1,5 @@
-local api = require "nvim-tree.api"
-local view = require "nvim-tree.view"
+local api = require("nvim-tree.api")
+local view = require("nvim-tree.view")
 
 local M = {}
 
@@ -12,7 +12,7 @@ local CMDS = {
       complete = "dir",
     },
     command = function(c)
-      api.tree.open { path = c.args }
+      api.tree.open({ path = c.args })
     end,
   },
   {
@@ -33,12 +33,12 @@ local CMDS = {
       complete = "dir",
     },
     command = function(c)
-      api.tree.toggle {
+      api.tree.toggle({
         find_file = false,
         focus = true,
         path = c.args,
         update_root = false,
-      }
+      })
     end,
   },
   {
@@ -79,11 +79,11 @@ local CMDS = {
       bar = true,
     },
     command = function(c)
-      api.tree.find_file {
+      api.tree.find_file({
         open = true,
         focus = true,
         update_root = c.bang,
-      }
+      })
     end,
   },
   {
@@ -95,12 +95,12 @@ local CMDS = {
       complete = "dir",
     },
     command = function(c)
-      api.tree.toggle {
+      api.tree.toggle({
         find_file = true,
         focus = true,
         path = c.args,
         update_root = c.bang,
-      }
+      })
     end,
   },
   {
@@ -134,6 +134,13 @@ local CMDS = {
       api.tree.collapse_all(true)
     end,
   },
+  {
+    name = "NvimTreeHiTest",
+    opts = {
+      desc = "nvim-tree: highlight test",
+    },
+    command = api.diagnostics.hi_test,
+  },
 }
 
 function M.get()

lua/nvim-tree/core.lua

@@ -1,8 +1,7 @@
-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"
+local events = require("nvim-tree.events")
+local notify = require("nvim-tree.notify")
+local view = require("nvim-tree.view")
+local log = require("nvim-tree.log")
 
 local M = {}
 
@@ -17,7 +16,21 @@ function M.init(foldername)
   if TreeExplorer then
     TreeExplorer:destroy()
   end
-  TreeExplorer = explorer.Explorer.new(foldername)
+
+  local err, path
+
+  if foldername then
+    path, err = vim.loop.fs_realpath(foldername)
+  else
+    path, err = vim.loop.cwd()
+  end
+  if path then
+    TreeExplorer = require("nvim-tree.explorer")({ path = path })
+  else
+    notify.error(err)
+    TreeExplorer = nil
+  end
+
   if not first_init_done then
     events._dispatch_ready()
     first_init_done = true
@@ -45,7 +58,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

@@ -1,131 +1,240 @@
-local utils = require "nvim-tree.utils"
-local view = require "nvim-tree.view"
-local core = require "nvim-tree.core"
-local log = require "nvim-tree.log"
+local core = require("nvim-tree.core")
+local utils = require("nvim-tree.utils")
+local view = require("nvim-tree.view")
+local log = require("nvim-tree.log")
+
+local DirectoryNode = require("nvim-tree.node.directory")
 
 local M = {}
 
-local severity_levels = {
+---COC severity level strings to LSP severity levels
+---@enum COC_SEVERITY_LEVELS
+local COC_SEVERITY_LEVELS = {
   Error = 1,
   Warning = 2,
   Information = 3,
   Hint = 4,
 }
 
----@return table
-local function from_nvim_lsp()
-  local buffer_severity = {}
+---Absolute Node path to LSP severity level
+---@alias NodeSeverities table<string, vim.diagnostic.Severity>
 
-  local is_disabled = false
-  if vim.fn.has "nvim-0.9" == 1 then
-    is_disabled = vim.diagnostic.is_disabled()
+---@class DiagStatus
+---@field value lsp.DiagnosticSeverity|nil
+---@field cache_version integer
+
+--- The buffer-severity mappings derived during the last diagnostic list update.
+---@type NodeSeverities
+local NODE_SEVERITIES = {}
+
+---The cache version number of the buffer-severity mappings.
+---@type integer
+local NODE_SEVERITIES_VERSION = 0
+
+---@param path string
+---@return string
+local function uniformize_path(path)
+  return utils.canonical_path(path:gsub("\\", "/"))
 end
 
-  if not is_disabled then
-    for _, diagnostic in ipairs(vim.diagnostic.get(nil, { severity = M.severity })) do
-      local buf = diagnostic.bufnr
-      if vim.api.nvim_buf_is_valid(buf) then
-        local bufname = vim.api.nvim_buf_get_name(buf)
-        local lowest_severity = buffer_severity[bufname]
-        if not lowest_severity or diagnostic.severity < lowest_severity then
-          buffer_severity[bufname] = diagnostic.severity
-        end
-      end
-    end
-  end
-
-  return buffer_severity
-end
-
----@param severity integer
+---Severity is within diagnostics.severity.min, diagnostics.severity.max
+---@param severity lsp.DiagnosticSeverity
 ---@param config table
 ---@return boolean
 local function is_severity_in_range(severity, config)
   return config.max <= severity and severity <= config.min
 end
 
----@return table
+---Handle any COC exceptions, preventing any propagation
+---@param err string
+local function handle_coc_exception(err)
+  log.line("diagnostics", "handle_coc_exception: %s", vim.inspect(err))
+  local notify = true
+
+  -- avoid distractions on interrupts (CTRL-C)
+  if err:find("Vim:Interrupt") or err:find("Keyboard interrupt") then
+    notify = false
+  end
+
+  if notify then
+    require("nvim-tree.notify").error("Diagnostics update from coc.nvim failed. " .. vim.inspect(err))
+  end
+end
+
+---COC service initialized
+---@return boolean
+local function is_using_coc()
+  return vim.g.coc_service_initialized == 1
+end
+
+---Marshal severities from COC. Does nothing when COC service not started.
+---@return NodeSeverities
 local function from_coc()
-  if vim.g.coc_service_initialized ~= 1 then
+  if not is_using_coc() then
     return {}
   end
 
-  local diagnostic_list = vim.fn.CocAction "diagnosticList"
-  if type(diagnostic_list) ~= "table" or vim.tbl_isempty(diagnostic_list) then
+  local ok, diagnostic_list = xpcall(function()
+    return vim.fn.CocAction("diagnosticList")
+  end, handle_coc_exception)
+  if not ok or type(diagnostic_list) ~= "table" or vim.tbl_isempty(diagnostic_list) then
     return {}
   end
 
-  local diagnostics = {}
-  for _, diagnostic in ipairs(diagnostic_list) do
-    local bufname = diagnostic.file
-    local coc_severity = severity_levels[diagnostic.severity]
-
-    local serverity = diagnostics[bufname] or vim.diagnostic.severity.HINT
-    diagnostics[bufname] = math.min(coc_severity, serverity)
-  end
-
   local buffer_severity = {}
-  for bufname, severity in pairs(diagnostics) do
-    if is_severity_in_range(severity, M.severity) then
-      buffer_severity[bufname] = severity
+  for _, diagnostic in ipairs(diagnostic_list) do
+    local bufname = uniformize_path(diagnostic.file)
+    local coc_severity = COC_SEVERITY_LEVELS[diagnostic.severity]
+    local highest_severity = buffer_severity[bufname] or coc_severity
+    if is_severity_in_range(highest_severity, M.severity) then
+      buffer_severity[bufname] = math.min(highest_severity, coc_severity)
     end
   end
 
   return buffer_severity
 end
 
-local function is_using_coc()
-  return vim.g.coc_service_initialized == 1
+---Maybe retrieve severity level from the cache
+---@param node Node
+---@return DiagStatus
+local function from_cache(node)
+  local nodepath = uniformize_path(node.absolute_path)
+  local max_severity = nil
+  if not node:is(DirectoryNode) then
+    -- direct cache hit for files
+    max_severity = NODE_SEVERITIES[nodepath]
+  else
+    -- dirs should be searched in the list of cached buffer names by prefix
+    for bufname, severity in pairs(NODE_SEVERITIES) do
+      local node_contains_buf = vim.startswith(bufname, nodepath .. "/")
+      if node_contains_buf then
+        if not max_severity or severity < max_severity then
+          max_severity = severity
+        end
+      end
+    end
+  end
+  return { value = max_severity, cache_version = NODE_SEVERITIES_VERSION }
 end
 
-function M.update()
-  if not M.enable or not core.get_explorer() or not view.is_buf_valid(view.get_bufnr()) then
+---Fired on DiagnosticChanged for a single buffer.
+---This will be called on set and reset of diagnostics.
+---On disabling LSP, a reset event will be sent for all buffers.
+---@param ev table standard event with data.diagnostics populated
+function M.update_lsp(ev)
+  if not M.enable or not ev or not ev.data or not ev.data.diagnostics then
     return
   end
-  utils.debounce("diagnostics", M.debounce_delay, function()
-    local profile = log.profile_start "diagnostics update"
-    log.line("diagnostics", "update")
 
-    local buffer_severity
-    if is_using_coc() then
-      buffer_severity = from_coc()
-    else
-      buffer_severity = from_nvim_lsp()
-    end
+  local profile_event = log.profile_start("DiagnosticChanged event")
 
-    local nodes_by_line = utils.get_nodes_by_line(core.get_explorer().nodes, core.get_nodes_starting_line())
-    for _, node in pairs(nodes_by_line) do
-      node.diag_status = nil
-    end
+  local diagnostics = vim.diagnostic.get(ev.buf)
 
-    for bufname, severity in pairs(buffer_severity) do
-      local bufpath = utils.canonical_path(bufname)
-      log.line("diagnostics", " bufpath '%s' severity %d", bufpath, severity)
-      if 0 < severity and severity < 5 then
-        for line, node in pairs(nodes_by_line) do
-          local nodepath = utils.canonical_path(node.absolute_path)
-          log.line("diagnostics", "  %d checking nodepath '%s'", line, nodepath)
+  -- use the buffer from the event, as ev.data.diagnostics will be empty on resolved diagnostics
+  local bufname = uniformize_path(vim.api.nvim_buf_get_name(ev.buf))
 
-          local node_contains_buf = vim.startswith(bufpath:gsub("\\", "/"), nodepath:gsub("\\", "/") .. "/")
-          if M.show_on_dirs and node_contains_buf and (not node.open or M.show_on_open_dirs) then
-            log.line("diagnostics", " matched fold node '%s'", node.absolute_path)
-            node.diag_status = severity
-          elseif nodepath == bufpath then
-            log.line("diagnostics", " matched file node '%s'", node.absolute_path)
-            node.diag_status = severity
+  ---@type vim.diagnostic.Severity?
+  local new_severity = nil
+
+  -- most severe (lowest) severity in user range
+  for _, diagnostic in ipairs(diagnostics) do
+    if diagnostic.severity >= M.severity.max and diagnostic.severity <= M.severity.min then
+      if not new_severity or diagnostic.severity < new_severity then
+        new_severity = diagnostic.severity
       end
     end
   end
+
+  -- record delta and schedule a redraw
+  if new_severity ~= NODE_SEVERITIES[bufname] then
+    NODE_SEVERITIES[bufname] = new_severity
+    NODE_SEVERITIES_VERSION = NODE_SEVERITIES_VERSION + 1
+
+    utils.debounce("DiagnosticChanged redraw", M.debounce_delay, function()
+      local profile_redraw = log.profile_start("DiagnosticChanged redraw")
+
+      local explorer = core.get_explorer()
+      if explorer then
+        explorer.renderer:draw()
+      end
+
+      log.profile_end(profile_redraw)
+    end)
+  end
+
+  log.profile_end(profile_event)
+end
+
+---Fired on CocDiagnosticChanged events:
+---debounced retrieval, cache update, version increment and draw
+function M.update_coc()
+  if not M.enable then
+    return
+  end
+  utils.debounce("CocDiagnosticChanged update", M.debounce_delay, function()
+    local profile = log.profile_start("CocDiagnosticChanged update")
+    NODE_SEVERITIES = from_coc()
+    NODE_SEVERITIES_VERSION = NODE_SEVERITIES_VERSION + 1
+    if log.enabled("diagnostics") then
+      for bufname, severity in pairs(NODE_SEVERITIES) do
+        log.line("diagnostics", "COC Indexing bufname '%s' with severity %d", bufname, severity)
+      end
     end
     log.profile_end(profile)
-    require("nvim-tree.renderer").draw()
+
+    local bufnr = view.get_bufnr()
+    local should_draw = bufnr and vim.api.nvim_buf_is_valid(bufnr) and vim.api.nvim_buf_is_loaded(bufnr)
+    if should_draw then
+      local explorer = core.get_explorer()
+      if explorer then
+        explorer.renderer:draw()
+      end
+    end
   end)
 end
 
+---Maybe retrieve diagnostic status for a node.
+---Returns cached value when node's version matches.
+---@param node Node
+---@return DiagStatus|nil
+function M.get_diag_status(node)
+  if not M.enable then
+    return nil
+  end
+
+  -- dir but we shouldn't show on dirs at all
+  if node:is(DirectoryNode) and not M.show_on_dirs then
+    return nil
+  end
+
+  -- here, we do a lazy update of the diagnostic status carried by the node.
+  -- This is by design, as diagnostics and nodes live in completely separate
+  -- worlds, and this module is the link between the two
+  if not node.diag_status or node.diag_status.cache_version < NODE_SEVERITIES_VERSION then
+    node.diag_status = from_cache(node)
+  end
+
+  local dir = node:as(DirectoryNode)
+
+  -- file
+  if not dir then
+    return node.diag_status
+  end
+
+  -- dir is closed or we should show on open_dirs
+  if not dir.open or M.show_on_open_dirs then
+    return node.diag_status
+  end
+  return nil
+end
+
 function M.setup(opts)
   M.enable = opts.diagnostics.enable
   M.debounce_delay = opts.diagnostics.debounce_delay
-  M.severity = opts.diagnostics.severity
+  M.severity = opts.diagnostics.diagnostic_opts and {
+    min = vim.diagnostic.severity.HINT,
+    max = vim.diagnostic.severity.ERROR
+  } or opts.diagnostics.severity
 
   if M.enable then
     log.line("diagnostics", "setup")

lua/nvim-tree/enum.lua

@@ -1,20 +1,14 @@
 local M = {}
 
----Setup options for "highlight_*"
----@enum HL_POSITION
-M.HL_POSITION = {
-  none = 0,
-  icon = 1,
-  name = 2,
-  all = 4,
-}
-
----Setup options for "*_placement"
----@enum ICON_PLACEMENT
-M.ICON_PLACEMENT = {
-  signcolumn = 0,
-  before = 1,
-  after = 2,
+---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/events.lua

@@ -1,4 +1,4 @@
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
 
 local M = {}
 
@@ -8,6 +8,7 @@ M.Event = {
   Ready = "Ready",
   WillRenameNode = "WillRenameNode",
   NodeRenamed = "NodeRenamed",
+  TreePreOpen = "TreePreOpen",
   TreeOpen = "TreeOpen",
   TreeClose = "TreeClose",
   WillCreateFile = "WillCreateFile",
@@ -91,6 +92,11 @@ function M._dispatch_folder_removed(folder_name)
   dispatch(M.Event.FolderRemoved, { folder_name = folder_name })
 end
 
+--@private
+function M._dispatch_on_tree_pre_open()
+  dispatch(M.Event.TreePreOpen, nil)
+end
+
 --@private
 function M._dispatch_on_tree_open()
   dispatch(M.Event.TreeOpen, nil)

lua/nvim-tree/explorer/explore.lua

@@ -1,101 +0,0 @@
-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 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)
-  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)
-  while true do
-    local name, t = vim.loop.fs_scandir_next(handle)
-    if not name then
-      break
-    end
-
-    local abs = utils.path_join { cwd, name }
-
-    local profile = log.profile_start("explore populate_children %s", abs)
-
-    t = get_type_from(t, abs)
-    if not filters.should_filter(abs, filter_status) 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)
-      elseif t == "file" then
-        child = builders.file(node, abs, name)
-      elseif t == "link" then
-        local link = builders.link(node, abs, name)
-        if link.link_to ~= nil then
-          child = link
-        end
-      end
-      if child then
-        table.insert(node.nodes, child)
-        nodes_by_path[child.absolute_path] = true
-        explorer_node.update_git_status(child, node_ignored, git_status)
-      end
-    end
-
-    log.profile_end(profile)
-  end
-end
-
----@param node Node
----@param status table
----@return Node[]|nil
-function M.explore(node, status)
-  local cwd = node.link_to or node.absolute_path
-  local handle = vim.loop.fs_scandir(cwd)
-  if not handle then
-    return
-  end
-
-  local profile = log.profile_start("explore init %s", node.absolute_path)
-
-  populate_children(handle, cwd, node, status)
-
-  local is_root = not node.parent
-  local child_folder_only = explorer_node.has_one_child_folder(node) and node.nodes[1]
-  if M.config.group_empty and not is_root and child_folder_only then
-    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)
-    node.nodes = ns or {}
-
-    log.profile_end(profile)
-    return ns
-  end
-
-  sorters.sort(node.nodes)
-  live_filter.apply_filter(node)
-
-  log.profile_end(profile)
-  return node.nodes
-end
-
-function M.setup(opts)
-  M.config = opts.renderer
-end
-
-return M

lua/nvim-tree/explorer/filters.lua

@@ -1,14 +1,60 @@
-local utils = require "nvim-tree.utils"
+local utils = require("nvim-tree.utils")
+local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
 
-local M = {
-  ignore_list = {},
-  exclude_list = {},
+local Class = require("nvim-tree.classic")
+
+---@alias FilterType "custom" | "dotfiles" | "git_ignored" | "git_clean" | "no_buffer" | "no_bookmark"
+
+---@class (exact) Filters: Class
+---@field enabled boolean
+---@field state table<FilterType, boolean>
+---@field private explorer Explorer
+---@field private exclude_list string[] filters.exclude
+---@field private ignore_list table<string, boolean> filters.custom string table
+---@field private custom_function (fun(absolute_path: string): boolean)|nil filters.custom function
+local Filters = Class:extend()
+
+---@class Filters
+---@overload fun(args: FiltersArgs): Filters
+
+---@class (exact) FiltersArgs
+---@field explorer Explorer
+
+---@protected
+---@param args FiltersArgs
+function Filters:new(args)
+  self.explorer        = args.explorer
+  self.ignore_list     = {}
+  self.exclude_list    = self.explorer.opts.filters.exclude
+  self.custom_function = nil
+
+  self.enabled         = self.explorer.opts.filters.enable
+  self.state           = {
+    custom      = true,
+    dotfiles    = self.explorer.opts.filters.dotfiles,
+    git_ignored = self.explorer.opts.filters.git_ignored,
+    git_clean   = self.explorer.opts.filters.git_clean,
+    no_buffer   = self.explorer.opts.filters.no_buffer,
+    no_bookmark = self.explorer.opts.filters.no_bookmark,
   }
 
+  local custom_filter  = self.explorer.opts.filters.custom
+  if type(custom_filter) == "function" then
+    self.custom_function = custom_filter
+  else
+    if custom_filter and #custom_filter > 0 then
+      for _, filter_name in pairs(custom_filter) do
+        self.ignore_list[filter_name] = true
+      end
+    end
+  end
+end
+
+---@private
 ---@param path string
 ---@return boolean
-local function is_excluded(path)
-  for _, node in ipairs(M.exclude_list) do
+function Filters:is_excluded(path)
+  for _, node in ipairs(self.exclude_list) do
     if path:match(node) then
       return true
     end
@@ -17,26 +63,27 @@ local function is_excluded(path)
 end
 
 ---Check if the given path is git clean/ignored
+---@private
 ---@param path string Absolute path
----@param git_status table from prepare
+---@param project GitProject from prepare
 ---@return boolean
-local function git(path, git_status)
-  if type(git_status) ~= "table" or type(git_status.files) ~= "table" or type(git_status.dirs) ~= "table" then
+function Filters:git(path, project)
+  if type(project) ~= "table" or type(project.files) ~= "table" or type(project.dirs) ~= "table" then
     return false
   end
 
   -- default status to clean
-  local status = git_status.files[path]
-  status = status or git_status.dirs.direct[path] and git_status.dirs.direct[path][1]
-  status = status or git_status.dirs.indirect[path] and git_status.dirs.indirect[path][1]
+  local xy = project.files[path]
+  xy = xy or project.dirs.direct[path] and project.dirs.direct[path][1]
+  xy = xy or project.dirs.indirect[path] and project.dirs.indirect[path][1]
 
   -- filter ignored; overrides clean as they are effectively dirty
-  if M.config.filter_git_ignored and status == "!!" then
+  if self.state.git_ignored and xy == "!!" then
     return true
   end
 
   -- filter clean
-  if M.config.filter_git_clean and not status then
+  if self.state.git_clean and not xy then
     return true
   end
 
@@ -44,18 +91,18 @@ local function git(path, git_status)
 end
 
 ---Check if the given path has no listed buffer
+---@private
 ---@param path string Absolute path
 ---@param bufinfo table vim.fn.getbufinfo { buflisted = 1 }
----@param unloaded_bufnr number optional bufnr recently unloaded via BufUnload event
 ---@return boolean
-local function buf(path, bufinfo, unloaded_bufnr)
-  if not M.config.filter_no_buffer or type(bufinfo) ~= "table" then
+function Filters:buf(path, bufinfo)
+  if not self.state.no_buffer or type(bufinfo) ~= "table" then
     return false
   end
 
   -- filter files with no open buffer and directories containing no open buffers
   for _, b in ipairs(bufinfo) do
-    if b.name == path or b.name:find(path .. "/", 1, true) and b.bufnr ~= unloaded_bufnr then
+    if b.name == path or b.name:find(path .. "/", 1, true) then
       return false
     end
   end
@@ -63,32 +110,78 @@ local function buf(path, bufinfo, unloaded_bufnr)
   return true
 end
 
+---@private
 ---@param path string
 ---@return boolean
-local function dotfile(path)
-  return M.config.filter_dotfiles and utils.path_basename(path):sub(1, 1) == "."
+function Filters:dotfile(path)
+  return self.state.dotfiles and utils.path_basename(path):sub(1, 1) == "."
 end
 
+---Bookmark is present
+---@private
+---@param path string
+---@param path_type string|nil filetype of path
+---@param bookmarks table<string, string|nil> path, filetype table of bookmarked files
+---@return boolean
+function Filters:bookmark(path, path_type, bookmarks)
+  if not self.state.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
+
+---@private
 ---@param path string
 ---@return boolean
-local function custom(path)
-  if not M.config.filter_custom then
+function Filters:custom(path)
+  if not self.state.custom then
     return false
   end
 
   local basename = utils.path_basename(path)
 
+  -- filter user's custom function
+  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
   end
 
-  local idx = path:match ".+()%.[^.]+$"
+  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
@@ -97,21 +190,27 @@ local function custom(path)
 end
 
 ---Prepare arguments for should_filter. This is done prior to should_filter for efficiency reasons.
----@param git_status table|nil optional results of git.load_project_status(...)
----@param unloaded_bufnr number|nil optional bufnr recently unloaded via BufUnload event
+---@param project GitProject? optional results of git.load_projects(...)
 ---@return table
---- git_status: reference
---- unloaded_bufnr: copy
+--- project: reference
 --- bufinfo: empty unless no_buffer set: vim.fn.getbufinfo { buflisted = 1 }
-function M.prepare(git_status, unloaded_bufnr)
+--- bookmarks: absolute paths to boolean
+function Filters:prepare(project)
   local status = {
-    git_status = git_status or {},
-    unloaded_bufnr = unloaded_bufnr,
+    project = project or {},
     bufinfo = {},
+    bookmarks = {},
   }
 
-  if M.config.filter_no_buffer then
-    status.bufinfo = vim.fn.getbufinfo { buflisted = 1 }
+  if self.state.no_buffer then
+    status.bufinfo = vim.fn.getbufinfo({ buflisted = 1 })
+  end
+
+  local explorer = require("nvim-tree.core").get_explorer()
+  if explorer then
+    for _, node in pairs(explorer.marks:list()) do
+      status.bookmarks[node.absolute_path] = node.type
+    end
   end
 
   return status
@@ -119,35 +218,70 @@ 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)
-  -- exclusions override all filters
-  if is_excluded(path) then
+function Filters:should_filter(path, fs_stat, status)
+  if not self.enabled then
     return false
   end
 
-  return git(path, status.git_status) or buf(path, status.bufinfo, status.unloaded_bufnr) or dotfile(path) or custom(path)
+  -- exclusions override all filters
+  if self:is_excluded(path) then
+    return false
   end
 
-function M.setup(opts)
-  M.config = {
-    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,
-  }
-
-  M.ignore_list = {}
-  M.exclude_list = opts.filters.exclude
-
-  local custom_filter = opts.filters.custom
-  if custom_filter and #custom_filter > 0 then
-    for _, filter_name in pairs(custom_filter) do
-      M.ignore_list[filter_name] = true
+  return self:git(path, status.project)
+    or self:buf(path, status.bufinfo)
+    or self:dotfile(path)
+    or self:custom(path)
+    or self:bookmark(path, fs_stat and fs_stat.type, status.bookmarks)
 end
+
+--- Check if the given path should be filtered, and provide the reason why it was
+---@param path string Absolute path
+---@param fs_stat uv.fs_stat.result|nil fs_stat of file
+---@param status table from prepare
+---@return FILTER_REASON
+function Filters:should_filter_as_reason(path, fs_stat, status)
+  if not self.enabled then
+    return FILTER_REASON.none
+  end
+
+  if self:is_excluded(path) then
+    return FILTER_REASON.none
+  end
+
+  if self:git(path, status.project) then
+    return FILTER_REASON.git
+  elseif self:buf(path, status.bufinfo) then
+    return FILTER_REASON.buf
+  elseif self:dotfile(path) then
+    return FILTER_REASON.dotfile
+  elseif self:custom(path) then
+    return FILTER_REASON.custom
+  elseif self:bookmark(path, fs_stat and fs_stat.type, status.bookmarks) then
+    return FILTER_REASON.bookmark
+  else
+    return FILTER_REASON.none
   end
 end
 
-return M
+---Toggle a type and refresh
+---@private
+---@param type FilterType? nil to disable all
+function Filters:toggle(type)
+  if not type or self.state[type] == nil then
+    self.enabled = not self.enabled
+  else
+    self.state[type] = not self.state[type]
+  end
+
+  local node = self.explorer:get_node_at_cursor()
+  self.explorer:reload_explorer()
+  if node then
+    self.explorer:focus_node_or_parent(node)
+  end
+end
+
+return Filters

lua/nvim-tree/explorer/init.lua

@@ -1,70 +1,672 @@
-local git = require "nvim-tree.git"
-local watch = require "nvim-tree.explorer.watch"
-local explorer_node = require "nvim-tree.explorer.node"
+local appearance = require("nvim-tree.appearance")
+local buffers = require("nvim-tree.buffers")
+local core = require("nvim-tree.core")
+local git = require("nvim-tree.git")
+local log = require("nvim-tree.log")
+local utils = require("nvim-tree.utils")
+local view = require("nvim-tree.view")
+local node_factory = require("nvim-tree.node.factory")
 
-local M = {}
+local DirectoryNode = require("nvim-tree.node.directory")
+local RootNode = require("nvim-tree.node.root")
+local Watcher = require("nvim-tree.watcher")
 
-M.explore = require("nvim-tree.explorer.explore").explore
-M.reload = require("nvim-tree.explorer.reload").reload
+local Iterator = require("nvim-tree.iterators.node-iterator")
+local NodeIterator = require("nvim-tree.iterators.node-iterator")
+
+local Filters = require("nvim-tree.explorer.filters")
+local Marks = require("nvim-tree.marks")
+local LiveFilter = require("nvim-tree.explorer.live-filter")
+local Sorter = require("nvim-tree.explorer.sorter")
+local Clipboard = require("nvim-tree.actions.fs.clipboard")
+local Renderer = require("nvim-tree.renderer")
+
+local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
+
+local config
+
+---@class (exact) Explorer: RootNode
+---@field uid_explorer number vim.loop.hrtime() at construction time
+---@field opts table user options
+---@field augroup_id integer
+---@field renderer Renderer
+---@field filters Filters
+---@field live_filter LiveFilter
+---@field sorters Sorter
+---@field marks Marks
+---@field clipboard Clipboard
+local Explorer = RootNode:extend()
 
 ---@class Explorer
----@field absolute_path string
----@field nodes Node[]
----@field open boolean
+---@overload fun(args: ExplorerArgs): Explorer
 
-local Explorer = {}
-Explorer.__index = Explorer
+---@class (exact) ExplorerArgs
+---@field path string
 
----@param cwd string|nil
----@return Explorer
-function Explorer.new(cwd)
-  cwd = vim.loop.fs_realpath(cwd or vim.loop.cwd())
+---@protected
+---@param args ExplorerArgs
+function Explorer:new(args)
+  Explorer.super.new(self, {
+    explorer      = self,
+    absolute_path = args.path,
+    name          = "..",
+  })
 
-  ---@class Explorer
-  local explorer = setmetatable({
-    absolute_path = cwd,
-    nodes = {},
-    open = true,
-  }, Explorer)
-  explorer.watcher = watch.create_watcher(explorer)
-  explorer:_load(explorer)
-  return explorer
+  self.uid_explorer = vim.loop.hrtime()
+  self.augroup_id   = vim.api.nvim_create_augroup("NvimTree_Explorer_" .. self.uid_explorer, {})
+
+  self.open         = true
+  self.opts         = config
+
+  self.sorters      = Sorter({ explorer = self })
+  self.renderer     = Renderer({ explorer = self })
+  self.filters      = Filters({ explorer = self })
+  self.live_filter  = LiveFilter({ explorer = self })
+  self.marks        = Marks({ explorer = self })
+  self.clipboard    = Clipboard({ explorer = self })
+
+  self:create_autocmds()
+
+  self:_load(self)
 end
 
----@private
----@param node Node
-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)
+function Explorer:destroy()
+  log.line("dev", "Explorer:destroy")
+
+  vim.api.nvim_del_augroup_by_id(self.augroup_id)
+
+  RootNode.destroy(self)
 end
 
----@param node Node
+function Explorer:create_autocmds()
+  -- reset and draw (highlights) when colorscheme is changed
+  vim.api.nvim_create_autocmd("ColorScheme", {
+    group = self.augroup_id,
+    callback = function()
+      appearance.setup()
+      view.reset_winhl()
+      self.renderer:draw()
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("BufWritePost", {
+    group = self.augroup_id,
+    callback = function()
+      if self.opts.auto_reload_on_write and not self.opts.filesystem_watchers.enable then
+        self:reload_explorer()
+      end
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("BufReadPost", {
+    group = self.augroup_id,
+    callback = function(data)
+      -- only handle normal files
+      if vim.bo[data.buf].buftype ~= "" then
+        return
+      end
+
+      if self.filters.state.no_buffer then
+        -- full reload is required to update the filter state
+        utils.debounce("Buf:filter_buffer_" .. self.uid_explorer, self.opts.view.debounce_delay, function()
+          self:reload_explorer()
+        end)
+      elseif self.opts.renderer.highlight_opened_files ~= "none" then
+        -- draw to update opened highlight
+        self.renderer:draw()
+      end
+    end,
+  })
+
+  -- update opened file buffers
+  vim.api.nvim_create_autocmd("BufUnload", {
+    group = self.augroup_id,
+    callback = function(data)
+      -- only handle normal files
+      if vim.bo[data.buf].buftype ~= "" then
+        return
+      end
+
+      if self.filters.state.no_buffer then
+        -- full reload is required to update the filter state
+        utils.debounce("Buf:filter_buffer_" .. self.uid_explorer, self.opts.view.debounce_delay, function()
+          self:reload_explorer()
+        end)
+      elseif self.opts.renderer.highlight_opened_files ~= "none" then
+        -- draw to update opened highlight; must be delayed as the buffer is still loaded during BufUnload
+        vim.schedule(function()
+          self.renderer:draw()
+        end)
+      end
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("BufEnter", {
+    group = self.augroup_id,
+    pattern = "NvimTree_*",
+    callback = function()
+      if utils.is_nvim_tree_buf(0) then
+        if vim.fn.getcwd() ~= core.get_cwd() or (self.opts.reload_on_bufenter and not self.opts.filesystem_watchers.enable) then
+          self:reload_explorer()
+        end
+      end
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("User", {
+    group = self.augroup_id,
+    pattern = { "FugitiveChanged", "NeogitStatusRefreshed" },
+    callback = function()
+      if not self.opts.filesystem_watchers.enable and self.opts.git.enable then
+        self:reload_git()
+      end
+    end,
+  })
+
+  if self.opts.hijack_cursor then
+    vim.api.nvim_create_autocmd("CursorMoved", {
+      group = self.augroup_id,
+      pattern = "NvimTree_*",
+      callback = function()
+        if utils.is_nvim_tree_buf(0) then
+          self:place_cursor_on_node()
+        end
+      end,
+    })
+  end
+
+  if self.opts.modified.enable then
+    vim.api.nvim_create_autocmd({ "BufModifiedSet", "BufWritePost" }, {
+      group = self.augroup_id,
+      callback = function()
+        utils.debounce("Buf:modified_" .. self.uid_explorer, self.opts.view.debounce_delay, function()
+          buffers.reload_modified()
+          self:reload_explorer()
+        end)
+      end,
+    })
+  end
+end
+
+---@param node DirectoryNode
 function Explorer:expand(node)
   self:_load(node)
 end
 
-function Explorer:destroy()
-  local function iterate(node)
-    explorer_node.node_destroy(node)
+---@param node DirectoryNode
+---@param project GitProject?
+---@return Node[]?
+function Explorer:reload(node, project)
+  local cwd = node.link_to or node.absolute_path
+  local handle = vim.loop.fs_scandir(cwd)
+  if not handle then
+    return
+  end
+
+  local profile = log.profile_start("reload %s", node.absolute_path)
+
+  local filter_status = self.filters:prepare(project)
+
+  if node.group_next then
+    node.nodes = { node.group_next }
+    node.group_next = nil
+  end
+
+  local remain_childs = {}
+
+  local node_ignored = node:is_git_ignored()
+  ---@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, _ = vim.loop.fs_scandir_next(handle)
+    if not name then
+      break
+    end
+
+    local abs = utils.path_join({ cwd, name })
+
+    -- path incorrectly specified as an integer
+    local stat = vim.loop.fs_lstat(abs) ---@diagnostic disable-line param-type-mismatch
+
+    local filter_reason = self.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
+        local n = nodes_by_path[abs]
+
+        if not stat or n.type ~= stat.type then
+          utils.array_remove(node.nodes, n)
+          n:destroy()
+          nodes_by_path[abs] = nil
+        end
+      end
+
+      if not nodes_by_path[abs] then
+        local new_child = node_factory.create({
+          explorer      = self,
+          parent        = node,
+          absolute_path = abs,
+          name          = name,
+          fs_stat       = stat
+        })
+        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 = utils.is_executable(abs) or false
+          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
+  end
+
+  node.nodes = vim.tbl_map(
+    self:update_git_statuses(nodes_by_path, node_ignored, project),
+    vim.tbl_filter(function(n)
+      if remain_childs[n.absolute_path] then
+        return remain_childs[n.absolute_path]
+      else
+        n:destroy()
+        return false
+      end
+    end, node.nodes)
+  )
+
+  local single_child = node:single_child_directory()
+  if config.renderer.group_empty and node.parent and single_child then
+    node.group_next = single_child
+    local ns = self:reload(single_child, project)
+    node.nodes = ns or {}
+    log.profile_end(profile)
+    return ns
+  end
+
+  self.sorters:sort(node.nodes)
+  self.live_filter:apply_filter(node)
+  log.profile_end(profile)
+  return node.nodes
+end
+
+---Refresh contents of all nodes to a path: actual directory and links.
+---Groups will be expanded if needed.
+---@param path string absolute path
+function Explorer:refresh_parent_nodes_for_path(path)
+  local profile = log.profile_start("refresh_parent_nodes_for_path %s", path)
+
+  -- collect parent nodes from the top down
+  local parent_nodes = {}
+  NodeIterator.builder({ self })
+    :recursor(function(node)
+      return node.nodes
+    end)
+    :applier(function(node)
+      local abs_contains = node.absolute_path and path:find(node.absolute_path, 1, true) == 1
+      local link_contains = node.link_to and path:find(node.link_to, 1, true) == 1
+      if abs_contains or link_contains then
+        table.insert(parent_nodes, node)
+      end
+    end)
+    :iterate()
+
+  -- refresh in order; this will expand groups as needed
+  for _, node in ipairs(parent_nodes) do
+    local toplevel = git.get_toplevel(node.absolute_path)
+    local project = git.get_project(toplevel) or {}
+
+    self:reload(node, project)
+    git.update_parent_projects(node, project, toplevel)
+  end
+
+  log.profile_end(profile)
+end
+
+---@private
+---@param node DirectoryNode
+function Explorer:_load(node)
+  local cwd = node.link_to or node.absolute_path
+  local project = git.load_project(cwd)
+  self:explore(node, project, self)
+end
+
+---@private
+---@param nodes_by_path Node[]
+---@param node_ignored boolean
+---@param project GitProject?
+---@return fun(node: Node): Node
+function Explorer:update_git_statuses(nodes_by_path, node_ignored, project)
+  return function(node)
+    if nodes_by_path[node.absolute_path] then
+      node:update_git_status(node_ignored, project)
+    end
+    return node
+  end
+end
+
+---@private
+---@param handle uv.uv_fs_t
+---@param cwd string
+---@param node DirectoryNode
+---@param project GitProject
+---@param parent Explorer
+function Explorer:populate_children(handle, cwd, node, project, parent)
+  local node_ignored = node:is_git_ignored()
+  local nodes_by_path = utils.bool_record(node.nodes, "absolute_path")
+
+  local filter_status = parent.filters:prepare(project)
+
+  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, _ = vim.loop.fs_scandir_next(handle)
+    if not name then
+      break
+    end
+
+    local abs = utils.path_join({ cwd, name })
+
+    if Watcher.is_fs_event_capable(abs) then
+      local profile = log.profile_start("populate_children %s", abs)
+
+      -- path incorrectly specified as an integer
+      local stat = vim.loop.fs_lstat(abs) ---@diagnostic disable-line param-type-mismatch
+
+      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] then
+        local child = node_factory.create({
+          explorer      = self,
+          parent        = node,
+          absolute_path = abs,
+          name          = name,
+          fs_stat       = stat
+        })
+        if child then
+          table.insert(node.nodes, child)
+          nodes_by_path[child.absolute_path] = true
+          child:update_git_status(node_ignored, project)
+        end
+      elseif node.hidden_stats then
+        for reason, value in pairs(FILTER_REASON) do
+          if filter_reason == value and type(node.hidden_stats[reason]) == "number" then
+            node.hidden_stats[reason] = node.hidden_stats[reason] + 1
+          end
+        end
+      end
+
+      log.profile_end(profile)
+    end
+  end
+end
+
+---@private
+---@param node DirectoryNode
+---@param project GitProject
+---@param parent Explorer
+---@return Node[]|nil
+function Explorer:explore(node, project, parent)
+  local cwd = node.link_to or node.absolute_path
+  local handle = vim.loop.fs_scandir(cwd)
+  if not handle then
+    return
+  end
+
+  local profile = log.profile_start("explore %s", node.absolute_path)
+
+  self:populate_children(handle, cwd, node, project, parent)
+
+  local is_root = not node.parent
+  local single_child = node:single_child_directory()
+  if config.renderer.group_empty and not is_root and single_child then
+    local child_cwd = single_child.link_to or single_child.absolute_path
+    local child_project = git.load_project(child_cwd)
+    node.group_next = single_child
+    local ns = self:explore(single_child, child_project, parent)
+    node.nodes = ns or {}
+
+    log.profile_end(profile)
+    return ns
+  end
+
+  parent.sorters:sort(node.nodes)
+  parent.live_filter:apply_filter(node)
+
+  log.profile_end(profile)
+  return node.nodes
+end
+
+---@private
+---@param projects GitProject[]
+function Explorer:refresh_nodes(projects)
+  Iterator.builder({ self })
+    :applier(function(n)
+      local dir = n:as(DirectoryNode)
+      if dir then
+        local toplevel = git.get_toplevel(dir.cwd or dir.link_to or dir.absolute_path)
+        self:reload(dir, projects[toplevel] or {})
+      end
+    end)
+    :recursor(function(n)
+      return n.group_next and { n.group_next } or (n.open and n.nodes)
+    end)
+    :iterate()
+end
+
+local event_running = false
+function Explorer:reload_explorer()
+  if event_running or vim.v.exiting ~= vim.NIL then
+    return
+  end
+  event_running = true
+
+  local projects = git.reload_all_projects()
+  self:refresh_nodes(projects)
+  if view.is_visible() then
+    self.renderer:draw()
+  end
+  event_running = false
+end
+
+function Explorer:reload_git()
+  if not git.config.git.enable or event_running then
+    return
+  end
+  event_running = true
+
+  local projects = git.reload_all_projects()
+  git.reload_node_status(self, projects)
+  self.renderer:draw()
+  event_running = false
+end
+
+---Cursor position as per vim.api.nvim_win_get_cursor
+---nil on no explorer or invalid view win
+---@return integer[]|nil
+function Explorer:get_cursor_position()
+  local winnr = view.get_winnr()
+  if not winnr or not vim.api.nvim_win_is_valid(winnr) then
+    return
+  end
+
+  return vim.api.nvim_win_get_cursor(winnr)
+end
+
+---@return Node|nil
+function Explorer:get_node_at_cursor()
+  local cursor = self:get_cursor_position()
+  if not cursor then
+    return
+  end
+
+  if cursor[1] == 1 and view.is_root_folder_visible(core.get_cwd()) then
+    return self
+  end
+
+  return self:get_nodes_by_line(core.get_nodes_starting_line())[cursor[1]]
+end
+
+function Explorer:place_cursor_on_node()
+  local ok, search = pcall(vim.fn.searchcount)
+  if ok and search and search.exact_match == 1 then
+    return
+  end
+
+  local node = self:get_node_at_cursor()
+  if not node or node.name == ".." then
+    return
+  end
+  node = node:get_parent_of_group() or node
+
+  local line = vim.api.nvim_get_current_line()
+  local cursor = vim.api.nvim_win_get_cursor(0)
+  local idx = vim.fn.stridx(line, node.name)
+
+  if idx >= 0 then
+    vim.api.nvim_win_set_cursor(0, { cursor[1], idx })
+  end
+end
+
+-- Find the line number of a node.
+---@param node Node?
+---@return integer -1 not found
+function Explorer:find_node_line(node)
+  if not node then
+    return -1
+  end
+
+  local first_node_line = core.get_nodes_starting_line()
+  local nodes_by_line = self:get_nodes_by_line(first_node_line)
+  local iter_start, iter_end = first_node_line, #nodes_by_line
+
+  for line = iter_start, iter_end, 1 do
+    if nodes_by_line[line] == node then
+      return line
+    end
+  end
+
+  return -1
+end
+
+-- get the node in the tree state depending on the absolute path of the node
+-- (grouped or hidden too)
+---@param path string
+---@return Node|nil
+---@return number|nil
+function Explorer:get_node_from_path(path)
+  if self.absolute_path == path then
+    return self
+  end
+
+  return Iterator.builder(self.nodes)
+    :hidden()
+    :matcher(function(node)
+      return node.absolute_path == path or node.link_to == path
+    end)
+    :recursor(function(node)
+      if node.group_next then
+        return { node.group_next }
+      end
       if node.nodes then
-      for _, child in pairs(node.nodes) do
-        iterate(child)
+        return node.nodes
       end
-    end
-  end
-  iterate(self)
+    end)
+    :iterate()
 end
 
-function M.setup(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)
+---Focus node passed as parameter if visible, otherwise focus first visible parent.
+---If none of the parents is visible focus root.
+---If node is nil do nothing.
+---@param node Node? node to focus
+function Explorer:focus_node_or_parent(node)
+  while node do
+    local found_node, i = self:find_node(function(node_)
+      return node_.absolute_path == node.absolute_path
+    end)
+
+    if found_node or node.parent == nil then
+      view.set_cursor({ i + 1, 1 })
+      break
     end
 
-M.Explorer = Explorer
+    node = node.parent
+  end
+end
 
-return M
+--- Get the node and index of the node from the tree that matches the predicate.
+--- The explored nodes are those displayed on the view.
+---@param fn fun(node: Node): boolean
+---@return table|nil
+---@return number
+function Explorer:find_node(fn)
+  local node, i = Iterator.builder(self.nodes)
+    :matcher(fn)
+    :recursor(function(node)
+      return node.group_next and { node.group_next } or (node.open and #node.nodes > 0 and node.nodes)
+    end)
+    :iterate()
+  i = view.is_root_folder_visible() and i or i - 1
+  if node and node.explorer.live_filter.filter then
+    i = i + 1
+  end
+  return node, i
+end
+
+--- Return visible nodes indexed by line
+---@param line_start number
+---@return table
+function Explorer:get_nodes_by_line(line_start)
+  local nodes_by_line = {}
+  local line = line_start
+
+  Iterator.builder(self.nodes)
+    :applier(function(node)
+      if node.group_next then
+        return
+      end
+      nodes_by_line[line] = node
+      line = line + 1
+    end)
+    :recursor(function(node)
+      return node.group_next and { node.group_next } or (node.open and #node.nodes > 0 and node.nodes)
+    end)
+    :iterate()
+
+  return nodes_by_line
+end
+
+---Api.tree.get_nodes
+---@return nvim_tree.api.Node
+function Explorer:get_nodes()
+  return self:clone()
+end
+
+function Explorer:setup(opts)
+  config = opts
+end
+
+return Explorer

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

@@ -0,0 +1,231 @@
+local view = require("nvim-tree.view")
+local utils = require("nvim-tree.utils")
+
+local Class = require("nvim-tree.classic")
+local Iterator = require("nvim-tree.iterators.node-iterator")
+local DirectoryNode = require("nvim-tree.node.directory")
+
+---@class (exact) LiveFilter: Class
+---@field explorer Explorer
+---@field prefix string
+---@field always_show_folders boolean
+---@field filter string
+local LiveFilter = Class:extend()
+
+---@class LiveFilter
+---@overload fun(args: LiveFilterArgs): LiveFilter
+
+---@class (exact) LiveFilterArgs
+---@field explorer Explorer
+
+---@protected
+---@param args LiveFilterArgs
+function LiveFilter:new(args)
+  self.explorer = args.explorer
+  self.prefix = self.explorer.opts.live_filter.prefix
+  self.always_show_folders = self.explorer.opts.live_filter.always_show_folders
+  self.filter = nil
+end
+
+---@param node_ Node?
+local function reset_filter(self, node_)
+  node_ = node_ or self.explorer
+
+  if node_ == nil then
+    return
+  end
+
+  local dir_ = node_:as(DirectoryNode)
+  if dir_ then
+    dir_.hidden_stats = vim.tbl_deep_extend("force", dir_.hidden_stats or {}, { live_filter = 0, })
+  end
+
+  Iterator.builder(node_.nodes)
+    :hidden()
+    :applier(function(node)
+      node.hidden = false
+      local dir = node:as(DirectoryNode)
+      if dir then
+        dir.hidden_stats = vim.tbl_deep_extend("force", dir.hidden_stats or {}, { live_filter = 0, })
+      end
+    end)
+    :iterate()
+end
+
+local overlay_bufnr = 0
+local overlay_winnr = 0
+
+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", {
+      pattern = "NvimTree_*",
+      group = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
+      callback = function()
+        if utils.is_nvim_tree_buf(0) then
+          view.close()
+        end
+      end,
+    })
+  end
+
+  vim.api.nvim_win_close(overlay_winnr, true)
+  vim.api.nvim_buf_delete(overlay_bufnr, { force = true })
+  overlay_bufnr = 0
+  overlay_winnr = 0
+
+  if self.filter == "" then
+    self:clear_filter()
+  end
+end
+
+---@param node Node
+---@return boolean
+local function matches(self, node)
+  if not self.explorer.filters.enabled then
+    return true
+  end
+
+  local path = node.absolute_path
+  local name = vim.fn.fnamemodify(path, ":t")
+  return vim.regex(self.filter):match_str(name) ~= nil
+end
+
+---@param node_ DirectoryNode?
+function LiveFilter:apply_filter(node_)
+  if not self.filter or self.filter == "" then
+    reset_filter(self, node_)
+    return
+  end
+
+  -- this iterator cannot yet be refactored with the Iterator module
+  -- since the node mapper is based on its children
+  local function iterate(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)
+        if n.hidden then
+          filtered_nodes = filtered_nodes + 1
+        end
+      end
+    end
+
+    node.hidden_stats.live_filter = filtered_nodes
+
+    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 self.explorer)
+end
+
+local function record_char(self)
+  vim.schedule(function()
+    self.filter = vim.api.nvim_buf_get_lines(overlay_bufnr, 0, -1, false)[1]
+    self:apply_filter()
+    self.explorer.renderer:draw()
+  end)
+end
+
+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 = function()
+      return record_char(self)
+    end,
+  })
+
+  vim.api.nvim_create_autocmd("InsertLeave", {
+    callback = function()
+      return remove_overlay(self)
+    end,
+    once = true,
+  })
+
+  vim.api.nvim_buf_set_keymap(overlay_bufnr, "i", "<CR>", "<cmd>stopinsert<CR>", {})
+end
+
+---@return integer
+local function calculate_overlay_win_width(self)
+  local wininfo = vim.fn.getwininfo(view.get_winnr())[1]
+
+  if wininfo then
+    return wininfo.width - wininfo.textoff - #self.prefix
+  end
+
+  return 20
+end
+
+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({
+      event   = "WinLeave",
+      pattern = "NvimTree_*",
+      group   = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
+    })
+  end
+
+  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(self),
+    height   = 1,
+    border   = "none",
+    style    = "minimal",
+  })
+
+  if vim.fn.has("nvim-0.10") == 1 then
+    vim.api.nvim_set_option_value("modifiable", true, { buf = overlay_bufnr })
+    vim.api.nvim_set_option_value("filetype", "NvimTreeFilter", { buf = overlay_bufnr })
+  else
+    vim.api.nvim_buf_set_option(overlay_bufnr, "modifiable", true) ---@diagnostic disable-line: deprecated
+    vim.api.nvim_buf_set_option(overlay_bufnr, "filetype", "NvimTreeFilter") ---@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, #self.filter + 1 })
+end
+
+function LiveFilter:start_filtering()
+  view.View.live_filter.prev_focused_node = self.explorer:get_node_at_cursor()
+  self.filter = self.filter or ""
+
+  self.explorer.renderer:draw()
+  local row = require("nvim-tree.core").get_nodes_starting_line() - 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(function()
+    return create_overlay(self)
+  end)
+end
+
+function LiveFilter:clear_filter()
+  local node = self.explorer:get_node_at_cursor()
+  local last_node = view.View.live_filter.prev_focused_node
+
+  self.filter = nil
+  reset_filter(self)
+  self.explorer.renderer:draw()
+
+  if node then
+    self.explorer:focus_node_or_parent(node)
+  elseif last_node then
+    self.explorer:focus_node_or_parent(last_node)
+  end
+end
+
+return LiveFilter

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

@@ -1,104 +0,0 @@
-local utils = require "nvim-tree.utils"
-local watch = require "nvim-tree.explorer.watch"
-
-local M = {}
-
----@param parent Node
----@param absolute_path string
----@param name string
----@return Node
-function M.folder(parent, absolute_path, name)
-  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),
-    group_next = nil, -- If node is grouped, this points to the next child dir/link node
-    has_children = has_children,
-    name = name,
-    nodes = {},
-    open = false,
-    parent = parent,
-  }
-
-  node.watcher = watch.create_watcher(node)
-
-  return node
-end
-
---- path is an executable file or directory
----@param absolute_path string
----@return boolean|nil
-function M.is_executable(absolute_path)
-  if utils.is_windows or utils.is_wsl then
-    --- executable detection on windows is buggy and not performant hence it is disabled
-    return false
-  else
-    return vim.loop.fs_access(absolute_path, "X")
-  end
-end
-
----@param parent Node
----@param absolute_path string
----@param name string
----@return Node
-function M.file(parent, absolute_path, name)
-  local ext = string.match(name, ".?[^.]+%.(.*)") or ""
-
-  return {
-    type = "file",
-    absolute_path = absolute_path,
-    executable = M.is_executable(absolute_path),
-    extension = ext,
-    fs_stat = vim.loop.fs_stat(absolute_path),
-    name = name,
-    parent = parent,
-  }
-end
-
--- TODO-INFO: sometimes fs_realpath returns nil
--- I expect this be a bug in glibc, because it fails to retrieve the path for some
--- links (for instance libr2.so in /usr/lib) and thus even with a C program realpath fails
--- when it has no real reason to. Maybe there is a reason, but errno is definitely wrong.
--- So we need to check for link_to ~= nil when adding new links to the main tree
----@param parent Node
----@param absolute_path string
----@param name string
----@return Node
-function M.link(parent, absolute_path, name)
-  --- 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
-    local handle = vim.loop.fs_scandir(link_to)
-    has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
-    open = false
-    nodes = {}
-  end
-
-  local node = {
-    type = "link",
-    absolute_path = absolute_path,
-    fs_stat = vim.loop.fs_stat(absolute_path),
-    group_next = nil, -- If node is grouped, this points to the next child dir/link node
-    has_children = has_children,
-    link_to = link_to,
-    name = name,
-    nodes = nodes,
-    open = open,
-    parent = parent,
-  }
-
-  if is_dir_link then
-    node.watcher = watch.create_watcher(node)
-  end
-
-  return node
-end
-
-return M

lua/nvim-tree/explorer/node.lua

@@ -1,149 +0,0 @@
-local M = {}
-
----@class GitStatus
----@field file string|nil
----@field dir table|nil
-
----@param parent_ignored boolean
----@param status table|nil
----@param absolute_path string
----@return GitStatus|nil
-local function get_dir_git_status(parent_ignored, status, absolute_path)
-  if parent_ignored then
-    return { file = "!!" }
-  end
-
-  if status then
-    return {
-      file = status.files and status.files[absolute_path],
-      dir = status.dirs and {
-        direct = status.dirs.direct[absolute_path],
-        indirect = status.dirs.indirect[absolute_path],
-      },
-    }
-  end
-end
-
----@param parent_ignored boolean
----@param status table
----@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]
-  return { file = file_status }
-end
-
----@param node Node
----@return boolean
-function M.has_one_child_folder(node)
-  return #node.nodes == 1 and node.nodes[1].nodes and vim.loop.fs_access(node.nodes[1].absolute_path, "R") or false
-end
-
----@param node Node
----@param parent_ignored boolean
----@param status table|nil
-function M.update_git_status(node, parent_ignored, status)
-  local get_status
-  if node.nodes then
-    get_status = get_dir_git_status
-  else
-    get_status = get_git_status
-  end
-
-  -- status of the node's absolute path
-  node.git_status = get_status(parent_ignored, status, node.absolute_path)
-
-  -- status of the link target, if the link itself is not dirty
-  if node.link_to and not node.git_status then
-    node.git_status = get_status(parent_ignored, status, node.link_to)
-  end
-end
-
----@param node Node
----@return GitStatus|nil
-function M.get_git_status(node)
-  local git_status = node and node.git_status
-  if not git_status then
-    -- status doesn't exist
-    return nil
-  end
-
-  if not node.nodes then
-    -- file
-    return git_status.file and { git_status.file }
-  end
-
-  -- dir
-  if not M.config.git.show_on_dirs then
-    return nil
-  end
-
-  local status = {}
-  if not require("nvim-tree.lib").get_last_group_node(node).open or M.config.git.show_on_open_dirs then
-    -- dir is closed or we should show on open_dirs
-    if git_status.file ~= nil then
-      table.insert(status, git_status.file)
-    end
-    if git_status.dir ~= nil then
-      if git_status.dir.direct ~= nil then
-        for _, s in pairs(node.git_status.dir.direct) do
-          table.insert(status, s)
-        end
-      end
-      if git_status.dir.indirect ~= nil then
-        for _, s in pairs(node.git_status.dir.indirect) do
-          table.insert(status, s)
-        end
-      end
-    end
-  else
-    -- dir is open and we shouldn't show on open_dirs
-    if git_status.file ~= nil then
-      table.insert(status, git_status.file)
-    end
-    if git_status.dir ~= nil and git_status.dir.direct ~= nil then
-      local deleted = {
-        [" D"] = true,
-        ["D "] = true,
-        ["RD"] = true,
-        ["DD"] = true,
-      }
-      for _, s in pairs(node.git_status.dir.direct) do
-        if deleted[s] then
-          table.insert(status, s)
-        end
-      end
-    end
-  end
-  if #status == 0 then
-    return nil
-  else
-    return status
-  end
-end
-
----@param node Node
----@return boolean
-function M.is_git_ignored(node)
-  return node and node.git_status ~= nil and node.git_status.file == "!!"
-end
-
----@param node Node
-function M.node_destroy(node)
-  if not node then
-    return
-  end
-
-  if node.watcher then
-    node.watcher:destroy()
-    node.watcher = nil
-  end
-end
-
-function M.setup(opts)
-  M.config = {
-    git = opts.git,
-  }
-end
-
-return M

lua/nvim-tree/explorer/reload.lua

@@ -1,240 +0,0 @@
-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 NodeIterator = require "nvim-tree.iterators.node-iterator"
-local Watcher = require "nvim-tree.watcher"
-
-local M = {}
-
----@param nodes_by_path table
----@param node_ignored boolean
----@param status table
----@return fun(node: Node): table
-local function update_status(nodes_by_path, node_ignored, status)
-  return function(node)
-    if nodes_by_path[node.absolute_path] then
-      explorer_node.update_git_status(node, node_ignored, status)
-    end
-    return node
-  end
-end
-
----@param path string
----@param callback fun(toplevel: string|nil, project: table|nil)
-local function reload_and_get_git_project(path, callback)
-  local toplevel = git.get_toplevel(path)
-
-  git.reload_project(toplevel, path, function()
-    callback(toplevel, git.get_project(toplevel) or {})
-  end)
-end
-
----@param node Node
----@param project table|nil
----@param root string|nil
-local function update_parent_statuses(node, project, root)
-  while project and node do
-    -- step up to the containing project
-    if node.absolute_path == root then
-      -- stop at the top of the tree
-      if not node.parent then
-        break
-      end
-
-      root = git.get_toplevel(node.parent.absolute_path)
-
-      -- stop when no more projects
-      if not root then
-        break
-      end
-
-      -- update the containing project
-      project = git.get_project(root)
-      git.reload_project(root, node.absolute_path, nil)
-    end
-
-    -- update status
-    explorer_node.update_git_status(node, explorer_node.is_git_ignored(node.parent), project)
-
-    -- maybe parent
-    node = node.parent
-  end
-end
-
----@param node Node
----@param git_status table
----@param unloaded_bufnr number|nil
-function M.reload(node, git_status, unloaded_bufnr)
-  local cwd = node.link_to or node.absolute_path
-  local handle = vim.loop.fs_scandir(cwd)
-  if not handle then
-    return
-  end
-
-  local profile = log.profile_start("reload %s", node.absolute_path)
-
-  local filter_status = filters.prepare(git_status, unloaded_bufnr)
-
-  if node.group_next then
-    node.nodes = { node.group_next }
-    node.group_next = nil
-  end
-
-  local child_names = {}
-
-  local node_ignored = explorer_node.is_git_ignored(node)
-  local nodes_by_path = utils.key_by(node.nodes, "absolute_path")
-  while true do
-    local name, t = vim.loop.fs_scandir_next(handle, cwd)
-    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
-    if not filters.should_filter(abs, filter_status) then
-      child_names[abs] = true
-
-      -- Recreate node if type changes.
-      if nodes_by_path[abs] then
-        local n = nodes_by_path[abs]
-
-        if n.type ~= t then
-          utils.array_remove(node.nodes, n)
-          explorer_node.node_destroy(n)
-          nodes_by_path[abs] = nil
-        end
-      end
-
-      if not nodes_by_path[abs] then
-        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)
-          nodes_by_path[abs] = folder
-          table.insert(node.nodes, folder)
-        elseif t == "file" then
-          local file = builders.file(node, abs, name)
-          nodes_by_path[abs] = file
-          table.insert(node.nodes, file)
-        elseif t == "link" then
-          local link = builders.link(node, abs, name)
-          if link.link_to ~= nil then
-            nodes_by_path[abs] = link
-            table.insert(node.nodes, link)
-          end
-        end
-      else
-        local n = nodes_by_path[abs]
-        if n then
-          n.executable = builders.is_executable(abs)
-          n.fs_stat = fs_stat_cached(abs)
-        end
-      end
-    end
-  end
-
-  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
-        return child_names[n.absolute_path]
-      else
-        explorer_node.node_destroy(n)
-        return false
-      end
-    end, node.nodes)
-  )
-
-  local is_root = not node.parent
-  local child_folder_only = explorer_node.has_one_child_folder(node) and node.nodes[1]
-  if M.config.group_empty and not is_root and child_folder_only then
-    node.group_next = child_folder_only
-    local ns = M.reload(child_folder_only, git_status)
-    node.nodes = ns or {}
-    log.profile_end(profile)
-    return ns
-  end
-
-  sorters.sort(node.nodes)
-  live_filter.apply_filter(node)
-  log.profile_end(profile)
-  return node.nodes
-end
-
----Refresh contents and git status for a single node
----@param node Node
----@param callback function
-function M.refresh_node(node, callback)
-  if type(node) ~= "table" then
-    callback()
-  end
-
-  local parent_node = utils.get_parent_of_group(node)
-
-  reload_and_get_git_project(node.absolute_path, function(toplevel, project)
-    require("nvim-tree.explorer.reload").reload(parent_node, project)
-
-    update_parent_statuses(parent_node, project, toplevel)
-
-    callback()
-  end)
-end
-
----Refresh contents of all nodes to a path: actual directory and links.
----Groups will be expanded if needed.
----@param path string absolute path
-function M.refresh_parent_nodes_for_path(path)
-  local explorer = require("nvim-tree.core").get_explorer()
-  if not explorer then
-    return
-  end
-
-  local profile = log.profile_start("refresh_parent_nodes_for_path %s", path)
-
-  -- collect parent nodes from the top down
-  local parent_nodes = {}
-  NodeIterator.builder({ explorer })
-    :recursor(function(node)
-      return node.nodes
-    end)
-    :applier(function(node)
-      local abs_contains = node.absolute_path and path:find(node.absolute_path, 1, true) == 1
-      local link_contains = node.link_to and path:find(node.link_to, 1, true) == 1
-      if abs_contains or link_contains then
-        table.insert(parent_nodes, node)
-      end
-    end)
-    :iterate()
-
-  -- refresh in order; this will expand groups as needed
-  for _, node in ipairs(parent_nodes) do
-    local toplevel = git.get_toplevel(node.absolute_path)
-    local project = git.get_project(toplevel) or {}
-
-    M.reload(node, project)
-    update_parent_statuses(node, project, toplevel)
-  end
-
-  log.profile_end(profile)
-end
-
-function M.setup(opts)
-  M.config = opts.renderer
-end
-
-return M

lua/nvim-tree/explorer/sorter.lua

@@ -1,12 +1,25 @@
-local M = {}
+local Class = require("nvim-tree.classic")
+local DirectoryNode = require("nvim-tree.node.directory")
 
-local C = {}
+---@alias SorterType "name" | "case_sensitive" | "modification_time" | "extension" | "suffix" | "filetype"
+---@alias SorterComparator fun(self: Sorter, a: Node, b: Node): boolean?
 
---- Predefined comparator, defaulting to name
----@param sorter string as per options
----@return function
-local function get_comparator(sorter)
-  return C[sorter] or C.name
+---@alias SorterUser fun(nodes: Node[]): SorterType?
+
+---@class (exact) Sorter: Class
+---@field private explorer Explorer
+local Sorter = Class:extend()
+
+---@class Sorter
+---@overload fun(args: SorterArgs): Sorter
+
+---@class (exact) SorterArgs
+---@field explorer Explorer
+
+---@protected
+---@param args SorterArgs
+function Sorter:new(args)
+  self.explorer = args.explorer
 end
 
 ---Create a shallow copy of a portion of a list.
@@ -23,30 +36,32 @@ local function tbl_slice(t, first, last)
   return slice
 end
 
----Evaluate `sort.folders_first` and `sort.files_first`
----@param a Node
----@param b Node
----@return boolean|nil
-local function folders_or_files_first(a, b)
-  if not (M.config.sort.folders_first or M.config.sort.files_first) then
-    return
+---Evaluate folders_first and sort.files_first returning nil when no order is necessary
+---@private
+---@type SorterComparator
+function Sorter:folders_or_files_first(a, b)
+  if not (self.explorer.opts.sort.folders_first or self.explorer.opts.sort.files_first) then
+    return nil
   end
 
-  if not a.nodes and b.nodes then
+  if not a:is(DirectoryNode) and b:is(DirectoryNode) then
     -- file <> folder
-    return M.config.sort.files_first
-  elseif a.nodes and not b.nodes then
+    return self.explorer.opts.sort.files_first
+  elseif a:is(DirectoryNode) and not b:is(DirectoryNode) then
     -- folder <> file
-    return not M.config.sort.files_first
-  end
+    return not self.explorer.opts.sort.files_first
   end
 
----@param t table
+  return nil
+end
+
+---@private
+---@param t Node[]
 ---@param first number
 ---@param mid number
 ---@param last number
----@param comparator fun(a: Node, b: Node): boolean
-local function merge(t, first, mid, last, comparator)
+---@param comparator SorterComparator
+function Sorter:merge(t, first, mid, last, comparator)
   local n1 = mid - first + 1
   local n2 = last - mid
   local ls = tbl_slice(t, first, mid)
@@ -56,7 +71,7 @@ local function merge(t, first, mid, last, comparator)
   local k = first
 
   while i <= n1 and j <= n2 do
-    if comparator(ls[i], rs[j]) then
+    if comparator(self, ls[i], rs[j]) then
       t[k] = ls[i]
       i = i + 1
     else
@@ -79,26 +94,29 @@ local function merge(t, first, mid, last, comparator)
   end
 end
 
----@param t table
+---@private
+---@param t Node[]
 ---@param first number
 ---@param last number
----@param comparator fun(a: Node, b: Node): boolean
-local function split_merge(t, first, last, comparator)
+---@param comparator SorterComparator
+function Sorter:split_merge(t, first, last, comparator)
   if (last - first) < 1 then
     return
   end
 
   local mid = math.floor((first + last) / 2)
 
-  split_merge(t, first, mid, comparator)
-  split_merge(t, mid + 1, last, comparator)
-  merge(t, first, mid, last, comparator)
+  self:split_merge(t, first,   mid,  comparator)
+  self:split_merge(t, mid + 1, last, comparator)
+  self:merge(t, first, mid, last, comparator)
 end
 
 ---Perform a merge sort using sorter option.
----@param t table nodes
-function M.sort(t)
-  if C.user then
+---@param t Node[]
+function Sorter:sort(t)
+  if self[self.explorer.opts.sort.sorter] then
+    self:split_merge(t, 1, #t, self[self.explorer.opts.sort.sorter])
+  elseif type(self.explorer.opts.sort.sorter) == "function" then
     local t_user = {}
     local origin_index = {}
 
@@ -107,7 +125,7 @@ function M.sort(t)
         absolute_path = n.absolute_path,
         executable    = n.executable,
         extension     = n.extension,
-        filetype = vim.filetype.match { filename = n.name },
+        filetype      = vim.filetype.match({ filename = n.name }),
         link_to       = n.link_to,
         name          = n.name,
         type          = n.type,
@@ -115,9 +133,10 @@ function M.sort(t)
       table.insert(origin_index, n)
     end
 
-    local predefined = C.user(t_user)
-    if predefined then
-      split_merge(t, 1, #t, get_comparator(predefined))
+    -- user may return a SorterType
+    local ret = self.explorer.opts.sort.sorter(t_user)
+    if self[ret] then
+      self:split_merge(t, 1, #t, self[ret])
       return
     end
 
@@ -130,7 +149,7 @@ function M.sort(t)
     end
 
     -- if missing value found, then using origin_index
-    local mini_comparator = function(a, b)
+    local mini_comparator = function(_, a, b)
       local a_index = user_index[a.absolute_path] or origin_index[a.absolute_path]
       local b_index = user_index[b.absolute_path] or origin_index[b.absolute_path]
 
@@ -140,47 +159,52 @@ function M.sort(t)
       return (a_index or 0) <= (b_index or 0)
     end
 
-    split_merge(t, 1, #t, mini_comparator) -- sort by user order
-  else
-    split_merge(t, 1, #t, get_comparator(M.config.sort.sorter))
+    self:split_merge(t, 1, #t, mini_comparator) -- sort by user order
   end
 end
 
+---@private
 ---@param a Node
 ---@param b Node
----@param ignorecase boolean|nil
+---@param ignore_case boolean
 ---@return boolean
-local function node_comparator_name_ignorecase_or_not(a, b, ignorecase)
+function Sorter:name_case(a, b, ignore_case)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
 
-  if ignorecase then
+  if ignore_case then
     return a.name:lower() <= b.name:lower()
   else
     return a.name <= b.name
   end
 end
 
-function C.case_sensitive(a, b)
-  return node_comparator_name_ignorecase_or_not(a, b, false)
+---@private
+---@type SorterComparator
+function Sorter:case_sensitive(a, b)
+  return self:name_case(a, b, false)
 end
 
-function C.name(a, b)
-  return node_comparator_name_ignorecase_or_not(a, b, true)
+---@private
+---@type SorterComparator
+function Sorter:name(a, b)
+  return self:name_case(a, b, true)
 end
 
-function C.modification_time(a, b)
+---@private
+---@type SorterComparator
+function Sorter:modification_time(a, b)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -199,17 +223,19 @@ function C.modification_time(a, b)
   return last_modified_b <= last_modified_a
 end
 
-function C.suffix(a, b)
+---@private
+---@type SorterComparator
+function Sorter:suffix(a, b)
   if not (a and b) then
     return true
   end
 
   -- directories go first
-  local early_return = folders_or_files_first(a, b)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   elseif a.nodes and b.nodes then
-    return C.name(a, b)
+    return self:name(a, b)
   end
 
   -- dotfiles go second
@@ -218,19 +244,19 @@ 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 self:name(a, b)
   end
 
   -- unsuffixed go third
-  local a_suffix_ndx = a.name:find "%.%w+$"
-  local b_suffix_ndx = b.name:find "%.%w+$"
+  local a_suffix_ndx = a.name:find("%.%w+$")
+  local b_suffix_ndx = b.name:find("%.%w+$")
 
   if not a_suffix_ndx and b_suffix_ndx then
     return true
   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 self:name(a, b)
   end
 
   -- finally, compare by suffixes
@@ -242,18 +268,20 @@ 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 self:name(a, b)
   end
 
   return a_suffix:lower() < b_suffix:lower()
 end
 
-function C.extension(a, b)
+---@private
+---@type SorterComparator
+function Sorter:extension(a, b)
   if not (a and b) then
     return true
   end
 
-  local early_return = folders_or_files_first(a, b)
+  local early_return = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -267,18 +295,20 @@ 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 self:name(a, b)
   end
 
   return a_ext < b_ext
 end
 
-function C.filetype(a, b)
-  local a_ft = vim.filetype.match { filename = a.name }
-  local b_ft = vim.filetype.match { filename = b.name }
+---@private
+---@type SorterComparator
+function Sorter:filetype(a, b)
+  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 = self:folders_or_files_first(a, b)
   if early_return ~= nil then
     return early_return
   end
@@ -292,19 +322,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 self:name(a, b)
   end
 
   return a_ft < b_ft
 end
 
-function M.setup(opts)
-  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
+return Sorter

lua/nvim-tree/explorer/watch.lua

@@ -1,5 +1,6 @@
-local log = require "nvim-tree.log"
-local utils = require "nvim-tree.utils"
+local log = require("nvim-tree.log")
+local git = require("nvim-tree.git")
+local utils = require("nvim-tree.utils")
 local Watcher = require("nvim-tree.watcher").Watcher
 
 local M = {
@@ -40,16 +41,20 @@ 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
 
----@param node Node
+---@param node DirectoryNode
 ---@return Watcher|nil
 function M.create_watcher(node)
   if not M.config.filesystem_watchers.enable or type(node) ~= "table" then
@@ -61,9 +66,10 @@ function M.create_watcher(node)
     return nil
   end
 
+  ---@param watcher Watcher
   local function callback(watcher)
-    log.line("watcher", "node event scheduled refresh %s", watcher.context)
-    utils.debounce(watcher.context, M.config.filesystem_watchers.debounce_delay, function()
+    log.line("watcher", "node event scheduled refresh %s", watcher.data.context)
+    utils.debounce(watcher.data.context, M.config.filesystem_watchers.debounce_delay, function()
       if watcher.destroyed then
         return
       end
@@ -72,15 +78,17 @@ function M.create_watcher(node)
       else
         log.line("watcher", "node event executing refresh '%s'", node.absolute_path)
       end
-      require("nvim-tree.explorer.reload").refresh_node(node, function()
-        require("nvim-tree.renderer").draw()
-      end)
+      git.refresh_dir(node)
     end)
   end
 
   M.uid = M.uid + 1
-  return Watcher:new(path, nil, callback, {
-    context = "explorer:watch:" .. path .. ":" .. M.uid,
+  return Watcher:create({
+    path = path,
+    callback = callback,
+    data = {
+      context = "explorer:watch:" .. path .. ":" .. M.uid
+    }
   })
 end
 

lua/nvim-tree/git/init.lua

@@ -1,21 +1,48 @@
-local log = require "nvim-tree.log"
-local utils = require "nvim-tree.utils"
-local git_utils = require "nvim-tree.git.utils"
-local Runner = require "nvim-tree.git.runner"
+local log = require("nvim-tree.log")
+local utils = require("nvim-tree.utils")
+local git_utils = require("nvim-tree.git.utils")
+
+local GitRunner = require("nvim-tree.git.runner")
 local Watcher = require("nvim-tree.watcher").Watcher
-local Iterator = require "nvim-tree.iterators.node-iterator"
-local explorer_node = require "nvim-tree.explorer.node"
+local Iterator = require("nvim-tree.iterators.node-iterator")
+local DirectoryNode = require("nvim-tree.node.directory")
+
+---Git short format status xy
+---@alias GitXY string
+
+-- Git short-format status
+---@alias GitPathXY table<string, GitXY>
+
+-- Git short-format statuses
+---@alias GitPathXYs table<string, GitXY[]>
+
+---Git short-format statuses for a single node
+---@class (exact) GitNodeStatus
+---@field file GitXY?
+---@field dir table<"direct" | "indirect", GitXY[]>?
+
+---Git state for an entire repo
+---@class (exact) GitProject
+---@field files GitProjectFiles?
+---@field dirs GitProjectDirs?
+---@field watcher Watcher?
+
+---@alias GitProjectFiles GitPathXY
+---@alias GitProjectDirs table<"direct" | "indirect", GitPathXYs>
 
 local M = {
   config = {},
 
-  -- all projects keyed by toplevel
+  ---all projects keyed by toplevel
+  ---@type table<string, GitProject>
   _projects_by_toplevel = {},
 
-  -- index of paths inside toplevels, false when not inside a project
+  ---index of paths inside toplevels, false when not inside a project
+  ---@type table<string, string|false>
   _toplevels_by_path = {},
 
   -- git dirs by toplevel
+  ---@type table<string, string>
   _git_dirs_by_toplevel = {},
 }
 
@@ -31,35 +58,35 @@ local WATCHED_FILES = {
 
 ---@param toplevel string|nil
 ---@param path string|nil
----@param project table
----@param git_status table|nil
-local function reload_git_status(toplevel, path, project, git_status)
+---@param project GitProject
+---@param project_files GitProjectFiles?
+local function reload_git_project(toplevel, path, project, project_files)
   if path then
     for p in pairs(project.files) do
       if p:find(path, 1, true) == 1 then
         project.files[p] = nil
       end
     end
-    project.files = vim.tbl_deep_extend("force", project.files, git_status)
+    project.files = vim.tbl_deep_extend("force", project.files, project_files)
   else
-    project.files = git_status
+    project.files = project_files or {}
   end
 
-  project.dirs = git_utils.file_status_to_dir_status(project.files, toplevel)
+  project.dirs = git_utils.project_files_to_project_dirs(project.files, toplevel)
 end
 
 --- Is this path in a known ignored directory?
 ---@param path string
----@param project table git status
+---@param project GitProject
 ---@return boolean
 local function path_ignored_in_project(path, project)
   if not path or not project then
     return false
   end
 
-  if project and project.files then
-    for file, status in pairs(project.files) do
-      if status == "!!" and vim.startswith(path, file) then
+  if project.files then
+    for p, xy in pairs(project.files) do
+      if xy == "!!" and vim.startswith(path, p) then
         return true
       end
     end
@@ -67,9 +94,8 @@ local function path_ignored_in_project(path, project)
   return false
 end
 
---- Reload all projects
----@return table projects maybe empty
-function M.reload()
+---@return GitProject[] maybe empty
+function M.reload_all_projects()
   if not M.config.git.enable then
     return {}
   end
@@ -82,11 +108,12 @@ function M.reload()
 end
 
 --- Reload one project. Does nothing when no project or path is ignored
----@param toplevel string|nil
----@param path string|nil optional path to update only
----@param callback function|nil
+---@param toplevel string?
+---@param path string? optional path to update only
+---@param callback function?
 function M.reload_project(toplevel, path, callback)
-  local project = M._projects_by_toplevel[toplevel]
+  local project = M._projects_by_toplevel[toplevel] --[[@as GitProject]]
+
   if not toplevel or not project or not M.config.git.enable then
     if callback then
       callback()
@@ -101,7 +128,8 @@ function M.reload_project(toplevel, path, callback)
     return
   end
 
-  local opts = {
+  ---@type GitRunnerArgs
+  local args = {
     toplevel       = toplevel,
     path           = path,
     list_untracked = git_utils.should_show_untracked(toplevel),
@@ -110,20 +138,21 @@ function M.reload_project(toplevel, path, callback)
   }
 
   if callback then
-    Runner.run(opts, function(git_status)
-      reload_git_status(toplevel, path, project, git_status)
+    ---@param path_xy GitPathXY
+    args.callback = function(path_xy)
+      reload_git_project(toplevel, path, project, path_xy)
       callback()
-    end)
+    end
+    GitRunner:run(args)
   else
-    -- TODO use callback once async/await is available
-    local git_status = Runner.run(opts)
-    reload_git_status(toplevel, path, project, git_status)
+    -- TODO #1974 use callback once async/await is available
+    reload_git_project(toplevel, path, project, GitRunner:run(args))
   end
 end
 
 --- Retrieve a known project
----@param toplevel string|nil
----@return table|nil project
+---@param toplevel string?
+---@return GitProject? project
 function M.get_project(toplevel)
   return M._projects_by_toplevel[toplevel]
 end
@@ -136,15 +165,18 @@ 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
 
-  if M._toplevels_by_path[path] then
-    return M._toplevels_by_path[path]
-  end
-
-  if M._toplevels_by_path[path] == false then
+  local tl = M._toplevels_by_path[path]
+  if tl then
+    return tl
+  elseif tl == false then
     return nil
   end
 
@@ -161,24 +193,38 @@ function M.get_toplevel(path)
     end
   end
 
-  -- attempt to fetch toplevel
+  -- attempt to fetch toplevel, cache if untracked
   local toplevel, git_dir = git_utils.get_toplevel(path)
   if not toplevel or not git_dir then
+    M._toplevels_by_path[path] = false
     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
-  return M._toplevels_by_path[path]
+
+  toplevel = M._toplevels_by_path[path]
+  if toplevel == false then
+    return nil
+  else
+    return toplevel
+  end
 end
 
 local function reload_tree_at(toplevel)
@@ -187,34 +233,40 @@ local function reload_tree_at(toplevel)
   end
 
   log.line("watcher", "git event executing '%s'", toplevel)
-  local root_node = utils.get_node_from_path(toplevel)
+
+  local explorer = require("nvim-tree.core").get_explorer()
+  if not explorer then
+    return nil
+  end
+
+  local root_node = explorer:get_node_from_path(toplevel)
   if not root_node then
     return
   end
 
   M.reload_project(toplevel, nil, function()
-    local git_status = M.get_project(toplevel)
+    local project = M.get_project(toplevel)
 
     Iterator.builder(root_node.nodes)
       :hidden()
       :applier(function(node)
-        local parent_ignored = explorer_node.is_git_ignored(node.parent)
-        explorer_node.update_git_status(node, parent_ignored, git_status)
+        local parent_ignored = node.parent and node.parent:is_git_ignored() or false
+        node:update_git_status(parent_ignored, project)
       end)
       :recursor(function(node)
         return node.nodes and #node.nodes > 0 and node.nodes
       end)
       :iterate()
 
-    require("nvim-tree.renderer").draw()
+    explorer.renderer:draw()
   end)
 end
 
 --- Load the project status for a path. Does nothing when no toplevel for path.
 --- Only fetches project status when unknown, otherwise returns existing.
 ---@param path string absolute
----@return table project maybe empty
-function M.load_project_status(path)
+---@return GitProject maybe empty
+function M.load_project(path)
   if not M.config.git.enable then
     return {}
   end
@@ -225,42 +277,48 @@ function M.load_project_status(path)
     return {}
   end
 
-  local status = M._projects_by_toplevel[toplevel]
-  if status then
-    return status
+  local project = M._projects_by_toplevel[toplevel]
+  if project then
+    return project
   end
 
-  local git_status = Runner.run {
+  local path_xys = GitRunner:run({
     toplevel       = toplevel,
     list_untracked = git_utils.should_show_untracked(toplevel),
     list_ignored   = true,
     timeout        = M.config.git.timeout,
-  }
+  })
 
   local watcher = nil
   if M.config.filesystem_watchers.enable then
     log.line("watcher", "git start")
 
+    ---@param w Watcher
     local callback = function(w)
-      log.line("watcher", "git event scheduled '%s'", w.toplevel)
-      utils.debounce("git:watcher:" .. w.toplevel, M.config.filesystem_watchers.debounce_delay, function()
+      log.line("watcher", "git event scheduled '%s'", w.data.toplevel)
+      utils.debounce("git:watcher:" .. w.data.toplevel, M.config.filesystem_watchers.debounce_delay, function()
         if w.destroyed then
           return
         end
-        reload_tree_at(w.toplevel)
+        reload_tree_at(w.data.toplevel)
       end)
     end
 
-    local git_dir = vim.env.GIT_DIR or M._git_dirs_by_toplevel[toplevel] or utils.path_join { toplevel, ".git" }
-    watcher = Watcher:new(git_dir, WATCHED_FILES, callback, {
+    local git_dir = vim.env.GIT_DIR or M._git_dirs_by_toplevel[toplevel] or utils.path_join({ toplevel, ".git" })
+    watcher = Watcher:create({
+      path     = git_dir,
+      files    = WATCHED_FILES,
+      callback = callback,
+      data     = {
         toplevel = toplevel,
+      }
     })
   end
 
-  if git_status then
+  if path_xys then
     M._projects_by_toplevel[toplevel] = {
-      files = git_status,
-      dirs = git_utils.file_status_to_dir_status(git_status, toplevel),
+      files   = path_xys,
+      dirs    = git_utils.project_files_to_project_dirs(path_xys, toplevel),
       watcher = watcher,
     }
     return M._projects_by_toplevel[toplevel]
@@ -270,6 +328,71 @@ function M.load_project_status(path)
   end
 end
 
+---@param dir DirectoryNode
+---@param project GitProject?
+---@param root string?
+function M.update_parent_projects(dir, project, root)
+  while project and dir do
+    -- step up to the containing project
+    if dir.absolute_path == root then
+      -- stop at the top of the tree
+      if not dir.parent then
+        break
+      end
+
+      root = M.get_toplevel(dir.parent.absolute_path)
+
+      -- stop when no more projects
+      if not root then
+        break
+      end
+
+      -- update the containing project
+      project = M.get_project(root)
+      M.reload_project(root, dir.absolute_path, nil)
+    end
+
+    -- update status
+    dir:update_git_status(dir.parent and dir.parent:is_git_ignored() or false, project)
+
+    -- maybe parent
+    dir = dir.parent
+  end
+end
+
+---Refresh contents and git status for a single directory
+---@param dir DirectoryNode
+function M.refresh_dir(dir)
+  local node = dir:get_parent_of_group() or dir
+  local toplevel = M.get_toplevel(dir.absolute_path)
+
+  M.reload_project(toplevel, dir.absolute_path, function()
+    local project = M.get_project(toplevel) or {}
+
+    dir.explorer:reload(node, project)
+
+    M.update_parent_projects(dir, project, toplevel)
+
+    dir.explorer.renderer:draw()
+  end)
+end
+
+---@param dir DirectoryNode?
+---@param projects GitProject[]
+function M.reload_node_status(dir, projects)
+  dir = dir and dir:as(DirectoryNode)
+  if not dir or #dir.nodes == 0 then
+    return
+  end
+
+  local toplevel = M.get_toplevel(dir.absolute_path)
+  local project = projects[toplevel] or {}
+  for _, node in ipairs(dir.nodes) do
+    node:update_git_status(dir:is_git_ignored(), project)
+    M.reload_node_status(node:as(DirectoryNode), projects)
+  end
+end
+
 function M.purge_state()
   log.line("git", "purge_state")
 

lua/nvim-tree/git/runner.lua

@@ -1,33 +1,62 @@
-local log = require "nvim-tree.log"
-local utils = require "nvim-tree.utils"
-local notify = require "nvim-tree.notify"
+local log = require("nvim-tree.log")
+local utils = require("nvim-tree.utils")
+local notify = require("nvim-tree.notify")
 
--- TODO add "${3rd}/luv/library" to "workspace.library"
----@class uv.uv_handle_t: table
----@class uv.uv_stream_t: uv.uv_handle_t
----@class uv.uv_pipe_t: uv.uv_stream_t
+local Class = require("nvim-tree.classic")
 
----@class Runner
-local Runner = {}
-Runner.__index = Runner
+---@class (exact) GitRunner: Class
+---@field private toplevel string absolute path
+---@field private path string? absolute path
+---@field private list_untracked boolean
+---@field private list_ignored boolean
+---@field private timeout integer
+---@field private callback fun(path_xy: GitPathXY)?
+---@field private path_xy GitPathXY
+---@field private rc integer? -- -1 indicates timeout
+local GitRunner = Class:extend()
+
+---@class GitRunner
+---@overload fun(args: GitRunnerArgs): GitRunner
+
+---@class (exact) GitRunnerArgs
+---@field toplevel string absolute path
+---@field path string? absolute path
+---@field list_untracked boolean
+---@field list_ignored boolean
+---@field timeout integer
+---@field callback fun(path_xy: GitPathXY)?
 
 local timeouts = 0
 local MAX_TIMEOUTS = 5
 
+---@protected
+---@param args GitRunnerArgs
+function GitRunner:new(args)
+  self.toplevel       = args.toplevel
+  self.path           = args.path
+  self.list_untracked = args.list_untracked
+  self.list_ignored   = args.list_ignored
+  self.timeout        = args.timeout
+  self.callback       = args.callback
+
+  self.path_xy        = {}
+  self.rc             = nil
+end
+
 ---@private
 ---@param status string
 ---@param path string|nil
-function Runner:_parse_status_output(status, path)
+function GitRunner:parse_status_output(status, path)
   if not path then
     return
   end
 
   -- replacing slashes if on windows
-  if vim.fn.has "win32" == 1 then
+  if vim.fn.has("win32") == 1 then
     path = path:gsub("/", "\\")
   end
   if #status > 0 and #path > 0 then
-    self.output[utils.path_remove_trailing(utils.path_join { self.toplevel, path })] = status
+    self.path_xy[utils.path_remove_trailing(utils.path_join({ self.toplevel, path }))] = status
   end
 end
 
@@ -35,12 +64,12 @@ end
 ---@param prev_output string
 ---@param incoming string
 ---@return string
-function Runner:_handle_incoming_data(prev_output, incoming)
+function GitRunner:handle_incoming_data(prev_output, incoming)
   if incoming and utils.str_find(incoming, "\n") then
     local prev = prev_output .. incoming
     local i = 1
     local skip_next_line = false
-    for line in prev:gmatch "[^\n]*\n" do
+    for line in prev:gmatch("[^\n]*\n") do
       if skip_next_line then
         skip_next_line = false
       else
@@ -50,7 +79,7 @@ function Runner:_handle_incoming_data(prev_output, incoming)
           -- skip next line if it is a rename entry
           skip_next_line = true
         end
-        self:_parse_status_output(status, path)
+        self:parse_status_output(status, path)
       end
       i = i + #line
     end
@@ -62,17 +91,18 @@ function Runner:_handle_incoming_data(prev_output, incoming)
     return prev_output .. incoming
   end
 
-  for line in prev_output:gmatch "[^\n]*\n" do
-    self:_parse_status_output(line)
+  for line in prev_output:gmatch("[^\n]*\n") do
+    self:parse_status_output(line)
   end
 
   return ""
 end
 
+---@private
 ---@param stdout_handle uv.uv_pipe_t
 ---@param stderr_handle uv.uv_pipe_t
----@return table
-function Runner:_getopts(stdout_handle, stderr_handle)
+---@return uv.spawn.options
+function GitRunner:get_spawn_options(stdout_handle, stderr_handle)
   local untracked = self.list_untracked and "-u" or nil
   local ignored = (self.list_untracked and self.list_ignored) and "--ignored=matching" or "--ignored=no"
   return {
@@ -82,16 +112,18 @@ function Runner:_getopts(stdout_handle, stderr_handle)
   }
 end
 
+---@private
 ---@param output string
-function Runner:_log_raw_output(output)
-  if log.enabled "git" and output and type(output) == "string" then
+function GitRunner:log_raw_output(output)
+  if log.enabled("git") and output and type(output) == "string" then
     log.raw("git", "%s", output)
     log.line("git", "done")
   end
 end
 
+---@private
 ---@param callback function|nil
-function Runner:_run_git_job(callback)
+function GitRunner:run_git_job(callback)
   local handle, pid
   local stdout = vim.loop.new_pipe(false)
   local stderr = vim.loop.new_pipe(false)
@@ -128,13 +160,13 @@ function Runner:_run_git_job(callback)
     end
   end
 
-  local opts = self:_getopts(stdout, stderr)
+  local spawn_options = self:get_spawn_options(stdout, stderr)
   log.line("git", "running job with timeout %dms", self.timeout)
-  log.line("git", "git %s", table.concat(utils.array_remove_nils(opts.args), " "))
+  log.line("git", "git %s",                        table.concat(utils.array_remove_nils(spawn_options.args), " "))
 
   handle, pid = vim.loop.spawn(
     "git",
-    opts,
+    spawn_options,
     vim.schedule_wrap(function(rc)
       on_finish(rc)
     end)
@@ -156,19 +188,20 @@ function Runner:_run_git_job(callback)
     if data then
       data = data:gsub("%z", "\n")
     end
-    self:_log_raw_output(data)
-    output_leftover = self:_handle_incoming_data(output_leftover, data)
+    self:log_raw_output(data)
+    output_leftover = self:handle_incoming_data(output_leftover, data)
   end
 
   local function manage_stderr(_, data)
-    self:_log_raw_output(data)
+    self:log_raw_output(data)
   end
 
   vim.loop.read_start(stdout, vim.schedule_wrap(manage_stdout))
   vim.loop.read_start(stderr, vim.schedule_wrap(manage_stderr))
 end
 
-function Runner:_wait()
+---@private
+function GitRunner:wait()
   local function is_done()
     return self.rc ~= nil
   end
@@ -177,64 +210,64 @@ function Runner:_wait()
   end
 end
 
----@param opts table
-function Runner:_finalise(opts)
+---@private
+function GitRunner:finalise()
   if self.rc == -1 then
-    log.line("git", "job timed out  %s %s", opts.toplevel, opts.path)
+    log.line("git", "job timed out  %s %s", self.toplevel, self.path)
     timeouts = timeouts + 1
     if timeouts == MAX_TIMEOUTS then
-      notify.warn(string.format("%d git jobs have timed out after git.timeout %dms, disabling git integration.", timeouts, opts.timeout))
+      notify.warn(string.format("%d git jobs have timed out after git.timeout %dms, disabling git integration.", timeouts,
+        self.timeout))
       require("nvim-tree.git").disable_git_integration()
     end
   elseif self.rc ~= 0 then
-    log.line("git", "job fail rc %d %s %s", self.rc, opts.toplevel, opts.path)
+    log.line("git", "job fail rc %d %s %s", self.rc, self.toplevel, self.path)
   else
-    log.line("git", "job success    %s %s", opts.toplevel, opts.path)
+    log.line("git", "job success    %s %s", self.toplevel, self.path)
   end
 end
 
---- Runs a git process, which will be killed if it takes more than timeout which defaults to 400ms
----@param opts table
----@param callback function|nil executed passing return when complete
----@return table|nil status by absolute path, nil if callback present
-function Runner.run(opts, callback)
-  local self = setmetatable({
-    toplevel = opts.toplevel,
-    path = opts.path,
-    list_untracked = opts.list_untracked,
-    list_ignored = opts.list_ignored,
-    timeout = opts.timeout or 400,
-    output = {},
-    rc = nil, -- -1 indicates timeout
-  }, Runner)
+---Return nil when callback present
+---@private
+---@return GitPathXY?
+function GitRunner:execute()
+  local async = self.callback ~= nil
+  local profile = log.profile_start("git %s job %s %s", async and "async" or "sync", self.toplevel, self.path)
 
-  local async = callback ~= nil
-  local profile = log.profile_start("git %s job %s %s", async and "async" or "sync", opts.toplevel, opts.path)
-
-  if async and callback then
+  if async and self.callback then
     -- async, always call back
-    self:_run_git_job(function()
+    self:run_git_job(function()
       log.profile_end(profile)
 
-      self:_finalise(opts)
+      self:finalise()
 
-      callback(self.output)
+      self.callback(self.path_xy)
     end)
   else
     -- sync, maybe call back
-    self:_run_git_job()
-    self:_wait()
+    self:run_git_job()
+    self:wait()
 
     log.profile_end(profile)
 
-    self:_finalise(opts)
+    self:finalise()
 
-    if callback then
-      callback(self.output)
+    if self.callback then
+      self.callback(self.path_xy)
     else
-      return self.output
+      return self.path_xy
     end
   end
 end
 
-return Runner
+---Static method to run a git process, which will be killed if it takes more than timeout
+---Return nil when callback present
+---@param args GitRunnerArgs
+---@return GitPathXY?
+function GitRunner:run(args)
+  local runner = GitRunner(args)
+
+  return runner:execute()
+end
+
+return GitRunner

lua/nvim-tree/git/utils.lua

@@ -1,10 +1,23 @@
-local log = require "nvim-tree.log"
-local utils = require "nvim-tree.utils"
+local log = require("nvim-tree.log")
+local utils = require("nvim-tree.utils")
 
 local M = {
   use_cygpath = false,
 }
 
+--- Execute system command
+---@param cmd string[]
+---@return string stdout
+---@return integer exit code
+local function system(cmd)
+  if vim.fn.has("nvim-0.10") == 1 then
+    local obj = vim.system(cmd):wait()
+    return obj.stdout or "", obj.code
+  else
+    return vim.fn.system(cmd), vim.v.shell_error
+  end
+end
+
 --- Retrieve the git toplevel directory
 ---@param cwd string path
 ---@return string|nil toplevel absolute path
@@ -16,35 +29,35 @@ function M.get_toplevel(cwd)
   local cmd = { "git", "-C", cwd, "rev-parse", "--show-toplevel", "--absolute-git-dir" }
   log.line("git", "%s", table.concat(cmd, " "))
 
-  local out = vim.fn.system(cmd)
+  local out, exitCode = system(cmd)
 
   log.raw("git", out)
   log.profile_end(profile)
 
-  if vim.v.shell_error ~= 0 or not out or #out == 0 or out:match "fatal" then
+  if exitCode ~= 0 or not out or #out == 0 or out:match("fatal") then
     return nil, nil
   end
 
-  local toplevel, git_dir = out:match "([^\n]+)\n+([^\n]+)"
+  local toplevel, git_dir = out:match("([^\n]+)\n+([^\n]+)")
   if not toplevel then
     return nil, nil
   end
   if not git_dir then
-    git_dir = utils.path_join { toplevel, ".git" }
+    git_dir = utils.path_join({ toplevel, ".git" })
   end
 
   -- git always returns path with forward slashes
-  if vim.fn.has "win32" == 1 then
+  if vim.fn.has("win32") == 1 then
     -- msys2 git support
     -- cygpath calls must in array format to avoid shell compatibility issues
     if M.use_cygpath then
-      toplevel = vim.fn.system { "cygpath", "-w", toplevel }
+      toplevel = vim.fn.system({ "cygpath", "-w", toplevel })
       if vim.v.shell_error ~= 0 then
         return nil, nil
       end
       -- remove trailing newline(\n) character added by vim.fn.system
       toplevel = toplevel:gsub("\n", "")
-      git_dir = vim.fn.system { "cygpath", "-w", git_dir }
+      git_dir = vim.fn.system({ "cygpath", "-w", git_dir })
       if vim.v.shell_error ~= 0 then
         return nil, nil
       end
@@ -58,10 +71,11 @@ function M.get_toplevel(cwd)
   return toplevel, git_dir
 end
 
+---@type table<string, boolean>
 local untracked = {}
 
 ---@param cwd string
----@return string|nil
+---@return boolean
 function M.should_show_untracked(cwd)
   if untracked[cwd] ~= nil then
     return untracked[cwd]
@@ -72,7 +86,7 @@ function M.should_show_untracked(cwd)
   local cmd = { "git", "-C", cwd, "config", "status.showUntrackedFiles" }
   log.line("git", table.concat(cmd, " "))
 
-  local has_untracked = vim.fn.system(cmd)
+  local has_untracked = system(cmd)
 
   log.raw("git", has_untracked)
   log.profile_end(profile)
@@ -81,8 +95,8 @@ function M.should_show_untracked(cwd)
   return untracked[cwd]
 end
 
----@param t table|nil
----@param k string
+---@param t table<string|integer, boolean>?
+---@param k string|integer
 ---@return table
 local function nil_insert(t, k)
   t = t or {}
@@ -90,31 +104,33 @@ local function nil_insert(t, k)
   return t
 end
 
----@param status table
+---@param project_files GitProjectFiles
 ---@param cwd string|nil
----@return table
-function M.file_status_to_dir_status(status, cwd)
-  local direct = {}
-  for p, s in pairs(status) do
+---@return GitProjectDirs
+function M.project_files_to_project_dirs(project_files, cwd)
+  ---@type GitProjectDirs
+  local project_dirs = {}
+
+  project_dirs.direct = {}
+  for p, s in pairs(project_files) do
     if s ~= "!!" then
       local modified = vim.fn.fnamemodify(p, ":h")
-      direct[modified] = nil_insert(direct[modified], s)
+      project_dirs.direct[modified] = nil_insert(project_dirs.direct[modified], s)
     end
   end
 
-  local indirect = {}
-  for dirname, statuses in pairs(direct) do
+  project_dirs.indirect = {}
+  for dirname, statuses in pairs(project_dirs.direct) do
     for s, _ in pairs(statuses) do
       local modified = dirname
       while modified ~= cwd and modified ~= "/" do
         modified = vim.fn.fnamemodify(modified, ":h")
-        indirect[modified] = nil_insert(indirect[modified], s)
+        project_dirs.indirect[modified] = nil_insert(project_dirs.indirect[modified], s)
       end
     end
   end
 
-  local r = { indirect = indirect, direct = direct }
-  for _, d in pairs(r) do
+  for _, d in pairs(project_dirs) do
     for dirname, statuses in pairs(d) do
       local new_statuses = {}
       for s, _ in pairs(statuses) do
@@ -123,12 +139,65 @@ function M.file_status_to_dir_status(status, cwd)
       d[dirname] = new_statuses
     end
   end
-  return r
+
+  return project_dirs
+end
+
+---Git file status for an absolute path
+---@param parent_ignored boolean
+---@param project GitProject?
+---@param path string
+---@param path_fallback string? alternative file path when no other file status
+---@return GitNodeStatus
+function M.git_status_file(parent_ignored, project, path, path_fallback)
+  ---@type GitNodeStatus
+  local ns
+
+  if parent_ignored then
+    ns = {
+      file = "!!"
+    }
+  elseif project and project.files then
+    ns = {
+      file = project.files[path] or project.files[path_fallback]
+    }
+  else
+    ns = {}
+  end
+
+  return ns
+end
+
+---Git file and directory status for an absolute path
+---@param parent_ignored boolean
+---@param project GitProject?
+---@param path string
+---@param path_fallback string? alternative file path when no other file status
+---@return GitNodeStatus?
+function M.git_status_dir(parent_ignored, project, path, path_fallback)
+  ---@type GitNodeStatus?
+  local ns
+
+  if parent_ignored then
+    ns = {
+      file = "!!"
+    }
+  elseif project then
+    ns = {
+      file = project.files and (project.files[path] or project.files[path_fallback]),
+      dir  = project.dirs and {
+        direct   = project.dirs.direct and project.dirs.direct[path],
+        indirect = project.dirs.indirect and project.dirs.indirect[path],
+      },
+    }
+  end
+
+  return ns
 end
 
 function M.setup(opts)
   if opts.git.cygwin_support then
-    M.use_cygpath = vim.fn.executable "cygpath" == 1
+    M.use_cygpath = vim.fn.executable("cygpath") == 1
   end
 end
 

lua/nvim-tree/help.lua

@@ -1,4 +1,5 @@
-local keymap = require "nvim-tree.keymap"
+local keymap = require("nvim-tree.keymap")
+local api = {} -- circular dependency
 
 local PAT_MOUSE = "^<.*Mouse"
 local PAT_CTRL = "^<C%-"
@@ -10,6 +11,8 @@ local WIN_HL = table.concat({
   "CursorLine:NvimTreeCursorLine",
 }, ",")
 
+local namespace_help_id = vim.api.nvim_create_namespace("NvimTreeHelp")
+
 local M = {
   config = {},
 
@@ -26,12 +29,12 @@ local function tidy_lhs(lhs)
   lhs = lhs:gsub("^<lt>", "<")
 
   -- shorten ctrls
-  if lhs:lower():match "^<ctrl%-" then
+  if lhs:lower():match("^<ctrl%-") then
     lhs = lhs:lower():gsub("^<ctrl%-", "<C%-")
   end
 
   -- uppercase ctrls
-  if lhs:lower():match "^<c%-" then
+  if lhs:lower():match("^<c%-") then
     lhs = lhs:upper()
   end
 
@@ -52,6 +55,7 @@ end
 --- sort vim command lhs roughly as per :help index
 ---@param a string
 ---@param b string
+---@return boolean
 local function sort_lhs(a, b)
   -- mouse first
   if a:match(PAT_MOUSE) and not b:match(PAT_MOUSE) then
@@ -79,18 +83,19 @@ local function sort_lhs(a, b)
 end
 
 --- Compute all lines for the buffer
----@return table strings of text
----@return table arrays of arguments 3-6 for nvim_buf_add_highlight()
+---@param map table keymap.get_keymap
+---@return string[] lines of text
+---@return HighlightRangeArgs[] hl_range_args for lines
 ---@return number maximum length of text
-local function compute()
+local function compute(map)
   local head_lhs = "nvim-tree mappings"
   local head_rhs1 = "exit: q"
   local head_rhs2 = string.format("sort by %s: s", M.config.sort_by == "key" and "description" or "keymap")
 
   -- formatted lhs and desc from active keymap
-  local mappings = vim.tbl_map(function(map)
-    return { lhs = tidy_lhs(map.lhs), desc = tidy_desc(map.desc) }
-  end, keymap.get_keymap())
+  local mappings = vim.tbl_map(function(m)
+    return { lhs = tidy_lhs(m.lhs), desc = tidy_desc(m.desc) }
+  end, map)
 
   -- sorter function for mappings
   local sort_fn
@@ -119,14 +124,20 @@ local function compute()
   -- increase desc if lines are shorter than the header
   max_desc = math.max(max_desc, #head_lhs + #head_rhs1 - max_lhs)
 
-  -- header, not padded
-  local hl = { { "NvimTreeRootFolder", 0, 0, #head_lhs } }
+  -- header text, not padded
   local lines = {
     head_lhs .. string.rep(" ", max_desc + max_lhs - #head_lhs - #head_rhs1 + 2) .. head_rhs1,
     string.rep(" ", max_desc + max_lhs - #head_rhs2 + 2) .. head_rhs2,
   }
   local width = #lines[1]
 
+  -- header highlight, assume one character keys
+  local hl_range_args = {
+    { higroup = "NvimTreeFolderName", start = { 0, 0, },         finish = { 0, #head_lhs, }, },
+    { higroup = "NvimTreeFolderName", start = { 0, width - 1, }, finish = { 0, width, }, },
+    { higroup = "NvimTreeFolderName", start = { 1, width - 1, }, finish = { 1, width, }, },
+  }
+
   -- mappings, left padded 1
   local fmt = string.format(" %%-%ds %%-%ds", max_lhs, max_desc)
   for i, l in ipairs(mappings) do
@@ -136,10 +147,10 @@ local function compute()
     width = math.max(#line, width)
 
     -- highlight lhs
-    table.insert(hl, { "NvimTreeFolderName", i + 1, 1, #l.lhs + 1 })
+    table.insert(hl_range_args, { higroup = "NvimTreeFolderName", start = { i + 1, 1, }, finish = { i + 1, #l.lhs + 1, }, })
   end
 
-  return lines, hl, width
+  return lines, hl_range_args, width
 end
 
 --- close the window and delete the buffer, if they exist
@@ -159,19 +170,31 @@ local function open()
   -- close existing, shouldn't be necessary
   close()
 
+  -- fetch all mappings
+  local map = keymap.get_keymap()
+
   -- text and highlight
-  local lines, hl, width = compute()
+  local lines, hl_range_args, width = compute(map)
 
   -- create the buffer
   M.bufnr = vim.api.nvim_create_buf(false, true)
 
   -- 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
-    vim.api.nvim_buf_add_highlight(M.bufnr, -1, h[1], h[2], h[3], h[4])
+  for _, args in ipairs(hl_range_args) do
+    if vim.fn.has("nvim-0.11") == 1 and vim.hl and vim.hl.range then
+      vim.hl.range(M.bufnr, namespace_help_id, args.higroup, args.start, args.finish, {})
+    else
+      vim.api.nvim_buf_add_highlight(M.bufnr, -1, args.higroup, args.start[1], args.start[2], args.finish[2]) ---@diagnostic disable-line: deprecated
+    end
   end
 
   -- open a very restricted window
@@ -195,12 +218,21 @@ local function open()
     open()
   end
 
-  local keymaps = {
+  -- hardcoded
+  local help_keymaps = {
     q = { fn = close, desc = "nvim-tree: exit help" },
+    ["<Esc>"] = { fn = close, desc = "nvim-tree: exit help" }, -- hidden
     s = { fn = toggle_sort, desc = "nvim-tree: toggle sorting method" },
   }
 
-  for k, v in pairs(keymaps) do
+  -- api help binding closes
+  for _, m in ipairs(map) do
+    if m.callback == api.tree.toggle_help then
+      help_keymaps[m.lhs] = { fn = close, desc = "nvim-tree: exit help" }
+    end
+  end
+
+  for k, v in pairs(help_keymaps) do
     vim.keymap.set("n", k, v.fn, {
       desc = v.desc,
       buffer = M.bufnr,
@@ -229,6 +261,8 @@ end
 function M.setup(opts)
   M.config.cursorline = opts.view.cursorline
   M.config.sort_by = opts.help.sort_by
+
+  api = require("nvim-tree.api")
 end
 
 return M

lua/nvim-tree/keymap.lua

@@ -1,7 +1,7 @@
 local M = {}
 
 --- Apply mappings to a scratch buffer and return buffer local mappings
----@param fn function(bufnr) on_attach or default_on_attach
+---@param fn fun(bufnr: integer) on_attach or default_on_attach
 ---@return table as per vim.api.nvim_buf_get_keymap
 local function generate_keymap(fn)
   -- create an unlisted scratch buffer
@@ -19,81 +19,6 @@ local function generate_keymap(fn)
   return keymap
 end
 
--- stylua: ignore start
----@param bufnr integer
-function M.default_on_attach(bufnr)
-  local api = require('nvim-tree.api')
-
-  local function opts(desc)
-    return {
-      desc = 'nvim-tree: ' .. desc,
-      buffer = bufnr,
-      noremap = true,
-      silent = true,
-      nowait = true,
-  }
-  end
-
-  -- BEGIN_DEFAULT_ON_ATTACH
-  vim.keymap.set('n', '<C-]>',   api.tree.change_root_to_node,        opts('CD'))
-  vim.keymap.set('n', '<C-e>',   api.node.open.replace_tree_buffer,   opts('Open: In Place'))
-  vim.keymap.set('n', '<C-k>',   api.node.show_info_popup,            opts('Info'))
-  vim.keymap.set('n', '<C-r>',   api.fs.rename_sub,                   opts('Rename: Omit Filename'))
-  vim.keymap.set('n', '<C-t>',   api.node.open.tab,                   opts('Open: New Tab'))
-  vim.keymap.set('n', '<C-v>',   api.node.open.vertical,              opts('Open: Vertical Split'))
-  vim.keymap.set('n', '<C-x>',   api.node.open.horizontal,            opts('Open: Horizontal Split'))
-  vim.keymap.set('n', '<BS>',    api.node.navigate.parent_close,      opts('Close Directory'))
-  vim.keymap.set('n', '<CR>',    api.node.open.edit,                  opts('Open'))
-  vim.keymap.set('n', '<Tab>',   api.node.open.preview,               opts('Open Preview'))
-  vim.keymap.set('n', '>',       api.node.navigate.sibling.next,      opts('Next Sibling'))
-  vim.keymap.set('n', '<',       api.node.navigate.sibling.prev,      opts('Previous Sibling'))
-  vim.keymap.set('n', '.',       api.node.run.cmd,                    opts('Run Command'))
-  vim.keymap.set('n', '-',       api.tree.change_root_to_parent,      opts('Up'))
-  vim.keymap.set('n', 'a',       api.fs.create,                       opts('Create File Or Directory'))
-  vim.keymap.set('n', 'bd',      api.marks.bulk.delete,               opts('Delete Bookmarked'))
-  vim.keymap.set('n', 'bt',      api.marks.bulk.trash,                opts('Trash Bookmarked'))
-  vim.keymap.set('n', 'bmv',     api.marks.bulk.move,                 opts('Move Bookmarked'))
-  vim.keymap.set('n', 'B',       api.tree.toggle_no_buffer_filter,    opts('Toggle Filter: No Buffer'))
-  vim.keymap.set('n', 'c',       api.fs.copy.node,                    opts('Copy'))
-  vim.keymap.set('n', 'C',       api.tree.toggle_git_clean_filter,    opts('Toggle Filter: Git Clean'))
-  vim.keymap.set('n', '[c',      api.node.navigate.git.prev,          opts('Prev Git'))
-  vim.keymap.set('n', ']c',      api.node.navigate.git.next,          opts('Next Git'))
-  vim.keymap.set('n', 'd',       api.fs.remove,                       opts('Delete'))
-  vim.keymap.set('n', 'D',       api.fs.trash,                        opts('Trash'))
-  vim.keymap.set('n', 'E',       api.tree.expand_all,                 opts('Expand All'))
-  vim.keymap.set('n', 'e',       api.fs.rename_basename,              opts('Rename: Basename'))
-  vim.keymap.set('n', ']e',      api.node.navigate.diagnostics.next,  opts('Next Diagnostic'))
-  vim.keymap.set('n', '[e',      api.node.navigate.diagnostics.prev,  opts('Prev Diagnostic'))
-  vim.keymap.set('n', 'F',       api.live_filter.clear,               opts('Clean Filter'))
-  vim.keymap.set('n', 'f',       api.live_filter.start,               opts('Filter'))
-  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', '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'))
-  vim.keymap.set('n', 'K',       api.node.navigate.sibling.first,     opts('First Sibling'))
-  vim.keymap.set('n', 'm',       api.marks.toggle,                    opts('Toggle Bookmark'))
-  vim.keymap.set('n', 'o',       api.node.open.edit,                  opts('Open'))
-  vim.keymap.set('n', 'O',       api.node.open.no_window_picker,      opts('Open: No Window Picker'))
-  vim.keymap.set('n', 'p',       api.fs.paste,                        opts('Paste'))
-  vim.keymap.set('n', 'P',       api.node.navigate.parent,            opts('Parent Directory'))
-  vim.keymap.set('n', 'q',       api.tree.close,                      opts('Close'))
-  vim.keymap.set('n', 'r',       api.fs.rename,                       opts('Rename'))
-  vim.keymap.set('n', 'R',       api.tree.reload,                     opts('Refresh'))
-  vim.keymap.set('n', 's',       api.node.run.system,                 opts('Run System'))
-  vim.keymap.set('n', 'S',       api.tree.search_node,                opts('Search'))
-  vim.keymap.set('n', 'u',       api.fs.rename_full,                  opts('Rename: Full Path'))
-  vim.keymap.set('n', 'U',       api.tree.toggle_custom_filter,       opts('Toggle Filter: Hidden'))
-  vim.keymap.set('n', 'W',       api.tree.collapse_all,               opts('Collapse'))
-  vim.keymap.set('n', 'x',       api.fs.cut,                          opts('Cut'))
-  vim.keymap.set('n', 'y',       api.fs.copy.filename,                opts('Copy Name'))
-  vim.keymap.set('n', 'Y',       api.fs.copy.relative_path,           opts('Copy Relative Path'))
-  vim.keymap.set('n', '<2-LeftMouse>',  api.node.open.edit,           opts('Open'))
-  vim.keymap.set('n', '<2-RightMouse>', api.tree.change_root_to_node, opts('CD'))
-  -- END_DEFAULT_ON_ATTACH
-end
--- stylua: ignore end
-
 ---@return table
 function M.get_keymap()
   return generate_keymap(M.on_attach)
@@ -104,6 +29,82 @@ function M.get_keymap_default()
   return generate_keymap(M.default_on_attach)
 end
 
+---@param bufnr integer
+function M.default_on_attach(bufnr)
+  local api = require("nvim-tree.api")
+
+  local function opts(desc)
+    return {
+      desc = "nvim-tree: " .. desc,
+      buffer = bufnr,
+      noremap = true,
+      silent = true,
+      nowait = true,
+    }
+  end
+
+  -- BEGIN_DEFAULT_ON_ATTACH
+  vim.keymap.set("n", "<C-]>",          api.tree.change_root_to_node,       opts("CD"))
+  vim.keymap.set("n", "<C-e>",          api.node.open.replace_tree_buffer,  opts("Open: In Place"))
+  vim.keymap.set("n", "<C-k>",          api.node.show_info_popup,           opts("Info"))
+  vim.keymap.set("n", "<C-r>",          api.fs.rename_sub,                  opts("Rename: Omit Filename"))
+  vim.keymap.set("n", "<C-t>",          api.node.open.tab,                  opts("Open: New Tab"))
+  vim.keymap.set("n", "<C-v>",          api.node.open.vertical,             opts("Open: Vertical Split"))
+  vim.keymap.set("n", "<C-x>",          api.node.open.horizontal,           opts("Open: Horizontal Split"))
+  vim.keymap.set("n", "<BS>",           api.node.navigate.parent_close,     opts("Close Directory"))
+  vim.keymap.set("n", "<CR>",           api.node.open.edit,                 opts("Open"))
+  vim.keymap.set("n", "<Tab>",          api.node.open.preview,              opts("Open Preview"))
+  vim.keymap.set("n", ">",              api.node.navigate.sibling.next,     opts("Next Sibling"))
+  vim.keymap.set("n", "<",              api.node.navigate.sibling.prev,     opts("Previous Sibling"))
+  vim.keymap.set("n", ".",              api.node.run.cmd,                   opts("Run Command"))
+  vim.keymap.set("n", "-",              api.tree.change_root_to_parent,     opts("Up"))
+  vim.keymap.set("n", "a",              api.fs.create,                      opts("Create File Or Directory"))
+  vim.keymap.set("n", "bd",             api.marks.bulk.delete,              opts("Delete Bookmarked"))
+  vim.keymap.set("n", "bt",             api.marks.bulk.trash,               opts("Trash Bookmarked"))
+  vim.keymap.set("n", "bmv",            api.marks.bulk.move,                opts("Move Bookmarked"))
+  vim.keymap.set("n", "B",              api.tree.toggle_no_buffer_filter,   opts("Toggle Filter: No Buffer"))
+  vim.keymap.set("n", "c",              api.fs.copy.node,                   opts("Copy"))
+  vim.keymap.set("n", "C",              api.tree.toggle_git_clean_filter,   opts("Toggle Filter: Git Clean"))
+  vim.keymap.set("n", "[c",             api.node.navigate.git.prev,         opts("Prev Git"))
+  vim.keymap.set("n", "]c",             api.node.navigate.git.next,         opts("Next Git"))
+  vim.keymap.set("n", "d",              api.fs.remove,                      opts("Delete"))
+  vim.keymap.set("n", "D",              api.fs.trash,                       opts("Trash"))
+  vim.keymap.set("n", "E",              api.tree.expand_all,                opts("Expand All"))
+  vim.keymap.set("n", "e",              api.fs.rename_basename,             opts("Rename: Basename"))
+  vim.keymap.set("n", "]e",             api.node.navigate.diagnostics.next, opts("Next Diagnostic"))
+  vim.keymap.set("n", "[e",             api.node.navigate.diagnostics.prev, opts("Prev Diagnostic"))
+  vim.keymap.set("n", "F",              api.live_filter.clear,              opts("Live Filter: Clear"))
+  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"))
+  vim.keymap.set("n", "K",              api.node.navigate.sibling.first,    opts("First Sibling"))
+  vim.keymap.set("n", "L",              api.node.open.toggle_group_empty,   opts("Toggle Group Empty"))
+  vim.keymap.set("n", "M",              api.tree.toggle_no_bookmark_filter, opts("Toggle Filter: No Bookmark"))
+  vim.keymap.set("n", "m",              api.marks.toggle,                   opts("Toggle Bookmark"))
+  vim.keymap.set("n", "o",              api.node.open.edit,                 opts("Open"))
+  vim.keymap.set("n", "O",              api.node.open.no_window_picker,     opts("Open: No Window Picker"))
+  vim.keymap.set("n", "p",              api.fs.paste,                       opts("Paste"))
+  vim.keymap.set("n", "P",              api.node.navigate.parent,           opts("Parent Directory"))
+  vim.keymap.set("n", "q",              api.tree.close,                     opts("Close"))
+  vim.keymap.set("n", "r",              api.fs.rename,                      opts("Rename"))
+  vim.keymap.set("n", "R",              api.tree.reload,                    opts("Refresh"))
+  vim.keymap.set("n", "s",              api.node.run.system,                opts("Run System"))
+  vim.keymap.set("n", "S",              api.tree.search_node,               opts("Search"))
+  vim.keymap.set("n", "u",              api.fs.rename_full,                 opts("Rename: Full Path"))
+  vim.keymap.set("n", "U",              api.tree.toggle_custom_filter,      opts("Toggle Filter: Hidden"))
+  vim.keymap.set("n", "W",              api.tree.collapse_all,              opts("Collapse All"))
+  vim.keymap.set("n", "x",              api.fs.cut,                         opts("Cut"))
+  vim.keymap.set("n", "y",              api.fs.copy.filename,               opts("Copy Name"))
+  vim.keymap.set("n", "Y",              api.fs.copy.relative_path,          opts("Copy Relative Path"))
+  vim.keymap.set("n", "<2-LeftMouse>",  api.node.open.edit,                 opts("Open"))
+  vim.keymap.set("n", "<2-RightMouse>", api.tree.change_root_to_node,       opts("CD"))
+  -- END_DEFAULT_ON_ATTACH
+end
+
 function M.setup(opts)
   if type(opts.on_attach) ~= "function" then
     M.on_attach = M.default_on_attach

lua/nvim-tree/legacy.lua

@@ -1,26 +1,74 @@
-local utils = require "nvim-tree.utils"
-local notify = require "nvim-tree.notify"
+local notify = require("nvim-tree.notify")
 
 local M = {}
 
+--- Create empty sub-tables if not present
+---@param tbl table to create empty inside of
+---@param path string dot separated string of sub-tables
+---@return table deepest sub-table
+local function create(tbl, path)
+  local t = tbl
+  for s in string.gmatch(path, "([^%.]+)%.*") do
+    if t[s] == nil then
+      t[s] = {}
+    end
+    t = t[s]
+  end
+
+  return t
+end
+
+--- Move a value from src to dst if value is nil on dst.
+--- Remove value from src
+---@param src table to copy from
+---@param src_path string dot separated string of sub-tables
+---@param src_pos string value pos
+---@param dst table to copy to
+---@param dst_path string dot separated string of sub-tables, created when missing
+---@param dst_pos string value pos
+---@param remove boolean
+local function move(src, src_path, src_pos, dst, dst_path, dst_pos, remove)
+  for pos in string.gmatch(src_path, "([^%.]+)%.*") do
+    if src[pos] and type(src[pos]) == "table" then
+      src = src[pos]
+    else
+      return
+    end
+  end
+  local src_val = src[src_pos]
+  if src_val == nil then
+    return
+  end
+
+  dst = create(dst, dst_path)
+  if dst[dst_pos] == nil then
+    dst[dst_pos] = src_val
+  end
+
+  if remove then
+    src[src_pos] = nil
+  end
+end
+
+-- 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)
-  utils.move_missing_val(opts, "", "update_cwd", opts, "", "sync_root_with_cwd", true)
+  move(opts, "update_focused_file", "update_cwd", opts, "update_focused_file", "update_root",        true)
+  move(opts, "",                    "update_cwd", opts, "",                    "sync_root_with_cwd", true)
 
   -- 2022/11/07
-  utils.move_missing_val(opts, "", "open_on_tab", opts, "tab.sync", "open", false)
-  utils.move_missing_val(opts, "", "open_on_tab", opts, "tab.sync", "close", true)
-  utils.move_missing_val(opts, "", "ignore_buf_on_tab_change", opts, "tab.sync", "ignore", true)
+  move(opts, "", "open_on_tab",              opts, "tab.sync", "open",   false)
+  move(opts, "", "open_on_tab",              opts, "tab.sync", "close",  true)
+  move(opts, "", "ignore_buf_on_tab_change", opts, "tab.sync", "ignore", true)
 
   -- 2022/11/22
-  utils.move_missing_val(opts, "renderer", "root_folder_modifier", opts, "renderer", "root_folder_label", true)
+  move(opts, "renderer", "root_folder_modifier", opts, "renderer", "root_folder_label", true)
 
   -- 2023/01/01
-  utils.move_missing_val(opts, "update_focused_file", "debounce_delay", opts, "view", "debounce_delay", true)
+  move(opts, "update_focused_file", "debounce_delay", opts, "view", "debounce_delay", true)
 
   -- 2023/01/08
-  utils.move_missing_val(opts, "trash", "require_confirm", opts, "ui.confirm", "trash", true)
+  move(opts, "trash", "require_confirm", opts, "ui.confirm", "trash", true)
 
   -- 2023/01/15
   if type(opts.view) == "table" and opts.view.adaptive_size ~= nil then
@@ -34,34 +82,60 @@ local function refactored(opts)
   end
 
   -- 2023/07/15
-  utils.move_missing_val(opts, "", "sort_by", opts, "sort", "sorter", true)
+  move(opts, "", "sort_by", opts, "sort", "sorter", true)
 
   -- 2023/07/16
-  utils.move_missing_val(opts, "git", "ignore", opts, "filters", "git_ignored", true)
+  move(opts, "git", "ignore", opts, "filters", "git_ignored", true)
 
   -- 2023/08/26
-  utils.move_missing_val(opts, "renderer.icons", "webdev_colors", opts, "renderer.icons.web_devicons.file", "color", true)
+  move(opts, "renderer.icons", "webdev_colors", opts, "renderer.icons.web_devicons.file", "color", true)
+
+  -- 2023/10/08
+  if type(opts.renderer) == "table" and type(opts.renderer.highlight_diagnostics) == "boolean" then
+    opts.renderer.highlight_diagnostics = opts.renderer.highlight_diagnostics and "name" or "none"
+  end
+
+  -- 2023/10/21
+  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
+  move(opts, "update_focused_file", "ignore_list", opts, "update_focused_file.update_root", "ignore_list", true)
+
+  -- 2025/04/30
+  if opts.renderer and opts.renderer.icons and type(opts.renderer.icons.padding) == "string" then
+    local icons_padding = opts.renderer.icons.padding
+    opts.renderer.icons.padding = {}
+    opts.renderer.icons.padding.icon = icons_padding
+  end
 end
 
 local function deprecated(opts)
   if type(opts.view) == "table" and opts.view.hide_root_folder then
-    notify.info "view.hide_root_folder is deprecated, please set renderer.root_folder_label = false"
+    notify.info("view.hide_root_folder is deprecated, please set renderer.root_folder_label = false")
   end
 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
 
   if opts.create_in_closed_folder then
-    notify.warn "create_in_closed_folder has been removed and is now the default behaviour. You may use api.fs.create to add a file under your desired node."
+    notify.warn(
+      "create_in_closed_folder has been removed and is now the default behaviour. You may use api.fs.create to add a file under your desired node.")
   end
   opts.create_in_closed_folder = nil
 end

lua/nvim-tree/lib.lua

@@ -1,8 +1,6 @@
-local renderer = require "nvim-tree.renderer"
-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 view = require("nvim-tree.view")
+local core = require("nvim-tree.core")
+local notify = require("nvim-tree.notify")
 
 ---@class LibOpenOpts
 ---@field path string|nil path
@@ -13,109 +11,6 @@ local M = {
   target_winid = nil,
 }
 
----@return Node|nil
-function M.get_node_at_cursor()
-  if not core.get_explorer() then
-    return
-  end
-
-  local winnr = view.get_winnr()
-  if not winnr then
-    return
-  end
-
-  local cursor = vim.api.nvim_win_get_cursor(view.get_winnr())
-  local line = cursor[1]
-
-  if line == 1 and view.is_root_folder_visible(core.get_cwd()) then
-    return { name = ".." }
-  end
-
-  return utils.get_nodes_by_line(core.get_explorer().nodes, core.get_nodes_starting_line())[line]
-end
-
----Create a sanitized partial copy of a node, populating children recursively.
----@param node Node|nil
----@return Node|nil cloned node
-local function clone_node(node)
-  if not node then
-    node = core.get_explorer()
-    if not node then
-      return nil
-    end
-  end
-
-  local n = {
-    absolute_path = node.absolute_path,
-    executable = node.executable,
-    extension = node.extension,
-    git_status = node.git_status,
-    has_children = node.has_children,
-    hidden = node.hidden,
-    link_to = node.link_to,
-    name = node.name,
-    open = node.open,
-    type = node.type,
-  }
-
-  if type(node.nodes) == "table" then
-    n.nodes = {}
-    for _, child in ipairs(node.nodes) do
-      table.insert(n.nodes, clone_node(child))
-    end
-  end
-
-  return n
-end
-
----Api.tree.get_nodes
----@return Node[]|nil
-function M.get_nodes()
-  return clone_node(core.get_explorer())
-end
-
--- If node is grouped, return the last node in the group. Otherwise, return the given node.
----@param node Node
----@return Node
-function M.get_last_group_node(node)
-  while node and node.group_next do
-    node = node.group_next
-  end
-
-  ---@diagnostic disable-next-line: return-type-mismatch -- it can't be nil
-  return node
-end
-
----@param node Node
----@return Node[]
-function M.get_all_nodes_in_group(node)
-  local next_node = utils.get_parent_of_group(node)
-  local nodes = {}
-  while next_node do
-    table.insert(nodes, next_node)
-    next_node = next_node.group_next
-  end
-  return nodes
-end
-
----@param node Node
-function M.expand_or_collapse(node)
-  if node.has_children then
-    node.has_children = false
-  end
-
-  if #node.nodes == 0 then
-    core.get_explorer():expand(node)
-  end
-
-  local open = not M.get_last_group_node(node).open
-  for _, n in ipairs(M.get_all_nodes_in_group(node)) do
-    n.open = open
-  end
-
-  renderer.draw()
-end
-
 function M.set_target_win()
   local id = vim.api.nvim_get_current_win()
   local tree_id = view.get_winnr()
@@ -138,14 +33,25 @@ local function open_view_and_draw()
   local cwd = vim.fn.getcwd()
   view.open()
   handle_buf_cwd(cwd)
-  renderer.draw()
+
+  local explorer = core.get_explorer()
+  if explorer then
+    explorer.renderer:draw()
+  end
 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
@@ -157,8 +63,9 @@ end
 ---@param prompt_select string
 ---@param items_short string[]
 ---@param items_long string[]
----@param callback fun(item_short: string)
-function M.prompt(prompt_input, prompt_select, items_short, items_long, callback)
+---@param kind string|nil
+---@param callback fun(item_short: string|nil)
+function M.prompt(prompt_input, prompt_select, items_short, items_long, kind, callback)
   local function format_item(short)
     for i, s in ipairs(items_short) do
       if short == s then
@@ -169,7 +76,7 @@ function M.prompt(prompt_input, prompt_select, items_short, items_long, callback
   end
 
   if M.select_prompts then
-    vim.ui.select(items_short, { prompt = prompt_select, format_item = format_item }, function(item_short)
+    vim.ui.select(items_short, { prompt = prompt_select, kind = kind, format_item = format_item }, function(item_short)
       callback(item_short)
     end)
   else
@@ -188,23 +95,40 @@ 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
+
+  local explorer = core.get_explorer()
+
   if should_hijack_current_buf() then
     view.close_this_tab_only()
     view.open_in_win()
-    renderer.draw()
+    if explorer then
+      explorer.renderer:draw()
+    end
   elseif opts.winid then
-    view.open_in_win { hijack_current_buf = false, resize = false, winid = opts.winid }
-    renderer.draw()
+    view.open_in_win({ hijack_current_buf = false, resize = false, winid = opts.winid })
+    if explorer then
+      explorer.renderer:draw()
+    end
   elseif opts.current_window then
-    view.open_in_win { hijack_current_buf = false, resize = false }
-    renderer.draw()
+    view.open_in_win({ hijack_current_buf = false, resize = false })
+    if explorer then
+      explorer.renderer:draw()
+    end
   else
     open_view_and_draw()
   end
   view.restore_tab_state()
-  events._dispatch_on_tree_open()
 end
 
 function M.setup(opts)
@@ -212,6 +136,7 @@ function M.setup(opts)
   M.hijack_directories = opts.hijack_directories
   M.respect_buf_cwd = opts.respect_buf_cwd
   M.select_prompts = opts.select_prompts
+  M.group_empty = opts.renderer.group_empty
 end
 
 return M

lua/nvim-tree/live-filter.lua

@@ -1,186 +0,0 @@
-local view = require "nvim-tree.view"
-local utils = require "nvim-tree.utils"
-local Iterator = require "nvim-tree.iterators.node-iterator"
-
-local M = {
-  filter = nil,
-}
-
-local function redraw()
-  require("nvim-tree.renderer").draw()
-end
-
----@param node_ Node|nil
-local function reset_filter(node_)
-  node_ = node_ or require("nvim-tree.core").get_explorer()
-
-  if node_ == nil then
-    return
-  end
-
-  Iterator.builder(node_.nodes)
-    :hidden()
-    :applier(function(node)
-      node.hidden = false
-    end)
-    :iterate()
-end
-
-local overlay_bufnr = nil
-local overlay_winnr = nil
-
-local function remove_overlay()
-  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", {
-      pattern = "NvimTree_*",
-      group = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
-      callback = function()
-        if utils.is_nvim_tree_buf(0) then
-          view.close()
-        end
-      end,
-    })
-  end
-
-  vim.api.nvim_win_close(overlay_winnr, true)
-  vim.api.nvim_buf_delete(overlay_bufnr, { force = true })
-  overlay_bufnr = nil
-  overlay_winnr = nil
-
-  if M.filter == "" then
-    M.clear_filter()
-  end
-end
-
----@param node Node
----@return boolean
-local function matches(node)
-  local path = node.absolute_path
-  local name = vim.fn.fnamemodify(path, ":t")
-  return vim.regex(M.filter):match_str(name) ~= nil
-end
-
----@param node_ Node|nil
-function M.apply_filter(node_)
-  if not M.filter or M.filter == "" then
-    reset_filter(node_)
-    return
-  end
-
-  -- TODO(kiyan): this iterator cannot yet be refactored with the Iterator module
-  -- since the node mapper is based on its children
-  local function iterate(node)
-    local filtered_nodes = 0
-    local nodes = node.group_next and { node.group_next } or node.nodes
-
-    if nodes then
-      for _, n in pairs(nodes) do
-        iterate(n)
-        if n.hidden then
-          filtered_nodes = filtered_nodes + 1
-        end
-      end
-    end
-
-    local has_nodes = nodes and (M.always_show_folders or #nodes > filtered_nodes)
-    local ok, is_match = pcall(matches, node)
-    node.hidden = not (has_nodes or (ok and is_match))
-  end
-
-  iterate(node_ or require("nvim-tree.core").get_explorer())
-end
-
-local function record_char()
-  vim.schedule(function()
-    M.filter = vim.api.nvim_buf_get_lines(overlay_bufnr, 0, -1, false)[1]
-    M.apply_filter()
-    redraw()
-  end)
-end
-
-local function configure_buffer_overlay()
-  overlay_bufnr = vim.api.nvim_create_buf(false, true)
-
-  vim.api.nvim_buf_attach(overlay_bufnr, true, {
-    on_lines = record_char,
-  })
-
-  vim.api.nvim_create_autocmd("InsertLeave", {
-    callback = remove_overlay,
-    once = true,
-  })
-
-  vim.api.nvim_buf_set_keymap(overlay_bufnr, "i", "<CR>", "<cmd>stopinsert<CR>", {})
-end
-
----@return integer
-local function calculate_overlay_win_width()
-  local wininfo = vim.fn.getwininfo(view.get_winnr())[1]
-
-  if wininfo then
-    return wininfo.width - wininfo.textoff - #M.prefix
-  end
-
-  return 20
-end
-
-local function create_overlay()
-  if view.View.float.enable then
-    -- don't close nvim-tree float when focus is changed to filter window
-    vim.api.nvim_clear_autocmds {
-      event = "WinLeave",
-      pattern = "NvimTree_*",
-      group = vim.api.nvim_create_augroup("NvimTree", { clear = false }),
-    }
-  end
-
-  configure_buffer_overlay()
-  overlay_winnr = vim.api.nvim_open_win(overlay_bufnr, true, {
-    col = 1,
-    row = 0,
-    relative = "cursor",
-    width = calculate_overlay_win_width(),
-    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 })
-  vim.cmd "startinsert"
-  vim.api.nvim_win_set_cursor(overlay_winnr, { 1, #M.filter + 1 })
-end
-
-function M.start_filtering()
-  view.View.live_filter.prev_focused_node = require("nvim-tree.lib").get_node_at_cursor()
-  M.filter = M.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
-  view.set_cursor { row, col }
-  -- needs scheduling to let the cursor move before initializing the window
-  vim.schedule(create_overlay)
-end
-
-function M.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
-  reset_filter()
-  redraw()
-
-  if node then
-    utils.focus_file(node.absolute_path)
-  elseif last_node then
-    utils.focus_file(last_node.absolute_path)
-  end
-end
-
-function M.setup(opts)
-  M.prefix = opts.live_filter.prefix
-  M.always_show_folders = opts.live_filter.always_show_folders
-end
-
-return M

lua/nvim-tree/log.lua

@@ -1,7 +1,12 @@
-local M = {
-  config = nil,
-  path = nil,
-}
+---@alias LogTypes "all" | "config" | "copy_paste" | "dev" | "diagnostics" | "git" | "profile" | "watcher"
+
+---@type table<LogTypes, boolean>
+local types = {}
+
+---@type string
+local file_path
+
+local M = {}
 
 --- Write to log file
 ---@param typ string as per log.types config
@@ -13,7 +18,26 @@ function M.raw(typ, fmt, ...)
   end
 
   local line = string.format(fmt, ...)
-  local file = io.open(M.path, "a")
+  local file = io.open(file_path, "a")
+  if file then
+    io.output(file)
+    io.write(line)
+    io.close(file)
+  end
+end
+
+--- Write to a new file
+---@param typ LogTypes as per log.types config
+---@param path string absolute path
+---@param fmt string for string.format
+---@param ... any arguments for string.format
+function M.file(typ, path, fmt, ...)
+  if not M.enabled(typ) then
+    return
+  end
+
+  local line = string.format(fmt, ...)
+  local file = io.open(path, "w")
   if file then
     io.output(file)
     io.write(line)
@@ -32,7 +56,7 @@ end
 ---@return Profile to pass to profile_end
 function M.profile_start(fmt, ...)
   local profile = {}
-  if M.enabled "profile" then
+  if M.enabled("profile") then
     profile.start = vim.loop.hrtime()
     profile.tag = string.format((fmt or "???"), ...)
     M.line("profile", "START %s", profile.tag)
@@ -44,7 +68,7 @@ end
 --- END is prefixed and duration in seconds is suffixed
 ---@param profile Profile returned from profile_start
 function M.profile_end(profile)
-  if M.enabled "profile" and type(profile) == "table" then
+  if M.enabled("profile") and type(profile) == "table" then
     local millis = profile.start and math.modf((vim.loop.hrtime() - profile.start) / 1000000) or -1
     M.line("profile", "END   %s %dms", profile.tag or "", millis)
   end
@@ -52,12 +76,12 @@ end
 
 --- Write to log file
 --- time and typ are prefixed and a trailing newline is added
----@param typ string as per log.types config
+---@param typ LogTypes as per log.types config
 ---@param fmt string for string.format
 ---@param ... any arguments for string.format
 function M.line(typ, fmt, ...)
   if M.enabled(typ) then
-    M.raw(typ, string.format("[%s] [%s] %s\n", os.date "%Y-%m-%d %H:%M:%S", typ, (fmt or "???")), ...)
+    M.raw(typ, string.format("[%s] [%s] %s\n", os.date("%Y-%m-%d %H:%M:%S"), typ, (fmt or "???")), ...)
   end
 end
 
@@ -69,33 +93,31 @@ function M.set_inspect_opts(opts)
 end
 
 --- Write to log file the inspection of a node
---- defaults to the node under cursor if none is provided
----@param typ string as per log.types config
----@param node table|nil node to be inspected
+---@param typ LogTypes as per log.types config
+---@param node Node node to be inspected
 ---@param fmt string for string.format
----@vararg any arguments for string.format
+---@param ... any arguments for string.format
 function M.node(typ, node, fmt, ...)
   if M.enabled(typ) then
-    node = node or require("nvim-tree.lib").get_node_at_cursor()
-    M.raw(typ, string.format("[%s] [%s] %s\n%s\n", os.date "%Y-%m-%d %H:%M:%S", typ, (fmt or "???"), vim.inspect(node, inspect_opts)), ...)
+    M.raw(typ, string.format("[%s] [%s] %s\n%s\n", os.date("%Y-%m-%d %H:%M:%S"), typ, (fmt or "???"), vim.inspect(node, inspect_opts)), ...)
   end
 end
 
 --- Logging is enabled for typ or all
----@param typ string as per log.types config
+---@param typ LogTypes as per log.types config
 ---@return boolean
 function M.enabled(typ)
-  return M.path ~= nil and (M.config.types[typ] or M.config.types.all)
+  return file_path ~= nil and (types[typ] or types.all)
 end
 
 function M.setup(opts)
-  M.config = opts.log
-  if M.config and M.config.enable and M.config.types then
-    M.path = string.format("%s/nvim-tree.log", vim.fn.stdpath "log", os.date "%H:%M:%S", vim.env.USER)
-    if M.config.truncate then
-      os.remove(M.path)
+  if opts.log and opts.log.enable and opts.log.types then
+    types = opts.log.types
+    file_path = string.format("%s/nvim-tree.log", vim.fn.stdpath("log"), os.date("%H:%M:%S"), vim.env.USER)
+    if opts.log.truncate then
+      os.remove(file_path)
     end
-    require("nvim-tree.notify").debug("nvim-tree.lua logging to " .. M.path)
+    require("nvim-tree.notify").debug("nvim-tree.lua logging to " .. file_path)
   end
 end
 

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

@@ -1,52 +0,0 @@
-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"
-local lib = require "nvim-tree.lib"
-
-local M = {
-  config = {},
-}
-
---- Delete nodes; each removal will be optionally notified
----@param nodes Node[]
-local function do_delete(nodes)
-  for _, node in pairs(nodes) do
-    remove_file.remove(node)
-  end
-
-  marks.clear_marks()
-
-  if not M.config.filesystem_watchers.enable then
-    require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
-  end
-end
-
---- Delete marked nodes, optionally prompting
-function M.bulk_delete()
-  local nodes = marks.get_marks()
-  if not nodes or #nodes == 0 then
-    notify.warn "No bookmarksed to delete."
-    return
-  end
-
-  if M.config.ui.confirm.remove then
-    local prompt_select = "Remove bookmarked ?"
-    local prompt_input = prompt_select .. " y/N: "
-    lib.prompt(prompt_input, prompt_select, { "", "y" }, { "No", "Yes" }, function(item_short)
-      utils.clear_prompt()
-      if item_short == "y" then
-        do_delete(nodes)
-      end
-    end)
-  else
-    do_delete(nodes)
-  end
-end
-
-function M.setup(opts)
-  M.config.ui = opts.ui
-  M.config.filesystem_watchers = opts.filesystem_watchers
-end
-
-return M

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

@@ -1,52 +0,0 @@
-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 M = {
-  config = {},
-}
-
-function M.bulk_move()
-  if #marks.get_marks() == 0 then
-    notify.warn "No bookmarks to move."
-    return
-  end
-
-  local input_opts = {
-    prompt = "Move to: ",
-    default = core.get_cwd(),
-    completion = "dir",
-  }
-
-  vim.ui.input(input_opts, function(location)
-    utils.clear_prompt()
-    if not location or location == "" then
-      return
-    end
-    if vim.fn.filewritable(location) ~= 2 then
-      notify.warn(location .. " is not writable, cannot move.")
-      return
-    end
-
-    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()
-
-    if not M.config.filesystem_watchers.enable then
-      require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
-    end
-  end)
-end
-
-function M.setup(opts)
-  M.config.filesystem_watchers = opts.filesystem_watchers
-end
-
-return M

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

@@ -1,47 +0,0 @@
-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"
-local lib = require "nvim-tree.lib"
-
-local M = {
-  config = {},
-}
-
---- Delete nodes; each removal will be optionally notified
----@param nodes Node[]
-local function do_trash(nodes)
-  for _, node in pairs(nodes) do
-    remove_file.remove(node)
-  end
-
-  marks.clear_marks()
-end
-
-function M.bulk_trash()
-  local nodes = marks.get_marks()
-  if not nodes or #nodes == 0 then
-    notify.warn "No bookmarks to trash."
-    return
-  end
-
-  if M.config.ui.confirm.trash then
-    local prompt_select = "Trash bookmarked ?"
-    local prompt_input = prompt_select .. " y/N: "
-    lib.prompt(prompt_input, prompt_select, { "", "y" }, { "No", "Yes" }, function(item_short)
-      utils.clear_prompt()
-      if item_short == "y" then
-        do_trash(nodes)
-      end
-    end)
-  else
-    do_trash(nodes)
-  end
-end
-
-function M.setup(opts)
-  M.config.ui = opts.ui
-  M.config.filesystem_watchers = opts.filesystem_watchers
-end
-
-return M

lua/nvim-tree/marks/init.lua

@@ -1,68 +1,271 @@
-local renderer = {} -- circular dependency
+local Iterator = require("nvim-tree.iterators.node-iterator")
+local core = require("nvim-tree.core")
+local lib = require("nvim-tree.lib")
+local notify = require("nvim-tree.notify")
+local open_file = require("nvim-tree.actions.node.open-file")
+local remove_file = require("nvim-tree.actions.fs.remove-file")
+local rename_file = require("nvim-tree.actions.fs.rename-file")
+local trash = require("nvim-tree.actions.fs.trash")
+local utils = require("nvim-tree.utils")
 
-local NvimTreeMarks = {}
+local Class = require("nvim-tree.classic")
+local DirectoryNode = require("nvim-tree.node.directory")
 
-local M = {}
+---@class (exact) Marks: Class
+---@field private explorer Explorer
+---@field private marks table<string, Node> by absolute path
+local Marks = Class:extend()
 
----@class MinimalNode
----@field absolute_path string
+---@class Marks
+---@overload fun(args: MarksArgs): Marks
 
----@param node Node|MinimalNode
-local function add_mark(node)
-  NvimTreeMarks[node.absolute_path] = node
+---@class (exact) MarksArgs
+---@field explorer Explorer
 
-  renderer.draw()
+---@protected
+---@param args MarksArgs
+function Marks:new(args)
+  self.explorer = args.explorer
+
+  self.marks = {}
 end
 
----@param node Node|MinimalNode
-local function remove_mark(node)
-  NvimTreeMarks[node.absolute_path] = nil
-
-  renderer.draw()
+---Clear all marks and reload if watchers disabled
+---@private
+function Marks:clear_reload()
+  self:clear()
+  if not self.explorer.opts.filesystem_watchers.enable then
+    self.explorer:reload_explorer()
+  end
 end
 
----@param node Node|MinimalNode
-function M.toggle_mark(node)
+---Clear all marks and redraw
+---@public
+function Marks:clear()
+  self.marks = {}
+  self.explorer.renderer:draw()
+end
+
+---@public
+---@param node Node
+function Marks:toggle(node)
   if node.absolute_path == nil then
     return
   end
 
-  if M.get_mark(node) then
-    remove_mark(node)
+  if self:get(node) then
+    self.marks[node.absolute_path] = nil
   else
-    add_mark(node)
+    self.marks[node.absolute_path] = node
   end
 
-  renderer.draw()
+  self.explorer.renderer:draw()
 end
 
-function M.clear_marks()
-  NvimTreeMarks = {}
-
-  renderer.draw()
+---Return node if marked
+---@public
+---@param node Node
+---@return Node|nil
+function Marks:get(node)
+  return node and self.marks[node.absolute_path]
 end
 
----@param node Node|MinimalNode
----@return table|nil
-function M.get_mark(node)
-  return NvimTreeMarks[node.absolute_path]
-end
-
----@return table
-function M.get_marks()
+---List marked nodes
+---@public
+---@return Node[]
+function Marks:list()
   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)
-  renderer = require "nvim-tree.renderer"
-
-  require("nvim-tree.marks.bulk-delete").setup(opts)
-  require("nvim-tree.marks.bulk-trash").setup(opts)
-  require("nvim-tree.marks.bulk-move").setup(opts)
+---Delete marked; each removal will be optionally notified
+---@public
+function Marks:bulk_delete()
+  if not next(self.marks) then
+    notify.warn("No bookmarks to delete.")
+    return
   end
 
-return M
+  local function execute()
+    for _, node in pairs(self.marks) do
+      remove_file.remove(node)
+    end
+    self:clear_reload()
+  end
+
+  if self.explorer.opts.ui.confirm.remove then
+    local prompt_select = "Remove bookmarked ?"
+    local prompt_input = prompt_select .. " y/N: "
+    lib.prompt(prompt_input, prompt_select, { "", "y" }, { "No", "Yes" }, "nvimtree_bulk_delete", function(item_short)
+      utils.clear_prompt()
+      if item_short == "y" then
+        execute()
+      end
+    end)
+  else
+    execute()
+  end
+end
+
+---Trash marked; each removal will be optionally notified
+---@public
+function Marks:bulk_trash()
+  if not next(self.marks) then
+    notify.warn("No bookmarks to trash.")
+    return
+  end
+
+  local function execute()
+    for _, node in pairs(self.marks) do
+      trash.remove(node)
+    end
+    self:clear_reload()
+  end
+
+  if self.explorer.opts.ui.confirm.trash then
+    local prompt_select = "Trash bookmarked ?"
+    local prompt_input = prompt_select .. " y/N: "
+    lib.prompt(prompt_input, prompt_select, { "", "y" }, { "No", "Yes" }, "nvimtree_bulk_trash", function(item_short)
+      utils.clear_prompt()
+      if item_short == "y" then
+        execute()
+      end
+    end)
+  else
+    execute()
+  end
+end
+
+---Move marked
+---@public
+function Marks:bulk_move()
+  if not next(self.marks) then
+    notify.warn("No bookmarks to move.")
+    return
+  end
+
+  local node_at_cursor = self.explorer:get_node_at_cursor()
+  local default_path = core.get_cwd()
+
+  if node_at_cursor and node_at_cursor:is(DirectoryNode) 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 = default_path,
+    completion = "dir",
+  }
+
+  vim.ui.input(input_opts, function(location)
+    utils.clear_prompt()
+    if not location or location == "" then
+      return
+    end
+    if vim.fn.filewritable(location) ~= 2 then
+      notify.warn(location .. " is not writable, cannot move.")
+      return
+    end
+
+    for _, node in pairs(self.marks) do
+      local head = vim.fn.fnamemodify(node.absolute_path, ":t")
+      local to = utils.path_join({ location, head })
+      rename_file.rename(node, to)
+    end
+
+    self:clear_reload()
+  end)
+end
+
+---Focus nearest marked node in direction.
+---@private
+---@param up boolean
+function Marks:navigate(up)
+  local node = self.explorer:get_node_at_cursor()
+  if not node then
+    return
+  end
+
+  local first, prev, next, last = nil, nil, nil, nil
+  local found = false
+
+  Iterator.builder(self.explorer.nodes)
+    :recursor(function(n)
+      local dir = n:as(DirectoryNode)
+      return dir and dir.open and dir.nodes
+    end)
+    :applier(function(n)
+      if n.absolute_path == node.absolute_path then
+        found = true
+        return
+      end
+
+      if not self:get(n) then
+        return
+      end
+
+      last = n
+      first = first or n
+
+      if found and not next then
+        next = n
+      end
+
+      if not found then
+        prev = n
+      end
+    end)
+    :iterate()
+
+  if not found then
+    return
+  end
+
+  if up then
+    self.explorer:focus_node_or_parent(prev or last)
+  else
+    self.explorer:focus_node_or_parent(next or first)
+  end
+end
+
+---@public
+function Marks:navigate_prev()
+  self:navigate(true)
+end
+
+---@public
+function Marks:navigate_next()
+  self:navigate(false)
+end
+
+---Prompts for selection of a marked node, sorted by absolute paths.
+---A folder will be focused, a file will be opened.
+---@public
+function Marks:navigate_select()
+  local list = vim.tbl_map(function(n)
+    return n.absolute_path
+  end, self:list())
+
+  table.sort(list)
+
+  vim.ui.select(list, {
+    prompt = "Select a file to open or a folder to focus",
+  }, function(choice)
+    if not choice or choice == "" then
+      return
+    end
+    local node = self.marks[choice]
+    if node and not node:is(DirectoryNode) and not utils.get_win_buf_from_path(node.absolute_path) then
+      open_file.fn("edit", node.absolute_path)
+    elseif node then
+      self.explorer:focus_node_or_parent(node)
+    end
+  end)
+end
+
+return Marks

lua/nvim-tree/marks/navigation.lua

@@ -1,102 +0,0 @@
-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"
-
----@param node table
----@param where string
----@return Node|nil
-local function get_nearest(node, where)
-  local first, prev, next, last = nil, nil, nil, nil
-  local found = false
-
-  Iterator.builder(core.get_explorer().nodes)
-    :recursor(function(n)
-      return n.open and n.nodes
-    end)
-    :applier(function(n)
-      if n.absolute_path == node.absolute_path then
-        found = true
-        return
-      end
-
-      if not Marks.get_mark(n) then
-        return
-      end
-
-      last = n
-      first = first or n
-
-      if found and not next then
-        next = n
-      end
-
-      if not found then
-        prev = n
-      end
-    end)
-    :iterate()
-
-  if not found then
-    return
-  end
-
-  if where == "next" then
-    return next or first
-  else
-    return prev or last
-  end
-end
-
----@param where string
----@param node table|nil
----@return Node|nil
-local function get(where, node)
-  if node then
-    return get_nearest(node, where)
-  end
-end
-
----@param node table|nil
-local function open_or_focus(node)
-  if node and not node.nodes and not utils.get_win_buf_from_path(node.absolute_path) then
-    open_file.fn("edit", node.absolute_path)
-  elseif node then
-    utils.focus_file(node.absolute_path)
-  end
-end
-
----@param where string
----@return function
-local function navigate_to(where)
-  return function()
-    local node = lib.get_node_at_cursor()
-    local next = get(where, node)
-    open_or_focus(next)
-  end
-end
-
-local M = {}
-
-M.next = navigate_to "next"
-M.prev = navigate_to "prev"
-
-function M.select()
-  local list = vim.tbl_map(function(n)
-    return n.absolute_path
-  end, Marks.get_marks())
-
-  vim.ui.select(list, {
-    prompt = "Select a file to open or a folder to focus",
-  }, function(choice)
-    if not choice or choice == "" then
-      return
-    end
-    local node = Marks.get_mark { absolute_path = choice }
-    open_or_focus(node)
-  end)
-end
-
-return M

lua/nvim-tree/modified.lua

@@ -1,40 +0,0 @@
-local M = {}
-
----@type table<string, boolean> record of which file is modified
-M._record = {}
-
----refresh M.record
-function M.reload()
-  M._record = {}
-  local bufs = vim.fn.getbufinfo { bufmodified = true, buflisted = true }
-  for _, buf in pairs(bufs) do
-    local path = buf.name
-    if path ~= "" then -- not a [No Name] buffer
-      -- mark all the parent as modified as well
-      while
-        M._record[path] ~= true
-        -- no need to keep going if already recorded
-        -- This also prevents an infinite loop
-      do
-        M._record[path] = true
-        path = vim.fn.fnamemodify(path, ":h")
-      end
-    end
-  end
-end
-
----@param node Node
----@return boolean
-function M.is_modified(node)
-  return M.config.enable
-    and M._record[node.absolute_path]
-    and (not node.nodes or M.config.show_on_dirs)
-    and (not node.open or M.config.show_on_open_dirs)
-end
-
----@param opts table
-function M.setup(opts)
-  M.config = opts.modified
-end
-
-return M

lua/nvim-tree/node.lua

@@ -1,37 +0,0 @@
----@meta
-
--- TODO add "${3rd}/luv/library" to "workspace.library"
----@class uv.uv_req_t: table
----@class uv.uv_fs_t: uv.uv_req_t
-
----@class ParentNode
----@field name string
-
----@class BaseNode
----@field absolute_path string
----@field executable boolean
----@field fs_stat uv.uv_fs_t
----@field git_status GitStatus|nil
----@field hidden boolean
----@field name string
----@field parent DirNode
----@field type string
----@field watcher function|nil
-
----@class DirNode: BaseNode
----@field has_children boolean
----@field group_next Node|nil
----@field nodes Node[]
----@field open boolean
-
----@class FileNode: BaseNode
----@field extension string
-
----@class SymlinkDirNode: DirNode
----@field link_to string
-
----@class SymlinkFileNode: FileNode
----@field link_to string
-
----@alias SymlinkNode SymlinkDirNode|SymlinkFileNode
----@alias Node ParentNode|DirNode|FileNode|SymlinkNode|Explorer

lua/nvim-tree/node/directory-link.lua

@@ -0,0 +1,87 @@
+local git_utils = require("nvim-tree.git.utils")
+local utils = require("nvim-tree.utils")
+
+local DirectoryNode = require("nvim-tree.node.directory")
+local LinkNode = require("nvim-tree.node.link")
+
+---@class (exact) DirectoryLinkNode: DirectoryNode, LinkNode
+local DirectoryLinkNode = DirectoryNode:extend()
+DirectoryLinkNode:implement(LinkNode)
+
+---@class DirectoryLinkNode
+---@overload fun(args: LinkNodeArgs): DirectoryLinkNode
+
+---@protected
+---@param args LinkNodeArgs
+function DirectoryLinkNode:new(args)
+  LinkNode.new(self, args)
+
+  -- create DirectoryNode with watcher on link_to
+  local absolute_path = args.absolute_path
+  args.absolute_path = args.link_to
+  DirectoryLinkNode.super.new(self, args)
+
+  self.type          = "link"
+
+  -- reset absolute path to the link itself
+  self.absolute_path = absolute_path
+end
+
+function DirectoryLinkNode:destroy()
+  DirectoryNode.destroy(self)
+end
+
+---Update the directory git_status of link target and the file status of the link itself
+---@param parent_ignored boolean
+---@param project GitProject?
+function DirectoryLinkNode:update_git_status(parent_ignored, project)
+  self.git_status = git_utils.git_status_dir(parent_ignored, project, self.link_to, self.absolute_path)
+end
+
+---@return HighlightedString name
+function DirectoryLinkNode:highlighted_icon()
+  if not self.explorer.opts.renderer.icons.show.folder then
+    return self:highlighted_icon_empty()
+  end
+
+  local str, hl
+
+  if self.open then
+    str = self.explorer.opts.renderer.icons.glyphs.folder.symlink_open
+    hl  = "NvimTreeOpenedFolderIcon"
+  else
+    str = self.explorer.opts.renderer.icons.glyphs.folder.symlink
+    hl  = "NvimTreeClosedFolderIcon"
+  end
+
+  return { str = str, hl = { hl } }
+end
+
+---Maybe override name with arrow
+---@return HighlightedString name
+function DirectoryLinkNode:highlighted_name()
+  local name = DirectoryNode.highlighted_name(self)
+
+  if self.explorer.opts.renderer.symlink_destination then
+    local link_to = utils.path_relative(self.link_to, self.explorer.absolute_path)
+
+    name.str      = string.format("%s%s%s", name.str, self.explorer.opts.renderer.icons.symlink_arrow, link_to)
+    name.hl       = { "NvimTreeSymlinkFolderName" }
+  end
+
+  return name
+end
+
+---Create a sanitized partial copy of a node, populating children recursively.
+---@param api_nodes table<number, nvim_tree.api.Node>? optional map of uids to api node to populate
+---@return nvim_tree.api.DirectoryLinkNode cloned
+function DirectoryLinkNode:clone(api_nodes)
+  local clone = DirectoryNode.clone(self, api_nodes) --[[@as nvim_tree.api.DirectoryLinkNode]]
+
+  clone.link_to = self.link_to
+  clone.fs_stat_target = self.fs_stat_target
+
+  return clone
+end
+
+return DirectoryLinkNode

lua/nvim-tree/node/directory.lua

@@ -0,0 +1,293 @@
+local git_utils = require("nvim-tree.git.utils")
+local icons = require("nvim-tree.renderer.components.devicons")
+local notify = require("nvim-tree.notify")
+
+local Node = require("nvim-tree.node")
+
+---@class (exact) DirectoryNode: Node
+---@field has_children boolean
+---@field group_next DirectoryNode? -- If node is grouped, this points to the next child dir/link node
+---@field nodes Node[]
+---@field open boolean
+---@field hidden_stats table? -- Each field of this table is a key for source and value for count
+---@field private watcher Watcher?
+local DirectoryNode = Node:extend()
+
+---@class DirectoryNode
+---@overload fun(args: NodeArgs): DirectoryNode
+
+---@protected
+---@param args NodeArgs
+function DirectoryNode:new(args)
+  DirectoryNode.super.new(self, args)
+
+  local handle       = vim.loop.fs_scandir(args.absolute_path)
+  local has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil or false
+
+  self.type          = "directory"
+
+  self.has_children  = has_children
+  self.group_next    = nil
+  self.nodes         = {}
+  self.open          = false
+  self.hidden_stats  = nil
+
+  self.watcher       = require("nvim-tree.explorer.watch").create_watcher(self)
+end
+
+function DirectoryNode:destroy()
+  if self.watcher then
+    self.watcher:destroy()
+    self.watcher = nil
+  end
+
+  if self.nodes then
+    for _, node in pairs(self.nodes) do
+      node:destroy()
+    end
+  end
+
+  Node.destroy(self)
+end
+
+---Update the git_status of the directory
+---@param parent_ignored boolean
+---@param project GitProject?
+function DirectoryNode:update_git_status(parent_ignored, project)
+  self.git_status = git_utils.git_status_dir(parent_ignored, project, self.absolute_path, nil)
+end
+
+---@return GitXY[]?
+function DirectoryNode:get_git_xy()
+  if not self.git_status or not self.explorer.opts.git.show_on_dirs then
+    return nil
+  end
+
+  local xys = {}
+  if not self:last_group_node().open or self.explorer.opts.git.show_on_open_dirs then
+    -- dir is closed or we should show on open_dirs
+    if self.git_status.file ~= nil then
+      table.insert(xys, self.git_status.file)
+    end
+    if self.git_status.dir ~= nil then
+      if self.git_status.dir.direct ~= nil then
+        for _, s in pairs(self.git_status.dir.direct) do
+          table.insert(xys, s)
+        end
+      end
+      if self.git_status.dir.indirect ~= nil then
+        for _, s in pairs(self.git_status.dir.indirect) do
+          table.insert(xys, s)
+        end
+      end
+    end
+  else
+    -- dir is open and we shouldn't show on open_dirs
+    if self.git_status.file ~= nil then
+      table.insert(xys, self.git_status.file)
+    end
+    if self.git_status.dir ~= nil and self.git_status.dir.direct ~= nil then
+      local deleted = {
+        [" D"] = true,
+        ["D "] = true,
+        ["RD"] = true,
+        ["DD"] = true,
+      }
+      for _, s in pairs(self.git_status.dir.direct) do
+        if deleted[s] then
+          table.insert(xys, s)
+        end
+      end
+    end
+  end
+  if #xys == 0 then
+    return nil
+  else
+    return xys
+  end
+end
+
+-- If node is grouped, return the last node in the group. Otherwise, return the given node.
+---@return DirectoryNode
+function DirectoryNode:last_group_node()
+  return self.group_next and self.group_next:last_group_node() or self
+end
+
+---Return the one and only one child directory
+---@return DirectoryNode?
+function DirectoryNode:single_child_directory()
+  if #self.nodes == 1 then
+    return self.nodes[1]:as(DirectoryNode)
+  end
+end
+
+---@private
+-- Toggle group empty folders
+function DirectoryNode:toggle_group_folders()
+  local is_grouped = self.group_next ~= nil
+
+  if is_grouped then
+    self:ungroup_empty_folders()
+  else
+    self:group_empty_folders()
+  end
+end
+
+---Group empty folders
+-- Recursively group nodes
+---@private
+---@return Node[]
+function DirectoryNode:group_empty_folders()
+  local single_child = self:single_child_directory()
+  if self.explorer.opts.renderer.group_empty and self.parent and single_child then
+    self.group_next = single_child
+    local ns = single_child:group_empty_folders()
+    self.nodes = ns or {}
+    return ns
+  end
+  return self.nodes
+end
+
+---Ungroup empty folders
+-- If a node is grouped, ungroup it: put node.group_next to the node.nodes and set node.group_next to nil
+---@private
+function DirectoryNode:ungroup_empty_folders()
+  if self.group_next then
+    self.group_next:ungroup_empty_folders()
+    self.nodes = { self.group_next }
+    self.group_next = nil
+  end
+end
+
+---@param toggle_group boolean?
+function DirectoryNode:expand_or_collapse(toggle_group)
+  toggle_group = toggle_group or false
+  if self.has_children then
+    self.has_children = false
+  end
+
+  if #self.nodes == 0 then
+    self.explorer:expand(self)
+  end
+
+  local head_node = self:get_parent_of_group() or self
+  if toggle_group then
+    head_node:toggle_group_folders()
+  end
+
+  local open = self:last_group_node().open
+  local next_open
+  if toggle_group then
+    next_open = open
+  else
+    next_open = not open
+  end
+
+  local node = head_node
+  while node do
+    node.open = next_open
+    node = node.group_next
+  end
+
+  self.explorer.renderer:draw()
+end
+
+---@return HighlightedString icon
+function DirectoryNode:highlighted_icon()
+  if not self.explorer.opts.renderer.icons.show.folder then
+    return self:highlighted_icon_empty()
+  end
+
+  local str, hl
+
+  -- devicon if enabled and available
+  if self.explorer.opts.renderer.icons.web_devicons.folder.enable then
+    str, hl = icons.get_icon(self.name)
+    if not self.explorer.opts.renderer.icons.web_devicons.folder.color then
+      hl = nil
+    end
+  end
+
+  -- default icon from opts
+  if not str then
+    if #self.nodes ~= 0 or self.has_children then
+      if self.open then
+        str = self.explorer.opts.renderer.icons.glyphs.folder.open
+      else
+        str = self.explorer.opts.renderer.icons.glyphs.folder.default
+      end
+    else
+      if self.open then
+        str = self.explorer.opts.renderer.icons.glyphs.folder.empty_open
+      else
+        str = self.explorer.opts.renderer.icons.glyphs.folder.empty
+      end
+    end
+  end
+
+  -- default hl
+  if not hl then
+    if self.open then
+      hl = "NvimTreeOpenedFolderIcon"
+    else
+      hl = "NvimTreeClosedFolderIcon"
+    end
+  end
+
+  return { str = str, hl = { hl } }
+end
+
+---@return HighlightedString icon
+function DirectoryNode:highlighted_name()
+  local str, hl
+
+  local name = self.name
+  local next = self.group_next
+  while next do
+    name = string.format("%s/%s", name, next.name)
+    next = next.group_next
+  end
+
+  if self.group_next and type(self.explorer.opts.renderer.group_empty) == "function" then
+    local new_name = self.explorer.opts.renderer.group_empty(name)
+    if type(new_name) == "string" then
+      name = new_name
+    else
+      notify.warn(string.format("Invalid return type for field renderer.group_empty. Expected string, got %s", type(new_name)))
+    end
+  end
+  str = string.format("%s%s", name, self.explorer.opts.renderer.add_trailing and "/" or "")
+
+  hl = "NvimTreeFolderName"
+  if vim.tbl_contains(self.explorer.opts.renderer.special_files, self.absolute_path) or vim.tbl_contains(self.explorer.opts.renderer.special_files, self.name) then
+    hl = "NvimTreeSpecialFolderName"
+  elseif self.open then
+    hl = "NvimTreeOpenedFolderName"
+  elseif #self.nodes == 0 and not self.has_children then
+    hl = "NvimTreeEmptyFolderName"
+  end
+
+  return { str = str, hl = { hl } }
+end
+
+---Create a sanitized partial copy of a node, populating children recursively.
+---@param api_nodes table<number, nvim_tree.api.Node>? optional map of uids to api node to populate
+---@return nvim_tree.api.DirectoryNode cloned
+function DirectoryNode:clone(api_nodes)
+  local clone        = Node.clone(self, api_nodes) --[[@as nvim_tree.api.DirectoryNode]]
+
+  clone.has_children = self.has_children
+  clone.nodes        = {}
+  clone.open         = self.open
+
+  local clone_child
+  for _, child in ipairs(self.nodes) do
+    clone_child = child:clone(api_nodes)
+    clone_child.parent = clone
+    table.insert(clone.nodes, clone_child)
+  end
+
+  return clone
+end
+
+return DirectoryNode

lua/nvim-tree/node/factory.lua

@@ -0,0 +1,48 @@
+local DirectoryLinkNode = require("nvim-tree.node.directory-link")
+local DirectoryNode = require("nvim-tree.node.directory")
+local FileLinkNode = require("nvim-tree.node.file-link")
+local FileNode = require("nvim-tree.node.file")
+local Watcher = require("nvim-tree.watcher")
+
+local M = {}
+
+---Factory function to create the appropriate Node
+---nil on invalid stat or invalid link target stat
+---@param args NodeArgs
+---@return Node?
+function M.create(args)
+  if not args.fs_stat then
+    return nil
+  end
+
+  if args.fs_stat.type == "directory" then
+    -- directory must be readable and enumerable
+    if vim.loop.fs_access(args.absolute_path, "R") and Watcher.is_fs_event_capable(args.absolute_path) then
+      return DirectoryNode(args)
+    end
+  elseif args.fs_stat.type == "file" then
+    return FileNode(args)
+  elseif args.fs_stat.type == "link" then
+    -- link target path and stat must resolve
+    local link_to = vim.loop.fs_realpath(args.absolute_path)
+    local link_to_stat = link_to and vim.loop.fs_stat(link_to)
+    if not link_to or not link_to_stat then
+      return
+    end
+
+    ---@cast args LinkNodeArgs
+    args.link_to        = link_to
+    args.fs_stat_target = link_to_stat
+
+    -- choose directory or file
+    if link_to_stat.type == "directory" then
+      return DirectoryLinkNode(args)
+    else
+      return FileLinkNode(args)
+    end
+  end
+
+  return nil
+end
+
+return M

lua/nvim-tree/node/file-link.lua

@@ -0,0 +1,72 @@
+local git_utils = require("nvim-tree.git.utils")
+local utils = require("nvim-tree.utils")
+
+local FileNode = require("nvim-tree.node.file")
+local LinkNode = require("nvim-tree.node.link")
+
+---@class (exact) FileLinkNode: FileNode, LinkNode
+local FileLinkNode = FileNode:extend()
+FileLinkNode:implement(LinkNode)
+
+---@class FileLinkNode
+---@overload fun(args: LinkNodeArgs): FileLinkNode
+
+---@protected
+---@param args LinkNodeArgs
+function FileLinkNode:new(args)
+  LinkNode.new(self, args)
+  FileLinkNode.super.new(self, args)
+
+  self.type = "link"
+end
+
+function FileLinkNode:destroy()
+  FileNode.destroy(self)
+end
+
+---Update the git_status of the target otherwise the link itself
+---@param parent_ignored boolean
+---@param project GitProject?
+function FileLinkNode:update_git_status(parent_ignored, project)
+  self.git_status = git_utils.git_status_file(parent_ignored, project, self.link_to, self.absolute_path)
+end
+
+---@return HighlightedString icon
+function FileLinkNode:highlighted_icon()
+  if not self.explorer.opts.renderer.icons.show.file then
+    return self:highlighted_icon_empty()
+  end
+
+  local str, hl
+
+  -- default icon from opts
+  str = self.explorer.opts.renderer.icons.glyphs.symlink
+  hl = "NvimTreeSymlinkIcon"
+
+  return { str = str, hl = { hl } }
+end
+
+---@return HighlightedString name
+function FileLinkNode:highlighted_name()
+  local str = self.name
+  if self.explorer.opts.renderer.symlink_destination then
+    local link_to = utils.path_relative(self.link_to, self.explorer.absolute_path)
+    str = string.format("%s%s%s", str, self.explorer.opts.renderer.icons.symlink_arrow, link_to)
+  end
+
+  return { str = str, hl = { "NvimTreeSymlink" } }
+end
+
+---Create a sanitized partial copy of a node
+---@param api_nodes table<number, nvim_tree.api.Node>? optional map of uids to api node to populate
+---@return nvim_tree.api.FileLinkNode cloned
+function FileLinkNode:clone(api_nodes)
+  local clone = FileNode.clone(self, api_nodes) --[[@as nvim_tree.api.FileLinkNode]]
+
+  clone.link_to = self.link_to
+  clone.fs_stat_target = self.fs_stat_target
+
+  return clone
+end
+
+return FileLinkNode

lua/nvim-tree/node/file.lua

@@ -0,0 +1,107 @@
+local git_utils = require("nvim-tree.git.utils")
+local icons = require("nvim-tree.renderer.components.devicons")
+local utils = require("nvim-tree.utils")
+
+local Node = require("nvim-tree.node")
+
+local PICTURE_MAP = {
+  jpg = true,
+  jpeg = true,
+  png = true,
+  gif = true,
+  webp = true,
+  jxl = true,
+}
+
+---@class (exact) FileNode: Node
+---@field extension string
+local FileNode = Node:extend()
+
+---@class FileNode
+---@overload fun(args: NodeArgs): FileNode
+
+---@protected
+---@param args NodeArgs
+function FileNode:new(args)
+  FileNode.super.new(self, args)
+
+  self.type       = "file"
+  self.extension  = string.match(args.name, ".?[^.]+%.(.*)") or ""
+  self.executable = utils.is_executable(args.absolute_path)
+end
+
+function FileNode:destroy()
+  Node.destroy(self)
+end
+
+---Update the GitStatus of the file
+---@param parent_ignored boolean
+---@param project GitProject?
+function FileNode:update_git_status(parent_ignored, project)
+  self.git_status = git_utils.git_status_file(parent_ignored, project, self.absolute_path, nil)
+end
+
+---@return GitXY[]?
+function FileNode:get_git_xy()
+  if not self.git_status then
+    return nil
+  end
+
+  return self.git_status.file and { self.git_status.file }
+end
+
+---@return HighlightedString icon
+function FileNode:highlighted_icon()
+  if not self.explorer.opts.renderer.icons.show.file then
+    return self:highlighted_icon_empty()
+  end
+
+  local str, hl
+
+  -- devicon if enabled and available, fallback to default
+  if self.explorer.opts.renderer.icons.web_devicons.file.enable then
+    str, hl = icons.get_icon(self.name, nil, { default = true })
+    if not self.explorer.opts.renderer.icons.web_devicons.file.color then
+      hl = nil
+    end
+  end
+
+  -- default icon from opts
+  if not str then
+    str = self.explorer.opts.renderer.icons.glyphs.default
+  end
+
+  -- default hl
+  if not hl then
+    hl = "NvimTreeFileIcon"
+  end
+
+  return { str = str, hl = { hl } }
+end
+
+---@return HighlightedString name
+function FileNode:highlighted_name()
+  local hl
+  if vim.tbl_contains(self.explorer.opts.renderer.special_files, self.absolute_path) or vim.tbl_contains(self.explorer.opts.renderer.special_files, self.name) then
+    hl = "NvimTreeSpecialFile"
+  elseif self.executable then
+    hl = "NvimTreeExecFile"
+  elseif PICTURE_MAP[self.extension] then
+    hl = "NvimTreeImageFile"
+  end
+
+  return { str = self.name, hl = { hl } }
+end
+
+---Create a sanitized partial copy of a node
+---@param api_nodes table<number, nvim_tree.api.Node>? optional map of uids to api node to populate
+---@return nvim_tree.api.FileNode cloned
+function FileNode:clone(api_nodes)
+  local clone = Node.clone(self, api_nodes) --[[@as nvim_tree.api.FileNode]]
+
+  clone.extension = self.extension
+
+  return clone
+end
+
+return FileNode

lua/nvim-tree/node/init.lua

@@ -0,0 +1,147 @@
+local Class = require("nvim-tree.classic")
+
+---Abstract Node class.
+---@class (exact) Node: Class
+---@field uid_node number vim.loop.hrtime() at construction time
+---@field type "file" | "directory" | "link" uv.fs_stat.result.type
+---@field explorer Explorer
+---@field absolute_path string
+---@field executable boolean
+---@field fs_stat uv.fs_stat.result?
+---@field git_status GitNodeStatus?
+---@field hidden boolean
+---@field name string
+---@field parent DirectoryNode?
+---@field diag_status DiagStatus?
+---@field private is_dot boolean cached is_dotfile
+local Node = Class:extend()
+
+---@class (exact) NodeArgs
+---@field explorer Explorer
+---@field parent DirectoryNode?
+---@field absolute_path string
+---@field name string
+---@field fs_stat uv.fs_stat.result?
+
+---@protected
+---@param args NodeArgs
+function Node:new(args)
+  self.uid_node      = vim.loop.hrtime()
+  self.explorer      = args.explorer
+  self.absolute_path = args.absolute_path
+  self.executable    = false
+  self.fs_stat       = args.fs_stat
+  self.git_status    = nil
+  self.hidden        = false
+  self.name          = args.name
+  self.parent        = args.parent
+  self.diag_status   = nil
+  self.is_dot        = false
+end
+
+function Node:destroy()
+end
+
+---Update the git_status of the node
+---Abstract
+---@param parent_ignored boolean
+---@param project GitProject?
+function Node:update_git_status(parent_ignored, project)
+  self:nop(parent_ignored, project)
+end
+
+---Short-format statuses
+---@return GitXY[]?
+function Node:get_git_xy()
+end
+
+---@return boolean
+function Node:is_git_ignored()
+  return self.git_status ~= nil and self.git_status.file == "!!"
+end
+
+---Node or one of its parents begins with a dot
+---@return boolean
+function Node:is_dotfile()
+  if
+    self.is_dot
+    or (self.name and (self.name:sub(1, 1) == "."))
+    or (self.parent and self.parent:is_dotfile())
+  then
+    self.is_dot = true
+    return true
+  end
+  return false
+end
+
+---Get the highest parent of grouped nodes, nil when not grouped
+---@return DirectoryNode?
+function Node:get_parent_of_group()
+  if not self.parent or not self.parent.group_next then
+    return nil
+  end
+
+  local node = self.parent
+  while node do
+    if node.parent and node.parent.group_next then
+      node = node.parent
+    else
+      return node
+    end
+  end
+end
+
+---Empty highlighted icon
+---@protected
+---@return HighlightedString icon
+function Node:highlighted_icon_empty()
+  return { str = "", hl = {} }
+end
+
+---Highlighted icon for the node
+---Empty for base Node
+---@return HighlightedString icon
+function Node:highlighted_icon()
+  return self:highlighted_icon_empty()
+end
+
+---Empty highlighted name
+---@protected
+---@return HighlightedString name
+function Node:highlighted_name_empty()
+  return { str = "", hl = {} }
+end
+
+---Highlighted name for the node
+---Empty for base Node
+---@return HighlightedString name
+function Node:highlighted_name()
+  return self:highlighted_name_empty()
+end
+
+---Create a sanitized partial copy of a node, populating children recursively.
+---@param api_nodes table<number, nvim_tree.api.Node>? optional map of uids to api node to populate
+---@return nvim_tree.api.Node cloned
+function Node:clone(api_nodes)
+  ---@type nvim_tree.api.Node
+  local clone = {
+    uid_node      = self.uid_node,
+    type          = self.type,
+    absolute_path = self.absolute_path,
+    executable    = self.executable,
+    fs_stat       = self.fs_stat,
+    git_status    = self.git_status,
+    hidden        = self.hidden,
+    name          = self.name,
+    parent        = nil,
+    diag_severity = self.diag_status and self.diag_status.value or nil,
+  }
+
+  if api_nodes then
+    api_nodes[self.uid_node] = clone
+  end
+
+  return clone
+end
+
+return Node

lua/nvim-tree/node/link.lua

@@ -0,0 +1,19 @@
+local Class = require("nvim-tree.classic")
+
+---@class (exact) LinkNode: Class
+---@field link_to string
+---@field fs_stat_target uv.fs_stat.result
+local LinkNode = Class:extend()
+
+---@class (exact) LinkNodeArgs: NodeArgs
+---@field link_to string
+---@field fs_stat_target uv.fs_stat.result
+
+---@protected
+---@param args LinkNodeArgs
+function LinkNode:new(args)
+  self.link_to = args.link_to
+  self.fs_stat_target = args.fs_stat_target
+end
+
+return LinkNode