return {
    'nvim-telescope/telescope.nvim',
    branch = 'master',
    -- tag = '0.1.8',
    dependencies = {
        'nvim-lua/plenary.nvim', 'nvim-telescope/telescope-live-grep-args.nvim',
        {'nvim-telescope/telescope-fzf-native.nvim', build = 'make'},
        'nvim-telescope/telescope-ui-select.nvim'
    },

    config = function()
        local actions = require("telescope.actions")
        --
        -- Built-in actions
        local transform_mod = require('telescope.actions.mt').transform_mod

        -- or create your custom action
        local custom_close = transform_mod({
            execute = function(prompt_bufnr)
                vim.g.neovide_scale_factor = 1
                actions.close(prompt_bufnr)
            end
        })

        require("telescope").setup({
            defaults = {
                -- Default configuration for telescope goes here:
                -- config_key = value,
                mappings = {
                    i = {
                        -- map actions.which_key to <C-h> (default: <C-/>)
                        -- actions.which_key shows the mappings for your picker,
                        -- e.g. git_{create, delete, ...}_branch for the git_branches picker
                        ["<esc>"] = custom_close.execute,
                        ["<C-c>"] = custom_close.execute
                    }
                },
                -- Layout settings
                layout_strategy = "horizontal",
                layout_config = {
                    horizontal = {
                        prompt_position = "bottom",
                        width = {padding = 0},
                        height = {padding = 0},
                        preview_width = 0.8
                    }
                },
                sorting_strategy = "ascending",
                scroll_strategy = "limit",
                file_ignore_patterns = {".git/[^h]"}
            },
            pickers = {find_files = {hidden = true}},
            extensions = {fzf = {}}
        })

        pcall(require('telescope').load_extension, 'fzf')
        pcall(require('telescope').load_extension, 'ui-select')

        vim.keymap.set("n", "<leader>pf",
                       function()
            require("telescope.builtin").find_files()
        end)
        small_font_telescope = function()
            vim.g.neovide_scale_factor = 0.70
        end
        vim.cmd "autocmd User TelescopeFindPre lua small_font_telescope()"
        vim.keymap.set("n", "<leader>pg", require("telescope").extensions
                           .live_grep_args.live_grep_args, {noremap = true})

        vim.keymap.del("n", "gri")
        vim.keymap.del("n", "grr")
        vim.keymap.del("n", "grn")
        vim.keymap.del("n", "grt")
        vim.keymap.del({"n", "x"}, "gra")

        vim.api.nvim_create_autocmd('LspAttach', {
            group = vim.api.nvim_create_augroup('lsp-attach', {clear = true}),
            callback = function(event)
                -- NOTE: Remember that Lua is a real programming language, and as such it is possible
                -- to define small helper and utility functions so you don't have to repeat yourself.
                --
                -- In this case, we create a function that lets us more easily define mappings specific
                -- for LSP related items. It sets the mode, buffer and description for us each time.
                local map = function(keys, func, desc, mode)
                    mode = mode or 'n'
                    vim.keymap.set(mode, keys, func,
                                   {buffer = event.buf, desc = 'LSP: ' .. desc})
                end

                -- Jump to the definition of the word under your cursor.
                --  This is where a variable was first declared, or where a function is defined, etc.
                --  To jump back, press <C-t>.
                map('gd', require('telescope.builtin').lsp_definitions,
                    '[G]oto [D]efinition')

                -- Find references for the word under your cursor.
                map('gr', require('telescope.builtin').lsp_references,
                    '[G]oto [R]eferences')

                -- Jump to the implementation of the word under your cursor.
                --  Useful when your language has ways of declaring types without an actual implementation.
                map('gI', require('telescope.builtin').lsp_implementations,
                    '[G]oto [I]mplementation')

                -- Jump to the type of the word under your cursor.
                --  Useful when you're not sure what type a variable is and you want to see
                --  the definition of its *type*, not where it was *defined*.
                map('<leader>D',
                    require('telescope.builtin').lsp_type_definitions,
                    'Type [D]efinition')

                -- Fuzzy find all the symbols in your current document.
                --  Symbols are things like variables, functions, types, etc.
                map('<leader>ds',
                    require('telescope.builtin').lsp_document_symbols,
                    '[D]ocument [S]ymbols')

                -- Fuzzy find all the symbols in your current workspace.
                --  Similar to document symbols, except searches over your entire project.
                map('<leader>ws',
                    require('telescope.builtin').lsp_dynamic_workspace_symbols,
                    '[W]orkspace [S]ymbols')

                -- Rename the variable under your cursor.
                --  Most Language Servers support renaming across files, etc.
                map('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')

                -- Execute a code action, usually your cursor needs to be on top of an error
                -- or a suggestion from your LSP for this to activate.
                map('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction',
                    {'n', 'x'})

                -- WARN: This is not Goto Definition, this is Goto Declaration.
                --  For example, in C this would take you to the header.
                map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')

                -- This function resolves a difference between neovim nightly (version 0.11) and stable (version 0.10)
                ---@param client vim.lsp.Client
                ---@param method vim.lsp.protocol.Method
                ---@param bufnr? integer some lsp support methods only in specific files
                ---@return boolean
                local function client_supports_method(client, method, bufnr)
                    if vim.fn.has 'nvim-0.11' == 1 then
                        return client:supports_method(method, bufnr)
                    else
                        return client.supports_method(method, {bufnr = bufnr})
                    end
                end

                -- The following two autocommands are used to highlight references of the
                -- word under your cursor when your cursor rests there for a little while.
                --    See `:help CursorHold` for information about when this is executed
                --
                -- When you move your cursor, the highlights will be cleared (the second autocommand).
                local client = vim.lsp.get_client_by_id(event.data.client_id)
                if client and client_supports_method(client, vim.lsp.protocol
                                                         .Methods
                                                         .textDocument_documentHighlight,
                                                     event.buf) then
                    local highlight_augroup =
                        vim.api.nvim_create_augroup('lsp-highlight',
                                                    {clear = false})
                    vim.api.nvim_create_autocmd({'CursorHold', 'CursorHoldI'}, {
                        buffer = event.buf,
                        group = highlight_augroup,
                        callback = vim.lsp.buf.document_highlight
                    })

                    vim.api.nvim_create_autocmd({'CursorMoved', 'CursorMovedI'},
                                                {
                        buffer = event.buf,
                        group = highlight_augroup,
                        callback = vim.lsp.buf.clear_references
                    })

                    vim.api.nvim_create_autocmd('LspDetach', {
                        group = vim.api.nvim_create_augroup('lsp-detach',
                                                            {clear = true}),
                        callback = function(event2)
                            vim.lsp.buf.clear_references()
                            vim.api.nvim_clear_autocmds {
                                group = 'lsp-highlight',
                                buffer = event2.buf
                            }
                        end
                    })
                end

                -- The following code creates a keymap to toggle inlay hints in your
                -- code, if the language server you are using supports them
                --
                -- This may be unwanted, since they displace some of your code
                if client and
                    client_supports_method(client, vim.lsp.protocol.Methods
                                               .textDocument_inlayHint,
                                           event.buf) then
                    map('<leader>th', function()
                        vim.lsp.inlay_hint.enable(
                            not vim.lsp.inlay_hint.is_enabled {
                                bufnr = event.buf
                            })
                    end, '[T]oggle Inlay [H]ints')
                end
            end
        })
    end
}