nixpkgs/pkgs/applications/editors/vim/plugins/overrides.nix

{
  lib,
  stdenv,
  config,
  # nixpkgs functions
  buildGoModule,
  callPackage,
  fetchFromGitHub,
  fetchpatch,
  fetchurl,
  replaceVars,
  # Language dependencies
  fetchYarnDeps,
  yarnConfigHook,
  python3,
  # Misc dependencies
  charm-freeze,
  code-minimap,
  dailies,
  dasht,
  deno,
  direnv,
  fzf,
  gawk,
  git,
  helm-ls,
  himalaya,
  htop,
  jq,
  khard,
  kulala-core,
  languagetool,
  libgit2,
  llvmPackages,
  neovim-unwrapped,
  nix,
  nodejs,
  openscad,
  openssh,
  openssl,
  ranger,
  ripgrep,
  sqlite,
  sshfs,
  stylish-haskell,
  tabnine,
  tmux,
  typescript,
  typescript-language-server,
  vim,
  which,
  xdg-utils,
  xdotool,
  xkb-switch,
  xwininfo,
  xxd,
  ycmd,
  zenity,
  zoxide,
  zsh,
  # codeium-nvim dependencies
  codeium,
  # command-t dependencies
  getconf,
  # cornelis dependencies
  cornelis,
  # cpsm dependencies
  boost,
  cmake,
  icu,
  ncurses,
  # devdocs-nvim dependencies
  pandoc,
  # nvim-tinygit
  gitMinimal,
  # opencode-nvim,
  opencode,
  lsof,
  # Preview-nvim dependencies
  md-tui,
  # sidekick-nvim dependencies
  copilot-language-server,
  # sved dependencies
  glib,
  gobject-introspection,
  wrapGAppsHook3,
  writeText,
  curl,
  # vim-agda dependencies
  agda,
  # vim-go dependencies
  asmfmt,
  delve,
  errcheck,
  go-motion,
  go-tools,
  gocode-gomod,
  godef,
  gogetdoc,
  golangci-lint,
  golint,
  gomodifytags,
  gopls,
  gotags,
  gotools,
  iferr,
  impl,
  reftools,
  revive,
  tree-sitter-grammars,
  neovimUtils,
  # hurl dependencies
  hurl,
  # must be lua51Packages
  aider-chat,
  # typst-preview dependencies
  tinymist,
  websocat,
  # lazydocker.nvim dependencies
  lazydocker,
  # lazyjj.nvim dependencies
  lazyjj,
  # luau-lsp-nvim dependencies
  luau-lsp,
  # uv.nvim dependencies
  uv,
  # nvim-vstsl dependencies
  vtsls,
  # search-and-replace.nvim dependencies
  fd,
  sad,
  # tv.nvim dependency
  television,
  tree-sitter,
  # fugit2-nvim
  gpgme,
}:
self: super:
let
  luaPackages = neovim-unwrapped.lua.pkgs;

  # Ensures new attributes are not added in this file.
  assertNoAdditions =
    overrides:
    let
      prevNames = lib.attrNames super;
      definedNames = lib.attrNames overrides;
      addedNames = lib.subtractLists prevNames definedNames;
    in
    lib.throwIfNot (addedNames == [ ])
      "vimPlugins: the following attributes should not be defined in overrides.nix:${
        lib.concatMapStrings (name: "\n- ${name}") addedNames
      }"
      overrides;
in
assertNoAdditions {
  # keep-sorted start case=no block=yes newline_separated=yes
  ack-vim = super.ack-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  advanced-git-search-nvim = super.advanced-git-search-nvim.overrideAttrs {
    checkInputs = with self; [
      fzf-lua
      snacks-nvim
      telescope-nvim
    ];
    dependencies = with self; [
      vim-fugitive
      vim-rhubarb
      plenary-nvim
    ];
    nvimSkipModules = [
      # Address in use error from fzf-lua on darwin
      # https://github.com/NixOS/nixpkgs/issues/431458
      "advanced_git_search.fzf.previewers.init"
      "advanced_git_search.fzf.pickers.init"
      "advanced_git_search.fzf.pickers.utils"
    ];
  };

  aerial-nvim = super.aerial-nvim.overrideAttrs {
    # optional dependencies
    checkInputs = with self; [
      lualine-nvim
      telescope-nvim
      fzf-lua
    ];
    nvimSkipModules = [
      # Address in use error from fzf-lua on darwin
      # https://github.com/NixOS/nixpkgs/issues/431458
      "aerial.fzf-lua"
    ];
  };

  agitator-nvim = super.agitator-nvim.overrideAttrs {
    dependencies = with self; [
      telescope-nvim
      plenary-nvim
    ];
  };

  aider-nvim = super.aider-nvim.overrideAttrs {
    runtimeDeps = [
      aider-chat
    ];
  };

  animation-nvim = super.animation-nvim.overrideAttrs {
    dependencies = [ self.middleclass ];
  };

  argtextobj-vim = super.argtextobj-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  arrow-nvim = super.arrow-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
    };
  });

  arshlib-nvim = super.arshlib-nvim.overrideAttrs {
    dependencies = with self; [
      nui-nvim
      plenary-nvim
    ];
  };

  astrocore = super.astrocore.overrideAttrs {
    dependencies = [ self.lazy-nvim ];
  };

  astroui = super.astroui.overrideAttrs {
    # Readme states that astrocore is an optional dependency
    checkInputs = [ self.astrocore ];
  };

  async-nvim = super.async-nvim.overrideAttrs {
    nvimSkipModules = [
      "docgen"
    ];
  };

  asyncrun-vim = super.asyncrun-vim.overrideAttrs {
    # Optional toggleterm integration
    checkInputs = [ self.toggleterm-nvim ];
  };

  augment-vim = super.augment-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = with lib.licenses; [
        mit
        unfree
      ];
    };
  });

  auto-git-diff = super.auto-git-diff.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  auto-pairs = super.auto-pairs.overrideAttrs (old: {
    meta = old.meta // {
      # README contains the full MIT license text.
      license = lib.licenses.mit;
    };
  });

  auto-session = super.auto-session.overrideAttrs {
    # Optional integration
    checkInputs = [ self.telescope-nvim ];
  };

  autosave-nvim = super.autosave-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  aw-watcher-vim = super.aw-watcher-vim.overrideAttrs {
    runtimeDeps = [
      curl
    ];
  };

  bamboo-nvim = super.bamboo-nvim.overrideAttrs (old: {
    # Optional integration
    checkInputs = with self; [
      barbecue-nvim
      lualine-nvim
    ];
    nvimSkipModules = [
      # Requires config table
      "bamboo.colors"
      "bamboo.terminal"
      "bamboo.highlights"
      "barbecue.theme.bamboo"
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  barbar-nvim = super.barbar-nvim.overrideAttrs (old: {
    # Optional integrations
    checkInputs = with self; [
      bufferline-nvim
      nvim-web-devicons
    ];
    # E5108: Error executing lua ...implugin-barbar.nvim-2025-04-28/lua/bufferline/utils.lua:10: module 'barbar.utils.hl' not found:
    nvimSkipModules = [ "bufferline.utils" ];

    meta = old.meta // {
      license = lib.licenses.json;
    };
  });

  barbecue-nvim = super.barbecue-nvim.overrideAttrs (old: {
    dependencies = with self; [
      nvim-lspconfig
      nvim-navic
    ];
    meta = old.meta // {
      description = "VS Code like winbar for Neovim";
      homepage = "https://github.com/utilyre/barbecue.nvim";
      license = lib.licenses.mit;
      maintainers = with lib.maintainers; [ lightquantum ];
    };
  });

  base16-vim = super.base16-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  base46 = super.base46.overrideAttrs (old: {
    dependencies = [ self.nvchad-ui ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  bclose-vim = super.bclose-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.cc-by-sa-30;
    };
  });

  bitbake = super.bitbake.overrideAttrs (old: {
    sourceRoot = "source/contrib/vim";
    meta = old.meta // {
      license = lib.licenses.gpl2Only;
    };
  });

  blink-calc = super.blink-calc.overrideAttrs {
    dependencies = [ self.blink-cmp ];
  };

  blink-cmp-conventional-commits = super.blink-cmp-conventional-commits.overrideAttrs {
    dependencies = [ self.blink-cmp ];
  };

  blink-cmp-copilot = super.blink-cmp-copilot.overrideAttrs {
    dependencies = [ self.copilot-lua ];
  };

  blink-cmp-dictionary = super.blink-cmp-dictionary.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  blink-cmp-env = super.blink-cmp-env.overrideAttrs {
    dependencies = [ self.blink-cmp ];
  };

  blink-cmp-git = super.blink-cmp-git.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  blink-cmp-latex = super.blink-cmp-latex.overrideAttrs {
    dependencies = [ self.blink-cmp ];
  };

  blink-cmp-nixpkgs-maintainers = super.blink-cmp-nixpkgs-maintainers.overrideAttrs {
    dependencies = [ self.blink-cmp ];
  };

  blink-cmp-npm-nvim = super.blink-cmp-npm-nvim.overrideAttrs {
    nvimSkipModules = [
      "minit"
    ];
  };

  blink-cmp-words = super.blink-cmp-words.overrideAttrs (old: {
    dependencies = [ self.blink-cmp ];
    meta = old.meta // {
      # TODO: Upstream also includes WordNet 3.0 data; add a license entry for
      # the Princeton WordNet license and use it here.
      license = lib.licenses.mit;
      description = "Offline word and synonym completion provider for Neovim";
      maintainers = with lib.maintainers; [ m3l6h ];
    };
  });

  blink-cmp-yanky = super.blink-cmp-yanky.overrideAttrs (old: {
    dependencies = [ self.blink-cmp ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  blink-emoji-nvim = super.blink-emoji-nvim.overrideAttrs {
    dependencies = [ self.blink-cmp ];
  };

  blink-nerdfont-nvim = super.blink-nerdfont-nvim.overrideAttrs {
    dependencies = [ self.blink-cmp ];
  };

  bluloco-nvim = super.bluloco-nvim.overrideAttrs {
    dependencies = [ self.lush-nvim ];
  };

  bufferline-nvim = super.bufferline-nvim.overrideAttrs {
    # depends on bufferline.lua being loaded first
    nvimSkipModules = [ "bufferline.commands" ];
  };

  BufOnly-vim = super.BufOnly-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  bufresize-nvim = super.bufresize-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  bullets-vim = super.bullets-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  camelcasemotion = super.camelcasemotion.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  catppuccin-nvim = super.catppuccin-nvim.overrideAttrs {
    nvimSkipModules = [
      "catppuccin.groups.integrations.noice"

      # TODO(@mrcjkb): re-enable when https://github.com/catppuccin/nvim/pull/995
      # has been merged and released.
      "catppuccin.lib.detect_integrations"
    ];
  };

  caw-vim = super.caw-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  ccc-nvim = super.ccc-nvim.overrideAttrs {
    # ccc auto-discover requires all pass
    # but there's a bootstrap module that hangs forever if we dont stop on first success
    nvimSkipModules = [ "ccc.kit.Thread.Server._bootstrap" ];
  };

  chadtree = super.chadtree.overrideAttrs (old: {
    # > E5108: Error executing lua ...implugin-chadtree-0-unstable-2026-01-18/lua/chadtree.lua:162: Vim:Failed to start server: address already in use
    doCheck = stdenv.hostPlatform.isLinux;
    buildInputs = [
      python3
    ];
    passthru = old.passthru // {
      python3Dependencies =
        ps: with ps; [
          pynvim-pp
          pyyaml
          std2
        ];
    };
    # We need some patches so it stops complaining about not being in a venv
    patches = [ ./patches/chadtree/emulate-venv.patch ];
  });

  ChatGPT-nvim = super.ChatGPT-nvim.overrideAttrs {
    dependencies = with self; [
      nui-nvim
      plenary-nvim
      telescope-nvim
    ];
  };

  cheatsheet-nvim = super.cheatsheet-nvim.overrideAttrs {
    dependencies = with self; [
      telescope-nvim
      plenary-nvim
    ];
  };

  CheckAttach = super.CheckAttach.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  checkmate-nvim = super.checkmate-nvim.overrideAttrs {
    checkInputs = with self; [
      # checkmate.snippets
      luasnip
    ];
  };

  clang_complete = super.clang_complete.overrideAttrs (old: {
    # In addition to the arguments you pass to your compiler, you also need to
    # specify the path of the C++ std header (if you are using C++).
    # These usually implicitly set by cc-wrapper around clang (pkgs/build-support/cc-wrapper).
    # The linked ruby code shows generates the required '.clang_complete' for cmake based projects
    # https://gist.github.com/Mic92/135e83803ed29162817fce4098dec144
    preFixup = ''
      substituteInPlace "$out"/plugin/clang_complete.vim \
        --replace-fail "let g:clang_library_path = ''
    + "''"
    + ''
      " "let g:clang_library_path='${lib.getLib llvmPackages.libclang}/lib/libclang.so'"

            substituteInPlace "$out"/plugin/libclang.py \
              --replace-fail "/usr/lib/clang" "${llvmPackages.clang.cc}/lib/clang"
    '';
    meta = old.meta // {
      # Docs say bsd3, except some LLVM project files under ncsa.
      license = with lib.licenses; [
        bsd3
        ncsa
      ];
    };
  });

  clangd_extensions-nvim = super.clangd_extensions-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  claude-code-nvim = super.claude-code-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
    ];
  };

  claude-fzf-history-nvim = super.claude-fzf-history-nvim.overrideAttrs (old: {
    dependencies = with self; [
      fzf-lua
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  claude-fzf-nvim = super.claude-fzf-nvim.overrideAttrs (old: {
    dependencies = with self; [
      claudecode-nvim
      fzf-lua
    ];
    # Failed to build help tags!
    # E670: Mix of help file encodings within a language: doc/claude-fzf-zh.txt
    # E154: Duplicate tag "claude-fzf-keymaps" in file doc/claude-fzf-en.txt
    preInstall = ''
      rm -r doc
    '';
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  clever-f-vim = super.clever-f-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  clighter8 = super.clighter8.overrideAttrs {
    preFixup = ''
      sed "/^let g:clighter8_libclang_path/s|')$|${lib.getLib llvmPackages.clang.cc}/lib/libclang.so')|" \
        -i "$out"/plugin/clighter8.vim
    '';
  };

  clipboard-image-nvim = super.clipboard-image-nvim.overrideAttrs {
    postPatch = ''
      sed -i -e 's/require "health"/vim.health/' lua/clipboard-image/health.lua
    '';
  };

  close-buffers-vim = super.close-buffers-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  cmake-tools-nvim = super.cmake-tools-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  cmd-parser-nvim = super.cmd-parser-nvim.overrideAttrs {
    # Has cmd-parser.init.test matched from lua/cmd-parser/init.test.lua
    # Can't be required and is only other module
    nvimRequireCheck = "cmd-parser";
  };

  cmp-ai = super.cmp-ai.overrideAttrs {
    # We dont want to bundle nvim-cmp anymore since blink.nvim can use these sources.
    # Add to check inputs though to validate plugin
    checkInputs = [ self.nvim-cmp ];
    dependencies = with self; [
      plenary-nvim
    ];
  };

  cmp-async-path = super.cmp-async-path.overrideAttrs (old: {
    checkInputs = [ self.nvim-cmp ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  cmp-beancount = super.cmp-beancount.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-buffer = super.cmp-buffer.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-calc = super.cmp-calc.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-clippy = super.cmp-clippy.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = with self; [
      plenary-nvim
    ];
  };

  cmp-cmdline = super.cmp-cmdline.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-cmdline-history = super.cmp-cmdline-history.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-conjure = super.cmp-conjure.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.conjure ];
  };

  cmp-copilot = super.cmp-copilot.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.copilot-vim ];
  };

  cmp-ctags = super.cmp-ctags.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-dap = super.cmp-dap.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.nvim-dap ];
  };

  cmp-dictionary = super.cmp-dictionary.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-digraphs = super.cmp-digraphs.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-dotenv = super.cmp-dotenv.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-emoji = super.cmp-emoji.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-fish = super.cmp-fish.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-fuzzy-buffer = super.cmp-fuzzy-buffer.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.fuzzy-nvim ];
  };

  cmp-fuzzy-path = super.cmp-fuzzy-path.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.fuzzy-nvim ];
  };

  cmp-git = super.cmp-git.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = with self; [ plenary-nvim ];
  };

  cmp-greek = super.cmp-greek.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-latex-symbols = super.cmp-latex-symbols.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-look = super.cmp-look.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-neosnippet = super.cmp-neosnippet.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.neosnippet-vim ];
  };

  cmp-nixpkgs-maintainers = super.cmp-nixpkgs-maintainers.overrideAttrs {
    nativeCheckInputs = [ nix ];
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-npm = super.cmp-npm.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.plenary-nvim ];
  };

  cmp-nvim-lsp-document-symbol = super.cmp-nvim-lsp-document-symbol.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-nvim-lsp-signature-help = super.cmp-nvim-lsp-signature-help.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-nvim-lua = super.cmp-nvim-lua.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-nvim-tags = super.cmp-nvim-tags.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-nvim-ultisnips = super.cmp-nvim-ultisnips.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-omni = super.cmp-omni.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-pandoc-nvim = super.cmp-pandoc-nvim.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.plenary-nvim ];
  };

  cmp-pandoc-references = super.cmp-pandoc-references.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-path = super.cmp-path.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-rg = super.cmp-rg.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-snippy = super.cmp-snippy.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.nvim-snippy ];
  };

  cmp-spell = super.cmp-spell.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-tabby = super.cmp-tabby.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-tabnine = super.cmp-tabnine.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    buildInputs = [ tabnine ];

    postFixup = ''
      mkdir -p $target/binaries/${tabnine.version}
      ln -s ${tabnine}/bin/ $target/binaries/${tabnine.version}/${tabnine.passthru.platform}
    '';
  };

  cmp-tmux = super.cmp-tmux.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ tmux ];
  };

  cmp-treesitter = super.cmp-treesitter.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-vim-lsp = super.cmp-vim-lsp.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.vim-lsp ];
  };

  cmp-vimtex = super.cmp-vimtex.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-vimwiki-tags = super.cmp-vimwiki-tags.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.vimwiki ];
  };

  cmp-vsnip = super.cmp-vsnip.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cmp-zsh = super.cmp-zsh.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ zsh ];
  };

  cmp_luasnip = super.cmp_luasnip.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
    dependencies = [ self.luasnip ];
  };

  cmp_yanky = super.cmp_yanky.overrideAttrs {
    checkInputs = [ self.nvim-cmp ];
  };

  cobalt2-nvim = super.cobalt2-nvim.overrideAttrs {
    dependencies = with self; [ colorbuddy-nvim ];
    # Few broken themes
    nvimSkipModules = [
      "cobalt2.plugins.init"
      "cobalt2.plugins.trouble"
      "cobalt2.plugins.gitsigns"
      "cobalt2.plugins.package-info"
      "cobalt2.plugins.indent-blankline"
      "cobalt2.plugins.marks"
      "cobalt2.theme"
    ];
  };

  coc-clap = super.coc-clap.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  coc-denite = super.coc-denite.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  coc-fzf = super.coc-fzf.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  coc-neco = super.coc-neco.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  coc-nvim = super.coc-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  codecompanion-history-nvim = super.codecompanion-history-nvim.overrideAttrs {
    dependencies = with self; [
      # transitive dependency for codecompanion-nvim
      plenary-nvim

      codecompanion-nvim
    ];
  };

  codecompanion-nvim = super.codecompanion-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional completion
      blink-cmp
      nvim-cmp
      # Optional pickers
      fzf-lua
      mini-nvim
      snacks-nvim
      telescope-nvim
    ];
    dependencies = [ self.plenary-nvim ];
    nvimSkipModules = [
      # Test
      "minimal"
    ];
  };

  codesettings-nvim = super.codesettings-nvim.overrideAttrs {
    # This module is a build CLI and should not be `require`d directly!
    nvimSkipModules = [ "codesettings.build.cli" ];
  };

  codewindow-nvim = super.codewindow-nvim.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  colorful-menu-nvim = super.colorful-menu-nvim.overrideAttrs {
    # Local bug reproduction modules
    nvimSkipModules = [
      "repro_blink"
      "repro_cmp"
      "repro_native_completion"
    ];
  };

  colorizer = super.colorizer.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  Colour-Sampler-Pack = super.Colour-Sampler-Pack.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  command-t = super.command-t.overrideAttrs {
    nativeBuildInputs = [
      getconf
    ];
    buildPhase = ''
      substituteInPlace lua/wincent/commandt/lib/Makefile \
        --replace-fail '/bin/bash' 'bash' \
        --replace-fail xcrun ""
      make build
    '';
  };

  competitest-nvim = super.competitest-nvim.overrideAttrs {
    dependencies = [ self.nui-nvim ];
  };

  compiler-explorer-nvim = super.compiler-explorer-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  compiler-nvim = super.compiler-nvim.overrideAttrs {
    dependencies = [ self.overseer-nvim ];
  };

  completion-buffers = super.completion-buffers.overrideAttrs {
    dependencies = [ self.completion-nvim ];
  };

  completion-tabnine = super.completion-tabnine.overrideAttrs {
    dependencies = [ self.completion-nvim ];
    buildInputs = [ tabnine ];
    postFixup = ''
      mkdir -p $target/binaries
      ln -s ${tabnine}/bin/TabNine $target/binaries/TabNine_$(uname -s)
    '';
  };

  conflict-marker-vim = super.conflict-marker-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  conjure = super.conjure.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
    nvimSkipModules = [
      # No parser for fennel
      "conjure.client.fennel.def-str-util"
    ];
  };

  context-vim = super.context-vim.overrideAttrs {
    # Vim plugin with optional lua highlight module
    nvimSkipModules = [ "context.highlight" ];
  };

  context_filetype-vim = super.context_filetype-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  copilot-cmp = super.copilot-cmp.overrideAttrs {
    dependencies = [ self.copilot-lua ];
    patches = [
      (fetchpatch {
        name = "fix-deprecated-function-call.patch";
        url = "https://github.com/zbirenbaum/copilot-cmp/commit/06430ebf99834ebc5d86c63816e409f4cb51fe79.patch";
        sha256 = "sha256-YOJPFC+qbyURFU58tAiAqbamQLmi7ovnJGkOeOTUPH0=";
      })
    ];
  };

  copilot-lualine = super.copilot-lualine.overrideAttrs {
    dependencies = with self; [
      copilot-lua
      lualine-nvim
    ];
    doInstallCheck = true;
  };

  copilot-vim = super.copilot-vim.overrideAttrs (old: {
    postInstall = ''
      substituteInPlace $out/autoload/copilot/client.vim \
        --replace-fail "let node = s:GetCommand('copilot_node_command', ['node'])" \
                       "let node = s:GetCommand('copilot_node_command', ['${nodejs}/bin/node'])"
    '';

    meta = old.meta // {
      license = lib.licenses.unfree;
    };
  });

  CopilotChat-nvim = super.CopilotChat-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional integrations
      fzf-lua
      telescope-nvim
      snacks-nvim
    ];
    dependencies = with self; [
      copilot-lua
      plenary-nvim
    ];
  };

  coq-vim = super.coq-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  coq_nvim = super.coq_nvim.overrideAttrs (old: {
    passthru = old.passthru // {
      python3Dependencies =
        ps: with ps; [
          pynvim-pp
          pyyaml
          std2
        ];
    };

    # We need some patches so it stops complaining about not being in a venv
    patches = [ ./patches/coq_nvim/emulate-venv.patch ];

    nvimRequireCheck = [
      # Other modules require global variables
      "coq"
    ];
  });

  cornelis = super.cornelis.overrideAttrs {
    dependencies = [ self.vim-textobj-user ];
    opt = [ self.vim-which-key ];
    # Unconditionally use the cornelis binary provided by the top-level package:
    patches = [ ./patches/cornelis/0001-Unconditionally-use-global-binary.patch ];
    postInstall = ''
      substituteInPlace $out/ftplugin/agda.vim \
        --subst-var-by CORNELIS "${lib.getBin cornelis}/bin/cornelis"
    '';
  };

  cpsm = super.cpsm.overrideAttrs (old: {
    nativeBuildInputs = [ cmake ];
    buildInputs = [
      python3
      boost
      icu
      ncurses
    ];
    buildPhase = ''
      runHook preBuild

      patchShebangs .
      export PY3=ON
      ./install.sh

      runHook postBuild
    '';
  });

  crates-nvim = super.crates-nvim.overrideAttrs {
    checkInputs = [
      # Optional null-ls integration
      self.none-ls-nvim
    ];
    dependencies = [ self.plenary-nvim ];
  };

  cspell-nvim = super.cspell-nvim.overrideAttrs {
    dependencies = with self; [
      none-ls-nvim
      plenary-nvim
    ];
  };

  ctrlp-cmatcher = super.ctrlp-cmatcher.overrideAttrs {
    # drop Python 2 patches
    # https://github.com/JazzCore/ctrlp-cmatcher/pull/44
    patches = [
      (fetchpatch {
        name = "drop_python2_pt1.patch";
        url = "https://github.com/JazzCore/ctrlp-cmatcher/commit/3abad6ea155a7f6e138e1de3ac5428177bfb0254.patch";
        sha256 = "sha256-fn2puqYeJdPTdlTT4JjwVz7b3A+Xcuj/xtP6TETlB1U=";
      })
      (fetchpatch {
        name = "drop_python2_pt2.patch";
        url = "https://github.com/JazzCore/ctrlp-cmatcher/commit/385c8d02398dbb328b1a943a94e7109fe6473a08.patch";
        sha256 = "sha256-yXKCq8sqO0Db/sZREuSeqKwKO71cmTsAvWftoOQehZo=";
      })
    ];
    buildInputs = with python3.pkgs; [
      python3
      setuptools
    ];
    buildPhase = ''
      patchShebangs .
      ./install.sh
    '';
  };

  ctrlp-vim = super.ctrlp-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  ctrlp-z = super.ctrlp-z.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  dailies-nvim = super.dailies-nvim.overrideAttrs {
    runtimeDeps = [
      dailies
    ];
  };

  darkearth-nvim = super.darkearth-nvim.overrideAttrs {
    dependencies = [ self.lush-nvim ];
  };

  ddc-filter-matcher_head = super.ddc-filter-matcher_head.overrideAttrs {
    dependencies = [ self.ddc-vim ];
  };

  ddc-filter-sorter_rank = super.ddc-filter-sorter_rank.overrideAttrs {
    dependencies = [ self.ddc-vim ];
  };

  ddc-fuzzy = super.ddc-fuzzy.overrideAttrs (old: {
    dependencies = [ self.ddc-vim ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  ddc-source-around = super.ddc-source-around.overrideAttrs {
    dependencies = [ self.ddc-vim ];
  };

  ddc-source-file = super.ddc-source-file.overrideAttrs {
    dependencies = [ self.ddc-vim ];
  };

  ddc-source-lsp = super.ddc-source-lsp.overrideAttrs (old: {
    dependencies = [ self.ddc-vim ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  ddc-ui-native = super.ddc-ui-native.overrideAttrs {
    dependencies = [ self.ddc-vim ];
  };

  ddc-ui-pum = super.ddc-ui-pum.overrideAttrs {
    dependencies = with self; [
      ddc-vim
      pum-vim
    ];
  };

  ddc-vim = super.ddc-vim.overrideAttrs {
    dependencies = [ self.denops-vim ];
  };

  debugmaster-nvim = super.debugmaster-nvim.overrideAttrs {
    dependencies = [ self.nvim-dap ];
  };

  defx-nvim = super.defx-nvim.overrideAttrs {
    dependencies = [ self.nvim-yarp ];
  };

  demicolon-nvim = super.demicolon-nvim.overrideAttrs (old: {
    dependencies = with self; [
      nvim-treesitter
      nvim-treesitter-textobjects
    ];
    meta = old.meta // {
      description = "Overloaded ; and , keys in Neovim";
      license = lib.licenses.mit;
      maintainers = with lib.maintainers; [ m3l6h ];
    };
  });

  denite-nvim = super.denite-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  denops-vim = super.denops-vim.overrideAttrs {
    postPatch = ''
      # Use Nix's Deno instead of an arbitrary install
      substituteInPlace ./autoload/denops.vim --replace-fail "call denops#_internal#conf#define('denops#deno', 'deno')" "call denops#_internal#conf#define('denops#deno', '${deno}/bin/deno')"
    '';
  };

  deoplete-fish = super.deoplete-fish.overrideAttrs {
    dependencies = with self; [
      deoplete-nvim
      vim-fish
    ];
  };

  deoplete-go = super.deoplete-go.overrideAttrs {
    nativeBuildInputs = [ (python3.withPackages (ps: with ps; [ setuptools ])) ];
    buildPhase = ''
      pushd ./rplugin/python3/deoplete/ujson
      python3 setup.py build --build-base=$PWD/build --build-lib=$PWD/build
      popd
      find ./rplugin/ -name "ujson*.so" -exec mv -v {} ./rplugin/python3/ \;
    '';
  };

  deoplete-julia = super.deoplete-julia.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  deoplete-khard = super.deoplete-khard.overrideAttrs (old: {
    dependencies = [ self.deoplete-nvim ];
    passthru = old.passthru // {
      python3Dependencies = ps: [ (ps.toPythonModule khard) ];
    };
    meta = old.meta // {
      description = "Address-completion for khard via deoplete";
      homepage = "https://github.com/nicoe/deoplete-khard";
      license = lib.licenses.mit;
      maintainers = with lib.maintainers; [ jorsn ];
    };
  });

  deoplete-lsp = super.deoplete-lsp.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  deoplete-nvim = super.deoplete-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  deoplete-zsh = super.deoplete-zsh.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  devdocs-nvim = super.devdocs-nvim.overrideAttrs {
    nvimSkipModules = [
      # Error initializing Devdocs state
      "devdocs.state"
    ];
    runtimeDeps = [
      curl
      jq
      pandoc
    ];
  };

  devdocs-vim = super.devdocs-vim.overrideAttrs (old: {
    meta = old.meta // {
      # README contains the MIT license text.
      license = lib.licenses.mit;
    };
  });

  diagram-nvim = super.diagram-nvim.overrideAttrs {
    dependencies = [ self.image-nvim ];
  };

  diffview-nvim = super.diffview-nvim.overrideAttrs (old: {
    dependencies = [ self.plenary-nvim ];

    doInstallCheck = true;
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
    };
  });

  diffview-plus-nvim = super.diffview-plus-nvim.overrideAttrs (old: {
    dependencies = [ self.plenary-nvim ];
    doInstallCheck = true;
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
      description = "Cycle through diffs for all modified files for any git rev (dlyongemallo's active fork)";
    };
  });

  direnv-vim = super.direnv-vim.overrideAttrs (old: {
    preFixup = old.preFixup or "" + ''
      substituteInPlace $out/autoload/direnv.vim \
        --replace-fail "let s:direnv_cmd = get(g:, 'direnv_cmd', 'direnv')" \
          "let s:direnv_cmd = get(g:, 'direnv_cmd', '${lib.getBin direnv}/bin/direnv')"
    '';
  });

  dotnet-nvim = super.dotnet-nvim.overrideAttrs {
    dependencies = with self; [
      telescope-nvim
      plenary-nvim
    ];
  };

  dropbar-nvim = super.dropbar-nvim.overrideAttrs {
    # Requires global config table
    nvimSkipModules = [ "dropbar.menu" ];
  };

  easy-dotnet-nvim = super.easy-dotnet-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
    ];
    checkInputs = with self; [
      # Pickers, can use telescope, fzf-lua, or snacks
      fzf-lua
      telescope-nvim
      neotest
    ];
  };

  echodoc-vim = super.echodoc-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  ecolog-nvim = super.ecolog-nvim.overrideAttrs {
    nvimSkipModules = [
      "repro"
    ];
  };

  editorconfig-vim = super.editorconfig-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd2;
    };
  });

  efmls-configs-nvim = super.efmls-configs-nvim.overrideAttrs {
    dependencies = [ self.nvim-lspconfig ];
  };

  eldritch-nvim = super.eldritch-nvim.overrideAttrs (old: {
    meta = old.meta // {
      description = "A theme for the Ancient Ones! (NVIM)";
      maintainers = with lib.maintainers; [ neonvoid ];
    };
  });

  elixir-tools-nvim = super.elixir-tools-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
    fixupPhase = ''
      patchShebangs $(find $out/bin/ -type f -not -name credo-language-server)
    '';
  };

  evergarden-nvim = super.evergarden-nvim.overrideAttrs (old: {
    # optional modules
    nvimSkipModules = [
      "evergarden.extras"
      "minidoc"
    ];
    meta = old.meta // {
      # EUPL-1.2 project with bundled Catppuccin MIT files.
      license = with lib.licenses; [
        eupl12
        mit
      ];
    };
  });

  executor-nvim = super.executor-nvim.overrideAttrs {
    dependencies = [ self.nui-nvim ];
  };

  faster-nvim = super.faster-nvim.overrideAttrs {
    nvimSkipModules = [
      # attempt to index global 'FasterConfig' (a nil value)
      "faster.commands"
    ];
  };

  fastfold = super.fastfold.overrideAttrs (old: {
    meta = old.meta // {
      # This plugin is under the license "Rien à Branler", which is a French translation of the WTFPL license.
      license = lib.licenses.wtfpl;
    };
  });

  faust-nvim = super.faust-nvim.overrideAttrs {
    dependencies = with self; [
      luasnip
      nvim-fzf
    ];
    nvimSkipModules = [
      # E5108: Error executing lua vim/_init_packages.lua:0: ...in-faust-nvim-2022-06-01/lua/faust-nvim/autosnippets.lua:3: '=' expected near 'wd'
      "faust-nvim.autosnippets"
    ];
  };

  fcitx-vim = super.fcitx-vim.overrideAttrs (old: {
    passthru = old.passthru // {
      python3Dependencies = ps: with ps; [ dbus-python ];
    };
    meta = old.meta // {
      description = "Keep and restore fcitx state when leaving/re-entering insert mode or search mode";
      license = lib.licenses.mit;
    };
  });

  file-line = super.file-line.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  flash-nvim = super.flash-nvim.overrideAttrs {
    # Docs require lazyvim
    # dependencies = with self; [ lazy-nvim ];
    nvimSkipModules = [ "flash.docs" ];
  };

  flit-nvim = super.flit-nvim.overrideAttrs {
    dependencies = [ self.leap-nvim ];
  };

  floaterm = super.floaterm.overrideAttrs {
    dependencies = [ self.nvzone-volt ];
  };

  flow-nvim = super.flow-nvim.overrideAttrs {
    nvimSkipModules = [
      # Optional barbecue integration requires flow.setup() first.
      "barbecue.theme.flow"
    ];
  };

  flutter-tools-nvim = super.flutter-tools-nvim.overrideAttrs {
    # Optional dap integration
    checkInputs = [ self.nvim-dap ];
    dependencies = [ self.plenary-nvim ];
  };

  forms = super.forms.overrideAttrs {
    dependencies = [ self.self ];
  };

  freeze-nvim = super.freeze-nvim.overrideAttrs {
    runtimeDeps = [ charm-freeze ];
  };

  fugit2-nvim = super.fugit2-nvim.overrideAttrs {
    # Requires web-devicons but mini.icons can mock them up
    checkInputs = [
      self.nvim-web-devicons
    ];
    dependencies = with self; [
      nui-nvim
      plenary-nvim
    ];
    # Patch libgit2 library dependency
    # Patch gpgme path
    postPatch = ''
      substituteInPlace lua/fugit2/core/libgit2.lua \
        --replace-fail \
        'M.library_path = "libgit2"' \
        'M.library_path = "${lib.getLib libgit2}/lib/libgit2${stdenv.hostPlatform.extensions.sharedLibrary}"'

      substituteInPlace lua/fugit2/core/gpgme.lua \
        --replace-fail \
        'local gpgme_library_path = "gpgme"' \
        'local gpgme_library_path = "${lib.getLib gpgme}/lib/libgpgme${stdenv.hostPlatform.extensions.sharedLibrary}"'

      # Upstream typo: pendulum was moved to fugit2.util but this require was not updated
      substituteInPlace lua/fugit2/view/git_blame_file.lua \
        --replace-fail \
        'require "fugit2.core.pendulum"' \
        'require "fugit2.util.pendulum"'
    '';
  };

  fuzzy-nvim = super.fuzzy-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional sorters
      telescope-zf-native-nvim
    ];
    dependencies = [ self.telescope-fzf-native-nvim ];
    nvimSkipModules = [
      # TODO: package fzy-lua-native
      "fuzzy_nvim.fzy_matcher"
    ];
  };

  fyler-nvim = super.fyler-nvim.overrideAttrs {
    nvimSkipModules = [
      # Requires setup
      "fyler.extensions.trash"
      "fyler.finder"
      "fyler.integrations.icon"
      "fyler.integrations.window_picker"
      "fyler.schemes.file"
      "fyler.state"
    ];
  };

  fzf-checkout-vim = super.fzf-checkout-vim.overrideAttrs {
    # The plugin has a makefile which tries to run tests in a docker container.
    # This prevents it.
    prePatch = ''
      rm Makefile
    '';
  };

  fzf-hoogle-vim = super.fzf-hoogle-vim.overrideAttrs (old: {
    # add this to your lua config to prevent the plugin from trying to write in the
    # nix store:
    # vim.g.hoogle_fzf_cache_file = vim.fn.stdpath('cache')..'/hoogle_cache.json'
    propagatedBuildInputs = [
      jq
      gawk
    ];
    dependencies = [ self.fzf-vim ];
    passthru = old.passthru // {
      initLua = "vim.g.hoogle_fzf_cache_file = vim.fn.stdpath('cache')..'/hoogle_cache.json";
    };
  });

  fzf-lsp-nvim = super.fzf-lsp-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  fzf-lua = super.fzf-lua.overrideAttrs {
    runtimeDeps = [ fzf ];
    nvimSkipModules = [
      "fzf-lua.spawn"
      "fzf-lua.rpc"
      "fzf-lua.types"
    ];
  };

  fzf-vim = super.fzf-vim.overrideAttrs {
    dependencies = [ self.fzf-wrapper ];
  };

  gen-nvim = super.gen-nvim.overrideAttrs {
    runtimeDeps = [ curl ];
  };

  gentoo-syntax = super.gentoo-syntax.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  gh-nvim = super.gh-nvim.overrideAttrs {
    dependencies = [ self.litee-nvim ];
  };

  ghcid = super.ghcid.overrideAttrs (old: {
    configurePhase = "cd plugins/nvim";
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  ghcmod-vim = super.ghcmod-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  git-conflict-nvim = super.git-conflict-nvim.overrideAttrs {
    # TODO: Remove after next fixed version
    # https://github.com/akinsho/git-conflict.nvim/issues/103
    version = "2.1.0";
    src = fetchFromGitHub {
      owner = "akinsho";
      repo = "git-conflict.nvim";
      tag = "v2.1.0";
      hash = "sha256-1t0kKxTGLuOvuRkoLgkoqMZpF+oKo8+gMsTdgPsSb+8=";
    };
  };

  git-worktree-nvim = super.git-worktree-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  gitlab-vim = super.gitlab-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  gitlinker-nvim = super.gitlinker-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  gitv = super.gitv.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  go-nvim = super.go-nvim.overrideAttrs {
    dependencies = with self; [
      nvim-treesitter
      guihua-lua
    ];
    checkInputs = with self; [
      luasnip
      none-ls-nvim
      plenary-nvim
    ];
    nvimSkipModules = [
      "init"
      # _GO_NVIM_CFG
      "go.ai.init"
      "go.comment"
      "go.format"
      "go.gotests"
      "go.project"
    ];
  };

  GPTModels-nvim = super.GPTModels-nvim.overrideAttrs {
    dependencies = with self; [
      nui-nvim
      telescope-nvim
    ];
  };

  gruvbox = super.gruvbox.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  guard-collection = super.guard-collection.overrideAttrs {
    dependencies = [ self.guard-nvim ];
  };

  guihua-lua = super.guihua-lua.overrideAttrs {
    dependencies = [ self.nvim-treesitter ];

    buildPhase = ''
      runHook preBuild

      pushd lua/fzy
      make
      popd

      runHook postBuild
    '';

    nvimSkipModules = [
      # lua module '.init' not found
      "fzy.fzy-lua-native"
      # Requires removed Neovim internal module vim.treesitter._highlight
      "guihua.ts_obsolete.highlight"
    ];
  };

  gundo-vim = super.gundo-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl2Plus;
    };
  });

  gv-vim = super.gv-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  gx-nvim = super.gx-nvim.overrideAttrs {
    runtimeDeps = [
      xdg-utils
    ];

    nvimRequireCheck = "gx";
  };

  hardhat-nvim = super.hardhat-nvim.overrideAttrs (old: {
    checkInputs = with self; [
      # optional integrations
      neotest
      telescope-nvim
      overseer-nvim
    ];

    dependencies = with self; [
      plenary-nvim
    ];

    nvimSkipModules = [
      # Cannot find hardhat.extmarks
      "overseer.component.hardhat.refresh_gas_extmarks"
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  hare-vim = super.hare-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  harpoon = super.harpoon.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  harpoon-lualine = super.harpoon-lualine.overrideAttrs {
    dependencies = [
      self.lualine-nvim
      self.harpoon2
    ];
  };

  harpoon2 = super.harpoon2.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  haskell-scope-highlighting-nvim = super.haskell-scope-highlighting-nvim.overrideAttrs {
    dependencies = [ self.nvim-treesitter-parsers.haskell ];
  };

  haskell-snippets-nvim = super.haskell-snippets-nvim.overrideAttrs {
    dependencies = [ self.luasnip ];
  };

  haskell-tools-nvim = super.haskell-tools-nvim.overrideAttrs {
    # Optional integrations
    checkInputs = [ self.telescope-nvim ];
  };

  heirline-components-nvim = super.heirline-components-nvim.overrideAttrs {
    nvimRequireCheck = "heirline-components.all";
  };

  helm-ls-nvim = super.helm-ls-nvim.overrideAttrs {
    runtimeDeps = [
      helm-ls
    ];
  };

  hex-nvim = super.hex-nvim.overrideAttrs {
    runtimeDeps = [ xxd ];
  };

  himalaya-vim = super.himalaya-vim.overrideAttrs {
    buildInputs = [ himalaya ];
    # Optional integrations
    checkInputs = with self; [
      fzf-lua
      telescope-nvim
    ];
    nvimSkipModules = [
      # Address in use error from fzf-lua on darwin
      # https://github.com/NixOS/nixpkgs/issues/431458
      "himalaya.folder.pickers.fzflua"
    ];
  };

  hoon-vim = super.hoon-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  hop-nvim = super.hop-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  hotpot-nvim = super.hotpot-nvim.overrideAttrs {
    # NOTE: Vim:E919: Directory not found in 'packpath': "pack/*/opt/hotpot-fennel-update"
    doCheck = false;
  };

  html5-vim = super.html5-vim.overrideAttrs (old: {
    meta = old.meta // {
      # README contains the MIT license text.
      license = lib.licenses.mit;
    };
  });

  hunk-nvim = super.hunk-nvim.overrideAttrs {
    dependencies = [ self.nui-nvim ];
  };

  hurl-nvim = super.hurl-nvim.overrideAttrs {
    dependencies = with self; [
      nui-nvim
      nvim-treesitter-parsers.hurl
      plenary-nvim
    ];

    runtimeDeps = [
      hurl
    ];

    nvimSkipModules = [
      # attempt to index global '_HURL_GLOBAL_CONFIG' (a nil value)
      "hurl.popup"
      "hurl.split"
    ];
  };

  idris2-nvim = super.idris2-nvim.overrideAttrs {
    dependencies = with self; [
      nui-nvim
      nvim-lspconfig
    ];

    doInstallCheck = true;
  };

  Improved-AnsiEsc = super.Improved-AnsiEsc.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  incsearch-easymotion-vim = super.incsearch-easymotion-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  indent-blankline-nvim = super.indent-blankline-nvim.overrideAttrs {
    # Meta file
    nvimSkipModules = [ "ibl.config.types" ];
  };

  indent-tools-nvim = super.indent-tools-nvim.overrideAttrs {
    checkInputs = [
      # nvim-treesitter-textobjects dep
      self.nvim-treesitter
    ];
    dependencies = with self; [
      arshlib-nvim
      # Optional dep for repeatable jumps
      nvim-treesitter-textobjects
    ];
  };

  instant-nvim = super.instant-nvim.overrideAttrs {
    nvimSkipModules = [
      # Requires global variable config
      "instant"
      # instant/log.lua:12: cannot use '...' outside a vararg function near '...'
      "instant.log"
    ];
  };

  intellitab-nvim = super.intellitab-nvim.overrideAttrs {
    dependencies = [ self.nvim-treesitter ];
  };

  intero-neovim = super.intero-neovim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  iosvkem = super.iosvkem.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  iswap-nvim = super.iswap-nvim.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  jdaddy-vim = super.jdaddy-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  jdd-nvim = super.jdd-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  jedi-vim = super.jedi-vim.overrideAttrs (old: {
    # checking for python3 support in vim would be neat, too, but nobody else seems to care
    buildInputs = [ python3.pkgs.jedi ];
    meta = old.meta // {
      description = "code-completion for python using python-jedi";
      license = lib.licenses.mit;
    };
  });

  jellybeans-nvim = super.jellybeans-nvim.overrideAttrs {
    dependencies = [ self.lush-nvim ];
  };

  jellybeans-vim = super.jellybeans-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  jinja-vim = super.jinja-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  jj-nvim = super.jj-nvim.overrideAttrs {
    # Don't install 30 MB of GIFs
    postPatch = ''
      rm -rf assets/
    '';
  };

  jq-vim = super.jq-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  jsonfly-nvim = super.jsonfly-nvim.overrideAttrs (old: {
    meta = old.meta // {
      # Top-level GPL-3.0 plus bundled luaunit BSD-2-Clause.
      license = with lib.licenses; [
        gpl3Only
        bsd2
      ];
      maintainers = old.meta.maintainers or [ ] ++ [
        lib.maintainers.myzel394
      ];
    };
  });

  julia-vim = super.julia-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  jupytext-nvim = super.jupytext-nvim.overrideAttrs (old: {
    passthru = old.passthru // {
      python3Dependencies = ps: [ ps.jupytext ];
    };
  });

  just-nvim = super.just-nvim.overrideAttrs {
    checkInputs = with self; [
      fidget-nvim
      nvim-notify
      telescope-nvim
    ];
    dependencies = with self; [
      plenary-nvim
    ];
  };

  kulala-nvim = super.kulala-nvim.overrideAttrs (
    old:
    let
      kulala-http-grammar = neovimUtils.grammarToPlugin (
        tree-sitter.buildGrammar {
          language = "kulala_http";
          inherit (luaPackages.tree-sitter-kulala_http) version src meta;
          generate = false;
        }
      );
    in
    {
      dependencies = [ kulala-http-grammar ];

      postPatch = ''
        substituteInPlace lua/kulala/config/defaults.lua \
          --replace-fail 'path = nil' 'path = "${lib.getExe kulala-core}"'
      '';

      nvimSkipModules = [
        # Requires some extra work to get CLI working in nixpkgs
        "cli.kulala_cli"
        # Upstream test harnesses are not require-safe modules
        "minit"
        "minit-userscript"
        "minitest"
        "test"
        # Legacy parser module; active parsing is handled by kulala-core
        "kulala.parser.treesitter"
      ];
    }
  );

  LanguageTool-nvim = super.LanguageTool-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  last256 = super.last256.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  lazy-lsp-nvim = super.lazy-lsp-nvim.overrideAttrs {
    dependencies = [ self.nvim-lspconfig ];
  };

  lazy-nvim = super.lazy-nvim.overrideAttrs {
    patches = [ ./patches/lazy-nvim/no-helptags.patch ];
    nvimSkipModules = [
      # Requires headless config option
      "lazy.manage.task.init"
      "lazy.manage.checker"
      "lazy.manage.init"
      "lazy.manage.runner"
      "lazy.view.commands"
      "lazy.build"
    ];
  };

  lazydocker-nvim = super.lazydocker-nvim.overrideAttrs {
    runtimeDeps = [
      lazydocker
    ];
  };

  lazyjj-nvim = super.lazyjj-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
    runtimeDeps = [
      lazyjj
    ];
  };

  LazyVim = super.LazyVim.overrideAttrs {
    # Any other dependency is optional
    dependencies = [ self.lazy-nvim ];
    nvimSkipModules = [
      # attempt to index global 'LazyVim' (a nil value)
      "lazyvim.config.keymaps"
      "lazyvim.plugins.extras.ai.copilot-native"
      "lazyvim.plugins.extras.ai.sidekick"
      "lazyvim.plugins.extras.ai.tabnine"
      "lazyvim.plugins.extras.coding.luasnip"
      "lazyvim.plugins.extras.coding.neogen"
      "lazyvim.plugins.extras.editor.fzf"
      "lazyvim.plugins.extras.editor.refactoring"
      "lazyvim.plugins.extras.editor.snacks_picker"
      "lazyvim.plugins.extras.editor.telescope"
      "lazyvim.plugins.extras.formatting.prettier"
      "lazyvim.plugins.extras.lang.dotnet"
      "lazyvim.plugins.extras.lang.markdown"
      "lazyvim.plugins.extras.lang.typescript.init"
      "lazyvim.plugins.extras.lang.typescript.vtsls"
      "lazyvim.plugins.init"
      "lazyvim.plugins.ui"
      "lazyvim.plugins.xtras"
    ];
  };

  LeaderF = super.LeaderF.overrideAttrs {
    nativeBuildInputs = [ python3.pkgs.setuptools ];
    buildInputs = [ python3 ];
    # rm */build/ to prevent dependencies on gcc
    # strip the *.so to keep files small
    buildPhase = ''
      patchShebangs .
      ./install.sh
      rm autoload/leaderf/fuzzyMatch_C/build/ -r
    '';
    stripDebugList = [ "autoload/leaderf/python" ];
  };

  lean-nvim = super.lean-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
    ];
  };

  leap-ast-nvim = super.leap-ast-nvim.overrideAttrs {
    dependencies = with self; [
      leap-nvim
      nvim-treesitter-legacy
    ];
  };

  leap-nvim = super.leap-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  leetcode-nvim = super.leetcode-nvim.overrideAttrs {
    checkInputs = with self; [
      snacks-nvim
      telescope-nvim
      mini-nvim
    ];
    dependencies = with self; [
      nui-nvim
      plenary-nvim
    ];

    doInstallCheck = true;
    nvimSkipModules = [
      # Requires setup call
      "leetcode.api.auth"
      "leetcode.api.headers"
      "leetcode.api.interpreter"
      "leetcode.api.problems"
      "leetcode.api.question"
      "leetcode.api.statistics"
      "leetcode.api.utils"
      "leetcode.cache.cookie"
      "leetcode.cache.init"
      "leetcode.cache.problemlist"
      "leetcode.picker.language.fzf"
      "leetcode.picker.question.fzf"
      "leetcode.picker.question.init"
      "leetcode.picker.question.snacks"
      "leetcode.picker.question.telescope"
      "leetcode.picker.question.mini"
      "leetcode.picker.tabs.fzf"
      "leetcode.runner.init"
      "leetcode-plugins.cn.api"
      "leetcode-ui.group.page.stats"
      "leetcode-ui.group.similar-questions"
      "leetcode-ui.layout.console"
      "leetcode-ui.lines.calendar"
      "leetcode-ui.lines.solved"
      "leetcode-ui.popup.console.result"
      "leetcode-ui.popup.info"
      "leetcode-ui.popup.languages"
      "leetcode-ui.popup.skills"
      "leetcode-ui.question"
      "leetcode-ui.renderer.menu"
      "leetcode-ui.renderer.result"
    ];
  };

  legendary-nvim = super.legendary-nvim.overrideAttrs {
    dependencies = [ self.sqlite-lua ];
    nvimSkipModules = [
      "vimdoc-gen"
      "vimdocrc"
    ];
  };

  lens-vim = super.lens-vim.overrideAttrs (old: {
    # remove duplicate g:lens#animate in doc/lens.txt
    # https://github.com/NixOS/nixpkgs/pull/105810#issuecomment-740007985
    # https://github.com/camspiers/lens.vim/pull/40/files
    patches = [
      ./patches/lens-vim/remove_duplicate_g_lens_animate.patch
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  lessspace-vim = super.lessspace-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  lexima-vim = super.lexima-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  lf-nvim = super.lf-nvim.overrideAttrs {
    dependencies = [ self.toggleterm-nvim ];
  };

  lf-vim = super.lf-vim.overrideAttrs (old: {
    dependencies = [ self.vim-floaterm ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  lh-brackets = super.lh-brackets.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  lh-vim-lib = super.lh-vim-lib.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  lightline-bufferline = super.lightline-bufferline.overrideAttrs {
    # Requires web-devicons but mini.icons can mock them up
    checkInputs = [ self.nvim-web-devicons ];
  };

  lightline-lsp = super.lightline-lsp.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.isc;
    };
  });

  lightswitch-nvim = super.lightswitch-nvim.overrideAttrs {
    dependencies = [ self.nui-nvim ];
  };

  lingua-franca-vim = super.lingua-franca-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd2;
    };
  });

  lir-nvim = super.lir-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  lispdocs-nvim = super.lispdocs-nvim.overrideAttrs {
    dependencies = with self; [
      conjure
      sqlite-lua
      telescope-nvim
      plenary-nvim
    ];
  };

  litee-calltree-nvim = super.litee-calltree-nvim.overrideAttrs (old: {
    dependencies = [ self.litee-nvim ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  litee-filetree-nvim = super.litee-filetree-nvim.overrideAttrs (old: {
    dependencies = [ self.litee-nvim ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  litee-nvim = super.litee-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  litee-symboltree-nvim = super.litee-symboltree-nvim.overrideAttrs (old: {
    dependencies = [ self.litee-nvim ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  live-preview-nvim = super.live-preview-nvim.overrideAttrs (old: {
    checkInputs = with self; [
      fzf-lua
      mini-pick
      snacks-nvim
      telescope-nvim
    ];

    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  live-share-nvim = super.live-share-nvim.overrideAttrs {
    # Loading the system libcrypto aborts the process on darwin,
    # point the FFI loader at the nixpkgs openssl instead
    postPatch = ''
      substituteInPlace lua/live-share/collab/crypto.lua \
        --replace-fail \
        '"crypto",' \
        '"${lib.getLib openssl}/lib/libcrypto${stdenv.hostPlatform.extensions.sharedLibrary}",'
    '';
  };

  lsp-format-modifications-nvim = super.lsp-format-modifications-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  lsp-format-nvim = super.lsp-format-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  lsp-rooter-nvim = super.lsp-rooter-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.wtfpl;
    };
  });

  lsp_extensions-nvim = super.lsp_extensions-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  lsp_lines-nvim = super.lsp_lines-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.isc;
    };
  });

  lspcontainers-nvim = super.lspcontainers-nvim.overrideAttrs {
    dependencies = [ self.nvim-lspconfig ];
  };

  lspecho-nvim = super.lspecho-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  lspsaga-nvim = super.lspsaga-nvim.overrideAttrs {
    # Other modules require setup call first
    nvimRequireCheck = "lspsaga";
  };

  ltex_extra-nvim = super.ltex_extra-nvim.overrideAttrs {
    # Other modules require setup call first
    nvimRequireCheck = "ltex_extra";
  };

  lualine-lsp-progress = super.lualine-lsp-progress.overrideAttrs {
    dependencies = [ self.lualine-nvim ];
  };

  luasnip-latex-snippets-nvim = super.luasnip-latex-snippets-nvim.overrideAttrs {
    dependencies = [ self.luasnip ];
    # E5108: /luasnip-latex-snippets/luasnippets/tex/utils/init.lua:3: module 'luasnip-latex-snippets.luasnippets.utils.conditions' not found:
    # Need to fix upstream
    nvimSkipModules = [
      "luasnip-latex-snippets.luasnippets.tex.utils.init"
    ];
  };

  LuaSnip-snippets-nvim = super.LuaSnip-snippets-nvim.overrideAttrs {
    checkInputs = [ self.luasnip ];
  };

  luau-lsp-nvim = super.luau-lsp-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
    runtimeDeps = [ luau-lsp ];
  };

  magma-nvim = super.magma-nvim.overrideAttrs (old: {
    passthru = old.passthru // {
      python3Dependencies =
        ps: with ps; [
          pynvim
          jupyter-client
          ueberzug
          pillow
          cairosvg
          plotly
          ipykernel
          pyperclip
          pnglatex
        ];
    };
  });

  maple-nvim = super.maple-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  mark-radar-nvim = super.mark-radar-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  markdoc-nvim = super.markdoc-nvim.overrideAttrs {
    dependencies = with self; [
      nvim-treesitter-parsers.markdown
      nvim-treesitter-parsers.markdown_inline
      nvim-treesitter-parsers.html
    ];
  };

  markdown-preview-nvim =
    let
      # We only need its dependencies `node-modules`.
      nodeDep = stdenv.mkDerivation {
        inherit (super.markdown-preview-nvim) pname version src;
        nativeBuildInputs = [
          yarnConfigHook
        ];
        yarnOfflineCache = fetchYarnDeps {
          yarnLock = "${super.markdown-preview-nvim.src}/yarn.lock";
          hash = "sha256-kzc9jm6d9PJ07yiWfIOwqxOTAAydTpaLXVK6sEWM8gg=";
        };
        installPhase = ''
          cp -r node_modules $out
        '';
      };
    in
    super.markdown-preview-nvim.overrideAttrs {
      runtimeDeps = [
        nodejs
      ];
      postInstall = ''
        cp -r ${nodeDep} $out/app/node_modules
      '';

      nativeBuildInputs = [ nodejs ];
      doInstallCheck = true;
      installCheckPhase = ''
        node $out/app/index.js --version
      '';
    };

  markid = super.markid.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  mason-lspconfig-nvim = super.mason-lspconfig-nvim.overrideAttrs {
    dependencies = with self; [
      mason-nvim
      nvim-lspconfig
    ];
  };

  mason-null-ls-nvim = super.mason-null-ls-nvim.overrideAttrs {
    dependencies = with self; [
      mason-nvim
      none-ls-nvim
      plenary-nvim
    ];
  };

  mason-nvim = super.mason-nvim.overrideAttrs {
    nvimSkipModules = [
      # lua/mason-vendor/zzlib/inflate-bwo.lua:15: 'end' expected near '&'
      "mason-vendor.zzlib.inflate-bwo"
      # E5108: Error executing lua ...mplugin-mason.nvim-2025-05-06/lua/mason-test/helpers.lua:7: module 'luassert.spy' not found:
      "mason-test.helpers"
    ];
  };

  mason-nvim-dap-nvim = super.mason-nvim-dap-nvim.overrideAttrs {
    dependencies = with self; [
      mason-nvim
      nvim-dap
    ];
  };

  mason-tool-installer-nvim = super.mason-tool-installer-nvim.overrideAttrs {
    dependencies = [ self.mason-nvim ];
  };

  material-vim = super.material-vim.overrideAttrs {
    # Optional integration
    checkInputs = [ self.lualine-nvim ];
  };

  mattn-calendar-vim = super.mattn-calendar-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  mcphub-nvim = super.mcphub-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
    checkInputs = [
      # Required by mcphub.extensions.luali
      self.lualine-nvim
    ];

    nvimSkipModules = [
      # ENOENT: no such file or directory (cmd): 'npm'
      "bundled_build"
    ];
  };

  mediawiki-vim = super.mediawiki-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  mini-nvim = super.mini-nvim.overrideAttrs {
    # reduce closure size
    postInstall = ''
      rm -rf $out/{Makefile,benchmarks,readmes,tests,scripts}
    '';
  };

  minimap-vim = super.minimap-vim.overrideAttrs {
    preFixup = ''
      substituteInPlace $out/plugin/minimap.vim \
        --replace-fail "code-minimap" "${code-minimap}/bin/code-minimap"
      substituteInPlace $out/bin/minimap_generator.sh \
        --replace-fail "code-minimap" "${code-minimap}/bin/code-minimap"
    '';

    doInstallCheck = true;
    vimCommandCheck = "MinimapToggle";
  };

  minuet-ai-nvim = super.minuet-ai-nvim.overrideAttrs {
    checkInputs = [
      # optional cmp integration
      self.nvim-cmp
      self.lualine-nvim
    ];
    dependencies = with self; [ plenary-nvim ];
    nvimSkipModules = [
      # Backends require configuration
      "minuet.backends.claude"
      "minuet.backends.codestral"
      "minuet.backends.gemini"
      "minuet.backends.openai"
      "minuet.backends.openai_compatible"
      "minuet.backends.openai_fim_compatible"
    ];
  };

  mkdnflow-nvim = super.mkdnflow-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
    # Requires setup call and has optional nvim-cmp dependency
    nvimRequireCheck = "mkdnflow";
  };

  modicator-nvim = super.modicator-nvim.overrideAttrs {
    # Optional lualine integration
    nvimSkipModules = [ "modicator.integration.lualine.init" ];
  };

  molokai = super.molokai.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  molten-nvim = super.molten-nvim.overrideAttrs {
    # Optional image providers
    checkInputs = with self; [
      image-nvim
      snacks-nvim
      wezterm-nvim
    ];
  };

  moonscript-vim = super.moonscript-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.wtfpl;
    };
  });

  mru = super.mru.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  multicursors-nvim = super.multicursors-nvim.overrideAttrs {
    dependencies = with self; [
      hydra-nvim
    ];
  };

  muren-nvim = super.muren-nvim.overrideAttrs (old: {
    dependencies = [ self.plenary-nvim ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  ncm2 = super.ncm2.overrideAttrs {
    dependencies = [ self.nvim-yarp ];
  };

  ncm2-dictionary = super.ncm2-dictionary.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  ncm2-jedi = super.ncm2-jedi.overrideAttrs (old: {
    dependencies = with self; [
      nvim-yarp
      ncm2
    ];
    passthru = old.passthru // {
      python3Dependencies = ps: with ps; [ jedi ];
    };
  });

  ncm2-neoinclude = super.ncm2-neoinclude.overrideAttrs {
    dependencies = [ self.neoinclude-vim ];
  };

  ncm2-neosnippet = super.ncm2-neosnippet.overrideAttrs {
    dependencies = [ self.neosnippet-vim ];
  };

  ncm2-syntax = super.ncm2-syntax.overrideAttrs {
    dependencies = [ self.neco-syntax ];
  };

  ncm2-ultisnips = super.ncm2-ultisnips.overrideAttrs (old: {
    dependencies = [ self.ultisnips ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neco-ghc = super.neco-ghc.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  neco-look = super.neco-look.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
    };
  });

  neco-syntax = super.neco-syntax.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neo-tree-nvim = super.neo-tree-nvim.overrideAttrs {
    checkInputs = [ git ];
    dependencies = with self; [
      plenary-nvim
      nui-nvim
    ];
    nvimSkipModules = [
      "neo-tree.types.fixes.compat-0.10"
    ];
  };

  neocomplete-vim = super.neocomplete-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neoconf-nvim = super.neoconf-nvim.overrideAttrs {
    dependencies = [ self.nvim-lspconfig ];

    doInstallCheck = true;
  };

  neogit = super.neogit.overrideAttrs {
    # Optional diffview integration
    checkInputs = [ self.diffview-nvim ];
    dependencies = [ self.plenary-nvim ];
    nvimSkipModules = [
      # E5108: Error executing lua ...vim-2024-06-13/lua/diffview/api/views/diff/diff_view.lua:13: attempt to index global 'DiffviewGlobal' (a nil value)
      # Requires diffview-nvim's plugin script to be sourced.
      "neogit.integrations.diffview"
    ];
  };

  neoinclude-vim = super.neoinclude-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neomru-vim = super.neomru-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neorepl-nvim = super.neorepl-nvim.overrideAttrs {
    nvimSkipModules = [
      # Requires main module loaded first
      "neorepl.bufs"
      "neorepl.map"
      "neorepl.repl"
    ];
  };

  neorg = super.neorg.overrideAttrs {
    dependencies = [
      (neovimUtils.grammarToPlugin tree-sitter-grammars.tree-sitter-norg)
      (neovimUtils.grammarToPlugin tree-sitter-grammars.tree-sitter-norg-meta)
    ];
  };

  neorg-telescope = super.neorg-telescope.overrideAttrs {
    buildInputs = [ luaPackages.lua-utils-nvim ];
    dependencies = with self; [
      neorg
      plenary-nvim
      telescope-nvim
    ];
  };

  neosnippet-snippets = super.neosnippet-snippets.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neosnippet-vim = super.neosnippet-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neoterm = super.neoterm.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.asl20;
    };
  });

  neotest-bash = super.neotest-bash.overrideAttrs {
    dependencies = with self; [
      neotest
      plenary-nvim
    ];
  };

  neotest-bun = super.neotest-bun.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
    ];
  };

  neotest-ctest = super.neotest-ctest.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-dart = super.neotest-dart.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-deno = super.neotest-deno.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-dotnet = super.neotest-dotnet.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-elixir = super.neotest-elixir.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-foundry = super.neotest-foundry.overrideAttrs (old: {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
    meta = old.meta // {
      license = with lib.licenses; [
        asl20
        mit
      ];
    };
  });

  neotest-go = super.neotest-go.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-golang = super.neotest-golang.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      nvim-dap-go
      nvim-treesitter
      plenary-nvim
    ];
  };

  neotest-gradle = super.neotest-gradle.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-gtest = super.neotest-gtest.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
      nvim-treesitter-parsers.cpp
    ];
  };

  neotest-haskell = super.neotest-haskell.overrideAttrs {
    dependencies = with self; [
      neotest
      plenary-nvim
    ];
  };

  neotest-java = super.neotest-java.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-jest = super.neotest-jest.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
    ];
    # Unit test assert
    nvimSkipModules = [ "neotest-jest-assertions" ];
  };

  neotest-minitest = super.neotest-minitest.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-mocha = super.neotest-mocha.overrideAttrs (old: {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neotest-pest = super.neotest-pest.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-phpunit = super.neotest-phpunit.overrideAttrs {
    dependencies = with self; [
      neotest
      plenary-nvim
      nvim-nio
    ];
  };

  neotest-playwright = super.neotest-playwright.overrideAttrs {
    checkInputs = with self; [
      # Optional picker integration
      telescope-nvim
    ];
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
    # Unit test assert
    nvimSkipModules = [ "neotest-playwright-assertions" ];
  };

  neotest-plenary = super.neotest-plenary.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-python = super.neotest-python.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-rspec = super.neotest-rspec.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-rust = super.neotest-rust.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-scala = super.neotest-scala.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neotest-testthat = super.neotest-testthat.overrideAttrs (old: {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neotest-vitest = super.neotest-vitest.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
    # Unit test assert
    nvimSkipModules = [ "neotest-vitest-assertions" ];
  };

  neotest-zig = super.neotest-zig.overrideAttrs {
    dependencies = with self; [
      neotest
      nvim-nio
      plenary-nvim
    ];
  };

  neovim-project = super.neovim-project.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      neovim-session-manager
    ];
  };

  neovim-sensible = super.neovim-sensible.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  neovim-session-manager = super.neovim-session-manager.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
    ];
  };

  neovim-tips = super.neovim-tips.overrideAttrs {
    dependencies = [
      self.nui-nvim
    ];
  };

  neovim-trunk = super.neovim-trunk.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  neoyank-vim = super.neoyank-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  netman-nvim = super.netman-nvim.overrideAttrs {
    # Optional neo-tree integration
    checkInputs = with self; [
      neo-tree-nvim
      # FIXME: propagate `neo-tree` dependencies
      git
      nui-nvim
      plenary-nvim
    ];
  };

  nginx-vim = super.nginx-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  nidhogg-nvim = super.nidhogg-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  nlsp-settings-nvim = super.nlsp-settings-nvim.overrideAttrs {
    dependencies = [ self.nvim-lspconfig ];
  };

  noctis-nvim = super.noctis-nvim.overrideAttrs {
    dependencies = [ self.lush-nvim ];
  };

  noice-nvim = super.noice-nvim.overrideAttrs {
    dependencies = [ self.nui-nvim ];
  };

  none-ls-extras-nvim = super.none-ls-extras-nvim.overrideAttrs {
    dependencies = [ self.none-ls-nvim ];
  };

  none-ls-nvim = super.none-ls-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  NotebookNavigator-nvim = super.NotebookNavigator-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  NrrwRgn = super.NrrwRgn.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  nterm-nvim = super.nterm-nvim.overrideAttrs {
    dependencies = [ self.aniseed ];
  };

  nvchad = super.nvchad.overrideAttrs {
    # You've signed up for a distro, providing dependencies.
    dependencies = with self; [
      gitsigns-nvim
      luasnip
      mason-nvim
      nvim-cmp
      nvim-lspconfig
      telescope-nvim
      nvim-treesitter-legacy
      nvchad-ui
    ];
    nvimSkipModules = [
      # Requires global config setup
      "nvchad.configs.cmp"
      "nvchad.configs.gitsigns"
      "nvchad.configs.mason"
      "nvchad.configs.nvimtree"
      "nvchad.configs.telescope"
    ];
  };

  nvchad-ui = super.nvchad-ui.overrideAttrs {
    dependencies = [ self.nvzone-volt ];
    nvimSkipModules = [
      # Requires global config setup
      "nvchad.term.init"
      "nvchad.themes.init"
      "nvchad.themes.mappings"
      "nvchad.cheatsheet.grid"
      "nvchad.cheatsheet.simple"
      "nvchad.blink.config"
      # Circular dependency with base46
      "nvchad.utils"
    ];
  };

  nvim-autopairs = super.nvim-autopairs.overrideAttrs {
    # Optional completion dependency
    checkInputs = with self; [
      nvim-cmp
    ];
    nvimSkipModules = [
      # compe not packaged anymore
      "nvim-autopairs.completion.compe"
    ];
  };

  nvim-biscuits = super.nvim-biscuits.overrideAttrs {
    dependencies = with self; [
      nvim-treesitter-legacy
      plenary-nvim
    ];
  };

  nvim-cokeline = super.nvim-cokeline.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  nvim-colorizer-lua = super.nvim-colorizer-lua.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
    };
  });

  nvim-coverage = super.nvim-coverage.overrideAttrs {
    dependencies = with self; [
      neotest
      plenary-nvim
    ];
    nvimSkipModules = [
      # TODO: Add lua-xmlreader package
      "coverage.parsers.corbertura"
    ];
  };

  nvim-dap = super.nvim-dap.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  nvim-dap-cortex-debug = super.nvim-dap-cortex-debug.overrideAttrs {
    dependencies = [ self.nvim-dap ];
  };

  nvim-dap-disasm = super.nvim-dap-disasm.overrideAttrs (old: {
    dependencies = [ self.nvim-dap ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  nvim-dap-lldb = super.nvim-dap-lldb.overrideAttrs {
    dependencies = [ self.nvim-dap ];
  };

  nvim-dap-python = super.nvim-dap-python.overrideAttrs (old: {
    dependencies = [ self.nvim-dap ];
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  nvim-dap-rego = super.nvim-dap-rego.overrideAttrs {
    dependencies = [ self.nvim-dap ];
  };

  nvim-dap-rr = super.nvim-dap-rr.overrideAttrs {
    dependencies = [ self.nvim-dap ];
  };

  nvim-dap-ui = super.nvim-dap-ui.overrideAttrs {
    dependencies = with self; [
      nvim-dap
      nvim-nio
    ];

    doInstallCheck = true;
  };

  nvim-dap-view = super.nvim-dap-view.overrideAttrs {
    dependencies = [ self.nvim-dap ];
  };

  nvim-dap-virtual-text = super.nvim-dap-virtual-text.overrideAttrs {
    dependencies = [ self.nvim-dap ];
  };

  nvim-dap-vscode-js = super.nvim-dap-vscode-js.overrideAttrs {
    dependencies = [ self.nvim-dap ];
  };

  nvim-FeMaco-lua = super.nvim-FeMaco-lua.overrideAttrs (old: {
    dependencies = [ self.nvim-treesitter-legacy ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  nvim-fzf-commands = super.nvim-fzf-commands.overrideAttrs {
    dependencies = [ self.nvim-fzf ];
    # Requires global variable setup nvim_fzf_directory
    nvimSkipModules = [ "fzf-commands.rg" ];
  };

  nvim-genghis = super.nvim-genghis.overrideAttrs {
    dependencies = [ self.dressing-nvim ];

    doInstallCheck = true;
  };

  nvim-highlite = super.nvim-highlite.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
    };
  });

  nvim-java = super.nvim-java.overrideAttrs {
    dependencies = with self; [
      lua-async
      mason-nvim
      nui-nvim
      nvim-dap
      nvim-java-core
      nvim-java-dap
      nvim-java-refactor
      nvim-java-test
      nvim-lspconfig
    ];
  };

  nvim-java-core = super.nvim-java-core.overrideAttrs {
    dependencies = with self; [
      mason-nvim
      nvim-lspconfig
    ];
  };

  nvim-java-dap = super.nvim-java-dap.overrideAttrs {
    dependencies = [ self.nvim-java-core ];
  };

  nvim-java-refactor = super.nvim-java-refactor.overrideAttrs {
    dependencies = [ self.nvim-java-core ];
    nvimSkipModules = [
      # Requires the `java.utils.ui` module which seems to be provided by `nvim-java` (cyclic dependency)
      # -> Skip to avoid infinite recursion
      "java-refactor.action"
      "java-refactor.refactor"
    ];
  };

  nvim-java-test = super.nvim-java-test.overrideAttrs {
    dependencies = [ self.nvim-java-core ];
  };

  nvim-jdtls = super.nvim-jdtls.overrideAttrs (old: {
    runtimeDeps = [ python3 ];
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  nvim-julia-autotest = super.nvim-julia-autotest.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.agpl3Only;
    };
  });

  nvim-k8s-crd = super.nvim-k8s-crd.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      nvim-lspconfig
    ];
  };

  nvim-lilypond-suite = super.nvim-lilypond-suite.overrideAttrs {
    nvimSkipModules = [
      # Option not set immediately
      "nvls.errors.lilypond-book"
      "nvls.tex"
      "nvls.texinfo"
    ];
  };

  nvim-lint = super.nvim-lint.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  nvim-lsp-file-operations = super.nvim-lsp-file-operations.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  nvim-lsputils = super.nvim-lsputils.overrideAttrs {
    dependencies = [ self.popfix ];
  };

  nvim-metals = super.nvim-metals.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
    dontBuild = true;
  };

  nvim-moonwalk = super.nvim-moonwalk.overrideAttrs {
    # Asserts log file exists before it is created
    nvimSkipModules = [ "moonwalk" ];
  };

  nvim-navbuddy = super.nvim-navbuddy.overrideAttrs {
    dependencies = with self; [
      nui-nvim
      nvim-lspconfig
      nvim-navic
    ];
  };

  nvim-navic = super.nvim-navic.overrideAttrs {
    dependencies = [ self.nvim-lspconfig ];
  };

  nvim-neoclip-lua = super.nvim-neoclip-lua.overrideAttrs (old: {
    # Optional dependencies
    checkInputs = with self; [
      fzf-lua
      telescope-nvim
    ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  nvim-nonicons = super.nvim-nonicons.overrideAttrs {
    # Requires web-devicons but mini.icons can mock them up
    checkInputs = [ self.nvim-web-devicons ];
  };

  nvim-notify = super.nvim-notify.overrideAttrs {
    # Optional fzf integration
    checkInputs = [
      self.fzf-lua
    ];

    nvimSkipModules = lib.optionals stdenv.hostPlatform.isDarwin [
      #FIXME: https://github.com/NixOS/nixpkgs/issues/431458
      # fzf-lua throws `address already in use` on darwin
      "notify.integrations.fzf"
    ];
  };

  nvim-nu = super.nvim-nu.overrideAttrs {
    dependencies = with self; [
      none-ls-nvim
      nvim-treesitter-parsers.nu
      plenary-nvim
    ];
  };

  nvim-parinfer = super.nvim-parinfer.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  nvim-remote-containers = super.nvim-remote-containers.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.unfree;
    };
  });

  nvim-rip-substitute = super.nvim-rip-substitute.overrideAttrs {
    buildInputs = [ ripgrep ];
  };

  nvim-scissors = super.nvim-scissors.overrideAttrs {
    checkInputs = [
      # Optional telescope picker
      self.telescope-nvim
      # Optional fzf-lua integration
      self.fzf-lua
    ];
  };

  nvim-snippets = super.nvim-snippets.overrideAttrs {
    checkInputs = [
      # Optional cmp integration
      self.nvim-cmp
    ];
  };

  nvim-teal-maker = super.nvim-teal-maker.overrideAttrs {
    postPatch = ''
      substituteInPlace lua/tealmaker/init.lua \
        --replace-fail cyan ${luaPackages.cyan}/bin/cyan
    '';
    vimCommandCheck = "TealBuild";
  };

  nvim-test = super.nvim-test.overrideAttrs {
    # Optional toggleterm integration
    checkInputs = [ self.toggleterm-nvim ];
    dependencies = with self; [
      nvim-treesitter
      nvim-treesitter-parsers.c_sharp
      nvim-treesitter-parsers.go
      nvim-treesitter-parsers.haskell
      nvim-treesitter-parsers.javascript
      nvim-treesitter-parsers.python
      nvim-treesitter-parsers.ruby
      nvim-treesitter-parsers.rust
      nvim-treesitter-parsers.typescript
      nvim-treesitter-parsers.zig
    ];
  };

  nvim-tinygit = super.nvim-tinygit.overrideAttrs {
    checkInputs = [
      gitMinimal
      # interactive staging support
      self.telescope-nvim
    ];
  };

  nvim-tree-lua = super.nvim-tree-lua.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
    };
  });

  nvim-treesitter = super.nvim-treesitter.overrideAttrs (
    callPackage ./nvim-treesitter/overrides.nix { } self super
  );

  # TODO: raise warning at 26.05; drop at 26.11
  nvim-treesitter-legacy =
    let
      drv = super.nvim-treesitter-legacy.overrideAttrs (
        callPackage ./nvim-treesitter-legacy/overrides.nix { } self super
      );
    in
    if config.allowAliases then
      lib.warnOnInstantiate "nvim-treesitter-legacy is deprecated, please migrate to the new version. This will become an error in 26.11" drv
    else
      drv;

  nvim-treesitter-pairs = super.nvim-treesitter-pairs.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  nvim-treesitter-pyfold = super.nvim-treesitter-pyfold.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  nvim-treesitter-refactor = super.nvim-treesitter-refactor.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  nvim-treesitter-sexp = super.nvim-treesitter-sexp.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  nvim-treesitter-textobjects = super.nvim-treesitter-textobjects.overrideAttrs {
    dependencies = [ self.nvim-treesitter ];
  };

  nvim-treesitter-textobjects-legacy = super.nvim-treesitter-textobjects-legacy.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  nvim-treesitter-textsubjects = super.nvim-treesitter-textsubjects.overrideAttrs {
    dependencies = [ self.nvim-treesitter-legacy ];
  };

  nvim-ufo = super.nvim-ufo.overrideAttrs {
    dependencies = [ self.promise-async ];
  };

  nvim-unception = super.nvim-unception.overrideAttrs {
    # Attempt rpc socket connection
    nvimSkipModules = [
      "client.client"
    ]
    ++ lib.optionals stdenv.hostPlatform.isDarwin [
      "server.server"
      "unception"
    ];
  };

  nvim-vtsls = super.nvim-vtsls.overrideAttrs {
    runtimeDeps = [ vtsls ];
    dependencies = [ self.nvim-lspconfig ];
  };

  nvim-whichkey-setup-lua = super.nvim-whichkey-setup-lua.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  nvzone-menu = super.nvzone-menu.overrideAttrs {
    # Plugin managers like Lazy.nvim expect pname to match the name of the git repository
    pname = "menu";
    checkInputs = with self; [
      # Optional integrations
      nvim-tree-lua
      neo-tree-nvim
      # FIXME: should propagate from neo-tree-nvim
      git
      nui-nvim
      plenary-nvim
    ];
    dependencies = [ self.nvzone-volt ];
  };

  nvzone-minty = super.nvzone-minty.overrideAttrs {
    # Plugin managers like Lazy.nvim expect pname to match the name of the git repository
    pname = "minty";
    dependencies = [ self.nvzone-volt ];
  };

  nvzone-typr = super.nvzone-typr.overrideAttrs {
    # Plugin managers like Lazy.nvim expect pname to match the name of the git repository
    pname = "typr";
    dependencies = [ self.nvzone-volt ];
  };

  nvzone-volt = super.nvzone-volt.overrideAttrs {
    # Plugin managers like Lazy.nvim expect pname to match the name of the git repository
    pname = "volt";
  };

  obsidian-nvim = super.obsidian-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional pickers
      fzf-lua
      mini-nvim
      snacks-nvim
      telescope-nvim
    ];
    nvimSkipModules = [
      # Issue reproduction file
      "minimal"
      # Address in use error from fzf-lua on darwin
      # https://github.com/NixOS/nixpkgs/issues/431458
      "obsidian.picker._fzf"
    ];
  };

  oceanic-next = super.oceanic-next.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.asl20;
    };
  });

  octo-nvim = super.octo-nvim.overrideAttrs {
    checkInputs = with self; [
      # Pickers, can use telescope or fzf-lua
      fzf-lua
      telescope-nvim
      snacks-nvim
    ];
    dependencies = with self; [
      plenary-nvim
    ];
  };

  oil-git-nvim = super.oil-git-nvim.overrideAttrs (old: {
    dependencies = [ self.oil-nvim ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  oil-git-status-nvim = super.oil-git-status-nvim.overrideAttrs {
    dependencies = [ self.oil-nvim ];
  };

  oil-lsp-diagnostics-nvim = super.oil-lsp-diagnostics-nvim.overrideAttrs {
    dependencies = [ self.oil-nvim ];
  };

  ollama-nvim = super.ollama-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  omni-vim = super.omni-vim.overrideAttrs {
    # Optional lightline integration
    nvimSkipModules = [ "omni-lightline" ];
  };

  omnisharp-extended-lsp-nvim = super.omnisharp-extended-lsp-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  one-nvim = super.one-nvim.overrideAttrs (old: {
    # E5108: /lua/one-nvim.lua:14: Unknown option 't_Co'
    # https://github.com/Th3Whit3Wolf/one-nvim/issues/23
    meta = old.meta // {
      broken = true;
    };
  });

  onedark-nvim = super.onedark-nvim.overrideAttrs {
    nvimSkipModules = [
      # Requires global config value
      "barbecue.theme.onedark"
      "onedark.highlights"
      "onedark.colors"
      "onedark.terminal"
    ];
  };

  onehalf = super.onehalf.overrideAttrs {
    configurePhase = "cd vim";
  };

  open-browser-vim = super.open-browser-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  opencode-nvim = super.opencode-nvim.overrideAttrs {
    runtimeDeps = [
      curl
      opencode
      lsof
    ];
  };

  # The plugin depends on either skim-vim or fzf-vim, but we don't want to force the user so we
  # avoid choosing one of them and leave it to the user
  openscad-nvim = super.openscad-nvim.overrideAttrs {
    runtimeDeps = [
      openscad
    ];

    # FIXME: can't find plugin root dir
    nvimSkipModules = [
      "openscad"
      "openscad.utilities"
    ];
  };

  org-notebook-nvim = super.org-notebook-nvim.overrideAttrs {
    dependencies = [
      self.orgmode
      self.jupyter-api-nvim
    ];
    nvimSkipModules = [
      # Requires mini.test, deno, and some deno dependencies, look into it once https://github.com/NixOS/nixpkgs/pull/453904 is merged
      "org-notebook.test"
    ];
  };

  org-roam-nvim = super.org-roam-nvim.overrideAttrs {
    dependencies = [ self.orgmode ];
  };

  otter-nvim = super.otter-nvim.overrideAttrs {
    dependencies = [ self.nvim-lspconfig ];
  };

  outline-nvim = super.outline-nvim.overrideAttrs {
    # Requires setup call
    nvimSkipModules = [ "outline.providers.norg" ];
  };

  overseer-nvim = super.overseer-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional integration
      neotest
      toggleterm-nvim
      nodejs
      nvim-dap
    ];
    checkPhase = ''
      runHook preCheck

      plugins=.testenv/data/nvim/site/pack/plugins/start
      mkdir -p "$plugins"
      ln -s ${self.plenary-nvim} "$plugins/plenary.nvim"
      bash run_tests.sh
      rm -r .testenv

      runHook postCheck
    '';
  };

  package-info-nvim = super.package-info-nvim.overrideAttrs {
    dependencies = [ self.nui-nvim ];
  };

  pantran-nvim = super.pantran-nvim.overrideAttrs {
    runtimeDeps = [ curl ];
  };

  parpar-nvim = super.parpar-nvim.overrideAttrs {
    dependencies = with self; [
      nvim-parinfer
      nvim-paredit
    ];
  };

  parrot-nvim = super.parrot-nvim.overrideAttrs (old: {
    runtimeDeps = [
      curl
    ];

    dependencies = with self; [
      plenary-nvim
    ];

    checkInputs = [
      curl
      ripgrep
      # Optional integrations
      self.blink-cmp
      self.nvim-cmp
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  peek-nvim = super.peek-nvim.overrideAttrs (old: {
    runtimeDeps = [
      deno
    ];

    patches = [
      # Patch peek-nvim to run using nixpkgs deno
      # This means end-users have to build peek-nvim the first time they use it...
      ./patches/peek-nvim/cmd.patch
    ];
  });

  perfanno-nvim = super.perfanno-nvim.overrideAttrs {
    checkInputs = with self; [
      fzf-lua
    ];
  };

  persistent-breakpoints-nvim = super.persistent-breakpoints-nvim.overrideAttrs {
    dependencies = with self; [
      nvim-dap
    ];
  };

  pgsql-vim = super.pgsql-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  plantuml-nvim = super.plantuml-nvim.overrideAttrs {
    dependencies = [ self.LibDeflate-nvim ];
  };

  poimandres-nvim = super.poimandres-nvim.overrideAttrs {
    # Optional treesitter support
    nvimSkipModules = [ "poimandres.highlights" ];
  };

  popup-nvim = super.popup-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  PreserveNoEOL = super.PreserveNoEOL.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  Preview-nvim = super.Preview-nvim.overrideAttrs {
    runtimeDeps = [
      md-tui
    ];
  };

  project-nvim = super.project-nvim.overrideAttrs {
    checkInputs = [
      # Optional telescope integration
      self.telescope-nvim
    ];
  };

  psc-ide-vim = super.psc-ide-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = with lib.licenses; [
        mit
        wtfpl
      ];
    };
  });

  python-mode = super.python-mode.overrideAttrs (old: {
    postPatch = (old.postPatch or "") + ''
      # NOTE: Fix broken symlink - the pytoolconfig directory was moved to src/
      # https://github.com/python-mode/python-mode/pull/1189#issuecomment-3109528360
      rm -f pymode/libs/pytoolconfig
      ln -sf ../../submodules/pytoolconfig/src/pytoolconfig pymode/libs/pytoolconfig

      # The current source tarball only ships a subset of the historical
      # submodules, so drop the now-dangling vendored linter symlinks.
      rm -f \
        pymode/libs/appdirs.py \
        pymode/libs/astroid \
        pymode/libs/mccabe.py \
        pymode/libs/pycodestyle.py \
        pymode/libs/pydocstyle \
        pymode/libs/pyflakes \
        pymode/libs/pylama \
        pymode/libs/pylint \
        pymode/libs/snowballstemmer \
        pymode/libs/toml \
        pymode/autopep8.py
    '';
  });

  pywal-nvim = super.pywal-nvim.overrideAttrs {
    # Optional feline integration
    nvimSkipModules = [ "pywal.feline" ];
  };

  QFEnter = super.QFEnter.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  qmk-nvim = super.qmk-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  quarto-nvim = super.quarto-nvim.overrideAttrs (old: {
    checkInputs = [
      # Optional runner
      self.iron-nvim
    ];
    dependencies = with self; [
      nvim-lspconfig
      otter-nvim
    ];
    meta = old.meta // {
      # LICENSE says GPL-2.0-or-later.
      license = lib.licenses.gpl2Plus;
    };
  });

  quickfixstatus = super.quickfixstatus.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  rainbow-delimiters-nvim = super.rainbow-delimiters-nvim.overrideAttrs (old: {
    nvimSkipModules = [
      # rainbow-delimiters.types.lua
      "rainbow-delimiters.types"
      # Test that requires an unpackaged dependency
      "rainbow-delimiters._test.highlight"
    ];
    meta = old.meta // {
      license = lib.licenses.asl20;
    };
  });

  range-highlight-nvim = super.range-highlight-nvim.overrideAttrs {
    dependencies = [ self.cmd-parser-nvim ];
  };

  ranger-nvim = super.ranger-nvim.overrideAttrs {
    runtimeDeps = [
      ranger
    ];
  };

  rcshell-vim = super.rcshell-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  readline-vim = super.readline-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  Recover-vim = super.Recover-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  refactoring-nvim = super.refactoring-nvim.overrideAttrs {
    dependencies = with self; [
      async-nvim
    ];
  };

  remote-nvim-nvim = super.remote-nvim-nvim.overrideAttrs {
    dontPatchShebangs = true;
    dependencies = with self; [
      nui-nvim
      plenary-nvim
    ];
    nvimSkipModules = [ "repro" ];
  };

  remote-sshfs-nvim = super.remote-sshfs-nvim.overrideAttrs {
    dependencies = with self; [
      telescope-nvim
      plenary-nvim
    ];
    runtimeDeps = [
      openssh
      sshfs
    ];
  };

  Rename = super.Rename.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  renamer-nvim = super.renamer-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  repolink-nvim = super.repolink-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  riv-vim = super.riv-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  rocks-nvim = super.rocks-nvim.overrideAttrs (old: {
    passthru = old.passthru // {
      initLua = ''
        vim.g.rocks_nvim = {
          luarocks_binary = "${neovim-unwrapped.lua.pkgs.luarocks_bootstrap}/bin/luarocks"
          }
      '';
    };
  });

  rtorrent-syntax-file = super.rtorrent-syntax-file.overrideAttrs (old: {
    meta = old.meta // {
      # README is the only upstream MIT notice.
      license = lib.licenses.mit;
    };
  });

  run-nvim = super.run-nvim.overrideAttrs (old: {
    dependencies = [
      self.telescope-nvim
    ];

    checkInputs = [
      # Transitive dependency of telescope.nvim
      # Issue: https://github.com/NixOS/nixpkgs/issues/394939
      self.plenary-nvim
    ];

    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  rust-tools-nvim = super.rust-tools-nvim.overrideAttrs {
    dependencies = [ self.nvim-lspconfig ];
  };

  rustaceanvim = super.rustaceanvim.overrideAttrs {
    checkInputs = [
      # Optional integration
      self.neotest
    ];
  };

  rzls-nvim = super.rzls-nvim.overrideAttrs {
    dependencies = [ self.roslyn-nvim ];
  };

  salt-vim = super.salt-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.asl20;
    };
  });

  samodostal-image-nvim = super.samodostal-image-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  schema-companion-nvim = super.schema-companion-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  screensaver-nvim = super.screensaver-nvim.overrideAttrs (old: {
    meta = old.meta // {
      description = "Screensaver plugin for Neovim";
      license = lib.licenses.mit;
      maintainers = with lib.maintainers; [ m3l6h ];
    };
  });

  scretch-nvim = super.scretch-nvim.overrideAttrs {
  };

  search-and-replace-nvim = super.search-and-replace-nvim.overrideAttrs {
    runtimeDeps = [
      fd
      sad
    ];
  };

  searchbox-nvim = super.searchbox-nvim.overrideAttrs {
    dependencies = [ self.nui-nvim ];
  };

  seoul256-vim = super.seoul256-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  sidekick-nvim = super.sidekick-nvim.overrideAttrs {
    runtimeDeps = [
      copilot-language-server
    ];

    nvimSkipModules = [
      "sidekick.docs"
    ];
  };

  skim-vim = super.skim-vim.overrideAttrs (old: {
    dependencies = [ self.skim ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  slimline-nvim = super.slimline-nvim.overrideAttrs {
    nvimSkipModules = [
      # Component modules read the user-supplied slimline.config at require time.
      "slimline.components.diagnostics"
      "slimline.components.filetype_lsp"
      "slimline.components.mode"
      "slimline.components.path"
      "slimline.components.progress"
      "slimline.components.recording"
      "slimline.components.searchcount"
      "slimline.components.selectioncount"
    ];
  };

  smart-open-nvim = super.smart-open-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      sqlite-lua
      telescope-nvim
    ];
    nvimSkipModules = [
      # optional dependency
      "smart-open.matching.algorithms.fzf_implementation"
    ];
  };

  smart-splits-nvim = super.smart-splits-nvim.overrideAttrs {
    nvimSkipModules = [
      "vimdoc-gen"
    ];
  };

  smartpairs-vim = super.smartpairs-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.wtfpl;
    };
  });

  snacks-nvim = super.snacks-nvim.overrideAttrs {
    # Optional trouble integration
    checkInputs = [ self.trouble-nvim ];
    nvimSkipModules = [
      # TODO: Plugin requires libsqlite available, create a test for it
      "snacks.picker.util.db"
    ];
  };

  snap = super.snap.overrideAttrs {
    nvimSkipModules = [
      "snap.consumer.fzy.all"
      "snap.consumer.fzy.filter"
      "snap.consumer.fzy.init"
      "snap.consumer.fzy.positions"
      "snap.consumer.fzy.score"
      # circular import
      "snap.producer.create"
    ];
  };

  solarized-osaka-nvim = super.solarized-osaka-nvim.overrideAttrs {
    checkInputs = [ self.fzf-lua ];

    nvimSkipModules = [
      # lua/solarized-osaka/extra/fzf.lua:55: color not found for header:FzfLuaTitle
      "solarized-osaka.extra.fzf"
    ];
  };

  sonarlint-nvim = super.sonarlint-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
      maintainers = old.meta.maintainers or [ ] ++ [
        lib.maintainers.sinics
      ];
    };
  });

  spaceman-nvim = super.spaceman-nvim.overrideAttrs {
    # Optional telescope integration
    nvimSkipModules = [ "spaceman.adapters.telescope" ];
  };

  sqlite-lua = super.sqlite-lua.overrideAttrs (
    old:
    let
      libsqlite = "${sqlite.out}/lib/libsqlite3${stdenv.hostPlatform.extensions.sharedLibrary}";
    in
    {
      postPatch = ''
        substituteInPlace lua/sqlite/defs.lua \
          --replace-fail "path = vim.g.sqlite_clib_path" "path = vim.g.sqlite_clib_path or '${lib.escapeShellArg libsqlite}'"
      '';

      passthru = old.passthru // {
        initLua = ''vim.g.sqlite_clib_path = "${libsqlite}"'';
      };

      nvimSkipModules = [
        # Example seeds and edits a database during require.
        "sqlite.examples.bookmarks"
        # Require "sql.utils" ?
        "sqlite.tbl.cache"
      ];
    }
  );

  srcery-vim = super.srcery-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  starrynight = super.starrynight.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  startup-nvim = super.startup-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  stylish-nvim = super.stylish-nvim.overrideAttrs {
    postPatch = ''
      substituteInPlace lua/stylish/common/mouse_hover_handler.lua --replace-fail xdotool ${xdotool}/bin/xdotool
      substituteInPlace lua/stylish/components/menu.lua --replace-fail xdotool ${xdotool}/bin/xdotool
      substituteInPlace lua/stylish/components/menu.lua --replace-fail xwininfo ${xwininfo}/bin/xwininfo
    '';
  };

  SudoEdit-vim = super.SudoEdit-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  supermaven-nvim = super.supermaven-nvim.overrideAttrs {
    # TODO: handle supermaven binary
    doCheck = false;
  };

  supertab = super.supertab.overrideAttrs (old: {
    meta = old.meta // {
      # README.rst contains the BSD-3-Clause notice.
      license = lib.licenses.bsd3;
    };
  });

  sved =
    let
      # we put the script in its own derivation to benefit the magic of wrapGAppsHook3
      svedbackend = stdenv.mkDerivation {
        name = "svedbackend-${super.sved.name}";
        inherit (super.sved) src;
        nativeBuildInputs = [
          wrapGAppsHook3
          gobject-introspection
        ];
        buildInputs = [
          glib
          (python3.withPackages (
            ps: with ps; [
              pygobject3
              pynvim
              dbus-python
            ]
          ))
        ];
        preferLocalBuild = true;
        installPhase = ''
          install -Dt $out/bin ftplugin/evinceSync.py
        '';
      };
      # the vim plugin expects evinceSync.py to be a python file, but it is a C wrapper
      pythonWrapper =
        writeText "evinceSync-wrapper.py" # python

          ''
            #!${python3}/bin/python3
            import os
            import sys
            os.execv("${svedbackend}/bin/evinceSync.py", sys.argv)
          '';
    in
    super.sved.overrideAttrs (old: {
      preferLocalBuild = true;
      postPatch = ''
        rm ftplugin/evinceSync.py
        install -m 544 ${pythonWrapper} ftplugin/evinceSync.py
      '';
      meta = old.meta // {
        description = "synctex support between vim/neovim and evince";
      };
    });

  switcher-nvim = super.switcher-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      nvim-web-devicons
    ];
  };

  tabmerge = super.tabmerge.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  tabpagebuffer-vim = super.tabpagebuffer-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  tabular = super.tabular.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  tagbar = super.tagbar.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  tardis-nvim = super.tardis-nvim.overrideAttrs (old: {
    dependencies = [ self.plenary-nvim ];
    meta = old.meta // {
      maintainers = with lib.maintainers; [ fredeb ];
    };
  });

  taskwiki = super.taskwiki.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  telekasten-nvim = super.telekasten-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-asynctasks-nvim = super.telescope-asynctasks-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-cheat-nvim = super.telescope-cheat-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      sqlite-lua
      telescope-nvim
    ];
  };

  telescope-coc-nvim = super.telescope-coc-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-dap-nvim = super.telescope-dap-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      nvim-dap
      telescope-nvim
    ];
  };

  telescope-emoji-nvim = super.telescope-emoji-nvim.overrideAttrs {
    dependencies = [ self.telescope-nvim ];
  };

  telescope-frecency-nvim = super.telescope-frecency-nvim.overrideAttrs {
    dependencies = with self; [
      sqlite-lua
      telescope-nvim
      plenary-nvim
    ];
    # Meta
    nvimSkipModules = [ "frecency.types" ];
  };

  telescope-fzf-native-nvim = super.telescope-fzf-native-nvim.overrideAttrs (old: {
    dependencies = [ self.telescope-nvim ];
    buildPhase = "make";
    meta = old.meta // {
      platforms = lib.platforms.all;
    };
  });

  telescope-fzf-writer-nvim = super.telescope-fzf-writer-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-fzy-native-nvim = super.telescope-fzy-native-nvim.overrideAttrs (old: {
    dependencies = [ self.telescope-nvim ];
    preFixup =
      let
        fzy-lua-native-path = "deps/fzy-lua-native";
        fzy-lua-native = stdenv.mkDerivation {
          name = "fzy-lua-native";
          src = "${old.src}/${fzy-lua-native-path}";
          # remove pre-compiled binaries
          preBuild = "rm -rf static/*";
          installPhase = ''
            install -Dm 444 -t $out/static static/*
            install -Dm 444 -t $out/lua lua/*
          '';
        };
      in
      ''
        rm -rf $target/${fzy-lua-native-path}/*
        ln -s ${fzy-lua-native}/static $target/${fzy-lua-native-path}/static
        ln -s ${fzy-lua-native}/lua $target/${fzy-lua-native-path}/lua
      '';
    meta = old.meta // {
      platforms = lib.platforms.all;
    };
  });

  telescope-git-conflicts-nvim = super.telescope-git-conflicts-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-github-nvim = super.telescope-github-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-glyph-nvim = super.telescope-github-nvim.overrideAttrs {
    dependencies = [ self.telescope-nvim ];
  };

  telescope-hierarchy-nvim = super.telescope-hierarchy-nvim.overrideAttrs {
    dependencies = with self; [
      telescope-nvim
      plenary-nvim
    ];
  };

  telescope-live-grep-args-nvim = super.telescope-live-grep-args-nvim.overrideAttrs (old: {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
    meta = old.meta // {
      license = lib.licenses.cc0;
    };
  });

  telescope-lsp-handlers-nvim = super.telescope-lsp-handlers-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-media-files-nvim = super.telescope-media-files-nvim.overrideAttrs {
    dependencies = with self; [
      telescope-nvim
      popup-nvim
      plenary-nvim
    ];
  };

  telescope-project-nvim = super.telescope-project-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  telescope-smart-history-nvim = super.telescope-smart-history-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-symbols-nvim = super.telescope-symbols-nvim.overrideAttrs {
    dependencies = [ self.telescope-nvim ];
  };

  telescope-ui-select-nvim = super.telescope-ui-select-nvim.overrideAttrs {
    dependencies = [ self.telescope-nvim ];
  };

  telescope-ultisnips-nvim = super.telescope-ultisnips-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-undo-nvim = super.telescope-undo-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-vim-bookmarks-nvim = super.telescope-vim-bookmarks-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-z-nvim = super.telescope-z-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  telescope-zf-native-nvim = super.telescope-zf-native-nvim.overrideAttrs {
    dependencies = with self; [ telescope-nvim ];
  };

  telescope-zoxide = super.telescope-zoxide.overrideAttrs {
    dependencies = with self; [ telescope-nvim ];

    buildInputs = [ zoxide ];

    postPatch = ''
      substituteInPlace lua/telescope/_extensions/zoxide/config.lua \
        --replace-fail "zoxide query -ls" "${zoxide}/bin/zoxide query -ls"
    '';
  };

  text-case-nvim = super.text-case-nvim.overrideAttrs {
    nvimSkipModules = [
      # some leftover from development
      "textcase.plugin.range"
    ];
  };

  timerly = super.timerly.overrideAttrs {
    dependencies = [ self.nvzone-volt ];
  };

  timestamp-vim = super.timestamp-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  tinted-vim = super.tinted-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  tmux-complete-vim = super.tmux-complete-vim.overrideAttrs {
    # Vim plugin with optional nvim-compe lua module
    nvimSkipModules = [ "compe_tmux" ];
  };

  todo-comments-nvim = super.todo-comments-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional trouble integration
      trouble-nvim
    ];
    dependencies = [ self.plenary-nvim ];
    nvimSkipModules = [
      # Optional fzf-lua integration
      # fzf-lua server must be running
      "todo-comments.fzf"
    ];
  };

  todo-txt-vim = super.todo-txt-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  tokyonight-nvim = super.tokyonight-nvim.overrideAttrs {
    checkInputs = [ self.fzf-lua ];
    nvimSkipModules = [
      # Meta file
      "tokyonight.docs"
    ];
  };

  treesitter-modules-nvim = super.treesitter-modules-nvim.overrideAttrs {
    dependencies = [ self.nvim-treesitter ];
  };

  triptych-nvim = super.triptych-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
  };

  trouble-nvim = super.trouble-nvim.overrideAttrs {
    # Meta file
    nvimSkipModules = [ "trouble.docs" ];
  };

  trust-vim = super.trust-vim.overrideAttrs (old: {
    meta = old.meta // {
      # TODO: Upstream includes bundled NYSL-licensed code; add an NYSL license
      # entry and include it alongside the Apache-2.0/MIT terms.
      license = lib.licenses.mit;
    };
  });

  tsc-nvim = super.tsc-nvim.overrideAttrs {
    postPatch = ''
      substituteInPlace lua/tsc/utils.lua --replace-fail \
      'bin_name = bin_name or "tsc"' \
      'bin_name = bin_name or "${typescript}/bin/tsc"'
    '';

    # Unit test
    nvimSkipModules = [ "tsc.better-messages-test" ];
  };

  tslime-vim = super.tslime-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.wtfpl;
    };
  });

  tsuquyomi = super.tsuquyomi.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  tuis-nvim = super.tuis-nvim.overrideAttrs (old: {
    meta = old.meta // {
      # README contains the MIT license text.
      license = lib.licenses.mit;
    };
  });

  tv-nvim = super.tv-nvim.overrideAttrs {
    runtimeDeps = [ television ];
  };

  typescript-tools-nvim = super.typescript-tools-nvim.overrideAttrs {
    dependencies = with self; [
      nvim-lspconfig
      plenary-nvim
    ];
    runtimeDeps = [
      typescript-language-server
    ];
  };

  typst-preview-nvim = super.typst-preview-nvim.overrideAttrs {
    postPatch = ''
      substituteInPlace lua/typst-preview/config.lua \
       --replace-fail "['tinymist'] = nil," "tinymist = '${lib.getExe tinymist}'," \
       --replace-fail "['websocat'] = nil," "websocat = '${lib.getExe websocat}',"
    '';
  };

  unicode-vim =
    let
      unicode-data = fetchurl {
        url = "http://www.unicode.org/Public/UNIDATA/UnicodeData.txt";
        sha256 = "16b0jzvvzarnlxdvs2izd5ia0ipbd87md143dc6lv6xpdqcs75s9";
      };
    in
    super.unicode-vim.overrideAttrs (old: {
      # redirect to /dev/null else changes terminal color
      buildPhase = ''
        cp "${unicode-data}" autoload/unicode/UnicodeData.txt
        echo "Building unicode cache"
        ${vim}/bin/vim --cmd ":set rtp^=$PWD" -c 'ru plugin/unicode.vim' -c 'UnicodeCache' -c ':echohl Normal' -c ':q' > /dev/null
      '';

      passthru = old.passthru // {
        initLua = ''vim.g.Unicode_data_directory="${self.unicode-vim}/autoload/unicode"'';
      };
      meta = old.meta // {
        license = lib.licenses.vim;
      };
    });

  unison = super.unison.overrideAttrs (old: {
    # Editor stuff isn't at top level
    postPatch = "cd editor-support/vim";
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  unite-vim = super.unite-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  uv-nvim = super.uv-nvim.overrideAttrs {
    runtimeDeps = [ uv ];
  };

  vader-vim = super.vader-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vCoolor-vim = super.vCoolor-vim.overrideAttrs (old: {
    # on linux can use either Zenity or Yad, on darwin it uses AppleScript
    propagatedBuildInputs = lib.optionals stdenv.hostPlatform.isLinux [ zenity ];
    meta = old.meta // {
      description = "Simple color selector/picker plugin";
      license = lib.licenses.publicDomain;
    };
  });

  verilog_systemverilog-vim = super.verilog_systemverilog-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-abolish = super.vim-abolish.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-addon-actions = super.vim-addon-actions.overrideAttrs {
    dependencies = with self; [
      vim-addon-mw-utils
      tlib_vim
    ];
  };

  vim-addon-async = super.vim-addon-async.overrideAttrs (old: {
    dependencies = [ self.vim-addon-signs ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-addon-background-cmd = super.vim-addon-background-cmd.overrideAttrs {
    dependencies = [ self.vim-addon-mw-utils ];
  };

  vim-addon-commenting = super.vim-addon-commenting.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-addon-completion = super.vim-addon-completion.overrideAttrs {
    dependencies = [ self.tlib_vim ];
  };

  vim-addon-goto-thing-at-cursor = super.vim-addon-goto-thing-at-cursor.overrideAttrs {
    dependencies = [ self.tlib_vim ];
  };

  vim-addon-manager = super.vim-addon-manager.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-addon-mru = super.vim-addon-mru.overrideAttrs {
    dependencies = with self; [
      vim-addon-other
      vim-addon-mw-utils
    ];
  };

  vim-addon-nix = super.vim-addon-nix.overrideAttrs {
    dependencies = with self; [
      vim-addon-completion
      vim-addon-goto-thing-at-cursor
      vim-addon-errorformats
      vim-addon-actions
      vim-addon-mw-utils
      tlib_vim
    ];
  };

  vim-addon-sql = super.vim-addon-sql.overrideAttrs {
    dependencies = with self; [
      vim-addon-completion
      vim-addon-background-cmd
      tlib_vim
    ];
  };

  vim-addon-syntax-checker = super.vim-addon-syntax-checker.overrideAttrs {
    dependencies = with self; [
      vim-addon-mw-utils
      tlib_vim
    ];
  };

  vim-addon-toggle-buffer = super.vim-addon-toggle-buffer.overrideAttrs {
    dependencies = with self; [
      vim-addon-mw-utils
      tlib_vim
    ];
  };

  vim-addon-xdebug = super.vim-addon-xdebug.overrideAttrs {
    dependencies = with self; [
      webapi-vim
      vim-addon-mw-utils
      vim-addon-signs
      vim-addon-async
    ];
  };

  vim-advanced-sorters = super.vim-advanced-sorters.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-agda = super.vim-agda.overrideAttrs {
    preFixup = ''
      substituteInPlace "$out"/autoload/agda.vim \
        --replace-fail "jobstart(['agda'" "jobstart(['${agda}/bin/agda'"
    '';
  };

  vim-angry = super.vim-angry.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-apathy = super.vim-apathy.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-apm = super.vim-apm.overrideAttrs {
    nvimSkipModules = [ "run" ];
  };

  vim-bazel = super.vim-bazel.overrideAttrs {
    dependencies = [ self.vim-maktaba ];
  };

  vim-bbye = super.vim-bbye.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.agpl3Plus;
    };
  });

  vim-beancount = super.vim-beancount.overrideAttrs (old: {
    passthru = old.passthru // {
      python3Dependencies = ps: with ps; [ beancount ];
    };
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-bepoptimist = super.vim-bepoptimist.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-capslock = super.vim-capslock.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-characterize = super.vim-characterize.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-clang-format = super.vim-clang-format.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-classpath = super.vim-classpath.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-clojure-static = super.vim-clojure-static.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-cmake = super.vim-cmake.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-codefmt = super.vim-codefmt.overrideAttrs {
    dependencies = [ self.vim-maktaba ];
  };

  # Due to case-sensitivity issues, the hash differs on Darwin systems, see:
  # https://github.com/NixOS/nixpkgs/issues/157609
  vim-coffee-script = super.vim-coffee-script.overrideAttrs (old: {
    meta = old.meta // {
      license = with lib.licenses; [
        wtfpl
        mit
      ];
    };
  });

  vim-colors-paramount = super.vim-colors-paramount.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-colors-solarized = super.vim-colors-solarized.overrideAttrs (old: {
    meta = old.meta // {
      # README carries the MIT license text.
      license = lib.licenses.mit;
    };
  });

  vim-colorschemes = super.vim-colorschemes.overrideAttrs (old: {
    src = old.src.overrideAttrs (srcOld: {
      postFetch =
        (srcOld.postFetch or "")
        + lib.optionalString (!stdenv.hostPlatform.isDarwin) ''
          rm $out/colors/darkBlue.vim
        '';
    });
  });

  vim-commentary = super.vim-commentary.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-CtrlXA = super.vim-CtrlXA.overrideAttrs (old: {
    meta = old.meta // {
      # This plugin is under the license "Rien à Branler", which is a French translation of the WTFPL license.
      license = lib.licenses.wtfpl;
    };
  });

  vim-dadbod = super.vim-dadbod.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-dadbod-ui = super.vim-dadbod-ui.overrideAttrs {
    dependencies = [ self.vim-dadbod ];

    doInstallCheck = true;
    vimCommandCheck = "DBUI";
  };

  vim-dasht = super.vim-dasht.overrideAttrs (old: {
    preFixup = ''
      substituteInPlace $out/autoload/dasht.vim \
        --replace-fail "['dasht']" "['${dasht}/bin/dasht']"
    '';
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-DetectSpellLang = super.vim-DetectSpellLang.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.unlicense;
    };
  });

  vim-diminactive = super.vim-diminactive.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  vim-dirdiff = super.vim-dirdiff.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  vim-dirvish = super.vim-dirvish.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
    };
  });

  vim-dispatch = super.vim-dispatch.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-dotenv = super.vim-dotenv.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-easy-align = super.vim-easy-align.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-easymotion = super.vim-easymotion.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-easytags = super.vim-easytags.overrideAttrs (old: {
    dependencies = [ self.vim-misc ];
    patches = [
      (fetchpatch {
        # https://github.com/xolox/vim-easytags/pull/170 fix version detection for universal-ctags
        url = "https://github.com/xolox/vim-easytags/commit/46e4709500ba3b8e6cf3e90aeb95736b19e49be9.patch";
        sha256 = "0x0xabb56xkgdqrg1mpvhbi3yw4d829n73lsnnyj5yrxjffy4ax4";
      })
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-elixir = super.vim-elixir.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.asl20;
    };
  });

  vim-emoji = super.vim-emoji.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-endwise = super.vim-endwise.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-erlang-compiler = super.vim-erlang-compiler.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-erlang-omnicomplete = super.vim-erlang-omnicomplete.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-erlang-runtime = super.vim-erlang-runtime.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-erlang-tags = super.vim-erlang-tags.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.asl20;
    };
  });

  vim-eunuch = super.vim-eunuch.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-figlet = super.vim-figlet.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-fireplace = super.vim-fireplace.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-flagship = super.vim-flagship.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-flog = super.vim-flog.overrideAttrs (old: {
    # Not intended to be required, used by vim plugin
    nvimSkipModules = [ "flog.graph_bin" ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-fold-cycle = super.vim-fold-cycle.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.wtfpl;
    };
  });

  vim-ft-diff_fold = super.vim-ft-diff_fold.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.zlib;
    };
  });

  vim-fugitive = super.vim-fugitive.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-fzf-coauthorship = super.vim-fzf-coauthorship.overrideAttrs {
    dependencies = with self; [ fzf-vim ];
  };

  vim-gist = super.vim-gist.overrideAttrs (old: {
    dependencies = [ self.webapi-vim ];
    meta = old.meta // {
      # README carries the BSD-2-Clause text; GitHub did not detect it.
      license = lib.licenses.bsd2;
    };
  });

  # change the go_bin_path to point to a path in the nix store. See the code in
  # fatih/vim-go here
  # https://github.com/fatih/vim-go/blob/155836d47052ea9c9bac81ba3e937f6f22c8e384/autoload/go/path.vim#L154-L159
  vim-github-dashboard = super.vim-github-dashboard.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-gnupg = super.vim-gnupg.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl2Plus;
    };
  });

  vim-go =
    let
      binPath = lib.makeBinPath [
        asmfmt
        delve
        errcheck
        go-motion
        go-tools # contains staticcheck, keyify
        gocode-gomod
        godef
        gogetdoc
        golint
        golangci-lint
        gomodifytags
        gopls
        gotags
        gotools # contains guru, gorename
        iferr
        impl
        reftools
        revive
      ];
    in
    super.vim-go.overrideAttrs (old: {
      postPatch = ''
        sed -i autoload/go/config.vim -Ee 's@"go_bin_path", ""@"go_bin_path", "${binPath}"@g'
      '';
      meta = old.meta // {
        license = lib.licenses.bsd3;
      };
    });

  vim-grammarous = super.vim-grammarous.overrideAttrs (old: {
    # use `:GrammarousCheck` to initialize checking
    # In neovim, you also want to use set
    #   let g:grammarous#show_first_error = 1
    # see https://github.com/rhysd/vim-grammarous/issues/39
    patches = [
      (replaceVars ./patches/vim-grammarous/set_default_languagetool.patch {
        inherit languagetool;
      })
    ];
    meta = old.meta // {
      # README carries the MIT license text; GitHub did not detect it.
      license = lib.licenses.mit;
    };
  });

  vim-gruvbox8 = super.vim-gruvbox8.overrideAttrs (old: {
    meta = old.meta // {
      # README declares MIT; GitHub did not detect it.
      license = lib.licenses.mit;
    };
  });

  vim-habamax = super.vim-habamax.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-hcl = super.vim-hcl.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-helm = super.vim-helm.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  vim-hexokinase = super.vim-hexokinase.overrideAttrs (old: {
    preFixup =
      let
        hexokinase = buildGoModule {
          name = "hexokinase";
          src = old.src + "/hexokinase";
          vendorHash = null;
        };
      in
      ''
        ln -s ${hexokinase}/bin/hexokinase $target/hexokinase/hexokinase
      '';

    meta = old.meta // {
      license = lib.licenses.vim;
      platforms = lib.platforms.all;
    };
  });

  vim-hier = super.vim-hier.overrideAttrs {
    buildInputs = [ vim ];
  };

  vim-hybrid = super.vim-hybrid.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-hypr-nav = super.vim-hypr-nav.overrideAttrs {
    runtimeDeps = [ jq ];
  };

  vim-indentwise = super.vim-indentwise.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Plus;
    };
  });

  vim-isort = super.vim-isort.overrideAttrs {
    postPatch = ''
      substituteInPlace autoload/vimisort.vim \
        --replace-fail 'import vim' 'import vim; import sys; sys.path.append("${python3.pkgs.isort}/${python3.sitePackages}")'
    '';
  };

  vim-javascript = super.vim-javascript.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-jdaddy = super.vim-jdaddy.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-jsbeautify = super.vim-jsbeautify.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-json = super.vim-json.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-LanguageTool = super.vim-LanguageTool.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-ledger = super.vim-ledger.overrideAttrs (old: {
    meta = old.meta // {
      # README carries the GPL-2.0-or-later notice; GitHub did not detect it.
      license = lib.licenses.gpl2Plus;
    };
  });

  vim-lexical = super.vim-lexical.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-lion = super.vim-lion.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-llvm = super.vim-llvm.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.WITH lib.licenses.asl20 lib.licenses.llvm-exception;
    };
  });

  vim-markdown = super.vim-markdown.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-mediawiki-editor = super.vim-mediawiki-editor.overrideAttrs (old: {
    passthru = old.passthru // {
      python3Dependencies = ps: [ ps.mwclient ];
    };
  });

  vim-merginal = super.vim-merginal.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-metamath = super.vim-metamath.overrideAttrs {
    preInstall = "cd vim";
  };

  vim-misc = super.vim-misc.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-niceblock = super.vim-niceblock.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-obsession = super.vim-obsession.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-opencl = super.vim-opencl.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3;
    };
  });

  vim-openscad = super.vim-openscad.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  vim-operator-replace = super.vim-operator-replace.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-operator-surround = super.vim-operator-surround.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-operator-user = super.vim-operator-user.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-orgmode = super.vim-orgmode.overrideAttrs (old: {
    meta = old.meta // {
      # Source is AGPL-3.0-only; bundled docs are GFDL-1.3-or-later.
      license = with lib.licenses; [
        agpl3Only
        fdl13Plus
      ];
    };
  });

  vim-peekaboo = super.vim-peekaboo.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-pencil = super.vim-pencil.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-pico8-syntax = super.vim-pico8-syntax.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-pluto = super.vim-pluto.overrideAttrs {
    dependencies = [ self.denops-vim ];
  };

  vim-pony = super.vim-pony.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-prettyprint = super.vim-prettyprint.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.zlib;
    };
  });

  vim-printer = super.vim-printer.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-projectionist = super.vim-projectionist.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-prosession = super.vim-prosession.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-protobuf = super.vim-protobuf.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.bsd3;
    };
  });

  vim-ps1 = super.vim-ps1.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.asl20;
    };
  });

  vim-ragtag = super.vim-ragtag.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-rails = super.vim-rails.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-repeat = super.vim-repeat.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-ReplaceWithRegister = super.vim-ReplaceWithRegister.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-ReplaceWithSameIndentRegister = super.vim-ReplaceWithSameIndentRegister.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-rsi = super.vim-rsi.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-salve = super.vim-salve.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-scriptease = super.vim-scriptease.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-sensible = super.vim-sensible.overrideAttrs (old: {
    patches = [ ./patches/vim-sensible/fix-nix-store-path-regex.patch ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-sentence-chopper = super.vim-sentence-chopper.overrideAttrs (old: {
    meta = old.meta // {
      # This plugin is under the license "Rien à Branler", which is a French translation of the WTFPL license.
      license = lib.licenses.wtfpl;
    };
  });

  vim-sexp-mappings-for-regular-people =
    super.vim-sexp-mappings-for-regular-people.overrideAttrs
      (old: {
        meta = old.meta // {
          license = lib.licenses.vim;
        };
      });

  vim-sile = super.vim-sile.overrideAttrs (old: {
    meta = old.meta // {
      license = with lib.licenses; [
        bsd0
        cc0
        gpl2Plus
      ];
    };
  });

  vim-sleuth = super.vim-sleuth.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-smalls = super.vim-smalls.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.cc-by-30;
    };
  });

  vim-snipmate = super.vim-snipmate.overrideAttrs (old: {
    dependencies = with self; [
      vim-addon-mw-utils
      tlib_vim
    ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-speeddating = super.vim-speeddating.overrideAttrs (old: {
    dependencies = [ self.vim-repeat ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-stationeers-ic10-syntax = super.vim-stationeers-ic10-syntax.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-stylish-haskell = super.vim-stylish-haskell.overrideAttrs (old: {
    postPatch = old.postPatch or "" + ''
      substituteInPlace ftplugin/haskell/stylish-haskell.vim --replace-fail \
        'g:stylish_haskell_command = "stylish-haskell"' \
        'g:stylish_haskell_command = "${stylish-haskell}/bin/stylish-haskell"'
    '';
  });

  vim-surround = super.vim-surround.overrideAttrs (old: {
    dependencies = [ self.vim-repeat ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-syntax-shakespeare = super.vim-syntax-shakespeare.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-SyntaxRange = super.vim-SyntaxRange.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-tabby = super.vim-tabby.overrideAttrs {
  };

  vim-table-mode = super.vim-table-mode.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-tabpagecd = super.vim-tabpagecd.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-tbone = super.vim-tbone.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-textobj-comment = super.vim-textobj-comment.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-textobj-entire = super.vim-textobj-entire.overrideAttrs (old: {
    dependencies = [ self.vim-textobj-user ];
    meta = old.meta // {
      maintainers = with lib.maintainers; [ workflow ];
      license = lib.licenses.mit;
    };
  });

  vim-textobj-function = super.vim-textobj-function.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-textobj-line = super.vim-textobj-line.overrideAttrs (old: {
    dependencies = [ self.vim-textobj-user ];
    meta = old.meta // {
      maintainers = with lib.maintainers; [ llakala ];
      license = lib.licenses.mit;
    };
  });

  vim-textobj-quote = super.vim-textobj-quote.overrideAttrs (old: {
    dependencies = [ self.vim-textobj-user ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-textobj-user = super.vim-textobj-user.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-tmux = super.vim-tmux.overrideAttrs (old: {
    meta = old.meta // {
      # original code publicDomain, MIT after fork
      license = with lib.licenses; [
        mit
        publicDomain
      ];
    };
  });

  vim-tpipeline = super.vim-tpipeline.overrideAttrs {
    # Requires global variable
    nvimSkipModules = [ "tpipeline.main" ];
  };

  vim-twiggy = super.vim-twiggy.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-ultest = super.vim-ultest.overrideAttrs {
    # NOTE: vim-ultest is no longer maintained.
    # If using Neovim, you can switch to using neotest (https://github.com/nvim-neotest/neotest) instead.
    nvimSkipModules = [ "ultest" ];
  };

  vim-unimpaired = super.vim-unimpaired.overrideAttrs (old: {
    dependencies = [ self.vim-repeat ];
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-vinegar = super.vim-vinegar.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vim-visual-increment = super.vim-visual-increment.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-visualstar = super.vim-visualstar.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.zlib;
    };
  });

  vim-waikiki = super.vim-waikiki.overrideAttrs (old: {
    meta = old.meta // {
      # README-only CC-BY-SA-4.0 notice; GitHub detection missed it.
      license = lib.licenses.cc-by-sa-40;
    };
  });

  vim-wakatime = super.vim-wakatime.overrideAttrs {
    buildInputs = [ python3 ];
    patchPhase = ''
      substituteInPlace plugin/wakatime.vim \
        --replace-fail 'autocmd BufEnter,VimEnter' \
                       'autocmd VimEnter' \
        --replace-fail 'autocmd CursorHold,CursorHoldI' \
                       'autocmd CursorHold,CursorHoldI,BufEnter'
    '';
  };

  vim-watchdogs = super.vim-watchdogs.overrideAttrs (old: {
    meta = old.meta // {
      # Plugin file licenses it under Perl terms (artistic1).
      license = lib.licenses.artistic1;
    };
  });

  vim-wordy = super.vim-wordy.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-xdebug = super.vim-xdebug.overrideAttrs (old: {
    postInstall = null;
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-xkbswitch = super.vim-xkbswitch.overrideAttrs {
    buildInputs = [ xkb-switch ];
  };

  vim-yapf = super.vim-yapf.overrideAttrs (old: {
    buildPhase = ''
      substituteInPlace ftplugin/python_yapf.vim \
        --replace-fail '"yapf"' '"${python3.pkgs.yapf}/bin/yapf"'
    '';
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vim-zettel = super.vim-zettel.overrideAttrs {
    dependencies = with self; [
      vimwiki
      fzf-vim
    ];
  };

  vim-zscript = super.vim-zscript.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.cc0;
    };
  });

  vimade = super.vimade.overrideAttrs {
    checkInputs = with self; [
      # Optional providers
      hlchunk-nvim
      mini-nvim
      snacks-nvim
    ];
  };

  vimagit = super.vimagit.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  VimCompletesMe = super.VimCompletesMe.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vimfiler-vim = super.vimfiler-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  VimOrganizer = super.VimOrganizer.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vimoutliner = super.vimoutliner.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  vimproc-vim = super.vimproc-vim.overrideAttrs (old: {
    buildInputs = [ which ];

    # TODO: revisit
    buildPhase = ''
      substituteInPlace autoload/vimproc.vim \
        --replace-fail vimproc_mac.so vimproc_unix.so \
        --replace-fail vimproc_linux64.so vimproc_unix.so \
        --replace-fail vimproc_linux32.so vimproc_unix.so
      make -f make_unix.mak
    '';

    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vimsence = super.vimsence.overrideAttrs (old: {
    meta = old.meta // {
      description = "Discord rich presence for Vim";
      homepage = "https://github.com/hugolgst/vimsence";
      maintainers = with lib.maintainers; [ hugolgst ];
    };
  });

  vimshell-vim = super.vimshell-vim.overrideAttrs (old: {
    dependencies = [ self.vimproc-vim ];
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  vimtex = super.vimtex.overrideAttrs {
    checkInputs = with self; [
      # Optional integrations
      fzf-lua
      snacks-nvim
    ];
  };

  vimwiki = super.vimwiki.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  virt-column-nvim = super.virt-column-nvim.overrideAttrs {
    # Meta file
    nvimSkipModules = [ "virt-column.config.types" ];
  };

  vis = super.vis.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vissort-vim = super.vissort-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  vivify-vim = super.vivify-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3;
    };
  });

  vs-tasks-nvim = super.vs-tasks-nvim.overrideAttrs {
    checkInputs = [
      # Optional telescope integration
      self.telescope-nvim
    ];
    dependencies = [
      self.plenary-nvim
    ];
  };

  webapi-vim = super.webapi-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  which-key-nvim = super.which-key-nvim.overrideAttrs {
    nvimSkipModules = [ "which-key.docs" ];
  };

  whichpy-nvim = super.whichpy-nvim.overrideAttrs {
    checkInputs = [
      # Optional telescope integration
      self.telescope-nvim
    ];
  };

  whitespace-nvim = super.whitespace-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  wiki-vim = super.wiki-vim.overrideAttrs {
    checkInputs = [
      # Optional picker integration
      self.telescope-nvim
      self.fzf-lua
    ];
  };

  windows-nvim = super.windows-nvim.overrideAttrs {
    dependencies = with self; [
      middleclass
      animation-nvim
    ];
    nvimSkipModules = [
      # Animation doesn't work headless
      "windows.autowidth"
      "windows.commands"
    ];
  };

  wtf-nvim = super.wtf-nvim.overrideAttrs {
    dependencies = with self; [
      nui-nvim
      plenary-nvim
    ];
  };

  xeno-nvim = super.xeno-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  xmake-nvim = super.xmake-nvim.overrideAttrs {
    nvimSkipModules = [
      # attempt to index upvalue 'options' (a nil value)
      "xmake.action"
      "xmake.command"
      "xmake.runner_wrapper"
    ];
  };

  xterm-color-table-vim = super.xterm-color-table-vim.overrideAttrs (old: {
    meta = old.meta // {
      # README-only MIT notice; GitHub detection missed it.
      license = lib.licenses.mit;
    };
  });

  yaml-companion-nvim = super.yaml-companion-nvim.overrideAttrs {
    dependencies = [
      self.nvim-lspconfig
      self.plenary-nvim
    ];
  };

  yaml-schema-detect-nvim = super.yaml-schema-detect-nvim.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      nvim-lspconfig
    ];
  };

  yank-path-nvim = super.yank-path-nvim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  yanky-nvim = super.yanky-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional telescope integration
      telescope-nvim
    ];
  };

  yazi-nvim = super.yazi-nvim.overrideAttrs {
    dependencies = [ self.plenary-nvim ];
    nvimSkipModules = [
      # Used for reproducing issues
      "repro"
    ];
  };

  YouCompleteMe = super.YouCompleteMe.overrideAttrs (old: {
    buildPhase = ''
      substituteInPlace plugin/youcompleteme.vim \
        --replace-fail "'ycm_path_to_python_interpreter', '''" \
        "'ycm_path_to_python_interpreter', '${python3}/bin/python3'"

      rm -r third_party/ycmd
      ln -s ${ycmd}/lib/ycmd third_party
    '';

    meta = old.meta // {
      description = "Code-completion engine for Vim";
      homepage = "https://github.com/Valloric/YouCompleteMe";
      license = lib.licenses.gpl3;
      maintainers = with lib.maintainers; [
        mel
      ];
      platforms = lib.platforms.unix;
    };
  });

  zeavim-vim = super.zeavim-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.publicDomain;
    };
  });

  zenbones-nvim = super.zenbones-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional lush-nvim integration
      lush-nvim
    ];
    nvimSkipModules = [
      # Requires global variable set
      "randombones"
      "randombones.palette"
      "randombones_dark.palette"
      "randombones_light"
      "randombones_light.palette"
      # Optional shipwright
      "zenbones.shipwright.runners.alacritty"
      "zenbones.shipwright.runners.foot"
      "zenbones.shipwright.runners.ghostty"
      "zenbones.shipwright.runners.iterm"
      "zenbones.shipwright.runners.kitty"
      "zenbones.shipwright.runners.lightline"
      "zenbones.shipwright.runners.lualine"
      "zenbones.shipwright.runners.tmux"
      "zenbones.shipwright.runners.vim"
      "zenbones.shipwright.runners.wezterm"
      "zenbones.shipwright.runners.windows_terminal"
      "randombones_dark"
    ];
  };

  zenburn = super.zenburn.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.gpl3Only;
    };
  });

  zig-vim = super.zig-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.mit;
    };
  });

  zk-nvim = super.zk-nvim.overrideAttrs {
    checkInputs = with self; [
      # Optional pickers
      fzf-lua
      mini-nvim
      snacks-nvim
      telescope-nvim
    ];
    nvimSkipModules = [
      # Address in use error from fzf-lua on darwin
      # https://github.com/NixOS/nixpkgs/issues/431458
      "zk.pickers.fzf_lua"
    ];
  };

  zoomwintab-vim = super.zoomwintab-vim.overrideAttrs (old: {
    meta = old.meta // {
      license = lib.licenses.vim;
    };
  });

  zotcite = super.zotcite.overrideAttrs {
    dependencies = with self; [
      plenary-nvim
      telescope-nvim
    ];
  };

  zoxide-vim = super.zoxide-vim.overrideAttrs {
    buildInputs = [ zoxide ];

    postPatch = ''
      substituteInPlace autoload/zoxide.vim \
        --replace-fail "'zoxide_executable', 'zoxide'" "'zoxide_executable', '${zoxide}/bin/zoxide'"
    '';
  };
  # keep-sorted end
}