"Simple API to create your own pickers"

[dkuettel]

Hi,

in the readme of the pickers it says "Simple API to create your own pickers". From some of the examples I could find it looks like it could be simple. But I'm having a hard time finding any documentation. Do you know if there is any?

For some of the types like snacks.picker.format I cannot find the type definition, plus for things like snacks.picker.Item looking at some of the built-in finders, they don't seem to really follow that type.

/cheers

[drowning-cat]

There's no guide or documentation for creating new pickers. If you can't find something in the docs/picker.md, you'll most likely need to look at the source code.

I'd recommend looking at how others trying to implement their pickers. You can find a few additional examples here:

• My enhancements (drowning-cat) #1768

Sources (entry point):

snacks.nvim/lua/snacks/picker/config/sources.lua

Lines 1 to 1093 in 882c996

	---@class snacks.picker.Config
	---@field supports_live? boolean
	---@class snacks.picker.sources.Config
	---@field [string] snacks.picker.Config|{}
	local M = {}
	M.autocmds = {
	finder = "vim_autocmds",
	format = "autocmd",
	preview = "preview",
	}
	---@class snacks.picker.buffers.Config: snacks.picker.Config
	---@field hidden? boolean show hidden buffers (unlisted)
	---@field unloaded? boolean show loaded buffers
	---@field current? boolean show current buffer
	---@field nofile? boolean show `buftype=nofile` buffers
	---@field modified? boolean show only modified buffers
	---@field sort_lastused? boolean sort by last used
	---@field filter? snacks.picker.filter.Config
	M.buffers = {
	finder = "buffers",
	format = "buffer",
	hidden = false,
	unloaded = true,
	current = true,
	sort_lastused = true,
	win = {
	input = {
	keys = {
	["<c-x>"] = { "bufdelete", mode = { "n", "i" } },
	},
	},
	list = { keys = { ["dd"] = "bufdelete" } },
	},
	}
	---@class snacks.picker.explorer.Config: snacks.picker.files.Config|{}
	---@field follow_file? boolean follow the file from the current buffer
	---@field tree? boolean show the file tree (default: true)
	---@field git_status? boolean show git status (default: true)
	---@field git_status_open? boolean show recursive git status for open directories
	---@field git_untracked? boolean needed to show untracked git status
	---@field diagnostics? boolean show diagnostics
	---@field diagnostics_open? boolean show recursive diagnostics for open directories
	---@field watch? boolean watch for file changes
	---@field exclude? string[] exclude glob patterns
	---@field include? string[] include glob patterns. These take precedence over `exclude`, `ignored` and `hidden`
	M.explorer = {
	finder = "explorer",
	sort = { fields = { "sort" } },
	supports_live = true,
	tree = true,
	watch = true,
	diagnostics = true,
	diagnostics_open = false,
	git_status = true,
	git_status_open = false,
	git_untracked = true,
	follow_file = true,
	focus = "list",
	auto_close = false,
	jump = { close = false },
	layout = { preset = "sidebar", preview = false },
	-- to show the explorer to the right, add the below to
	-- your config under `opts.picker.sources.explorer`
	-- layout = { layout = { position = "right" } },
	formatters = {
	file = { filename_only = true },
	severity = { pos = "right" },
	},
	matcher = { sort_empty = false, fuzzy = false },
	config = function(opts)
	return require("snacks.picker.source.explorer").setup(opts)
	end,
	win = {
	list = {
	keys = {
	["<BS>"] = "explorer_up",
	["l"] = "confirm",
	["h"] = "explorer_close", -- close directory
	["a"] = "explorer_add",
	["d"] = "explorer_del",
	["r"] = "explorer_rename",
	["c"] = "explorer_copy",
	["m"] = "explorer_move",
	["o"] = "explorer_open", -- open with system application
	["P"] = "toggle_preview",
	["y"] = { "explorer_yank", mode = { "n", "x" } },
	["p"] = "explorer_paste",
	["u"] = "explorer_update",
	["<c-c>"] = "tcd",
	["<leader>/"] = "picker_grep",
	["<c-t>"] = "terminal",
	["."] = "explorer_focus",
	["I"] = "toggle_ignored",
	["H"] = "toggle_hidden",
	["Z"] = "explorer_close_all",
	["]g"] = "explorer_git_next",
	["[g"] = "explorer_git_prev",
	["]d"] = "explorer_diagnostic_next",
	["[d"] = "explorer_diagnostic_prev",
	["]w"] = "explorer_warn_next",
	["[w"] = "explorer_warn_prev",
	["]e"] = "explorer_error_next",
	["[e"] = "explorer_error_prev",
	},
	},
	},
	}
	M.cliphist = {
	finder = "system_cliphist",
	format = "text",
	preview = "preview",
	confirm = { "copy", "close" },
	}
	-- Neovim colorschemes with live preview
	M.colorschemes = {
	finder = "vim_colorschemes",
	format = "text",
	preview = "colorscheme",
	preset = "vertical",
	confirm = function(picker, item)
	picker:close()
	if item then
	picker.preview.state.colorscheme = nil
	vim.schedule(function()
	vim.cmd("colorscheme " .. item.text)
	end)
	end
	end,
	}
	-- Neovim command history
	---@type snacks.picker.history.Config
	M.command_history = {
	finder = "vim_history",
	name = "cmd",
	format = "text",
	preview = "none",
	main = { current = true },
	layout = {
	preset = "vscode",
	},
	confirm = "cmd",
	formatters = { text = { ft = "vim" } },
	}
	-- Neovim commands
	M.commands = {
	finder = "vim_commands",
	format = "command",
	preview = "preview",
	confirm = "cmd",
	}
	---@class snacks.picker.diagnostics.Config: snacks.picker.Config
	---@field filter? snacks.picker.filter.Config
	---@field severity? vim.diagnostic.SeverityFilter
	M.diagnostics = {
	finder = "diagnostics",
	format = "diagnostic",
	sort = {
	fields = {
	"is_current",
	"is_cwd",
	"severity",
	"file",
	"lnum",
	},
	},
	matcher = { sort_empty = true },
	-- only show diagnostics from the cwd by default
	filter = { cwd = true },
	}
	---@type snacks.picker.diagnostics.Config
	M.diagnostics_buffer = {
	finder = "diagnostics",
	format = "diagnostic",
	sort = {
	fields = { "severity", "file", "lnum" },
	},
	matcher = { sort_empty = true },
	filter = { buf = true },
	}
	---@class snacks.picker.files.Config: snacks.picker.proc.Config
	---@field cmd? "fd"| "rg"| "find" command to use. Leave empty to auto-detect
	---@field hidden? boolean show hidden files
	---@field ignored? boolean show ignored files
	---@field dirs? string[] directories to search
	---@field follow? boolean follow symlinks
	---@field exclude? string[] exclude patterns
	---@field args? string[] additional arguments
	---@field ft? string|string[] file extension(s)
	---@field rtp? boolean search in runtimepath
	M.files = {
	finder = "files",
	format = "file",
	show_empty = true,
	hidden = false,
	ignored = false,
	follow = false,
	supports_live = true,
	}
	---@class snacks.picker.gh.Config: snacks.picker.Config
	---@field app? string GitHub App author
	---@field assignee? string filter by assignee
	---@field author? string filter by author
	---@field jq? string custom jq filter
	---@field label? string filter by label(s)
	---@field limit? number number of items to fetch (default: 50)
	---@field repo? string GitHub repository (owner/repo). Defaults to current git repo
	---@class snacks.picker.gh.issue.Config: snacks.picker.gh.Config
	---@field state "open" | "closed" | "all"
	---@field mention? string filter by mention
	---@field milestone? string filter by milestone
	M.gh_issue = {
	title = " Issues",
	finder = "gh_issue",
	format = "gh_format",
	preview = "gh_preview",
	sort = { fields = { "score:desc", "idx" } },
	supports_live = true,
	live = true,
	confirm = "gh_actions",
	win = {
	input = {
	keys = {
	["<a-b>"] = { "gh_browse", mode = { "n", "i" } },
	["<c-y>"] = { "gh_yank", mode = { "n", "i" } },
	},
	},
	list = {
	keys = {
	["y"] = { "gh_yank", mode = { "n", "x" } },
	},
	},
	},
	}
	---@class snacks.picker.gh.pr.Config: snacks.picker.gh.Config
	---@field state "open" | "closed" | "merged" | "all"
	---@field draft? boolean filter draft PRs
	---@field base? string filter by base branch
	M.gh_pr = {
	title = " Pull Requests",
	finder = "gh_pr",
	format = "gh_format",
	preview = "gh_preview",
	sort = { fields = { "score:desc", "idx" } },
	supports_live = true,
	live = true,
	confirm = "gh_actions",
	win = {
	input = {
	keys = {
	["<a-b>"] = { "gh_browse", mode = { "n", "i" } },
	["<c-y>"] = { "gh_yank", mode = { "n", "i" } },
	},
	},
	list = {
	keys = {
	["y"] = { "gh_yank", mode = { "n", "x" } },
	},
	},
	},
	}
	---@class snacks.picker.gh.diff.Config: snacks.picker.Config
	---@field group? boolean group changes by file (when false, show individual hunks)
	---@field pr number number PR number to diff against
	---@field repo? string GitHub repository (owner/repo). Defaults to current git repo
	M.gh_diff = {
	title = " Pull Request Diff",
	group = true,
	finder = "gh_diff",
	format = "git_status",
	preview = "gh_preview_diff",
	win = {
	preview = {
	keys = {
	["a"] = { "gh_comment", mode = { "n", "x" } },
	["<cr>"] = { "gh_actions", mode = { "n", "x" } },
	},
	},
	},
	}
	---@class snacks.picker.gh.reactions.Config: snacks.picker.Config
	---@field number number issue or PR number
	---@field repo string GitHub repository (owner/repo). Defaults to current git repo
	M.gh_reactions = {
	layout = { preset = "select", layout = { max_width = 50 } },
	title = " Reactions",
	main = { current = true },
	group = true,
	finder = "gh_reactions",
	format = "gh_format_reaction",
	}
	---@class snacks.picker.gh.labels.Config: snacks.picker.Config
	---@field number number issue or PR number
	---@field repo string GitHub repository (owner/repo). Defaults to current git repo
	M.gh_labels = {
	layout = { preset = "select", layout = { max_width = 50 } },
	title = " Labels",
	main = { current = true },
	group = true,
	finder = "gh_labels",
	format = "gh_format_label",
	}
	---@class snacks.picker.gh.actions.Config: snacks.picker.Config
	---@field number number issue or PR number
	---@field repo string GitHub repository (owner/repo). Defaults to current git repo
	---@field type "issue" | "pr"
	---@field item? snacks.picker.gh.Item
	M.gh_actions = {
	layout = { preset = "select", layout = { max_width = 50 } },
	title = " Actions",
	main = { current = true },
	finder = "gh_get_actions",
	format = "gh_format_action",
	confirm = "gh_perform_action",
	}
	--- Git arguments are use like this:
	--- * git [<cmd_args>] <cmd> [<args>]
	--- * cmd may be `status`, `log`, `diff`, etc.
	---@class snacks.picker.git.Config: snacks.picker.Config,snacks.picker.git.Args
	---@field args? string[] additional arguments to pass to `git`
	---@field cmd_args? string[] additional arguments to pass to the `git <cmd>``
	---@class snacks.picker.git.branches.Config: snacks.picker.git.Config
	---@field all? boolean show all branches, including remote
	M.git_branches = {
	all = false,
	finder = "git_branches",
	format = "git_branch",
	preview = "git_log",
	confirm = "git_checkout",
	win = {
	input = {
	keys = {
	["<c-a>"] = { "git_branch_add", mode = { "n", "i" } },
	["<c-x>"] = { "git_branch_del", mode = { "n", "i" } },
	},
	},
	},
	---@param picker snacks.Picker
	on_show = function(picker)
	for i, item in ipairs(picker:items()) do
	if item.current then
	picker.list:view(i)
	Snacks.picker.actions.list_scroll_center(picker)
	break
	end
	end
	end,
	}
	-- Find git files
	---@class snacks.picker.git.files.Config: snacks.picker.git.Config
	---@field untracked? boolean show untracked files
	---@field submodules? boolean show submodule files
	M.git_files = {
	finder = "git_files",
	show_empty = true,
	format = "file",
	untracked = false,
	submodules = false,
	}
	-- Grep in git files
	---@class snacks.picker.git.grep.Config: snacks.picker.git.Config
	---@field untracked? boolean search in untracked files
	---@field submodules? boolean search in submodule files
	---@field need_search? boolean require a search pattern
	---@field pathspec? string|string[] pathspec pattern(s)
	---@field ignorecase? boolean ignore case
	M.git_grep = {
	finder = "git_grep",
	format = "file",
	untracked = false,
	need_search = true,
	submodules = false,
	show_empty = true,
	supports_live = true,
	live = true,
	}
	-- Git log
	---@class snacks.picker.git.log.Config: snacks.picker.git.Config
	---@field follow? boolean track file history across renames
	---@field current_file? boolean show current file log
	---@field current_line? boolean show current line log
	---@field author? string filter commits by author
	M.git_log = {
	finder = "git_log",
	format = "git_log",
	preview = "git_show",
	confirm = "git_checkout",
	supports_live = true,
	sort = { fields = { "score:desc", "idx" } },
	}
	---@type snacks.picker.git.log.Config
	M.git_log_file = {
	finder = "git_log",
	format = "git_log",
	preview = "git_show",
	current_file = true,
	follow = true,
	confirm = "git_checkout",
	sort = { fields = { "score:desc", "idx" } },
	}
	---@type snacks.picker.git.log.Config
	M.git_log_line = {
	finder = "git_log",
	format = "git_log",
	preview = "git_show",
	current_line = true,
	follow = true,
	confirm = "git_checkout",
	sort = { fields = { "score:desc", "idx" } },
	}
	M.git_stash = {
	finder = "git_stash",
	format = "git_stash",
	preview = "git_stash",
	confirm = "git_stash_apply",
	}
	---@class snacks.picker.git.status.Config: snacks.picker.git.Config
	---@field ignored? boolean show ignored files
	M.git_status = {
	finder = "git_status",
	format = "git_status",
	preview = "git_status",
	win = {
	input = {
	keys = {
	["<Tab>"] = { "git_stage", mode = { "n", "i" } },
	["<c-r>"] = { "git_restore", mode = { "n", "i" }, nowait = true },
	},
	},
	},
	}
	---@class snacks.picker.git.diff.Config: snacks.picker.git.Config
	---@field group? boolean group changes by file (when false, show individual hunks)
	---@field staged? boolean show staged changes
	---@field base? string base commit/branch/tag to diff against (default: HEAD)
	M.git_diff = {
	group = false,
	finder = "git_diff",
	format = "git_status",
	preview = "diff",
	matcher = { sort_empty = true },
	sort = { fields = { "score:desc", "file", "idx" } },
	win = {
	input = {
	keys = {
	["<Tab>"] = { "git_stage", mode = { "n", "i" } },
	["<c-r>"] = { "git_restore", mode = { "n", "i" }, nowait = true },
	},
	},
	},
	}
	---@class snacks.picker.grep.Config: snacks.picker.proc.Config
	---@field cmd? string
	---@field hidden? boolean show hidden files
	---@field ignored? boolean show ignored files
	---@field dirs? string[] directories to search
	---@field follow? boolean follow symlinks
	---@field glob? string|string[] glob file pattern(s)
	---@field ft? string|string[] ripgrep file type(s). See `rg --type-list`
	---@field regex? boolean use regex search pattern (defaults to `true`)
	---@field buffers? boolean search in open buffers
	---@field need_search? boolean require a search pattern
	---@field exclude? string[] exclude patterns
	---@field args? string[] additional arguments
	---@field rtp? boolean search in runtimepath
	M.grep = {
	finder = "grep",
	regex = true,
	format = "file",
	show_empty = true,
	live = true, -- live grep by default
	supports_live = true,
	}
	---@type snacks.picker.grep.Config|{}
	M.grep_buffers = {
	finder = "grep",
	format = "file",
	live = true,
	buffers = true,
	need_search = false,
	supports_live = true,
	}
	---@type snacks.picker.grep.Config|{}
	M.grep_word = {
	finder = "grep",
	regex = false,
	args = { "--word-regexp" },
	format = "file",
	search = function(picker)
	return picker:word()
	end,
	live = false,
	supports_live = true,
	}
	-- Neovim help tags
	---@class snacks.picker.help.Config: snacks.picker.Config
	---@field lang? string[] defaults to `vim.opt.helplang`
	M.help = {
	finder = "help",
	format = "text",
	previewers = {
	file = { ft = "help" },
	},
	win = { preview = { minimal = true } },
	confirm = "help",
	}
	M.highlights = {
	finder = "vim_highlights",
	format = "hl",
	preview = "preview",
	confirm = "close",
	}
	---@class snacks.picker.icons.Config: snacks.picker.Config
	---@field icon_sources? string[] list of sources to use
	--- Custom icon sources can be added here. The key is the source name,
	--- and the value is the file path or URL to load icons from.
	--- The file should be a JSON array of:
	--- `{[1]:string, [2]:string}|{icon:string, name:string, category:string}`
	--- The format is compatible with https://github.com/nvim-telescope/telescope-symbols.nvim
	---@field custom_sources? table<string,string> additional icon sources `table<source,file|url>`
	M.icons = {
	main = { current = true },
	finder = "icons",
	format = "icon",
	layout = { preset = "vscode" },
	confirm = "put",
	}
	M.jumps = {
	finder = "vim_jumps",
	format = "file",
	main = { current = true },
	}
	---@class snacks.picker.keymaps.Config: snacks.picker.Config
	---@field global? boolean show global keymaps
	---@field local? boolean show buffer keymaps
	---@field plugs? boolean show plugin keymaps
	---@field modes? string[]
	M.keymaps = {
	finder = "vim_keymaps",
	format = "keymap",
	preview = "preview",
	global = true,
	plugs = false,
	["local"] = true,
	modes = { "n", "v", "x", "s", "o", "i", "c", "t" },
	---@param picker snacks.Picker
	confirm = function(picker, item)
	picker:norm(function()
	if item then
	picker:close()
	vim.api.nvim_input(item.item.lhs)
	end
	end)
	end,
	actions = {
	toggle_global = function(picker)
	picker.opts.global = not picker.opts.global
	picker:find()
	end,
	toggle_buffer = function(picker)
	picker.opts["local"] = not picker.opts["local"]
	picker:find()
	end,
	},
	win = {
	input = {
	keys = {
	["<a-g>"] = { "toggle_global", mode = { "n", "i" }, desc = "Toggle Global Keymaps" },
	["<a-b>"] = { "toggle_buffer", mode = { "n", "i" }, desc = "Toggle Buffer Keymaps" },
	},
	},
	},
	}
	--- Search for a lazy.nvim plugin spec
	M.lazy = {
	finder = "lazy_spec",
	pattern = "'",
	}
	-- Search lines in the current buffer
	---@class snacks.picker.lines.Config: snacks.picker.Config
	---@field buf? number
	M.lines = {
	finder = "lines",
	format = "lines",
	layout = {
	preview = "main",
	preset = "ivy",
	},
	jump = { match = true },
	-- allow any window to be used as the main window
	main = { current = true },
	---@param picker snacks.Picker
	on_show = function(picker)
	local cursor = vim.api.nvim_win_get_cursor(picker.main)
	local info = vim.api.nvim_win_call(picker.main, vim.fn.winsaveview)
	picker.list:view(cursor[1], info.topline)
	picker:show_preview()
	end,
	sort = { fields = { "score:desc", "idx" } },
	}
	-- Loclist
	---@type snacks.picker.qf.Config
	M.loclist = {
	finder = "qf",
	format = "file",
	qf_win = 0,
	main = { current = true },
	}
	---@class snacks.picker.lsp.Config: snacks.picker.Config
	---@field include_current? boolean default false
	---@field unique_lines? boolean include only locations with unique lines
	---@field filter? snacks.picker.filter.Config
	---@class snacks.picker.lsp.config.Config: snacks.picker.Config
	---@field installed? boolean only show installed servers
	---@field configured? boolean only show configured servers (setup with lspconfig)
	---@field attached? boolean|number only show attached servers. When `number`, show only servers attached to that buffer (can be 0)
	M.lsp_config = {
	finder = "lsp.config#find",
	format = "lsp.config#format",
	preview = "lsp.config#preview",
	confirm = "close",
	sort = { fields = { "score:desc", "attached_buf", "attached", "enabled", "installed", "name" } },
	matcher = { sort_empty = true },
	}
	-- LSP declarations
	---@type snacks.picker.lsp.Config
	M.lsp_declarations = {
	finder = "lsp_declarations",
	format = "file",
	include_current = false,
	auto_confirm = true,
	jump = { tagstack = true, reuse_win = true },
	}
	-- LSP definitions
	---@type snacks.picker.lsp.Config
	M.lsp_definitions = {
	finder = "lsp_definitions",
	format = "file",
	include_current = false,
	auto_confirm = true,
	jump = { tagstack = true, reuse_win = true },
	}
	-- LSP implementations
	---@type snacks.picker.lsp.Config
	M.lsp_implementations = {
	finder = "lsp_implementations",
	format = "file",
	include_current = false,
	auto_confirm = true,
	jump = { tagstack = true, reuse_win = true },
	}
	-- LSP incoming calls
	---@type snacks.picker.lsp.Config
	M.lsp_incoming_calls = {
	finder = "lsp_incoming_calls",
	format = "lsp_symbol",
	include_current = false,
	workspace = true, -- this ensures the file is included in the formatter
	auto_confirm = true,
	jump = { tagstack = true, reuse_win = true },
	}
	-- LSP outgoing calls
	---@type snacks.picker.lsp.Config
	M.lsp_outgoing_calls = {
	finder = "lsp_outgoing_calls",
	format = "lsp_symbol",
	include_current = false,
	workspace = true, -- this ensures the file is included in the formatter
	auto_confirm = true,
	jump = { tagstack = true, reuse_win = true },
	}
	-- LSP references
	---@class snacks.picker.lsp.references.Config: snacks.picker.lsp.Config
	---@field include_declaration? boolean default true
	M.lsp_references = {
	finder = "lsp_references",
	format = "file",
	include_declaration = true,
	include_current = false,
	auto_confirm = true,
	jump = { tagstack = true, reuse_win = true },
	}
	-- LSP document symbols
	---@class snacks.picker.lsp.symbols.Config: snacks.picker.Config
	---@field tree? boolean show symbol tree
	---@field keep_parents? boolean keep parent symbols when filtering
	---@field filter table<string, string[]|boolean>? symbol kind filter
	---@field workspace? boolean show workspace symbols
	M.lsp_symbols = {
	finder = "lsp_symbols",
	format = "lsp_symbol",
	tree = true,
	filter = {
	default = {
	"Class",
	"Constructor",
	"Enum",
	"Field",
	"Function",
	"Interface",
	"Method",
	"Module",
	"Namespace",
	"Package",
	"Property",
	"Struct",
	"Trait",
	},
	-- set to `true` to include all symbols
	markdown = true,
	help = true,
	-- you can specify a different filter for each filetype
	lua = {
	"Class",
	"Constructor",
	"Enum",
	"Field",
	"Function",
	"Interface",
	"Method",
	"Module",
	"Namespace",
	-- "Package", -- remove package since luals uses it for control flow structures
	"Property",
	"Struct",
	"Trait",
	},
	},
	}
	---@type snacks.picker.lsp.symbols.Config
	M.lsp_workspace_symbols = vim.tbl_extend("force", {}, M.lsp_symbols, {
	workspace = true,
	tree = false,
	supports_live = true,
	live = true, -- live by default
	})
	-- LSP type definitions
	---@type snacks.picker.lsp.Config
	M.lsp_type_definitions = {
	finder = "lsp_type_definitions",
	format = "file",
	include_current = false,
	auto_confirm = true,
	jump = { tagstack = true, reuse_win = true },
	}
	M.man = {
	finder = "system_man",
	format = "man",
	preview = "man",
	confirm = function(picker, item, action)
	---@cast action snacks.picker.jump.Action
	picker:close()
	if item then
	vim.schedule(function()
	local cmd = "Man " .. item.ref ---@type string
	if action.cmd == "vsplit" then
	cmd = "vert " .. cmd
	elseif action.cmd == "tab" then
	cmd = "tab " .. cmd
	end
	vim.cmd(cmd)
	end)
	end
	end,
	}
	---@class snacks.picker.marks.Config: snacks.picker.Config
	---@field global? boolean show global marks
	---@field local? boolean show buffer marks
	M.marks = {
	finder = "vim_marks",
	format = "file",
	global = true,
	["local"] = true,
	win = {
	input = {
	keys = {
	["<c-x>"] = { "mark_delete", mode = { "n", "i" } },
	},
	},
	},
	}
	---@class snacks.picker.notifications.Config: snacks.picker.Config
	---@field filter? snacks.notifier.level|fun(notif: snacks.notifier.Notif): boolean
	M.notifications = {
	finder = "snacks_notifier",
	format = "notification",
	preview = "preview",
	formatters = { severity = { level = true } },
	confirm = "close",
	}
	-- List all available sources
	M.pickers = {
	finder = "meta_pickers",
	format = "text",
	confirm = function(picker, item)
	picker:close()
	if item then
	vim.schedule(function()
	Snacks.picker(item.text)
	end)
	end
	end,
	}
	M.picker_actions = {
	finder = "meta_actions",
	format = "text",
	}
	M.picker_format = {
	finder = "meta_format",
	format = "text",
	}
	M.picker_layouts = {
	finder = "meta_layouts",
	format = "text",
	on_change = function(picker, item)
	vim.schedule(function()
	picker:set_layout(item.text)
	end)
	end,
	}
	M.picker_preview = {
	finder = "meta_preview",
	format = "text",
	}
	-- Open recent projects
	---@class snacks.picker.projects.Config: snacks.picker.Config
	---@field filter? snacks.picker.filter.Config
	---@field dev? string|string[] top-level directories containing multiple projects (sub-folders that contains a root pattern)
	---@field projects? string[] list of project directories
	---@field patterns? string[] patterns to detect project root directories
	---@field recent? boolean include project directories of recent files
	---@field max_depth? number maximum depth to search in dev directories (default: 2)
	M.projects = {
	finder = "recent_projects",
	format = "file",
	dev = { "~/dev", "~/projects" },
	confirm = "load_session",
	patterns = { ".git", "_darcs", ".hg", ".bzr", ".svn", "package.json", "Makefile" },
	recent = true,
	matcher = {
	frecency = true, -- use frecency boosting
	sort_empty = true, -- sort even when the filter is empty
	cwd_bonus = false,
	},
	sort = { fields = { "score:desc", "idx" } },
	win = {
	preview = { minimal = true },
	input = {
	keys = {
	-- every action will always first change the cwd of the current tabpage to the project
	["<c-e>"] = { { "tcd", "picker_explorer" }, mode = { "n", "i" } },
	["<c-f>"] = { { "tcd", "picker_files" }, mode = { "n", "i" } },
	["<c-g>"] = { { "tcd", "picker_grep" }, mode = { "n", "i" } },
	["<c-r>"] = { { "tcd", "picker_recent" }, mode = { "n", "i" }, nowait = true },
	["<c-w>"] = { { "tcd" }, mode = { "n", "i" } },
	["<c-t>"] = {
	function(picker)
	vim.cmd("tabnew")
	Snacks.notify("New tab opened")
	picker:close()
	Snacks.picker.projects()
	end,
	mode = { "n", "i" },
	},
	},
	},
	},
	}
	-- Quickfix list
	---@type snacks.picker.qf.Config
	M.qflist = {
	finder = "qf",
	format = "file",
	}
	-- Find recent files
	---@class snacks.picker.recent.Config: snacks.picker.Config
	---@field filter? snacks.picker.filter.Config
	M.recent = {
	finder = "recent_files",
	format = "file",
	filter = {
	paths = {
	[vim.fn.stdpath("data")] = false,
	[vim.fn.stdpath("cache")] = false,
	[vim.fn.stdpath("state")] = false,
	},
	},
	}
	-- Neovim registers
	M.registers = {
	finder = "vim_registers",
	main = { current = true },
	format = "register",
	preview = "preview",
	confirm = { "copy", "close" },
	}
	-- Special picker that resumes the last picker
	M.resume = {}
	-- Open or create scratch buffers
	M.scratch = {
	finder = "scratch",
	format = "scratch_format",
	confirm = "scratch_open",
	win = {
	input = {
	keys = {
	["<c-x>"] = { "scratch_delete", mode = { "n", "i" } },
	["<c-n>"] = { "scratch_new", mode = { "n", "i" } },
	},
	},
	},
	}
	-- Neovim search history
	---@type snacks.picker.history.Config
	M.search_history = {
	finder = "vim_history",
	name = "search",
	format = "text",
	preview = "none",
	main = { current = true },
	layout = { preset = "vscode" },
	confirm = "search",
	formatters = { text = { ft = "regex" } },
	}
	--- Config used by `vim.ui.select`.
	--- Not meant to be used directly.
	---@class snacks.picker.select.Config: snacks.picker.Config
	---@field kinds? table<string, snacks.picker.Config|{}> custom snacks picker configs for specific `vim.ui.select` kinds
	M.select = {
	items = {}, -- these are set dynamically
	main = { current = true },
	layout = { preset = "select" },
	}
	---@class snacks.picker.smart.Config: snacks.picker.Config
	---@field finders? string[] list of finders to use
	---@field filter? snacks.picker.filter.Config
	M.smart = {
	multi = { "buffers", "recent", "files" },
	format = "file", -- use `file` format for all sources
	matcher = {
	cwd_bonus = true, -- boost cwd matches
	frecency = true, -- use frecency boosting
	sort_empty = true, -- sort even when the filter is empty
	},
	transform = "unique_file",
	}
	M.spelling = {
	finder = "vim_spelling",
	format = "text",
	main = { current = true },
	layout = { preset = "vscode" },
	confirm = "item_action",
	}
	-- Search tags file
	---@class snacks.picker.tags.Config: snacks.picker.Config
	M.tags = {
	workspace = true, -- search tags in the workspace
	finder = "vim_tags",
	format = "lsp_symbol",
	}
	---@class snacks.picker.treesitter.Config: snacks.picker.Config
	---@field filter table<string, string[]|boolean>? symbol kind filter
	---@field tree? boolean show symbol tree
	M.treesitter = {
	finder = "treesitter_symbols",
	format = "lsp_symbol",
	tree = true,
	filter = {
	default = {
	"Class",
	"Enum",
	"Field",
	"Function",
	"Method",
	"Module",
	"Namespace",
	"Struct",
	"Trait",
	},
	-- set to `true` to include all symbols
	markdown = true,
	help = true,
	},
	}
	---@class snacks.picker.undo.Config: snacks.picker.Config
	---@field diff? vim.text.diff.Opts
	M.undo = {
	finder = "vim_undo",
	format = "undo",
	preview = "diff",
	confirm = "item_action",
	win = {
	preview = { wo = { number = false, relativenumber = false, signcolumn = "no" } },
	input = {
	keys = {
	["<c-y>"] = { "yank_add", mode = { "n", "i" } },
	["<c-s-y>"] = { "yank_del", mode = { "n", "i" } },
	},
	},
	},
	actions = {
	yank_add = { action = "yank", field = "added_lines" },
	yank_del = { action = "yank", field = "removed_lines" },
	},
	icons = { tree = { last = "┌╴" } }, -- the tree is upside down
	diff = {
	ctxlen = 4,
	ignore_cr_at_eol = true,
	ignore_whitespace_change_at_eol = true,
	indent_heuristic = true,
	},
	}
	-- Open a project from zoxide
	M.zoxide = {
	finder = "files_zoxide",
	format = "file",
	confirm = "load_session",
	win = {
	preview = {
	minimal = true,
	},
	},
	}
	return M

Finders:

https://github.com/folke/snacks.nvim/tree/main/lua/snacks/picker/source

for example vim_:

snacks.nvim/lua/snacks/picker/source/vim.lua

Lines 1 to 516 in 882c996

	local M = {}
	---@class snacks.picker.history.Config: snacks.picker.Config
	---@field name string
	function M.commands()
	local commands = vim.api.nvim_get_commands({})
	for k, v in pairs(vim.api.nvim_buf_get_commands(0, {})) do
	if type(k) == "string" then -- fixes vim.empty_dict() bug
	commands[k] = v
	end
	end
	for _, c in ipairs(vim.fn.getcompletion("", "command")) do
	if not commands[c] and c:find("^[a-z]") then
	commands[c] = { definition = "completion" }
	end
	end
	---@async
	---@param cb async fun(item: snacks.picker.finder.Item)
	return function(cb)
	---@type string[]
	local names = vim.tbl_keys(commands)
	table.sort(names)
	for _, name in pairs(names) do
	local def = commands[name]
	cb({
	text = name,
	desc = def.script_id and def.script_id < 0 and def.definition or nil,
	command = def,
	cmd = name,
	preview = {
	text = vim.inspect(def),
	ft = "lua",
	},
	})
	end
	end
	end
	---@param opts snacks.picker.history.Config
	function M.history(opts)
	local count = vim.fn.histnr(opts.name)
	local items = {}
	for i = count, 1, -1 do
	local line = vim.fn.histget(opts.name, i)
	if not line:find("^%s*$") then
	table.insert(items, {
	text = line,
	cmd = line,
	preview = {
	text = line,
	ft = "text",
	},
	})
	end
	end
	return items
	end
	---@param opts snacks.picker.marks.Config
	---@type snacks.picker.finder
	function M.marks(opts, ctx)
	local marks = {} ---@type vim.fn.getmarklist.ret.item[]
	local current_buf = ctx.filter.current_buf
	if opts.global then
	vim.list_extend(marks, vim.fn.getmarklist())
	end
	if opts["local"] then
	vim.list_extend(marks, vim.fn.getmarklist(current_buf))
	end
	---@type snacks.picker.finder.Item[]
	local items = {}
	local bufname = vim.api.nvim_buf_get_name(current_buf)
	for _, mark in ipairs(marks) do
	local file = mark.file or bufname
	local buf = mark.pos[1] and mark.pos[1] > 0 and mark.pos[1] or nil
	local line ---@type string?
	if buf and mark.pos[2] > 0 and vim.api.nvim_buf_is_valid(mark.pos[1]) then
	line = vim.api.nvim_buf_get_lines(buf, mark.pos[2] - 1, mark.pos[2], false)[1]
	end
	local label = mark.mark:sub(2, 2)
	items[#items + 1] = {
	text = table.concat({ label, file, line }, " "),
	label = label,
	line = line,
	buf = buf,
	file = file,
	pos = mark.pos[2] > 0 and { mark.pos[2], mark.pos[3] },
	}
	end
	table.sort(items, function(a, b)
	return a.label < b.label
	end)
	return items
	end
	function M.jumps()
	local jumps = vim.fn.getjumplist()[1]
	local items = {} ---@type snacks.picker.finder.Item[]
	for _, jump in ipairs(jumps) do
	local buf = jump.bufnr and vim.api.nvim_buf_is_valid(jump.bufnr) and jump.bufnr or 0
	local file = jump.filename or buf and vim.api.nvim_buf_get_name(buf) or nil
	if buf or file then
	local line ---@type string?
	if buf then
	line = vim.api.nvim_buf_get_lines(buf, jump.lnum - 1, jump.lnum, false)[1]
	end
	local label = tostring(#jumps - #items)
	table.insert(items, 1, {
	label = Snacks.picker.util.align(label, #tostring(#jumps), { align = "right" }),
	buf = buf,
	line = line,
	text = table.concat({ file, line }, " "),
	file = file,
	pos = jump.lnum and jump.lnum > 0 and { jump.lnum, jump.col } or nil,
	})
	end
	end
	return items
	end
	function M.autocmds()
	local autocmds = vim.api.nvim_get_autocmds({})
	local items = {} ---@type snacks.picker.finder.Item[]
	for _, au in ipairs(autocmds) do
	local item = au --[[@as snacks.picker.finder.Item]]
	item.text = Snacks.picker.util.text(item, { "event", "group_name", "pattern", "command" })
	item.preview = {
	text = vim.inspect(au),
	ft = "lua",
	}
	item.item = au
	if au.callback then
	local info = debug.getinfo(au.callback, "S")
	if info.what == "Lua" then
	item.file = info.source:sub(2)
	item.pos = { info.linedefined, 0 }
	item.preview = "file"
	end
	end
	items[#items + 1] = item
	end
	return items
	end
	function M.highlights()
	local hls = vim.api.nvim_get_hl(0, {}) --[[@as table<string,vim.api.keyset.get_hl_info> ]]
	local items = {} ---@type snacks.picker.finder.Item[]
	for group, hl in pairs(hls) do
	local defs = {} ---@type {group:string, hl:vim.api.keyset.get_hl_info}[]
	defs[#defs + 1] = { group = group, hl = hl }
	local link = hl.link
	local done = { [group] = true } ---@type table<string, boolean>
	while link and not done[link] do
	done[link] = true
	local hl_link = hls[link]
	if hl_link then
	defs[#defs + 1] = { group = link, hl = hl_link }
	link = hl_link.link
	else
	break
	end
	end
	local code = {} ---@type string[]
	local extmarks = {} ---@type snacks.picker.Extmark[]
	local row = 1
	for _, def in ipairs(defs) do
	for _, prop in ipairs({ "fg", "bg", "sp" }) do
	local v = def.hl[prop]
	if type(v) == "number" then
	def.hl[prop] = ("#%06X"):format(v)
	end
	end
	code[#code + 1] = ("%s = %s"):format(def.group, vim.inspect(def.hl))
	extmarks[#extmarks + 1] = { row = row, col = 0, hl_group = def.group, end_col = #def.group }
	row = row + #vim.split(code[#code], "\n") + 1
	end
	items[#items + 1] = {
	text = vim.inspect(defs):gsub("\n", " "),
	hl_group = group,
	preview = {
	text = table.concat(code, "\n\n"),
	ft = "lua",
	extmarks = extmarks,
	},
	}
	end
	table.sort(items, function(a, b)
	return a.hl_group < b.hl_group
	end)
	return items
	end
	function M.colorschemes()
	local items = {} ---@type snacks.picker.finder.Item[]
	local rtp = vim.o.runtimepath
	if package.loaded.lazy then
	rtp = rtp .. "," .. table.concat(require("lazy.core.util").get_unloaded_rtp(""), ",")
	end
	local files = vim.fn.globpath(rtp, "colors/*", false, true) ---@type string[]
	for _, file in ipairs(files) do
	local name = vim.fn.fnamemodify(file, ":t:r")
	local ext = vim.fn.fnamemodify(file, ":e")
	if ext == "vim" or ext == "lua" then
	items[#items + 1] = {
	text = name,
	file = file,
	}
	end
	end
	return items
	end
	---@param opts snacks.picker.keymaps.Config
	function M.keymaps(opts)
	local items = {} ---@type snacks.picker.finder.Item[]
	local maps = {} ---@type vim.api.keyset.get_keymap[]
	for _, mode in ipairs(opts.modes) do
	if opts.global then
	vim.list_extend(maps, vim.api.nvim_get_keymap(mode))
	end
	if opts["local"] then
	vim.list_extend(maps, vim.api.nvim_buf_get_keymap(0, mode))
	end
	end
	local done = {} ---@type table<string, boolean>
	for _, km in ipairs(maps) do
	local key = Snacks.picker.util.text(km, { "mode", "lhs", "buffer" })
	local keep = true
	if opts.plugs == false and km.lhs:match("^<Plug>") then
	keep = false
	end
	if keep and not done[key] then
	done[key] = true
	local item = {
	mode = km.mode,
	item = km,
	key = km.lhs,
	preview = {
	text = vim.inspect(km),
	ft = "lua",
	},
	}
	if km.callback then
	local info = debug.getinfo(km.callback, "S")
	item.info = info
	if info.what == "Lua" then
	local source = info.source:sub(2)
	item.file = source:gsub("^vim/", vim.env.VIMRUNTIME .. "/lua/vim/")
	if source:find("^vim/") and info.linedefined == 0 then
	item.search = "/vim\\.keymap\\.set.*['\"]" .. km.lhs
	else
	item.pos = { info.linedefined, 0 }
	end
	item.preview = "file"
	end
	end
	item.text = Snacks.util.normkey(km.lhs)
	.. " "
	.. Snacks.picker.util.text(km, { "mode", "lhs", "rhs", "desc" })
	.. (item.file or "")
	items[#items + 1] = item
	end
	end
	return items
	end
	function M.registers()
	local registers = '*+"-:.%/#=_abcdefghijklmnopqrstuvwxyz0123456789'
	local items = {} ---@type snacks.picker.finder.Item[]
	local is_osc52 = vim.g.clipboard and vim.g.clipboard.name == "OSC 52"
	local has_clipboard = vim.g.loaded_clipboard_provider == 2
	for i = 1, #registers, 1 do
	local reg = registers:sub(i, i)
	local value = ""
	if is_osc52 and reg:match("[%+%*]") then
	value = "OSC 52 detected, register not checked to maintain compatibility"
	elseif has_clipboard or not reg:match("[%+%*]") then
	local ok, reg_value = pcall(vim.fn.getreg, reg, 1)
	value = (ok and reg_value or "") --[[@as string]]
	end
	if value ~= "" then
	table.insert(items, {
	text = ("%s: %s"):format(reg, value:gsub("\n", "\\n"):gsub("\r", "\\r")),
	reg = reg,
	label = reg,
	data = value,
	value = value:gsub("\n", "\\n"):gsub("\r", "\\r"),
	preview = {
	text = value,
	ft = "text",
	},
	})
	end
	end
	return items
	end
	function M.spelling()
	local buf = vim.api.nvim_get_current_buf()
	local win = vim.api.nvim_get_current_win()
	local cursor = vim.api.nvim_win_get_cursor(0)
	local line = vim.api.nvim_buf_get_lines(buf, cursor[1] - 1, cursor[1], false)[1]
	-- get a misspelled word from under the cursor, if not found, then use the cursor_word instead
	local bad = vim.fn.spellbadword() ---@type string[]
	local word = bad[1] == "" and vim.fn.expand("<cword>") or bad[1]
	local suggestions = vim.fn.spellsuggest(word, 25, bad[2] == "caps")
	local items = {} ---@type snacks.picker.finder.Item[]
	for _, label in ipairs(suggestions) do
	table.insert(items, {
	text = label,
	action = function()
	-- skip whitespace
	local col = cursor[2] + 1
	while line:sub(col, col):match("%s") and col < #line do
	col = col + 1
	vim.api.nvim_win_set_cursor(win, { cursor[1], col - 1 })
	end
	vim.cmd('normal! "_ciw' .. label)
	end,
	})
	end
	return items
	end
	---@class snacks.picker.tags.Tag
	---@field name string
	---@field filename string
	---@field cmd string
	---@field kind? string
	---@field static? string
	---@param opts snacks.picker.tags.Config
	---@type snacks.picker.finder
	function M.tags(opts, ctx)
	local buf = ctx.filter.current_buf
	---@type snacks.picker.tags.Tag[]
	local tags = vim.fn.taglist(ctx.filter.search == "" and ".*" or ctx.filter.search, vim.api.nvim_buf_get_name(buf))
	local ret = {} ---@type snacks.picker.finder.Item[]
	local lsp_kinds = {
	c = "Class",
	d = "Constant",
	e = "Enum",
	f = "Function",
	g = "EnumMember",
	l = "Variable",
	m = "Method",
	s = "Struct",
	t = "TypeParameter",
	v = "Variable",
	F = "Field",
	M = "Module",
	n = "Namespace",
	P = "Property",
	S = "Struct",
	T = "TypeParameter",
	}
	for _, tag in ipairs(tags) do
	---@type snacks.picker.finder.Item
	local item = {
	text = tag.name,
	name = tag.name,
	file = tag.filename,
	search = tag.cmd,
	kind = tag.kind,
	lsp_kind = lsp_kinds[tag.kind] or "Text",
	}
	ret[#ret + 1] = item
	end
	return ret
	end
	---@param opts snacks.picker.undo.Config
	---@type snacks.picker.finder
	function M.undo(opts, ctx)
	local tree = vim.fn.undotree()
	local buf = vim.api.nvim_get_current_buf()
	local file = vim.api.nvim_buf_get_name(buf)
	local items = {} ---@type snacks.picker.finder.Item[]
	local diff_fn = vim.text and vim.text.diff or vim.diff
	-- Copy the current buffer to a temporary file and load the undo history.
	-- This is done to prevent the current buffer from being modified,
	-- and is way better for performance, since LSP change tracking won't be triggered
	local tmp_file = vim.fn.stdpath("cache") .. "/snacks-undo"
	local tmp_undo = tmp_file .. ".undo"
	local tmpbuf = vim.fn.bufadd(tmp_file)
	vim.bo[tmpbuf].swapfile = false
	vim.fn.writefile(vim.api.nvim_buf_get_lines(buf, 0, -1, false), tmp_file)
	vim.fn.bufload(tmpbuf)
	vim.api.nvim_buf_call(buf, function()
	vim.cmd("silent wundo! " .. tmp_undo)
	end)
	vim.api.nvim_buf_call(tmpbuf, function()
	pcall(vim.cmd, "silent rundo " .. tmp_undo)
	end)
	---@param item snacks.picker.finder.Item
	local function resolve(item)
	local entry = item.item ---@type vim.fn.undotree.entry
	---@type string[], string[]
	local before, after = {}, {}
	local ei = vim.o.eventignore
	vim.o.eventignore = "all"
	vim.api.nvim_buf_call(tmpbuf, function()
	-- state after the undo
	vim.cmd("noautocmd silent undo " .. entry.seq)
	after = vim.api.nvim_buf_get_lines(tmpbuf, 0, -1, false)
	-- state before the undo
	vim.cmd("noautocmd silent undo")
	before = vim.api.nvim_buf_get_lines(tmpbuf, 0, -1, false)
	end)
	vim.o.eventignore = ei
	local diff = diff_fn(table.concat(before, "\n") .. "\n", table.concat(after, "\n") .. "\n", opts.diff) --[[@as string]]
	local changes = {} ---@type string[]
	local added_lines = {} ---@type string[]
	local removed_lines = {} ---@type string[]
	for _, line in ipairs(vim.split(diff, "\n")) do
	if line:sub(1, 1) == "+" then
	changes[#changes + 1] = line:sub(2)
	added_lines[#added_lines + 1] = line:sub(2)
	elseif line:sub(1, 1) == "-" then
	changes[#changes + 1] = line:sub(2)
	removed_lines[#removed_lines + 1] = line:sub(2)
	end
	end
	diff = Snacks.picker.util.tpl(
	"diff --git a/{file} b/{file}\n--- {file}\n+++ {file}\n{diff}",
	{ file = vim.fn.fnamemodify(file, ":."), diff = diff }
	)
	item.text = table.concat(changes, " ")
	item.data = table.concat(added_lines, "\n")
	item.added_lines = table.concat(added_lines, "\n")
	item.removed_lines = table.concat(removed_lines, "\n")
	item.added = #added_lines
	item.removed = #removed_lines
	item.diff = diff
	end
	---@param entries? vim.fn.undotree.entry[]
	---@param parent? snacks.picker.finder.Item
	local function add(entries, parent)
	entries = entries or {}
	table.sort(entries, function(a, b)
	return a.seq < b.seq
	end)
	local last ---@type snacks.picker.finder.Item?
	for e, entry in ipairs(entries) do
	add(entry.alt, last or parent)
	local item = {
	seq = entry.seq,
	buf = buf,
	resolve = resolve,
	file = file,
	item = entry,
	current = entry.seq == tree.seq_cur,
	parent = parent,
	last = e == #entries,
	action = function()
	vim.api.nvim_buf_call(buf, function()
	vim.cmd("undo " .. entry.seq)
	end)
	end,
	}
	items[#items + 1] = item
	last = item
	end
	end
	add(tree.entries)
	-- Resolve the items in batches to prevent blocking the UI
	---@param cb async fun(item: snacks.picker.finder.Item)
	---@async
	return function(cb)
	ctx.async:on("done", function()
	vim.schedule(function()
	-- Clean up the temporary files
	vim.api.nvim_buf_delete(tmpbuf, { force = true })
	vim.fn.delete(tmp_file)
	vim.fn.delete(tmp_undo)
	end)
	end)
	for i = #items, 1, -1 do
	local item = items[i]
	cb(item)
	if item.current then
	ctx.picker.list:set_target(#items - i + 1)
	end
	end
	while #items > 0 do
	vim.schedule(function()
	local count = 0
	while #items > 0 and count < 5 do
	count = count + 1
	local item = table.remove(items, 1)
	Snacks.picker.util.resolve(item)
	end
	ctx.async:resume()
	end)
	ctx.async:suspend()
	end
	end
	end
	return M

Formatters:

snacks.nvim/lua/snacks/picker/format.lua

Lines 1 to 741 in 882c996

	---@class snacks.picker.formatters
	---@field [string] snacks.picker.format
	local M = {}
	local uv = vim.uv or vim.loop
	function M.severity(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	local severity = item.severity
	severity = type(severity) == "number" and vim.diagnostic.severity[severity] or severity
	if not severity or type(severity) == "number" then
	return ret
	end
	---@cast severity string
	local lower = severity:lower()
	local cap = severity:sub(1, 1):upper() .. lower:sub(2)
	if picker.opts.formatters.severity.pos == "right" then
	return {
	{
	col = 0,
	virt_text = { { picker.opts.icons.diagnostics[cap], "Diagnostic" .. cap } },
	virt_text_pos = "right_align",
	hl_mode = "combine",
	},
	}
	end
	if picker.opts.formatters.severity.icons then
	ret[#ret + 1] = { picker.opts.icons.diagnostics[cap], "Diagnostic" .. cap, virtual = true }
	ret[#ret + 1] = { " ", virtual = true }
	end
	if picker.opts.formatters.severity.level then
	ret[#ret + 1] = { lower:upper(), "Diagnostic" .. cap, virtual = true }
	ret[#ret + 1] = { " ", virtual = true }
	end
	return ret
	end
	function M.filename(item, picker)
	---@type snacks.picker.Highlight[]
	local ret = {}
	if not item.file then
	return ret
	end
	local path = Snacks.picker.util.path(item) or item.file
	if picker.opts.icons.files.enabled ~= false then
	local name, cat = path, (item.dir and "directory" or "file")
	if item.buf and vim.api.nvim_buf_is_loaded(item.buf) and vim.bo[item.buf].buftype ~= "" then
	name = vim.bo[item.buf].filetype
	cat = "filetype"
	end
	local icon, hl = Snacks.util.icon(name, cat, {
	fallback = picker.opts.icons.files,
	})
	if item.buftype == "terminal" then
	icon, hl = " ", "Special"
	end
	if item.dir and item.open then
	icon = picker.opts.icons.files.dir_open
	end
	icon = Snacks.picker.util.align(icon, picker.opts.formatters.file.icon_width or 2)
	ret[#ret + 1] = { icon, hl, virtual = true }
	end
	local base_hl = item.dir and "SnacksPickerDirectory" or "SnacksPickerFile"
	local function is(prop)
	local it = item
	while it do
	if it[prop] then
	return true
	end
	it = it.parent
	end
	end
	if is("ignored") then
	base_hl = "SnacksPickerPathIgnored"
	elseif item.filename_hl then
	base_hl = item.filename_hl
	elseif is("hidden") then
	base_hl = "SnacksPickerPathHidden"
	end
	local dir_hl = "SnacksPickerDir"
	if picker.opts.formatters.file.filename_only then
	path = vim.fn.fnamemodify(item.file, ":t")
	path = path == "" and item.file or path
	ret[#ret + 1] = { path, base_hl, field = "file" }
	else
	ret[#ret + 1] = {
	"",
	resolve = function(max_width)
	local truncpath = Snacks.picker.util.truncpath(
	path,
	math.max(max_width, picker.opts.formatters.file.min_width or 20),
	{ cwd = picker:cwd(), kind = picker.opts.formatters.file.truncate }
	)
	local dir, base = truncpath:match("^(.*)/(.+)$")
	local resolved = {} ---@type snacks.picker.Highlight[]
	if base and dir then
	if picker.opts.formatters.file.filename_first then
	resolved[#resolved + 1] = { base, base_hl, field = "file" }
	resolved[#resolved + 1] = { " " }
	resolved[#resolved + 1] = { dir, dir_hl, field = "file" }
	else
	resolved[#resolved + 1] = { dir .. "/", dir_hl, field = "file" }
	resolved[#resolved + 1] = { base, base_hl, field = "file" }
	end
	else
	resolved[#resolved + 1] = { truncpath, base_hl, field = "file" }
	end
	return resolved
	end,
	}
	end
	if item.pos and item.pos[1] > 0 then
	ret[#ret + 1] = { ":", "SnacksPickerDelim" }
	ret[#ret + 1] = { tostring(item.pos[1]), "SnacksPickerRow" }
	if item.pos[2] > 0 then
	ret[#ret + 1] = { ":", "SnacksPickerDelim" }
	ret[#ret + 1] = { tostring(item.pos[2]), "SnacksPickerCol" }
	end
	end
	ret[#ret + 1] = { " " }
	if item.type == "link" then
	local real = uv.fs_realpath(item.file)
	local broken = not real
	real = real or uv.fs_readlink(item.file)
	if real then
	ret[#ret + 1] = { "-> ", "SnacksPickerDelim" }
	ret[#ret + 1] =
	{ Snacks.picker.util.truncpath(real, 20), broken and "SnacksPickerLinkBroken" or "SnacksPickerLink" }
	ret[#ret + 1] = { " " }
	end
	end
	return ret
	end
	function M.file(item, picker)
	---@type snacks.picker.Highlight[]
	local ret = {}
	if item.label then
	ret[#ret + 1] = { item.label, "SnacksPickerLabel" }
	ret[#ret + 1] = { " ", virtual = true }
	end
	if item.parent then
	vim.list_extend(ret, M.tree(item, picker))
	end
	if item.status then
	vim.list_extend(ret, M.file_git_status(item, picker))
	end
	if item.severity then
	vim.list_extend(ret, M.severity(item, picker))
	end
	vim.list_extend(ret, M.filename(item, picker))
	if item.comment then
	table.insert(ret, { item.comment, "SnacksPickerComment" })
	table.insert(ret, { " " })
	end
	if item.line then
	if item.positions then
	local offset = Snacks.picker.highlight.offset(ret)
	Snacks.picker.highlight.matches(ret, item.positions, offset)
	end
	Snacks.picker.highlight.format(item, item.line, ret)
	table.insert(ret, { " " })
	end
	return ret
	end
	function M.commit_message(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	local msg = item.msg ---@type string
	local type, scope, breaking, body = msg:match("^(%S+)%s*(%(.-%))(!?):%s*(.*)$")
	if not type then
	type, breaking, body = msg:match("^(%S+)(!?):%s*(.*)$")
	end
	local msg_hl = "SnacksPickerGitMsg"
	if type and body then
	local dimmed = vim.tbl_contains({ "chore", "bot", "build", "ci", "style", "test" }, type)
	msg_hl = dimmed and "SnacksPickerDimmed" or "SnacksPickerGitMsg"
	ret[#ret + 1] =
	{ type, breaking ~= "" and "SnacksPickerGitBreaking" or dimmed and "SnacksPickerBold" or "SnacksPickerGitType" }
	if scope and scope ~= "" then
	ret[#ret + 1] = { scope, "SnacksPickerGitScope" }
	end
	if breaking ~= "" then
	ret[#ret + 1] = { "!", "SnacksPickerGitBreaking" }
	end
	ret[#ret + 1] = { ":", "SnacksPickerDelim" }
	ret[#ret + 1] = { " " }
	msg = body
	end
	ret[#ret + 1] = { msg, msg_hl }
	Snacks.picker.highlight.markdown(ret)
	Snacks.picker.highlight.highlight(ret, {
	["#%d+"] = "SnacksPickerGitIssue",
	})
	return ret
	end
	function M.git_log(item, picker)
	local a = Snacks.picker.util.align
	local ret = {} ---@type snacks.picker.Highlight[]
	ret[#ret + 1] = { picker.opts.icons.git.commit, "SnacksPickerGitCommit" }
	local c = item.commit or item.branch or "HEAD"
	ret[#ret + 1] = { a(c, 8, { truncate = true }), "SnacksPickerGitCommit" }
	ret[#ret + 1] = { " " }
	if item.date then
	ret[#ret + 1] = { a(item.date, 16), "SnacksPickerGitDate" }
	end
	ret[#ret + 1] = { " " }
	Snacks.picker.highlight.extend(ret, M.commit_message(item, picker))
	if item.author then
	ret[#ret + 1] = { " <" .. item.author .. ">", "SnacksPickerGitAuthor" }
	end
	return ret
	end
	function M.git_branch(item, picker)
	local a = Snacks.picker.util.align
	local ret = {} ---@type snacks.picker.Highlight[]
	if item.current then
	ret[#ret + 1] = { a("", 2), "SnacksPickerGitBranchCurrent" }
	else
	ret[#ret + 1] = { a("", 2) }
	end
	if item.detached then
	ret[#ret + 1] = { a("(detached HEAD)", 30, { truncate = true }), "SnacksPickerGitDetached" }
	else
	ret[#ret + 1] = { a(item.branch, 30, { truncate = true }), "SnacksPickerGitBranch" }
	end
	ret[#ret + 1] = { " " }
	Snacks.picker.highlight.extend(ret, M.git_log(item, picker))
	return ret
	end
	function M.git_stash(item, picker)
	local a = Snacks.picker.util.align
	local ret = {} ---@type snacks.picker.Highlight[]
	ret[#ret + 1] = { a(item.stash, 10), "SnacksPickerIdx" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(item.branch, 10, { truncate = true }), "SnacksPickerGitBranch" }
	ret[#ret + 1] = { " " }
	Snacks.picker.highlight.extend(ret, M.git_log(item, picker))
	return ret
	end
	function M.tree(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	local icons = picker.opts.icons.tree
	local indent = {} ---@type string[]
	local node = item
	while node and node.parent do
	local is_last, icon = node.last, ""
	if node ~= item then
	icon = is_last and " " or icons.vertical
	else
	icon = is_last and icons.last or icons.middle
	end
	table.insert(indent, 1, icon)
	node = node.parent
	end
	ret[#ret + 1] = { table.concat(indent), "SnacksPickerTree" }
	return ret
	end
	function M.undo(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	local entry = item.item ---@type vim.fn.undotree.entry
	local a = Snacks.picker.util.align
	if item.current then
	ret[#ret + 1] = { a("", 2), "SnacksPickerUndoCurrent" }
	else
	ret[#ret + 1] = { a("", 2) }
	end
	vim.list_extend(ret, M.tree(item, picker))
	local w = vim.api.nvim_strwidth(ret[#ret][1])
	ret[#ret + 1] = { tostring(entry.seq), "SnacksPickerIdx" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(" ", 8 - w - #tostring(entry.seq)) }
	ret[#ret + 1] = { a(Snacks.picker.util.reltime(entry.time), 15), "SnacksPickerTime" }
	ret[#ret + 1] = { " " }
	local function num(v, prefix)
	v = v or 0
	return a((v and v > 0 and prefix .. v or ""), 4)
	end
	ret[#ret + 1] = { num(item.added, "+"), "SnacksPickerUndoAdded" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { num(item.removed, "-"), "SnacksPickerUndoRemoved" }
	if entry.save then
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(picker.opts.icons.undo.saved, 2), "SnacksPickerUndoSaved" }
	end
	return ret
	end
	function M.lsp_symbol(item, picker)
	local opts = picker.opts --[[@as snacks.picker.lsp.symbols.Config]]
	local ret = {} ---@type snacks.picker.Highlight[]
	if item.tree and not opts.workspace then
	vim.list_extend(ret, M.tree(item, picker))
	end
	local kind = item.lsp_kind or item.kind or "Unknown" ---@type string
	kind = picker.opts.icons.kinds[kind] and kind or "Unknown"
	local kind_hl = "SnacksPickerIcon" .. kind
	ret[#ret + 1] = { picker.opts.icons.kinds[kind], kind_hl }
	ret[#ret + 1] = { " " }
	local name = vim.trim(item.name:gsub("\r?\n", " "))
	name = name == "" and item.detail or name
	Snacks.picker.highlight.format(item, name, ret)
	if opts.workspace then
	local offset = Snacks.picker.highlight.offset(ret, { char_idx = true })
	ret[#ret + 1] = { Snacks.picker.util.align(" ", 40 - offset) }
	vim.list_extend(ret, M.filename(item, picker))
	end
	return ret
	end
	---@param opts snacks.picker.ui_select.Opts
	---@return snacks.picker.format
	function M.ui_select(opts)
	return function(item, picker)
	local count = picker:count()
	local ret = {} ---@type snacks.picker.Highlight[]
	local idx = tostring(item.idx)
	idx = (" "):rep(#tostring(count) - #idx) .. idx
	ret[#ret + 1] = { idx .. ".", "SnacksPickerIdx" }
	ret[#ret + 1] = { " " }
	if opts.kind == "codeaction" then
	---@type lsp.Command|lsp.CodeAction, lsp.HandlerContext
	local action, ctx = item.item.action, item.item.ctx
	local client = vim.lsp.get_client_by_id(ctx.client_id)
	ret[#ret + 1] = { action.title }
	if client then
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { ("[%s]"):format(client.name), "SnacksPickerSpecial" }
	end
	elseif opts.format_item then
	local t = opts.format_item(item.item, true)
	if type(t) == "string" then
	ret[#ret + 1] = { t }
	elseif type(t) == "table" then
	vim.list_extend(ret, t)
	end
	else
	ret[#ret + 1] = { tostring(item.item) }
	end
	return ret
	end
	end
	function M.lines(item)
	local ret = {} ---@type snacks.picker.Highlight[]
	local line_count = vim.api.nvim_buf_line_count(item.buf)
	local idx = Snacks.picker.util.align(tostring(item.idx), #tostring(line_count), { align = "right" })
	ret[#ret + 1] = { idx, "LineNr", virtual = true }
	ret[#ret + 1] = { " ", virtual = true }
	ret[#ret + 1] = { item.text }
	local offset = #idx + 2
	for _, extmark in ipairs(item.highlights or {}) do
	extmark = vim.deepcopy(extmark)
	if type(extmark[1]) ~= "string" then
	---@cast extmark snacks.picker.Extmark
	extmark.col = extmark.col + offset
	if extmark.end_col then
	extmark.end_col = extmark.end_col + offset
	end
	end
	ret[#ret + 1] = extmark
	end
	return ret
	end
	function M.text(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	local ft = item.ft or picker.opts.formatters.text.ft
	if ft then
	Snacks.picker.highlight.format(item, item.text, ret, { lang = ft })
	else
	ret[#ret + 1] = { item.text, item.text_hl }
	end
	return ret
	end
	function M.command(item)
	local ret = {} ---@type snacks.picker.Highlight[]
	ret[#ret + 1] = { item.cmd, "SnacksPickerCmd" .. (item.cmd:find("^[a-z]") and "Builtin" or "") }
	if item.desc then
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { item.desc, "SnacksPickerDesc" }
	end
	return ret
	end
	function M.diagnostic(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	local diag = item.item ---@type vim.Diagnostic
	if item.severity then
	vim.list_extend(ret, M.severity(item, picker))
	end
	local message = diag.message
	ret[#ret + 1] = { message }
	Snacks.picker.highlight.markdown(ret)
	ret[#ret + 1] = { " " }
	if diag.source then
	ret[#ret + 1] = { diag.source, "SnacksPickerDiagnosticSource" }
	ret[#ret + 1] = { " " }
	end
	if diag.code then
	ret[#ret + 1] = { ("(%s)"):format(diag.code), "SnacksPickerDiagnosticCode" }
	ret[#ret + 1] = { " " }
	end
	vim.list_extend(ret, M.filename(item, picker))
	return ret
	end
	function M.autocmd(item)
	local ret = {} ---@type snacks.picker.Highlight[]
	---@type vim.api.keyset.get_autocmds.ret
	local au = item.item
	local a = Snacks.picker.util.align
	ret[#ret + 1] = { a(au.event, 15), "SnacksPickerAuEvent" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(au.pattern, 10), "SnacksPickerAuPattern" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(tostring(au.group_name or ""), 15), "SnacksPickerAuGroup" }
	ret[#ret + 1] = { " " }
	if au.command ~= "" then
	Snacks.picker.highlight.format(item, au.command, ret, { lang = "vim" })
	else
	ret[#ret + 1] = { "callback", "Function" }
	end
	return ret
	end
	function M.hl(item)
	local ret = {} ---@type snacks.picker.Highlight[]
	ret[#ret + 1] = { item.hl_group, item.hl_group }
	return ret
	end
	function M.man(item)
	local a = Snacks.picker.util.align
	local ret = {} ---@type snacks.picker.Highlight[]
	ret[#ret + 1] = { a(item.page, 20), "SnacksPickerManPage" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { ("(%s)"):format(item.section), "SnacksPickerManSection" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { item.desc, "SnacksPickerManDesc" }
	return ret
	end
	-- Pretty keymaps using which-key icons when available
	function M.keymap(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	---@type vim.api.keyset.get_keymap
	local k = item.item
	local a = Snacks.picker.util.align
	if package.loaded["which-key"] then
	local Icons = require("which-key.icons")
	local icon, hl = Icons.get({ keymap = k, desc = k.desc })
	if icon then
	ret[#ret + 1] = { a(icon, 3), hl }
	else
	ret[#ret + 1] = { " " }
	end
	end
	local lhs = Snacks.util.normkey(k.lhs)
	ret[#ret + 1] = { k.mode, "SnacksPickerKeymapMode" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(lhs, 15), "SnacksPickerKeymapLhs" }
	ret[#ret + 1] = { " " }
	local icon_nowait = picker.opts.icons.keymaps.nowait
	if k.nowait == 1 then
	ret[#ret + 1] = { icon_nowait, "SnacksPickerKeymapNowait" }
	else
	ret[#ret + 1] = { (" "):rep(vim.api.nvim_strwidth(icon_nowait)) }
	end
	ret[#ret + 1] = { " " }
	if k.buffer and k.buffer > 0 then
	ret[#ret + 1] = { a("buf:" .. k.buffer, 6), "SnacksPickerBufNr" }
	else
	ret[#ret + 1] = { a("", 6) }
	end
	ret[#ret + 1] = { " " }
	local rhs_len = 0
	if k.rhs and k.rhs ~= "" then
	local rhs = k.rhs or ""
	rhs_len = #rhs
	local cmd = rhs:lower():find("<cmd>")
	if cmd then
	ret[#ret + 1] = { rhs:sub(1, cmd + 4), "NonText" }
	rhs = rhs:sub(cmd + 5)
	local cr = rhs:lower():find("<cr>$")
	if cr then
	rhs = rhs:sub(1, cr - 1)
	end
	Snacks.picker.highlight.format(item, rhs, ret, { lang = "vim" })
	if cr then
	ret[#ret + 1] = { "<CR>", "NonText" }
	end
	elseif rhs:lower():find("^<plug>") then
	ret[#ret + 1] = { "<Plug>", "NonText" }
	local plug = rhs:sub(7):gsub("^%(", ""):gsub("%)$", "")
	ret[#ret + 1] = { "(", "SnacksPickerDelim" }
	Snacks.picker.highlight.format(item, plug, ret, { lang = "vim" })
	ret[#ret + 1] = { ")", "SnacksPickerDelim" }
	elseif rhs:find("v:lua%.") then
	ret[#ret + 1] = { "v:lua", "NonText" }
	ret[#ret + 1] = { ".", "SnacksPickerDelim" }
	Snacks.picker.highlight.format(item, rhs:sub(7), ret, { lang = "lua" })
	else
	ret[#ret + 1] = { k.rhs, "SnacksPickerKeymapRhs" }
	end
	else
	ret[#ret + 1] = { "callback", "Function" }
	rhs_len = 8
	end
	if rhs_len < 15 then
	ret[#ret + 1] = { (" "):rep(15 - rhs_len) }
	end
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(k.desc or "", 20) }
	if item.file then
	ret[#ret + 1] = { " " }
	vim.list_extend(ret, M.filename(item, picker))
	end
	return ret
	end
	function M.git_status(item, picker)
	local status = item.status
	if not status and item.block then
	local block = item.block ---@type snacks.picker.diff.Block
	status = block.new and "A" or block.delete and "D" or block.rename and "R" or block.copy and "C" or "M"
	status = block.unmerged and (status .. status) or item.staged and (status .. " ") or (" " .. status)
	elseif not status then
	return M.filename(item, picker)
	end
	local ret = {} ---@type snacks.picker.Highlight[]
	local a = Snacks.picker.util.align
	local s = vim.trim(status):sub(1, 1)
	local hls = {
	["A"] = "SnacksPickerGitStatusAdded",
	["M"] = "SnacksPickerGitStatusModified",
	["D"] = "SnacksPickerGitStatusDeleted",
	["R"] = "SnacksPickerGitStatusRenamed",
	["C"] = "SnacksPickerGitStatusCopied",
	["?"] = "SnacksPickerGitStatusUntracked",
	}
	local hl = hls[s] or "SnacksPickerGitStatus"
	hl = status:sub(1, 1) == "M" and "SnacksPickerGitStatusStaged" or hl
	ret[#ret + 1] = { a(status, 2, { align = "right" }), hl }
	ret[#ret + 1] = { " " }
	if item.rename then
	local file = item.file
	item.file = item.rename
	item._path = nil
	vim.list_extend(ret, M.filename(item, picker))
	item.file = file
	item._path = nil
	ret[#ret + 1] = { "-> ", "SnacksPickerDelim" }
	ret[#ret + 1] = { " " }
	end
	vim.list_extend(ret, M.filename(item, picker))
	return ret
	end
	function M.file_git_status(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	local status = require("snacks.picker.source.git").git_status(item.status)
	local hl = "SnacksPickerGitStatus"
	if status.unmerged then
	hl = "SnacksPickerGitStatusUnmerged"
	elseif status.staged then
	hl = "SnacksPickerGitStatusStaged"
	else
	hl = "SnacksPickerGitStatus" .. status.status:sub(1, 1):upper() .. status.status:sub(2)
	end
	if picker.opts.formatters.file.git_status_hl then
	item.filename_hl = hl
	end
	local icon = status.status:sub(1, 1):upper()
	icon = status.status == "untracked" and "?" or status.status == "ignored" and "!" or icon
	if picker.opts.icons.git.enabled then
	icon = picker.opts.icons.git[status.unmerged and "unmerged" or status.status] or icon --[[@as string]]
	if status.staged then
	icon = picker.opts.icons.git.staged
	end
	end
	ret[#ret + 1] = {
	col = 0,
	virt_text = { { icon, hl }, { " " } },
	virt_text_pos = "right_align",
	hl_mode = "combine",
	}
	return ret
	end
	function M.register(item)
	local ret = {} ---@type snacks.picker.Highlight[]
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { "[", "SnacksPickerDelim" }
	ret[#ret + 1] = { item.reg, "SnacksPickerRegister" }
	ret[#ret + 1] = { "]", "SnacksPickerDelim" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { item.value }
	return ret
	end
	function M.buffer(item, picker)
	local ret = {} ---@type snacks.picker.Highlight[]
	ret[#ret + 1] = { Snacks.picker.util.align(tostring(item.buf), 3), "SnacksPickerBufNr" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { Snacks.picker.util.align(item.flags, 2, { align = "right" }), "SnacksPickerBufFlags" }
	ret[#ret + 1] = { " " }
	vim.list_extend(ret, M.filename(item, picker))
	if item.buftype ~= "" then
	ret[#ret + 1] = { " " }
	vim.list_extend(ret, {
	{ "[", "SnacksPickerDelim" },
	{ item.buftype, "SnacksPickerBufType" },
	{ "]", "SnacksPickerDelim" },
	})
	end
	if item.name == "" and item.filetype ~= "" then
	ret[#ret + 1] = { " " }
	vim.list_extend(ret, {
	{ "[", "SnacksPickerDelim" },
	{ item.filetype, "SnacksPickerFileType" },
	{ "]", "SnacksPickerDelim" },
	})
	end
	return ret
	end
	function M.selected(item, picker)
	local a = Snacks.picker.util.align
	local selected = picker.opts.icons.ui.selected
	local unselected = picker.opts.icons.ui.unselected
	local width = math.max(vim.api.nvim_strwidth(selected), vim.api.nvim_strwidth(unselected))
	local ret = {} ---@type snacks.picker.Highlight[]
	if picker.list:is_selected(item) then
	ret[#ret + 1] = { a(selected, width), "SnacksPickerSelected", virtual = true }
	elseif picker.opts.formatters.selected.unselected then
	ret[#ret + 1] = { a(unselected, width), "SnacksPickerUnselected", virtual = true }
	else
	ret[#ret + 1] = { a("", width) }
	end
	return ret
	end
	function M.debug(item, picker)
	local score = item.score
	if not picker.matcher.sorting then
	score = picker.matcher.DEFAULT_SCORE
	if item.score_add then
	score = score + item.score_add
	end
	if item.score_mul then
	score = score * item.score_mul
	end
	end
	local ret = {} ---@type snacks.picker.Highlight[]
	ret[#ret + 1] = { ("%.2f "):format(score), "Number" }
	return ret
	end
	function M.icon(item, picker)
	local a = Snacks.picker.util.align
	---@cast item snacks.picker.Icon
	local ret = {} ---@type snacks.picker.Highlight[]
	local icon_width = vim.api.nvim_strwidth(item.icon)
	ret[#ret + 1] = { a(item.icon, icon_width > 3 and 15 or 3), "SnacksPickerIcon" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(item.source, 10), "SnacksPickerIconSource" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(item.name, 30), "SnacksPickerIconName" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(item.category, 8), "SnacksPickerIconCategory" }
	return ret
	end
	function M.notification(item, picker)
	local a = Snacks.picker.util.align
	local ret = {} ---@type snacks.picker.Highlight[]
	local notif = item.item ---@type snacks.notifier.Notif
	ret[#ret + 1] = { a(os.date("%R", notif.added), 5), "SnacksPickerTime" }
	ret[#ret + 1] = { " " }
	if item.severity then
	vim.list_extend(ret, M.severity(item, picker))
	end
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { a(notif.title or "", 15), "SnacksNotifierHistoryTitle" }
	ret[#ret + 1] = { " " }
	ret[#ret + 1] = { notif.msg, "SnacksPickerNotificationMessage" }
	Snacks.picker.highlight.markdown(ret)
	-- ret[#ret + 1] = { " " }
	return ret
	end
	return M

Previewers:

snacks.nvim/lua/snacks/picker/preview.lua

Lines 1 to 379 in 882c996

	---@class snacks.picker.previewers
	local M = {}
	local uv = vim.uv or vim.loop
	local ns = vim.api.nvim_create_namespace("snacks.picker.preview")
	---@param ctx snacks.picker.preview.ctx
	function M.directory(ctx)
	ctx.preview:reset()
	ctx.preview:minimal()
	local path = Snacks.picker.util.path(ctx.item)
	if not path then
	ctx.preview:notify("Item has no `file`", "error")
	return
	end
	local name = vim.fn.fnamemodify(path, ":t")
	ctx.preview:set_title(ctx.item.title or name)
	local ls = {} ---@type {file:string, type:"file"|"directory"}[]
	for file, t in vim.fs.dir(path) do
	t = t or Snacks.util.path_type(path .. "/" .. file)
	ls[#ls + 1] = { file = file, type = t }
	end
	ctx.preview:set_lines(vim.split(string.rep("\n", #ls), "\n"))
	table.sort(ls, function(a, b)
	if a.type ~= b.type then
	return a.type == "directory"
	end
	return a.file < b.file
	end)
	for i, item in ipairs(ls) do
	local is_dir = item.type == "directory"
	local cat = is_dir and "directory" or "file"
	local hl = is_dir and "Directory" or nil
	local icon, icon_hl = Snacks.util.icon(item.file, cat, {
	fallback = ctx.picker.opts.icons.files,
	})
	local line = { { icon .. " ", icon_hl }, { item.file, hl } }
	vim.api.nvim_buf_set_extmark(ctx.buf, ns, i - 1, 0, {
	virt_text = line,
	})
	end
	end
	---@param ctx snacks.picker.preview.ctx
	function M.image(ctx)
	local buf = ctx.preview:scratch()
	ctx.preview:set_title(ctx.item.title or vim.fn.fnamemodify(ctx.item.file, ":t"))
	Snacks.image.buf.attach(buf, { src = Snacks.picker.util.path(ctx.item) })
	end
	---@param ctx snacks.picker.preview.ctx
	function M.none(ctx)
	ctx.preview:reset()
	ctx.preview:notify("no preview available", "warn")
	end
	---@param ctx snacks.picker.preview.ctx
	function M.preview(ctx)
	if ctx.item.preview == "file" then
	return M.file(ctx)
	end
	assert(type(ctx.item.preview) == "table", "item.preview must be a table")
	ctx.preview:reset()
	local lines = vim.split(ctx.item.preview.text, "\n")
	ctx.preview:set_lines(lines)
	if ctx.item.preview.ft then
	ctx.preview:highlight({ ft = ctx.item.preview.ft })
	end
	for _, extmark in ipairs(ctx.item.preview.extmarks or {}) do
	local e = vim.deepcopy(extmark)
	e.col, e.row = nil, nil
	vim.api.nvim_buf_set_extmark(ctx.buf, ns, (extmark.row or 1) - 1, extmark.col, e)
	end
	if ctx.item.preview.loc ~= false then
	ctx.preview:loc()
	end
	end
	---@param ctx snacks.picker.preview.ctx
	function M.file(ctx)
	if ctx.item.buf and not ctx.item.file and not vim.api.nvim_buf_is_valid(ctx.item.buf) then
	ctx.preview:notify("Buffer no longer exists", "error")
	return
	end
	if ctx.item.buf and not vim.api.nvim_buf_is_valid(ctx.item.buf) and (ctx.item.file or ""):sub(1, 1) == "[" then
	ctx.preview:notify("Buffer no longer exists", "error")
	return
	end
	local title = ctx.item.preview_title or ctx.item.title
	-- used by some LSP servers that load buffers with custom URIs
	if ctx.item.buf and vim.uri_from_bufnr(ctx.item.buf):sub(1, 4) ~= "file" then
	if not vim.api.nvim_buf_is_loaded(ctx.item.buf) then
	vim.b[ctx.item.buf].snacks_picker_loaded = true
	vim.fn.bufload(ctx.item.buf)
	end
	elseif ctx.item.file and ctx.item.file:find("^%w+://") then
	ctx.item.buf = vim.fn.bufadd(ctx.item.file)
	vim.b[ctx.item.buf].snacks_picker_loaded = true
	vim.fn.bufload(ctx.item.buf)
	end
	if ctx.item.buf and vim.api.nvim_buf_is_loaded(ctx.item.buf) then
	if not title then
	local name = vim.api.nvim_buf_get_name(ctx.item.buf)
	title = uv.fs_stat(name) and vim.fn.fnamemodify(name, ":t") or name
	end
	ctx.preview:set_title(title)
	ctx.preview:set_buf(ctx.item.buf)
	else
	local path = Snacks.picker.util.path(ctx.item)
	if not path then
	ctx.preview:notify("Item has no `file`", "error")
	return
	end
	if Snacks.image.supports_file(path) and Snacks.image.config.enabled ~= false then
	return M.image(ctx)
	end
	-- re-use existing preview when path is the same
	if path ~= Snacks.picker.util.path(ctx.prev) then
	ctx.preview:reset()
	vim.bo[ctx.buf].buftype = ""
	title = title or vim.fn.fnamemodify(path, ":t")
	ctx.preview:set_title(title)
	local stat = uv.fs_stat(path)
	if not stat then
	ctx.preview:notify("file not found: " .. path, "error")
	return false
	end
	if stat.type == "directory" then
	return M.directory(ctx)
	end
	local max_size = ctx.picker.opts.previewers.file.max_size or (1024 * 1024)
	if stat.size > max_size then
	ctx.preview:notify("large file > 1MB", "warn")
	return false
	end
	if stat.size == 0 then
	ctx.preview:notify("empty file", "warn")
	return false
	end
	local file = assert(io.open(path, "r"))
	local is_binary = false
	local ft = ctx.picker.opts.previewers.file.ft or vim.filetype.match({ filename = path })
	if ft == "bigfile" then
	ft = nil
	end
	local lines = {}
	for line in file:lines() do
	---@cast line string
	if #line > ctx.picker.opts.previewers.file.max_line_length then
	line = line:sub(1, ctx.picker.opts.previewers.file.max_line_length) .. "..."
	end
	-- Check for binary data in the current line
	if line:find("[%z\1-\8\11\12\14-\31]") then
	is_binary = true
	if not ft then
	ctx.preview:notify("binary file", "warn")
	return
	end
	end
	table.insert(lines, line)
	end
	file:close()
	if is_binary then
	ctx.preview:wo({ number = false, relativenumber = false, cursorline = false, signcolumn = "no" })
	end
	ctx.preview:set_lines(lines)
	ctx.preview:highlight({ file = path, ft = ctx.picker.opts.previewers.file.ft, buf = ctx.buf })
	end
	end
	ctx.preview:loc()
	end
	---@param diff string|string[]|snacks.picker.diff.Block[]
	---@param ft "diff"|"git"
	---@param ctx snacks.picker.preview.ctx
	local function fancy_diff(diff, ft, ctx)
	local buf = ctx.preview:scratch()
	ctx.preview.win:map()
	require("snacks.picker.util.diff").render(buf, ns, diff, {
	annotations = ctx.item.annotations or ctx.picker.opts.annotations,
	})
	Snacks.util.wo(ctx.win, ctx.picker.opts.previewers.diff.wo or {})
	end
	---@param cmd string[]
	---@param ctx snacks.picker.preview.ctx
	---@param opts? snacks.job.Opts|{ft?: string}
	function M.cmd(cmd, ctx, opts)
	opts = opts or {}
	local Job = require("snacks.util.job")
	local buf = ctx.preview:scratch()
	vim.bo[buf].buftype = "nofile"
	opts = Snacks.config.merge(opts, {
	debug = ctx.picker.opts.debug.proc,
	term = opts.term ~= false and not opts.ft and opts.pty ~= false,
	width = vim.api.nvim_win_get_width(ctx.win),
	height = vim.api.nvim_win_get_height(ctx.win),
	cwd = ctx.item.cwd or ctx.picker.opts.cwd,
	env = {
	PAGER = "cat",
	DELTA_PAGER = "cat",
	},
	})
	local style = ctx.picker.opts.previewers.diff.style
	if style == "fancy" and vim.tbl_contains({ "diff", "git" }, opts.ft) then
	opts.on_line = function() end or nil -- disable default line handler
	opts.on_lines = function(_, lines)
	fancy_diff(lines, opts.ft, ctx)
	end
	end
	local job = Job.new(buf, cmd, opts)
	if opts.ft and style ~= "fancy" then
	ctx.preview:highlight({ ft = opts.ft })
	end
	return job
	end
	---@param ctx snacks.picker.preview.ctx
	---@return string[], boolean terminal
	local function git(ctx, ...)
	local terminal = ctx.picker.opts.previewers.diff.style == "terminal"
	local ret = { "git" }
	vim.list_extend(ret, not terminal and { "--no-pager" } or {})
	vim.list_extend(ret, ctx.picker.opts.previewers.git.args or {})
	vim.list_extend(ret, { ... })
	return ret, terminal
	end
	---@param ctx snacks.picker.preview.ctx
	function M.git_show(ctx)
	local cmd, terminal = git(ctx, "show", ctx.item.commit)
	local pathspec = ctx.item.files or ctx.item.file
	pathspec = type(pathspec) == "table" and pathspec or { pathspec }
	if #pathspec > 0 then
	cmd[#cmd + 1] = "--"
	vim.list_extend(cmd, pathspec)
	end
	M.cmd(cmd, ctx, { ft = not terminal and "git" or nil })
	end
	---@param ctx snacks.picker.preview.ctx
	function M.git_log(ctx)
	local cmd = git(
	ctx,
	"--no-pager",
	"log",
	"--pretty=format:%h %s (%ch) <%an>",
	"--abbrev-commit",
	"--decorate",
	"--date=short",
	"--color=never",
	"--no-show-signature",
	"--no-patch",
	ctx.item.commit
	)
	M.cmd(cmd, ctx, {
	ft = "git",
	---@param text string
	on_line = function(_, text)
	local commit, msg, date, author = text:match("^(%S+) (.*) %((.*)%) <(.*)>$")
	if commit then
	local hl = Snacks.picker.format.git_log({
	idx = 1,
	score = 0,
	text = "",
	commit = commit,
	msg = msg,
	date = date,
	author = author,
	}, ctx.picker)
	Snacks.picker.highlight.render(ctx.buf, ns, { hl }, { append = true })
	Snacks.util.wo(ctx.win, { breakindent = true, wrap = true, linebreak = true })
	end
	end,
	})
	end
	---@param ctx snacks.picker.preview.ctx
	function M.diff(ctx)
	local style = ctx.picker.opts.previewers.diff.style
	local cmd = vim.deepcopy(ctx.picker.opts.previewers.diff.cmd)
	style = style == "terminal" and vim.fn.executable(cmd[1]) == 0 and "fancy" or style
	if style == "syntax" then
	ctx.item.preview = { text = ctx.item.diff, ft = "diff", loc = false }
	return M.preview(ctx)
	elseif style ~= "terminal" then
	return fancy_diff(ctx.item.diff, "diff", ctx)
	end
	if cmd[1] == "delta" and not vim.tbl_contains(cmd, "--dark") and not vim.tbl_contains(cmd, "--light") then
	table.insert(cmd, 2, "--" .. vim.o.background)
	end
	M.cmd(cmd, ctx, {
	input = ctx.item.diff,
	})
	end
	---@param ctx snacks.picker.preview.ctx
	function M.git_diff(ctx)
	local cmd, terminal = git(ctx, "diff")
	if not ctx.item.status then
	cmd[#cmd + 1] = "HEAD" -- generic diff against HEAD
	elseif ctx.item.status:find("[UAD][UAD]") then
	cmd[#cmd + 1] = "--cc" -- combined diff for conflicts
	elseif ctx.item.status:sub(1, 1) ~= " " then
	cmd[#cmd + 1] = "--cached" -- staged changes
	end
	if ctx.item.file then
	vim.list_extend(cmd, { "--", ctx.item.file })
	end
	M.cmd(cmd, ctx, {
	ft = not terminal and "diff" or nil,
	})
	end
	---@param ctx snacks.picker.preview.ctx
	function M.git_stash(ctx)
	local cmd, terminal = git(ctx, "stash", "show", "--patch", ctx.item.stash)
	M.cmd(cmd, ctx, { ft = not terminal and "diff" or nil })
	end
	---@param ctx snacks.picker.preview.ctx
	function M.git_status(ctx)
	local ss = ctx.item.status
	if ss:find("^[A?]") then
	M.file(ctx)
	else
	M.git_diff(ctx)
	end
	end
	---@param ctx snacks.picker.preview.ctx
	function M.colorscheme(ctx)
	if not ctx.preview.state.colorscheme then
	ctx.preview.state.colorscheme = vim.g.colors_name or "default"
	ctx.preview.state.background = vim.o.background
	ctx.preview.win:on("WinClosed", function()
	vim.schedule(function()
	if not ctx.preview.state.colorscheme then
	return
	end
	vim.cmd("colorscheme " .. ctx.preview.state.colorscheme)
	vim.o.background = ctx.preview.state.background
	end)
	end, { win = true })
	end
	vim.schedule(function()
	vim.cmd("colorscheme " .. ctx.item.text)
	end)
	Snacks.picker.preview.file(ctx)
	end
	---@param ctx snacks.picker.preview.ctx
	function M.man(ctx)
	M.cmd({ "man", ctx.item.section, ctx.item.page }, ctx, {
	ft = "man",
	env = {
	MANPAGER = ctx.picker.opts.previewers.man_pager or vim.fn.executable("col") == 1 and "col -bx" or "cat",
	MANWIDTH = tostring(ctx.preview.win:dim().width),
	MANPATH = vim.env.MANPATH,
	},
	})
	end
	return M

[Eckii24]

Just point your ai assistant at the source of snacks and let it find out the details required for your individual requirement 😀

[dkuettel]

much appreciated @drowning-cat , it helped and I got it to work.