nvim/pack/acp/opt/coc.nvim/doc/coc.txt

*coc-nvim.txt*				LSP support for Vim & Neovim.

Version: 0.0.79
Author: Qiming Zhao <chemzqm at gmail.com>
License: MIT license

CONTENTS					*coc-contents*

Introduction					|coc-introduction|
Requirements					|coc-requirements|
Installation					|coc-installation|
Configuration					|coc-configuration|
Completion					|coc-completion|
Interface					|coc-interface|
  Key mappings					|coc-key-mappings|
  Variables						|coc-variables|
  Functions						|coc-functions|
  Commands						|coc-commands|
  Autocmds						|coc-autocmds|
  Highlights					|coc-highlights|
List						|coc-list|
  List command					|coc-list-command|
  List command options 				|coc-list-options|
  List configuration				|coc-list-configuration|
  List mappings					|coc-list-mappings|
  list sources					|coc-list-sources|
    Location						|coc-list-location|
    Extensions						|coc-list-extensions|
    Diagnostics						|coc-list-diagnostics|
    Outline						|coc-list-outline|
    Symbols						|coc-list-symbols|
    Services						|coc-list-services|
    Commands						|coc-list-commands|
    Links						|coc-list-links|
    Sources						|coc-list-completion-sources|
    Lists						|coc-list-lists|
Statusline support				|coc-status|
  Manual						|coc-status-manual|
  Airline						|coc-status-airline|
  Lightline						|coc-status-lightline|
FAQ						|coc-faq|
Changelog					|coc-changelog|

==============================================================================
INTRODUCTION						*coc-introduction*

Coc.nvim enhances your (Neo)Vim to match the user experience provided by VSCode
through rich plugin ecosystem and Language Server Protocol support.

Some of the features include:~

- APIs that are compatible with both Vim8 and Neovim.
- Loading VSCode-like extensions.
- Configuring coc.nvim and its extensions by using JSON configuration file.
- Configuring Language Servers that implement Language Server Protocol (LSP).

It's designed to have a good integration with other Vim plugins as much as
possible.

Note: This plugin doesn't comes with any support for specific language, you
have to install extensions or configure languageserver for LSP features.

Note: This plugin doesn't change your key-mappings, you have to configure them
yourself.

==============================================================================
REQUIREMENTS						*coc-requirements*

Neovim >= 0.3.2 or Vim >= 8.0.1453.

NodeJS https://nodejs.org/ >= 10.12.0

==============================================================================
INSTALLATION						*coc-installation*

If you're using [vim-plug](https://github.com/junegunn/vim-plug), add this to
your `init.vim` or `.vimrc`: >

  Plug 'neoclide/coc.nvim', {'branch': 'release'}

And run: >

  :PlugInstall

For other plugin managers, use code from the release branch.

Or use Vim's built-in plugin ecosystem like: >

  #!/bin/sh
  # for vim8
  mkdir -p ~/.vim/pack/coc/start
  cd ~/.vim/pack/coc/start
  curl --fail -L https://github.com/neoclide/coc.nvim/archive/release.tar.gz|tar xzfv -
  # for neovim
  mkdir -p ~/.local/share/nvim/site/pack/coc/start
  cd ~/.local/share/nvim/site/pack/coc/start
  curl --fail -L https://github.com/neoclide/coc.nvim/archive/release.tar.gz|tar xzfv -

==============================================================================
CONFIGURATION						*coc-configuration*

Configurations of coc.nvim are stored in file names `coc-settings.json` that
can be opened using |:CocConfig| for user configuration file or
|:CocLocalConfig| for local configuration file.

The location of global configuration can be configured by `g:coc_config_home`.

Configure |b:coc_root_patterns| for project root resolve.

To enable JSON completion and validation support of the settings file, install
the `coc-json` extension by command:

	CocInstall coc-json

Check out https://github.com/neoclide/coc.nvim/wiki/Using-the-configuration-file
for more details.

Built-in configurations:~

							*coc-config-http*
"http.proxy":~

	HTTP proxy URI, used for extensions that send request, default: `""`

"http.proxyStrictSSL":~

	Controls whether the proxy server certificate should be verified
	against the list of supplied CAs, default: `true`

							*coc-config-suggest*
"suggest.enablePreselect":~

	Enable preselect feature on Neovim, default: `false`

"suggest.maxPreviewWidth":~

	Maximum width of floating preview window, default: `80`

"suggest.labelMaxLength":~

	Maximum length of label shown in 'pum', default: `200`

"suggest.enablePreview":~

	Add preview option to 'completeopt', default: `false`

"suggest.floatEnable":~

	Enable floating window for documentation when possible, default: `true`

"suggest.detailMaxLength":~

	Max length of detail that will be shown in popup menu, default: `100`

"suggest.detailField":~

	Where to add the detail in complete item when it's less than max
	length, default: `"menu"`

	Valid options: ["abbr", "menu", "preview"]

"suggest.autoTrigger":~

	How should completion be triggered, default: `"always"`

	Valid options: ["always", "trigger", "none"]

	- `always`: trigger suggest on word characters and trigger
	  characters.
	- `trigger`: trigger suggest on trigger characters only.
	- `none`: no auto trigger at all.

"suggest.languageSourcePriority":~

	Priority of language sources, default: `99`

"suggest.numberSelect":~

	Input number to select complete item, it could be wrong when
	using '<up>' and '<down>' to select complete item, default: `false`

"suggest.disableKind":~

	Remove kind field from Vim complete item, default: `false`

"suggest.disableMenu":~

	Remove menu field from Vim complete item, default: `false`

"suggest.snippetIndicator":~

	The character used in completion item abbreviation to indicate it
	expands as code snippet, default: `"~"`

"suggest.maxCompleteItemCount":~

	Maximum number of complete items shown in Vim, default: `50`

"suggest.preferCompleteThanJumpPlaceholder":~

	Confirm completion instead of jump to next placeholder when completion
	activates, default: `false`

"suggest.fixInsertedWord":~

	Inserted word replaces the next one, default: `true`

"suggest.localityBonus":~

	Boost suggestions that appear closer to the cursor position,
	default: `true`

"suggest.triggerAfterInsertEnter":~

	Trigger completion after |InsertEnter|. Requires "suggest.autoTrigger"
	to be set, default: `false`

"suggest.timeout":~

	Timeout for completion (unit: milliseconds), default: `5000`

"suggest.minTriggerInputLength":~

	Number of characters in the current word after which the completion
	triggers, default: `1`

"suggest.triggerCompletionWait":~

	Delay between typing the trigger character and completion start which
	initiates server synchronization, default: `50`

"suggest.echodocSupport":~

	Add function signature to `user_data.signature` to support `echodoc.vim`,
	default: `false`

"suggest.acceptSuggestionOnCommitCharacter":~

	The server provides a set of commit characters: these characters can
	trigger completion item acceptance. This also inserts commit character
	after the completion item text. Requires `CompleteChanged` event to work,
	default: `false`

"suggest.noselect":~

	Prevent Vim from selecting the first item on completion start,
	default: `true`

"suggest.keepCompleteopt":~

	When enabled, 'completeopt' is not overridden. Autocompletion will be
	disabled if 'completeopt' doesn't have 'noinsert' and 'noselect', default:
	`false`

"suggest.lowPrioritySourceLimit":~

	Max items count for source priority lower than `90`.

"suggest.highPrioritySourceLimit":~

	Max items count for source priority bigger than or equal to `90`.

"suggest.disableMenuShortcut":~

	Disable shortcut of completion source in menu, default: `false`

"suggest.removeDuplicateItems":~

	Remove completion items with duplicated word for all sources, snippet
	items are excluded, default: `false`

"suggest.defaultSortMethod":~

	Default sorting behavior for suggested completion items, default:
	`length`

"suggest.invalidInsertCharacters":~

	Invalid character for strip valid word when inserting text of complete
	item, default: ` ,(,<,{,[,\r,\n`

"suggest.asciiCharactersOnly":~

	Suggest ASCII characters only, default: `false`

"suggest.completionItemKindLabels":~

	Set custom labels to completion item kinds, default: `{}`.

	Example configuration: with https://nerdfonts.com:  >

	  "suggest.completionItemKindLabels": {
		"keyword": "\uf1de",
		"variable": "\ue79b",
		"value": "\uf89f",
		"operator": "\u03a8",
		"function": "\u0192",
		"reference": "\ufa46",
		"constant": "\uf8fe",
		"method": "\uf09a",
		"struct": "\ufb44",
		"class": "\uf0e8",
		"interface": "\uf417",
		"text": "\ue612",
		"enum": "\uf435",
		"enumMember": "\uf02b",
		"module": "\uf40d",
		"color": "\ue22b",
		"property": "\ue624",
		"field": "\uf9be",
		"unit": "\uf475",
		"event": "\ufacd",
		"file": "\uf723",
		"folder": "\uf114",
		"snippet": "\ue60b",
		"typeParameter": "\uf728",
		"default": "\uf29c"
	}
<
							*coc-config-diagnostic*
"diagnostic.enable":~

	Display diagnostics, default: `true`

"diagnostic.enableSign":~

	Enable signs for diagnostics, default: `true`

"diagnostic.enableMessage":~

	When to enable show messages of diagnostics.

	Valid options: ["always","jump","never"], always means including
	cursor hold and after jump to another diagnostic.

	default: `"always"`

"diagnostic.enableHighlightLineNumber":~

	Enable highlighting line numbers for diagnostics, only works with
	neovim and `diagnostic.enableSign` is true.

	default: `true`

"diagnostic.locationlistUpdate"~

	Update locationlist on diagnostics change, only works with
	locationlist opened by :CocDiagnostics command and first window of
	associated buffer.

	default: `true`

"diagnostic.level":~

	Filter diagnostics by severity, default: `"hint"`

	Valid options: ["hint", "information", "warning", "error"]

"diagnostic.messageDelay":~

	How long to wait (in milliseconds) before displaying the diagnostic
	message with echo or float.

	Default: `200`

"diagnostic.maxWindowWidth":~

	Maximum width of diagnostics floating window, default: `80`

"diagnostic.checkCurrentLine":~

	Show all diagnostics of the current line if none of them are at the current
	position, default: `false`

"diagnostic.messageTarget":~

	Diagnostic message target, default: `"float"`

	Valid options: ["echo", "float"]

"diagnostic.refreshOnInsertMode":~

	Refresh diagnostics when in insert mode, default: `false`

"diagnostic.refreshAfterSave":~

	Refresh diagnostics after file save only, default: `false`

"diagnostic.displayByAle":~

	Use ALE for displaying diagnostics. This will disable coc.nvim for
	displaying diagnostics. Restart to make changes take the effect, default:
	`false`

"diagnostic.virtualText":~

	Use Neovim virtual text to display diagnostics, default: `false`

"diagnostic.virtualTextCurrentLineOnly":~

	Only show virtualText diagnostic on current cursor line, default:
	`true`

"diagnostic.virtualTextPrefix":~

	The prefix added for virtual text diagnostics, default: `" "`

"diagnostic.virtualTextLines":~

	The number of non-empty lines from a diagnostic to display, default: `3`

"diagnostic.virtualTextLineSeparator":~

	The text that will mark a line end from the diagnostic message,
	default: `" \\ "`

"diagnostic.highlightOffset":~

	Offset number of buffer.addHighlight, Neovim only, default: `1000`

"diagnostic.signOffset":~

	Offset number of sign, default: `1000`

"diagnostic.errorSign":~

	Sign of error diagnostics shown in the 'signcolumn', default: `">>"`

"diagnostic.warningSign":~

	Sign of warning diagnostics shown in the 'signcolumn', default: `"⚠"`

"diagnostic.infoSign":~

	Sign of info diagnostics shown in the 'signcolumn', default: `">>"`

"diagnostic.hintSign":~

	Sign of hint diagnostics shown in the 'signcolumn', default: `">>"`

"diagnostic.maxWindowHeight":~

	Maximum height of diagnostics floating window, default: `8`

"diagnostic.filetypeMap":~

	A map between buffer filetype and the filetype assigned to diagnostics.
	To syntax highlight diagnostics withs their parent buffer type use
	`"default": "bufferType"`, default: `{}`

"diagnostic.format":~

	Define the diagnostic format.
	Available parts: source, code, severity, message

	Default: `[%source%code] [%severity] %message`

"diagnostic.separateRelatedInformationAsDiagnostics":~

	Separate related information as diagnostics, default: `false`

"signature.enable":~

	Enable signature help when trigger character typed. Requires service restart
	on change, default: `true`

"signature.maxWindowWidth":~

	Max width of signature float window, default: `60`

"signature.triggerSignatureWait":~

	Delay for signature request trigger (milliseconds), default: `50`.
	Change to higher value for slow Language Servers.

"signature.target":~

	Target of signature help, use `"float"` when possible by default.

	Valid options: ["float", "echo"]

"signature.preferShownAbove":~

	Show signature help's floating window above cursor when possible. Requires
	restart on change, default: `true`

"signature.hideOnTextChange":~

	Hide signature help's floating window when text changed. Requires restart
	on change, default: `false`

"signature.maxWindowHeight":~

	Maximum height of floating window with the signature help, default: `8`

							*coc-config-refactor*
"refactor.openCommand":~

	Open command for refactor window, default: `vsplit`

"refactor.beforeContext":~

	Print num lines of leading context before each match, default: `3`

"refactor.afterContext":~

	Print num lines of trailing context after each match, default: `3`

							*coc-config-codelens*
"codeLens.enable":~

	Enable `codeLens` feature. Requires Neovim with virtual text feature,
	default: `false`

"codeLens.separator":~

	Separator text for `codeLens` in virtual text, default: `"‣"`

"codeLens.subseparator":~

	Subseparator text for multiple `codeLens`es in virtual text, default: `" "`

"workspace.ignoredFiletypes":~

	Filetypes to ignore for workspace folder resolution,
	default: `["markdown","log","txt","help"]`

	Note: This is the filetype after mapping by `g:coc_filetype_map`.

							*coc-config-list*
"list.indicator":~

	The character used as first character in prompt line, default: `">"`

"list.height":~

	Height of split list window, default: `10`

"list.signOffset":~

	Sign offset of list, should be different from other plugins, default: `900`

"list.selectedSignText":~

	Sign text for selected lines, default: `"*"`

"list.limitLines":~

	Limit lines shown in the list buffer, default: `30000`

"list.maxPreviewHeight":~

	Max height for preview window of list, default: `12`

"list.previewHighlightGroup":~

	Highlight group used for highlighting the range in preview window,
	default: `"Search"`

"list.nextKeymap":~

	Key for selecting next line in the insert mode, default: `"<C-j>"`

"list.previousKeymap":~

	Key for selecting previous line in the insert mode, default: `"<C-k>"`

"list.extendedSearchMode": ~

	Enable extended search mode which allows multiple search patterns delimited
	by spaces, default: `true`

"list.normalMappings":~

	Custom key mappings in the normal mode, default: `{}`

"list.insertMappings":~

	Custom key mappings in the insert mode, default: `{}`

"list.interactiveDebounceTime":~

	Debouce time for input change on interactive mode, default: `100`

"list.previewSplitRight":~

	Use vsplit for preview window, default: `false`

"list.source.symbols.excludes":~

	Patterns of mimimatch for filepath to execlude from symbols list,
	default: `[]`

"list.source.outline.ctagsFilestypes":~

	Filetypes that should use `ctags` for outline instead of language server,
	default: `[]`

							*coc-config-preferences*
"coc.preferences.maxFileSize":~

	Maximum file size in bytes that coc.nvim should handle, default: `'10MB'`

"coc.preferences.promptWorkspaceEdit":~

	Prompt confirm from user for workspace edit.
	default: `true`

"coc.preferences.useQuickfixForLocations":~

	Use Vim's quickfix list for jump locations. Requires restart on change,
	default: `false`

"coc.preferences.extensionUpdateCheck":~

	Interval for checking extension updates, default: `"daily"`

	Valid options: ["daily","weekly","never"]

"coc.preferences.snippetStatusText":~

	Text shown in 'statusline' to indicate snippet session is activate.
	Check |coc-status| for statusline integration.

	Default: `"SNIP"`

"coc.preferences.hoverTarget":~

	Target to show hover information, default is floating window when possible.

	Valid options: ["preview", "echo", "float"]

"coc.preferences.previewAutoClose":~

	Auto close preview window of hover upon cursor move, default: `true`

"coc.preferences.previewMaxHeight":~

	Max height of preview window for hover, default: `12`

"coc.preferences.colorSupport":~

	Enable color highlight if Language Server support it, default: `true`

"coc.preferences.currentFunctionSymbolAutoUpdate":~

	Automatically update the value of `b:coc_current_function` on `CursorHold`
	event, default: `false`

"coc.preferences.formatOnInsertLeave":~

	Trigger format on type when insert leave by send \n to the server.
	Default: `false`

"coc.preferences.formatOnSaveFiletypes":~

	Filetypes for which formatting triggers after saving, default: `[]`

	Note: This is the filetype after mapping by `g:coc_filetype_map`.

"coc.preferences.enableFloatHighlight":~

	Enable highlight for floating window, default: `true`

"coc.preferences.rootPatterns":~

	Root patterns to resolve `workspaceFolder` from parent folders of opened
	files, resolved from up to down, default:
	`[".git",".hg",".projections.json"]`

"coc.preferences.watchmanPath":~

	Executable path for https://facebook.github.io/watchman/, detected
	from $PATH by default, default: `null`

"coc.preferences.jumpCommand":~

	Command used for location jump performed for goto definition, goto
	references etc, default: `"edit"`

	Valid options: ["edit", "split", "vsplit", "tabe", "drop", "tab drop"]

"coc.preferences.messageLevel":~

	Message level for filter echoed messages default: `"more"`

	Valid options: ["more", "warning", "error"]

"coc.preferences.formatOnType":~

	Set to true to enable format on type, default: `false`

"coc.preferences.bracketEnterImprove":~

	Improve handling of pressing enter inside brackets (`<> {} [] ()`) by
	adding a new empty line below and moving the cursor to it.

	Works with |coc#on_enter()|, default: `true`

"coc.preferences.formatOnTypeFiletypes":~

	Filetypes that should run format on typing, default: `[]`

	Note: takes effect when `coc.preferences.formatOnType` set `true`.
	Note: This is the filetype after mapping by `g:coc_filetype_map`.

"coc.preferences.snippets.enable":~

	Enables snippets support, default: `true`

"coc.preferences.listOfWorkspaceEdit":~

	List should contains changed locations after workspace edit, default
	to vim's quickfix, default: `quickfix`

"coc.preferences.highlightTimeout":~

	Highlight timeout for buffer in floating window, default: `500`

"coc.preferences.floatActions":~

	Set to false to disable float/popup support for actions menu.
	Default: `true`

"coc.preferences.promptInput":~

	Use prompt buffer in float window for user input, works on latest
	neovim >= 0.4.3 only.
	Default: `true`

"coc.preferences.enableMarkdown":~

	Tell the language server that markdown text format is supported,
	note that you may have additional escaped characters for markdown
	text.

"coc.preferences.silentAutoupdate"~

	Not open split window with update status when performing auto update.

						*coc-config-cursors*
"cursors.cancelKey":~

	Key used for cancel cursors session, default: `<esc>`

"cursors.nextKey":~

	Key used for jump to next cursors position. , default: `<C-n>`

"cursors.previousKey":~

	Key used for jump to previous cursors position, default: `<C-p>`

						*coc-config-npm*
"npm.binPath":~

	Command or full path of npm or yarn executable for install/update
	extensions, default: `npm`

						*coc-config-languageserver*
"languageserver":~

	Dictionary of Language Servers, key is the ID of corresponding server,
	and value is configuration of languageserver. Default: `{}`

	Properties of languageserver configuration:

	- "enable": Change to `false` to disable that languageserver.

	- "filetypes": Supported filetypes, add * in array for all filetypes.
	  Note: it's required for start the languageserver, please make sure
	  your filetype is expected by `:CocCommand document.echoFiletype` command

	- "additionalSchemes": Additional uri schemes, default schemes
	  including file & untitled.
	  Note: you have to setup vim provide content for custom uri as well.

	- "cwd": Working directory used to start languageserver, vim's cwd is
	  used by default.

	- "env": Environment variables for child process.

	- "settings": Settings for languageserver, received on server
	  initialiation.

	- "trace.server": Trace level of communication between server and
	  client that showed with output channel.

	- "stdioEncoding": Encoding used for stdio of child process.

	- "initializationOptions": Initialization options passed to
	  languageserver (it's deprecated)

	- "rootPatterns": Root patterns used to resolve rootPath from current
	  file.

	- "requireRootPattern": If true, doesn't start server when root
	  pattern not found.

	- "ignoredRootPaths": Absolute root paths that language server should
	  not use as rootPath, higher priority than rootPatterns.

	- "disableDynamicRegister": Disable dynamic registerCapability feature
	  for this languageserver to avoid duplicated feature regstration.

	- "disableWorkspaceFolders": Disable workspaceFolders feature for this
	  languageserver.

	- "disableSnippetCompletion": Disable snippet completion feature for
	  this languageserver.

	- "disableDiagnostics": Disable handle diagnostics for this
	  languageserver.

	- "disableCompletion": Disable completion feature for this
	  languageserver.

	- "formatterPriority": Priority of this languageserver's fomatter.

	- "revealOutputChannelOn": Configure message level to show the output
	  channel buffer.

	- "progressOnInitialization": Enable progress report on languageserver
	  initialize.

Language server start with command:~

	Additional fields can be used for command language server:

	- "command": Executable program name in $PATH or absolute path of
	  executable used for start languageserver.

	- "args": Command line arguments of command.

	- "detached": Detach language server when is true.

	- "shell": Use shell for server process, default: `false`

Language server start with module:~

	Additional fields can be used forlanguage server started by node
	module:

	- "module": Absolute filepath of javascript file.

	- "args": Extra arguments used on fork javascript module.

	- "runtime": Absolute path of node runtime, node runtime of coc.nvim
	  is used by default.

	- "execArgv": Argv passed to node on fork, normally used for
	  debugging, ex: `["--nolazy", "--inspect-brk=6045"]`

	- "transport": Transport kind used by server, could be 'ipc', 'stdio',
	  'socket' and 'pipe'. 'ipc' is used by default (recommended).

	- "transportPort": Port number used when transport is 'socket'.

Language server use initialized socket server:~

	- "port": Port number of socket server.

	- "host": Host of socket server, default to `127.0.0.1`.

==============================================================================
COMPLETION						*coc-completion*

Default behavior of coc.nvim's completion:

- Completion is automatically triggered.
- 'completeopt' is temporarily changed to `noinsert,menuone`.
- Snippet complete item would only be expanded after confirm completion.

Use configurations |coc-config-suggest| to change behavior of completion.

Tips:~

- 'completeopt' used by coc.nvim default to `noselect,menuone`.

- Your 'completeopt' option would be changed and restored during completion,
  so you can still use `menu,preview` for Vim's built in completion.

- Snippet expand and additional edit feature of LSP requires confirm
  completion to work.

- Floating window is available on Neovim >= 0.4.0.

------------------------------------------------------------------------------

Example key-mappings:~

Map <tab> to trigger completion and navigate to the next item: >

    function! s:check_back_space() abort
      let col = col('.') - 1
      return !col || getline('.')[col - 1]  =~ '\s'
    endfunction

    inoremap <silent><expr> <TAB>
		  \ pumvisible() ? "\<C-n>" :
		  \ <SID>check_back_space() ? "\<TAB>" :
		  \ coc#refresh()


Map <c-space> to trigger completion: >

	inoremap <silent><expr> <c-space> coc#refresh()
<
<CR> to confirm completion, use: >

	inoremap <expr> <cr> pumvisible() ? "\<C-y>" : "\<CR>"
<
To make <CR> auto-select the first completion item and notify coc.nvim to
format on enter, use: >

	inoremap <silent><expr> <cr> pumvisible() ? coc#_select_confirm()
				\: "\<C-g>u\<CR>\<c-r>=coc#on_enter()\<CR>"

Map <tab> for trigger completion, completion confirm, snippet expand and jump
like VSCode. >

	inoremap <silent><expr> <TAB>
	  \ pumvisible() ? coc#_select_confirm() :
	  \ coc#expandableOrJumpable() ?
	  \ "\<C-r>=coc#rpc#request('doKeymap', ['snippets-expand-jump',''])\<CR>" :
	  \ <SID>check_back_space() ? "\<TAB>" :
	  \ coc#refresh()

	function! s:check_back_space() abort
	  let col = col('.') - 1
	  return !col || getline('.')[col - 1]  =~# '\s'
	endfunction

	let g:coc_snippet_next = '<tab>'
<
Note: the `coc-snippets` extension is required for this to work.

==============================================================================
INTERFACE						*coc-interface*

------------------------------------------------------------------------------

Coc doesn't come with a default global keymap, you need to configure the
mappings yourself.

Key mappings						*coc-key-mappings*

Note: Mappings that start with `i_` works for insert mode `n_` works for
normal mode, `v_` works for visual mode.

<Plug>(coc-diagnostic-info)				*n_coc-diagnostic-info*

	Show diagnostic message of current position by invoke |coc-action-diagnosticInfo|

<Plug>(coc-diagnostic-next)				*n_coc-diagnostic-next*

	Jump to next diagnostic position.

<Plug>(coc-diagnostic-prev)				*n_coc-diagnostic-prev*

	Jump to previous diagnostic position.

<Plug>(coc-diagnostic-next-error)			*n_coc-diagnostic-next-error*

	Jump to next diagnostic error position.

<Plug>(coc-diagnostic-prev-error)			*n_coc-diagnostic-prev-error*

	Jump to previous diagnostic error position.

<Plug>(coc-definition)					*n_coc-definition*

	Jump to definition(s) of current symbol by invoke
	|coc-action-jumpDefinition|

<Plug>(coc-declaration)					*n_coc-declaration*

	Jump to declaration(s) of current symbol by invoke
	||coc-action-jumpDeclaration||

<Plug>(coc-implementation)				*n_coc-implementation*

	Jump to implementation(s) of current symbol by invoke
	||coc-action-jumpImplementation||

<Plug>(coc-type-definition)				*n_coc-type-definition*

	Jump to type definition(s) of current symbol by invoke
	||coc-action-jumpTypeDefinition||

<Plug>(coc-references)					*n_coc-references*

	Jump to references of current symbol by invoke
	|coc-action-jumpReferences|

<Plug>(coc-references-used)				*n_coc-references-used*

	Jump to references of current symbol exclude declarations.

<Plug>(coc-format-selected)				*n_coc-format-selected*
							*v_coc-format-selected*

	Format selected range, would work in both visual mode and normal mode,
	when used in normal mode, the selection works on the motion object.

	For example: >

	vmap <leader>p  <Plug>(coc-format-selected)
	nmap <leader>p  <Plug>(coc-format-selected)
<
	makes `<leader>p` format the visually selected range, and you can use
	`<leader>pap` to format a paragraph.

<Plug>(coc-format)					*n_coc-format*

	Format the whole buffer by invoke |coc-action-format|, normally you
	would like to use a command like: >

	command! -nargs=0 Format :call CocAction('format')
<
	to format the current buffer.

<Plug>(coc-rename)					*n_coc-rename*

	Rename symbol under cursor to a new word by invoke |coc-action-rename|

<Plug>(coc-codeaction)					*n_coc-codeaction*

	Get and run code action(s) for current file.

<Plug>(coc-codeaction-line)				*n_coc-codeaction-line*

	Get and run code action(s) for current line.

<Plug>(coc-codeaction-selected)				*n_coc-codeaction-selected*
							*v_coc-codeaction-selected*

	Get and run code action(s) with the selected region.
	Works with both normal and visual mode.

<Plug>(coc-openlink)					*n_coc-openlink*

	Open link under cursor.

<Plug>(coc-codelens-action)				*n_coc-codelens-action*

	Do command from codeLens of current line.

<Plug>(coc-fix-current)					*n_coc-fix-current*

	Try first quickfix action for diagnostics on the current line.

<Plug>(coc-float-hide)					*n_coc-float-hide*

	Hide all float windows.

<Plug>(coc-float-jump)					*n_coc-float-jump*

	Jump to first float window, works on neovim only since vim's popup
	doesn't have support for focus.

<Plug>(coc-refactor)					*n_coc-refactor*

	Open refactor window for refactor of current symbol.

<Plug>(coc-range-select)				*n_coc-range-select*
<Plug>(coc-range-select)				*v_coc-range-select*

	Select next selection range.

	Note: requires selection ranges feature of language server, like:
	coc-tsserver, coc-python

<Plug>(coc-range-select-backward)			*v_coc-range-select-backward*

	Select previous selection range.

	Note: requires selection ranges feature of language server, like:
	coc-tsserver, coc-python

<Plug>(coc-funcobj-i)					*n_coc-funcobj-i*
							*v_coc-funcobj-i*

      Select inside function. Recommend mapping:

      xmap if <Plug>(coc-funcobj-i)
      omap if <Plug>(coc-funcobj-i)

      Note: Requires 'textDocument.documentSymbol' support from the language
      server.

<Plug>(coc-funcobj-a)					*n_coc-funcobj-a*
							*v_coc-funcobj-a*

	Select around function. Recommended mapping:

	xmap af <Plug>(coc-funcobj-a)
	omap af <Plug>(coc-funcobj-a)

	Note: Requires 'textDocument.documentSymbol' support from the language
	server.

<Plug>(coc-classobj-i)					*n_coc-classobj-i*
							*v_coc-classobj-i*

	Select inside class/struct/interface. Recommended mapping:

	xmap ic <Plug>(coc-classobj-i)
	omap ic <Plug>(coc-classobj-i)

	Note: Requires 'textDocument.documentSymbol' support from the language
	server.


<Plug>(coc-classobj-a)					*n_coc-classobj-a*
							*v_coc-classobj-a*

	Select around class/struct/interface. Recommended mapping:

	xmap ac <Plug>(coc-classobj-a)
	omap ac <Plug>(coc-classobj-a)

	Note: Requires 'textDocument.documentSymbol' support from the language
	server.

------------------------------------------------------------------------------
VARIABLES						*coc-variables*

b:coc_enabled						*b:coc_enabled*

	Set to `0` on buffer create if you don't want coc.nvim receive content
	from buffer. Normally used with |BufAdd| autocmd, ex:
>
	" Disable file with size > 1MB
	autocmd BufAdd * if getfsize(expand('<afile>')) > 1024*1024 |
				\ let b:coc_enabled=0 |
				\ ndif
<
b:coc_root_patterns					*b:coc_root_patterns*

	Root patterns used for resolving workspaceFolder for
	the current file, will be used instead of
	`"coc.preferences.rootPatterns"` setting. E.g.: >

	autocmd FileType python let b:coc_root_patterns =
				\ ['.git', '.env']
<

b:coc_suggest_disable					*b:coc_suggest_disable*

	Disable completion support of current buffer. E.g.: >

	" Disable completion for python
	autocmd FileType python let b:coc_suggest_disable = 1

b:coc_diagnostic_disable				*b:coc_diagnostic_disable*

	Disable diagnostic support of current buffer.

b:coc_suggest_blacklist                 	        *b:coc_suggest_blacklist*

	List of input words for which completion should not be triggered.
	E.g.: >

	" Disable completion for 'end' in lua files
	autocmd FileType lua let b:coc_suggest_blacklist = ["end"]

b:coc_additional_keywords				*b:coc_additional_keywords*

	Addition keyword characters for generate keywords. E.g.: >

	" Add keyword characters for css
	autocmd FileType css let b:coc_additional_keywords = ["-"]

b:coc_current_function					*b:coc_current_function*

	Function string that current cursor in.

	Set `"coc.preferences.currentFunctionSymbolAutoUpdate": true`
	in coc-settings.json to update it on CursorHold.

g:coc_disable_startup_warning 				*g:coc_disable_startup_warning*

	Disable possible warning on startup for old vim/node version.

	Default: 0

g:coc_disable_uncaught_error 				 *g:coc_disable_uncaught_error*

	Disable uncaught error messages from node process of coc.nvim.

	Default: 0

g:coc_channel_timeout					*g:coc_channel_timeout*

	Channel timeout in seconds for request to node client.

	Default: 30

g:coc_disable_transparent_cursor			*g:coc_disable_transparent_cursor*

	Disable transparent cursor when CocList is activated.
	Set it to `1` if you have issue with transparent
	cursor.

	Default: 0

g:coc_last_hover_message				*g:coc_last_hover_message*

	Last message echoed from `doHover`, can be used in statusline.

	Note: not used when floating or preview window used for `doHover`.

g:coc_start_at_startup					*g:coc_start_at_startup*

	Start coc service on startup, use |CocStart| to start server when you
	set it to 0.

	Default: 1

g:coc_user_config					*g:coc_user_config*


	User configuration object, define this variable when you can't use
	|coc#config()|

g:coc_global_extensions					*g:coc_global_extensions*

	Global extension names to install when they aren't installed.
>
	let g:coc_global_extensions = ['coc-json', 'coc-git']
<
g:coc_uri_prefix_replace_patterns			*g:coc_uri_prefix_replace_patterns*

	This map defines URI prefix replacements. This is useful in the case
	that an LSP requires code to adhere to a particular directory
	structure. For example, `/Users/myUser/workspace` can be mapped to
	`/home/myUser/workspace`.
>
	let g:coc_uri_prefix_replace_patterns = {'/Users': '/home'}
<
g:coc_enable_locationlist				*g:coc_enable_locationlist*

	Use location list of |CocList| when jump to locations.

	Set it to 0 when you need customize behavior of location jump by use
	|CocLocationsChange| and |g:coc_jump_locations|

	If you want use vim's quickfix list instead, add
	`"coc.preferences.useQuickfixForLocations": true` in your
	configuration file, this configuration would be ignored and no autocmd
	triggered.

	Default: 1

g:coc_snippet_next					*g:coc_snippet_next*

	Trigger key for going to the next snippet position, applied in insert
	and select mode.

	Only works when snippet session is activated.

	Default: <C-j>

g:coc_snippet_prev					*g:coc_snippet_prev*

	Trigger key for going to the previous snippet position, applied in
	insert and select mode.

	Only works when snippet session is activated.

	Default: <C-k>

g:coc_filetype_map					*g:coc_filetype_map*

	Map for document filetypes so the server could handle current document
	as another filetype, ex: >

	let g:coc_filetype_map = {
		\ 'html.swig': 'html',
		\ 'wxss': 'css',
		\ }
<
	Default: {}

	Note: coc will always map filetype `javascript.jsx` to
	`javascriptreact` and `typescript.tsx` to
	`typescriptreact`. You can find the mapped filetype
	of the current buffer by running `:CocCommand document.echoFiletype`.

g:coc_selectmode_mapping				*g:coc_selectmode_mapping*

	Add key mappings for making snippet select mode easier. >

	snoremap <silent> <BS> <c-g>c
	snoremap <silent> <DEL> <c-g>c
	snoremap <silent> <c-h> <c-g>c
	snoremap <c-r> <c-g>"_c<c-r>
<
	Default: 1

g:coc_node_path						*g:coc_node_path*

	Path to node executable to start coc service. ex: >

	let g:coc_node_path = '/usr/local/opt/node@10/bin/node'
<
	Use this when coc has problems with your system node,

	Note: you can use `~` as home directory.

g:coc_force_bundle					*g:coc_force_bundle*

	When lib folder with javascript code exists, coc.nvim would use
	compiled javascript from lib folder, set this variable to `1` if you
	want it use `build/index.js` created by webpack.

	Default: 0

g:coc_node_args						*g:coc_node_args*

	Arguments passed to node when starting coc service from source code.

	Useful for starting coc in debug mode, ex: >
>
	let g:coc_node_args = ['--nolazy', '--inspect-brk=6045']
<
	Default: []

g:coc_jump_locations					*g:coc_jump_locations*

	This variable would be set to jump locations when the
	|CocLocationsChange| autocmd is fired.

	Each location item contains:

	'filename': full file path.
	'lnum': line number (1 based).
	'col': column number(1 based).
	'text':  line content of location.

g:coc_process_pid					*g:coc_process_pid*

	Process pid of coc.nvim service. If your vim doesn't kill coc.nvim
	process on exit, use:
>
	autocmd VimLeavePre * if get(g:, 'coc_process_pid', 0)
		\	| call system('kill -9 '.g:coc_process_pid) | endif
<
	in your vimrc.

g:coc_status_error_sign					*g:coc_status_error_sign*

	Error character used for statusline, default: `E`

g:coc_status_warning_sign				*g:coc_status_warning_sign*

	Warning character used for statusline, default: `W`

g:coc_watch_extensions					*g:coc_watch_extensions*

	Extensions to watch for reload, used for developing extensions only,
	need watchman installed.

g:coc_quickfix_open_command				*g:coc_quickfix_open_command*

	Command used for open quickfix list.  To jump fist position after
	quickfix list opend, you can use:
>
	let g:coc_quickfix_open_command = 'copen|cfirst'
<
	Default: |copen|

g:WorkspaceFolders					*g:WorkspaceFolders*

	Current workspace folders, used for restoring from a session file, add
	`set sessionoptions+=globals` to vimrc for restoring globals.

g:node_client_debug					*g:node_client_debug*

	Enable debug mode of node client for check rpc messages between vim
	and coc.nvim, use command: >

	:call coc#client#open_log()
<
	to open the log file.

	Default: `0`

g:coc_cursors_activated					*g:coc_cursors_activated*

	Use expression `get(g:, 'coc_cursors_activated',0)` to check if
	cursors session is activated.

g:coc_config_home					*g:coc_config_home*

	Configure the directory which will be used to look for
	`coc-settings.json`, default:

	Windows: `~/AppData/Local/nvim`
	Other: `~/.config/nvim`

g:coc_data_home						*g:coc_data_home*

	Configure the directory which will be used to for coc data
	files(extensions, mru and so on), default:

	Windows: `~/AppData/Local/coc`
	Other: `~/.config/coc`

g:coc_last_float_win					*g:coc_last_float_win*

	Window id of latest created float/popup window.

g:coc_sources_disable_map 				*g:coc_sources_disable_map*

	Configure disabled sources for different filetypes.
	Use `:CocList sources` for loaded complete sources.  ex:
>
	let g:coc_sources_disable_map = { \ 'python': ['omni', 'tag'] \ }

g:coc_borderchars 					*g:coc_borderchars*

	Border characters used by border window, default to:
>
	['─', '│', '─', '│', '┌', '┐', '┘', '└']

g:coc_prompt_win_width 					*g:coc_prompt_win_width*

	Width of input prompt window on neovim >= 0.5.0.  Prompt buffer can't
	work with vim8's popup yet.

------------------------------------------------------------------------------

Some variables are provided by coc.nvim so you can use them in your
statusline. See |coc-status| for detail.

b:coc_diagnostic_info					*b:coc_diagnostic_info*

	Diagnostic information of current buffer, the format would look like:

	`{'error': 0, 'warning': 0, 'information': 0, 'hint':0}`

	can be used to customize statusline. See |coc-status|.

g:coc_status						*g:coc_status*

	Status string contributed by extensions, used for status line.

------------------------------------------------------------------------------
FUNCTIONS						*coc-functions*

Coc functions are normally used by user defined command/keymap or other
plugins.

Note: some functions only work after the coc service has been initialized.

To run a function on startup, use an autocmd like: >

	autocmd User CocNvimInit call CocAction('runCommand',
						\ 'tsserver.watchBuild')
<
coc#start([{option}]) 					*coc#start()*

	Start completion with optional {option}.  Option could contains:

		- `source` specific completion source name.

	ex:  >

	inoremap <silent> <C-w> <C-R>=coc#start({'source': 'word'})<CR>
<
	Use `CocList sources` to get available sources.

coc#config({section}, {value})				*coc#config()*

	Change user configuration by Vim script, no changes would be made to
	user configuration file. ex: >

	call coc#config('coc.preferences', {
		\ 'timeout': 1000,
		\})
	call coc#config('languageserver', {
		\ 'ccls': {
		\   "command": "ccls",
		\   "trace.server": "verbose",
		\   "filetypes": ["c", "cpp", "objc", "objcpp"]
		\ }
		\})
<

	Note: this function can be called multiple times.

	Note: this function can be called before the service has been
	initialized.

	Note: this function can work alongside the user configuration file,
	but it's not recommended to use both.

coc#add_extension({name}, ...)				*coc#add_extension()*

	Deprecated function for install extensions not exists.
	Use |g:coc_global_extensions| variable instead.

	ex: >

	call coc#add_extension('coc-json', 'coc-tsserver', 'coc-rls')
<
	This function can be called before service initialized.
	This function can be called multiple times.

coc#add_command({id}, {command}, [{title}])		*coc#add_command()*

	Add custom Vim command to commands list opened by
	`:CocList commands` .

	Example: >

	call coc#add_command('mundoToggle', 'MundoToggle',
		\ 'toggle mundo window')
<
coc#refresh()						*coc#refresh()*

	Start or refresh completion at current cursor position, bind this to
	'imap' to trigger completion, ex: >

	inoremap <silent><expr> <c-space> coc#refresh()
<
coc#expandable()					*coc#expandable()*

	Check if a snippet is expandable at the current position.
	Requires `coc-snippets` extension installed.

coc#jumpable()						*coc#jumpable()*

	Check if a snippet is jumpable at the current position.

coc#expandableOrJumpable()				*coc#expandableOrJumpable()*

	Check if a snippet is expandable or jumpable at the current position.
	Requires `coc-snippets` extension installed.

coc#on_enter()						*coc#on_enter()*

	Notify coc.nvim that `<enter>` has been pressed.

	Used for the format on type and improvement of brackets, ex: >

	inoremap <silent><expr> <cr> pumvisible() ? coc#_select_confirm()
				\: "\<C-g>u\<CR>\<c-r>=coc#on_enter()\<CR>"
<
	Note：to enable formatOnType, add ` "coc.preferences.formatOnType": true`
	in your settings file.

coc#status()						*coc#status()*

	Return a status string that can be used in the status line, the status
	includes diagnostic information from `b:coc_diagnostic_info` and
	extension contributed statuses from `g:coc_status`. For statusline
	integration, see |coc-status|

coc#_select_confirm()					*coc#_select_confirm()*

	Select first completion item if no completion item is selected, then
	confirm the completion.

	Note: for this function to work as expected, either |CompleteChanged|
	autocmd should exists or only <C-n> and <C-p> should be used to select
	a completion item.


health#coc#check()					*health#coc#check()*

	Neovim only, run health check, triggered by ':checkhealth'
	command.

coc#util#job_command()					*coc#util#job_command()*

	Get the job command used for starting the coc service.

coc#util#get_config_home()				*coc#util#get_config_home()*

	Get the config directory that contains the user's coc-settings.json.

coc#util#get_data_home()				*coc#util#get_data_home()*

	Get `coc` data directory.

coc#util#extension_root()				*coc#util#extension_root()*

	Return extensions root of coc.nvim.

coc#util#rebuild()					*coc#util#rebuild()*

	Rebuild coc extensions.

coc#util#float_scroll({forward})			*coc#util#float_scroll()*

	Deprecated, please use |coc#float#scroll|.

coc#util#root_patterns()				*coc#util#root_patterns()*

	Get root patterns used for current document.

	Result could be something like: >

	{'global': ['.git', '.hg', '.projections.json'], 'buffer': [], 'server': v:null}
<
coc#util#get_config({key})				*coc#util#get_config()*

	Get configuration (mostly defined in coc-settings.json)	by {key}, ex: >

	:echo coc#util#get_config('coc.preferences')

coc#float#close_all() 					*coc#float#close_all()*

	Close all float windows/popups.

	Note: Popup/float windows created by other plugins will also be
	cleared.

coc#float#close({winid}) 				*coc#float#close()*

	Close float window/popup with {winid}.

coc#float#has_scroll() 					*coc#float#has_scroll()*

	Return `1` when there is scrollable float window or popup.
	Example key-mappings:
>
	if has('nvim-0.4.3') || has('patch-8.2.0750')
	  nnoremap <nowait><expr> <C-f> coc#float#has_scroll() ? coc#float#scroll(1) : "\<C-f>"
	  nnoremap <nowait><expr> <C-b> coc#float#has_scroll() ? coc#float#scroll(0) : "\<C-b>"
	  inoremap <nowait><expr> <C-f> coc#float#has_scroll() ? "\<c-r>=coc#float#scroll(1)\<cr>" : "\<Right>"
	  inoremap <nowait><expr> <C-b> coc#float#has_scroll() ? "\<c-r>=coc#float#scroll(0)\<cr>" : "\<Left>"
	endif
<
coc#float#scroll({forward}, [{amount}])

	Scroll all scrollable float windows/popups, scroll backward when
	{forward} is not `1`. {amount} could be number or full page when
	omitted.

	Note: this function requires nvim >= 0.4.3 or vim >= 8.2.750 to work.

CocRequest({id}, {method}, [{params}])			*CocRequest()*

	Send a request to language client of {id} with {method} and optional
	{params}. ex: >

	call CocRequest('tslint', 'textDocument/tslint/allFixes',
		\  {'textDocument': {'uri': 'file:///tmp'}})
<
	Vim error will be raised if the response contains an error.

							*CocRequestAsync()*

CocRequestAsync({id}, {method}, [{params}, [{callback}]])

	Send async request to remote language server.
	{callback} function is called with error and response.

CocNotify({id}, {method}, [{params}])			*CocNotify()*

	Send notification to remote language server, ex:
>
	call CocNotify('ccls', '$ccls/reload')
<
							*CocRegistNotification()*

CocRegistNotification({id}, {method}, {callback})

	Regist notification callback for specified client {id} and {method},
	example: >

	autocmd User CocNvimInit call CocRegistNotification('ccls',
		\ '$ccls/publishSemanticHighlight', function('s:Handler'))
<
	{callback} is called with single param as notification result.

	Note: when register notification with same {id} and {method}, only the
	later registered would work.

							*CocLocations()*

CocLocations({id}, {method}, [{params}, {openCommand}])

	Send location request to language client of {id} with
	{method} and optional {params}. eg: >

	call CocLocations('ccls', '$ccls/call',  {'callee': v:true})

	call CocLocations('ccls', '$ccls/call',  {}, 'vsplit')
<
	{openCommand}: optional command to open buffer, default to
	`coc.preferences.jumpCommand` , |:edit| by default.  When it's
	`v:false` locations list would always used.

							*CocLocationsAsync()*

CocLocationsAsync({id}, {method}, [{params}, {openCommand}])

	Same as |CocLocations()|, but send notification to server instead
	of request.


CocAction({action}, [...{args}])			*CocAction()*

	Run {action} of coc with optional extra {args}.

							*CocActionAsync()*

CocActionAsync({action}, [...{args}, [{callback}]])

	Call CocAction without blocking vim.

	Optional callback is called with `error` as the first argument and
	`response` as the second argument.

CocHasProvider({feature})				*CocHasProvider()*

	Check if provider exists for specified feature. Supported features:

	`rename` `onTypeEdit` `documentLink` `documentColor` `foldingRange`
	`format` `codeAction` `workspaceSymbols` `formatRange` `hover`
	`signature` `documentSymbol` `documentHighlight` `definition`
	`declaration` `typeDefinition` `reference` `implementation` `codeLens`
	`selectionRange`

CocTagFunc({pattern}, {flags}, {info})			*CocTagFunc()*

	Used for vim's 'tagfunc' option, to make tag search by |CTRL-]| use
	coc.nvim as provider.

------------------------------------------------------------------------------
							*coc-action*
Available Actions ~

Acceptable {action} names for |CocAction()| and |CocActionAsync|.

"sourceStat"						*coc-action-sourceStat*

	get the list of completion source stats for the current buffer.

"refreshSource" [{source}]				*coc-action-refreshSource*

	refresh all sources or a source with a name of {source}.

"toggleSource" {source}					*coc-action-toggleSource*

	enable/disable {source}.

"diagnosticList"					*coc-action-diagnosticList*

	Get all diagnostic items of the current Neovim session.

"diagnosticInfo"					*coc-action-diagnosticInfo*

	Show diagnostic message at the current position, do not truncate.

"diagnosticToggle"					*coc-action-diagnosticToggle*

	Enable/disable diagnostics on the fly, not work when `displayByAle` is
	enabled.

"diagnosticPreview"					*coc-action-diagnosticPreview*

	Show diagnostics under current cursor in preview window.

"jumpDefinition" [{openCommand}]			*coc-action-jumpDefinition*

	jump to definition position of the current symbol.
	Return `v:false` when location not found.

	|coc-list-location| is used when more than one position is available.

	To always use |coc-list-location|| for locations, use `v:false` for
	{openCommand}.

	{openCommand}: optional command to open buffer, default to
	`coc.preferences.jumpCommand` in `coc-settings.json`

"jumpDeclaration" [{openCommand}]			*coc-action-jumpDeclaration*

	jump to declaration position of the current symbol.
	Return `v:false` when location not found.

	same behavior as "jumpDefinition".

	When {openCommand} is `v:false`, location list would be always used.

"jumpImplementation" [{openCommand}]			*coc-action-jumpImplementation*

	Jump to implementation position of the current symbol.
	Return `v:false` when location not found.

	same behavior as "jumpDefinition"

"jumpTypeDefinition" [{openCommand}]			*coc-action-jumpTypeDefinition*

	Jump to type definition position of the current symbol.
	Return `v:false` when location not found.

	same behavior as "jumpDefinition"

"jumpReferences" [{openCommand}]			*coc-action-jumpReferences*

	Jump to references position of the current symbol.
	Return `v:false` when location not found.

	same behavior as "jumpDefinition"

"doHover" [{hoverTarget}]					*coc-action-doHover*

	Show documentation of the current word in a preview window.
	Return `v:false` when hover not found.

	{hoverTarget}: optional specification for where to show hover info,
	defaults to `coc.preferences.hoverTarget` in `coc-settings.json`.
	Valid options: ["preview", "echo", "float"]

	Note: the behavior would change in Neovim, where floating windows are
	available.

"getHover"						*coc-action-getHover*

	Get documentation text array on current position, returns array of
	string.

"showSignatureHelp"					*coc-action-showSignatureHelp*

	Echo signature help of current function, return `v:false` when
	signature not found.  You may want to set up an autocmd like this: >

	autocmd User CocJumpPlaceholder call
				\ CocActionAsync('showSignatureHelp')
<
"getCurrentFunctionSymbol"				 *coc-action-getCurrentFunctionSymbol*

	Return the function string that current cursor in.

"documentSymbols"					*coc-action-documentSymbols*

	Get a list of symbols in the current document.

"rename"						*coc-action-rename*

	Rename the symbol under the cursor position, user will be prompted for
	a new name.

	Note: coc.nvim support rename for disk files, but your language server
	may not.

"selectionRanges"					*coc-action-selectionRanges*

	Get selection ranges of current position from language server.

"services"						*coc-action-services*

	Get an information list for all services.

"toggleService" {serviceId}				*coc-action-toggleService*

	Start or stop a service.

"format"						*coc-action-format*

	Format current buffer using the language server.
	Return `v:false` when format failed.

"formatSelected" [{mode}]				*coc-action-formatSelected*

	Format the selected range, {mode} should be one of visual mode: `v` ,
	`V`, `char`, `line`.

	When {mode} is omitted, it should be called using |formatexpr|.


"codeAction" [{mode}] [{only}]				*coc-action-codeAction*

	Prompt for a code action and do it.

	{mode} should be result of visualmode(), when used in visualmode,
	could be empty string or v:null for none visualmode.

	{only} can be title of a codeAction or list of CodeActionKind.

"codeActionRange" {start} {end} [{kind}]		*coc-action-codeActionRange*

	Run code action for range.

	{start} start line number of range.
	{end} end line number of range.
	{kind} code action kind, see |coc-action-codeActions| for available
	action kind.

"codeLensAction"					*coc-action-codeLensAction*

	Invoke the command for codeLens of current line (or the line that
	contains codeLens just above). Prompt would be shown when multiple
	actions are available.

"commands"						*coc-action-commands*

	Get a list of available service commands for the current buffer.

"runCommand" [{name}] [...{args}]			*coc-action-runCommand*

	Run a global command provided by the language server. If {name} is not
	provided, a prompt with a list of commands is shown to be selected.

	{args} are passed as arguments of command.

	You can bind your custom command like so: >

	command! -nargs=0 OrganizeImport
		\ :call CocActionAsync('runCommand', 'tsserver.organizeImports')

"fold" {{kind}}						*coc-action-fold*

	Fold the current buffer, optionally use {kind} for filtering folds,
	{kind} could be either 'comment', 'imports' or 'region'

	Return `v:false` when failed.

"highlight"						*coc-action-highlight*

	Highlight the symbols under the cursor.
	Overwrite the highlight groups `CocHighlightText`, `CocHighlightRead`
	and `CocHighlightWrite` for customizing the colors.

	To enable highlight on CursorHold, create an autocmd like this: >

	autocmd CursorHold * silent call CocActionAsync('highlight')
<
"openLink" [{command}]					*coc-action-openlink*

	Open a link under the cursor with {command}.
	{command} default to `edit`.

	File and URL links are supported, return `v:false` when failed.

	Note: it needs language server support documentLink feature to work.

"extensionStats"					*coc-action-extensionStats*

	Get all extension states as a list. Including `id`, `root` and
	`state`.

	State could be `disabled`, `activated` and `loaded`.

"toggleExtension" {id}					*coc-action-toggleExtension*

	Enable/disable an extension.

"uninstallExtension" {id}				*coc-action-uninstallExtension*

	Uninstall an extension.

"reloadExtension" {id}					*coc-action-reloadExtension*

	Reload an activated extension.

"activeExtension" {id}					*coc-action-activeExtension*

	Activate extension of {id}.

"deactivateExtension" {id}				*coc-action-deactivateExtension*

	Deactivate extension of {id}.

"pickColor"						*coc-action-pickColor*

	Change the color at the current cursor position.

	Requires language server support for the document color request.

	Note: only works on mac or when you have python support on Vim and
	have the gtk module installed.

"colorPresentation"					*coc-action-colorPresentation*

	Change the color presentation at the current color position.

	Requires a language server that supports color representation
	requests.

"codeActions" [{mode}] [{only}]				*coc-action-codeActions*

	Get and invoke codeActions on current document, quickpick menu would
	be shown when there're many codeActions.

	{mode} can be result of |visualmode()| for visual selected
	range.  When it's falsy value, current file is used as range.

	{only} can be array of codeActionKind, possible values including:
	 - 'refactor': Base kind for refactoring actions
	 - 'quickfix': base kind for quickfix actions
	 - 'refactor.extract': Base kind for refactoring extraction actions
	 - 'refactor.inline': Base kind for refactoring inline actions
	 - 'refactor.rewrite': Base kind for refactoring rewrite actions
	 - 'source': Base kind for source actions
	 - 'source.organizeImports': Base kind for an organize imports source
	   action
	 - 'source.fixAll': Base kind for auto-fix source actions

	{only} can also be string, which means filter by tilte of codeAction.

"organizeImport" 					*coc-action-organizeImport*

	Run organize import codeAction for current buffer.
	Show warning when codeAction not found.

"fixAll" 						*coc-action-fixAll*

	Run fixAll codeAction for current buffer.
	Show warning when codeAction not found.


"quickfixes" [{visualmode}]				*coc-action-quickfixes*

	Get quickfix codeActions of current buffer.

	Add {visualmode} as second argument get quickfix actions with range of
	latest |visualmode()|

"doCodeAction" {codeAction}				*coc-action-doCodeAction*

	Do a codeAction.

"doQuickfix"						*coc-action-doQuickfix*

	Do the first quickfix action for the current line.
	Return `v:false` when no quickfix action found.

"addRanges" {ranges}					*coc-action-addRanges*

	Ranges must be provided as array of range type: https://git.io/fjiEG

"getWordEdit"						 *coc-action-getWordEdit*

	Get workspaceEdit of current word, language server used when possible,
	extract word from current buffer as fallback.

"getWorkspaceSymbols" {input} [{bufnr}]		*coc-action-getWorkspaceSymbols*

	Get workspace symbols from {input} and optional {bufnr} (use current
	bufnr when empty).

------------------------------------------------------------------------------
COMMANDS						*coc-commands*

:CocStart						*:CocStart*

	Start the coc.nvim server, do nothing if it's already started.

:CocRestart						*:CocRestart*

	Restart coc.nvim service.

	Use this command when you want coc to start all over again.

:CocDisable						*:CocDisable*

	Disable handling vim events.

:CocEnable						*:CocEnable*

	Enable handling vim events.

:CocConfig						*:CocConfig*

	Edit the user config file `.vim/coc-settings.json` in
	|coc#util#get_config_home()|

:CocLocalConfig						*:CocLocalConfig*

	Edit or create `.vim/coc-settings.json` of the current working
	directory.

:CocInstall [{option}] {name} ...			*:CocInstall*

	Install one or more coc extensions.

	{option}: could be `-sync` for use blocked process to download instead
	of terminal.

	Examples: >

	" Install latest coc-omni
	:CocInstall coc-omni
	" Install coc-omni 1.0.0
	:CocInstall coc-omni@1.0.0
	" Install snippet extension from github
	:CocInstall https://github.com/dsznajder/vscode-es7-javascript-react-snippets
>
:CocUninstall {name}					*:CocUninstall*

	Uninstall an extension, use <tab> to complete the extension
	name.

:CocUpdate						*:CocUpdate*

	Update all coc extensions to the latest version.

:CocUpdateSync						*:CocUpdateSync*

	Block version of update coc extensions.

:CocRebuild						*:CocRebuild*

	Run `npm rebuild` for coc extensions.

	May be required when environment nodejs get upgraded.

:CocCommand {name} [{args}] ...				*:CocCommand*

	Run a command contributed by extensions, use `<tab>` for name
	completion.

:{range}CocAction  [{only}]                            *:CocAction*

	Get codeActions of current document in actions list,
	with optional {range}.

	{only} can be `quickfix`, `refactor`, `source.fixAll` as
	CodeActionKind.

:{range}CocFix                                         *:CocFix*

	Same as `:CocAction quickfix` for quickfix actions.

:CocOpenLog						*:CocOpenLog*

	Open log file of coc.nvim.

	Use environmental variable `NVIM_COC_LOG_FILE` for fixed log file.
	Note: the log would be cleared when coc.nvim started.

	Use environment variable `NVIM_COC_LOG_LEVEL` to change log level
	(default 'info').  Use shell command: >

	export NVIM_COC_LOG_LEVEL=debug
<
	or add: >

	let $NVIM_COC_LOG_LEVEL='debug'
<
	to the beggining of your `.vimrc`

:CocInfo						*:CocInfo*

	Show version and log information in a split window, useful for
	submitting a bug report.

:CocDiagnostics	[height] 				*:CocDiagnostics*

	Open vim's |location-list| with diagnostics of current buffer.

:CocSearch 						*:CocSearch*

	Perform search by ripgrep https://github.com/BurntSushi/ripgrep,
	refactor window would be opened.

	Note: the search is performed on your files, so normally you should
	save your buffers before invoke this command.

	Common arguments for ripgrep:~

	`-e` `--regexp`: treat search pattern as regexp.
	`-F` `--fixed-strings`: treat search pattern as fixed string.
	`-L` `--follow`: follow symbolic links while traversing directories.
	`-g` `--glob` {GLOB}: Include or exclude files and directories for
	searching that match the given glob.
	`--hidden`: Search hidden files and directories.
	`--no-ignore-vcs`:  Don't respect version control ignore files
	(.gitignore, etc.).
	`--no-ignore`: Don't respect ignore files (.gitignore, .ignore, etc.).
	`-w` `--word-regexp`: Only show matches surrounded by word boundaries.
	`-S` `--smart-case`: Searches case insensitively if the pattern is all
	lowercase. Search case sensitively otherwise.
	`--no-config`: Never read configuration files.
	`-x` `--line-regexp`: Only show matches surrounded by line boundaries.

	Use `:man 1 rg` in your terminal for more details.

	Note: By default, hidden files and directories are skipped.

	Note: By default, vcs ignore files including `.gitignore` and
	`.ignore` are respected

	Excape arguments:~

	|<f-args>| is used to convert command line arguments to arguments of
	rg, which means you have to escape space for single argument. For
	example, if you want to search `import { Neovim` , you have to use:
>
	:CocSearch import\ \{\ Neovim
<
	The escape for `{` is required because rg use regexp be default, or:
>
	:CocSearch -F import\ {\ Neovim
<
	for strict match.

	Change and save:~

	Refactor session is started with searched patterns highlighted, just
	change the text and save refactor buffer to make changes across all
	related files. You can make any kind of changes, including add lines
	and remove lines.

------------------------------------------------------------------------------
AUTOCMD							*coc-autocmds*

							*CocLocationsChange*

:autocmd User CocLocationsChange {command}

	For building a custom view of locations, set
	|g:coc_enable_locationlist| to 0 and use this autocmd with with
	|g:coc_jump_locations|

	For example, to disable auto preview of location list, use:
>
	let g:coc_enable_locationlist = 0 autocmd User CocLocationsChange
	CocList --normal location
<
						*CocNvimInit*
:autocmd User CocNvimInit {command}

	Triggered after the coc services have started.

	If you want to trigger an action of coc after Vim has started, this
	autocmd should be used because coc is always started asynchronously.

						*CocStatusChange*

:autocmd User CocStatusChange {command}

	Triggered after `g:coc_status` changed, can be used for refresh
	stautsline.

						*CocDiagnosticChange*

:autocmd User CocDiagnosticChange {command}

	Triggered after the diagnostic status has changed.

	Could be used for updating the statusline.

						*CocJumpPlaceholder*

:autocmd User CocJumpPlaceholder {command}

	Triggered after a jump to a placeholder. Can be used for
	showing signature help like: >

	autocmd User CocJumpPlaceholder call CocActionAsync('showSignatureHelp')
<
						*CocOpenFloat*

:autocmd User CocOpenFloat {command}

	Triggered when a floating window is opened.  The window is not
	focused, use |g:coc_last_float_win| to get window id.

						*CocTerminalOpen*
:autocmd User CocTerminalOpen {command}

	Triggered when the terminal is shown, can be used for adjusting the
	window height.

------------------------------------------------------------------------------

HIGHLIGHTS						*coc-highlights*

To customize a highlight, simply use |:highlight| command of Vim in your
vimrc, like: >

	" make error texts have a red color
	highlight CocErrorHighlight ctermfg=Red  guifg=#ff0000
<
Note: don't use `:hi default` for overwriting the highlights.

Note: highlight commands should appear after the |:colorscheme| command or use
|ColorScheme| autocmd to make sure customized highlight works after color
scheme change.

CocErrorSign						*CocErrorSign*

  Default: `hi CocErrorSign  ctermfg=Red guifg=#ff0000`

  The highlight used for error signs.

CocWarningSign						*CocWarningSign*

  Default: `hi CocWarningSign  ctermfg=Brown guifg=#ff922b`

  The highlight used for warning signs.

CocInfoSign						*CocInfoSign*

  Default: `hi CocInfoSign  ctermfg=Yellow guifg=#fab005`

  The highlight used for information signs.

CocHintSign						*CocHintSign*

  Default: `hi CocHintSign  ctermfg=Blue guifg=#15aabf`

  The highlight used for hint signs.

CocErrorVirtualText					*CocErrorVirtualText*

  Default: `hi default link CocErrorVirtualText  CocErrorSign`

  The highlight used for error signs.

CocWarningVirtualText					*CocWarningVirtualText*

  Default: `hi default link CocWarningVirtualText CocWarningSign`

  The highlight used for warning signs.

CocInfoVirtualText					*CocInfoVirtualText*

  Default: `hi default link CocInfoVirtualText CocInfoSign`

  The highlight used for information signs.

CocHintVirtualText					*CocHintVirtualText*

  Default: `hi default link CocHintVirtualText CocHintSign`

  The highlight used for hint signs.

CocErrorHighlight					*CocErrorHighlight*

  Default: `hi default link CocErrorHighlight   CocUnderline`

  The highlight used for error text.

CocWarningHighlight					*CocWarningHighlight*

  Default: `hi default link CocWarningHighlight   CocUnderline`

  The highlight used for warning text.

CocInfoHighlight					*CocInfoHighlight*

  Default: `hi default link CocInfoHighlight   CocUnderline`

  The highlight used for information text.

CocHintHighlight					*CocHintHighlight*

  Default: `hi default link CocHintHighlight   CocUnderline`

  The highlight used for hint text.

CocHighlightText					*CocHighlightText*

  Default `hi default link CursorColumn`

  The highlight used for document highlight feature. Normally used for
  highlighting same symbols in the buffer at the current cursor position.

CocHighlightRead					*CocHighlightRead*

  Default `hi default link CocHighlightRead  CocHighlightText`

  Highlight for `Read` kind of document symbol.

CocHighlightWrite					*CocHighlightWrite*

  Default `hi default link CocHighlightWrite  CocHighlightText`

  Highlight for `Write` kind of document symbol.

CocErrorLine						*CocErrorLine*

  Default `undefined`

  Line highlight of sign for a line that contains error diagnostic.

CocWarningLine						*CocWarningLine*

  Default `undefined`

  Line highlight of sign for a line that contains warning diagnostic.

CocInfoLine						*CocInfoLine*

  Default `undefined`

  Line highlight of sign for a line that contains info diagnostic.

CocHintLine						*CocHintLine*

  Default `undefined`

  Highlight for a line with diagnostic hint.

CocCodeLens						*CocCodeLens*

  Default: `ctermfg=Gray    guifg=#999999`

  Highlight group of virtual text for codeLens.

CocFloating						*CocFloating*

  Default: `NormalFloat` on neovim, `Pmenu` on vim.

  Normal highlight group of floating windows/popups.

CocErrorFloat						*CocErrorFloat*

  Default: `hi default link CocErrorFloat CocErrorSign`

  The highlight used for floating windows/popups with errors.

CocWarningFloat						*CocWarningFloat*

  Default: `hi default link CocWarningFloat CocWarningSign`

  Highlight group of warnings in floating windows/popups.

CocInfoFloat						*CocInfoFloat*

  Default: `hi default link CocInfoFloat CocInfoSign`

  Highlight group of infos in floating windows/popups.

CocHintFloat						*CocHintFloat*

  Default: `hi default link CocHintFloat CocHintSign`

  Highlight group of hints in floating windows/popups.

CocCursorRange						*CocCursorRange*

  Default: `hi default link CocCursorRange Search`

  The highlight used for cursor ranges.

CocHoverRange						*CocHoverRange*

  Default: `hi default link CocHoverRange Search`

  The highlight used for current hover range.

CocMenuSel						*CocMenuSel*

  Default: `hi default link CocMenuSel PmenuSel`

  The highlight used for selected menu item, works on neovim only.

CocListMode						*CocListMode*

  Default: `hi default link CocListMode ModeMsg`

  The highlight used for mode in statusline of CocList.

CocListPath						*CocListPath*

  Default: `hi default link CocListPath Comment`

  The highlight used for current cwd in statusline of CocList.

==============================================================================
LIST SUPPORT						*coc-list*

Built-in list support to make working with lists of items easier.

The following features are supported:

* Insert & normal mode.
* Default key-mappings for insert & normal mode.
* Customize key-mappings for insert & normal mode.
* Commands for reopening & doing actions with a previous list.
* Different match modes.
* Interactive mode.
* Auto preview on cursor move.
* Number select support.
* Built-in actions for locations.
* Parse ANSI code.
* Mouse support.
* Select actions using <tab>.
* Multiple selections using <space> in normal mode.
* Select lines by visual selection.

------------------------------------------------------------------------------

LIST COMMAND						*coc-list-command*

:CocList [{...options}] [{source}] [{...args}]		*:CocList*

	Open coc list of {source}, Ex: >

	:CocList --normal location
<
	For current jump locations.

	See |coc-list-options| for available list options,

	Also check |coc-config-list| for list configuration.

	{args} are sent to source during the fetching of list.
	Press `?` on normal mode to get supported {args} of current
	list.

	When {source} is empty, lists source is used.

:CocListResume [{name}]					*:CocListResume*

	Reopen last opened list, input and cursor position will be preserved.

:CocPrev [{name}]					*:CocPrev*

	Invoke default action for the previous item in the last {name} list.

	Doesn't open the list window if it's closed.

:CocNext [{name}]					*:CocNext*

	Invoke the default action for the next item in the last {name} list.

	Doesn't open the list window if it's closed.

:CocFirst [{name}]					*:CocFirst*

	Invoke default action for first item in the last {name} list.

:CocLast [{name}]					*:CocLast*

	Invoke default action for last item in the last {name} list.

							*coc-list-options*
Options of CocList command~

--top
	Show list as top window.

--tab
	Open list in new tabpage.

--normal

	Start list in normal mode, recommended for short list.

--no-sort
	Disable sort made by fuzzy score or most recently used, use it when
	it's already sorted.

--input={input}

	Specify the input on session start.

--strict
-S
	Use strict matching instead of fuzzy matching.

--regex
-R
	Use regex matching instead of fuzzy matching.

--ignore-case

	Ignore case when using strict matching or regex matching.

--number-select
-N
	Type a line number to select an item and invoke the default action on
	insert mode. Type `0` to select the 10th line.


--interactive
-I
	Use interactive mode, list items would be reloaded on input
	change, filter and sort would be done by list implementation.

	Note: filtering and sorting would be done by underlying task, which
	means options including `--strict`, `--no-sort`, `--regex`,
	`--ignore-case` would not work at all.

	Note: it requires list implementation have support for interactive
	mode.

--auto-preview
-A

	Start a preview for the current item on the visible list.

--no-quit

	Not quit list session after do action.

	Note: you may need to refresh the list for current state.

--first

	Invoke default action for first list item on list open.
	Nothing happens when the list is empty.

------------------------------------------------------------------------------

LIST CONFIGURATION					*coc-list-configuration*

Use `coc-settings.json` for configuration of lists.

The general configuration of list starts with 'list.'.

Checkout |coc-config-list| or type `list.` in your settings file to get completion
list.

For configuration of a specified list, use section that starts with:
`list.source.{name}`, where `{name}` is the name of list.

Configure default options:~

Use `list.source.{name}.defaultOptions` setting like: >

	// make symbols list use normal mode and interactive by default
	"list.source.symbols.defaultOptions": ["--interactive", "--number-select"],
<
Note: some list like symbols only work in interactive mode, you must
include `--interactive` to `defaultOptions`.

Note: default options will not be used when there're options passed
with |:CocList| command.

Config default arguments:~

Use `list.source.{name}.defaultArgs` setting like: >

	// use regex match for grep source
	"list.source.grep.defaultArgs": ["-regex"],

Note: default arguments used only when arguments from |:CocList| command is
empty.

Note: Type `?` on normal mode to get supported arguments of current list.

------------------------------------------------------------------------------

LIST MAPPINGS						*coc-list-mappings*

Default mappings on insert mode:

<Esc>       - cancel list session.
<C-c>       - stop loading task.
<C-v>       - paste text from system clipboard.
<C-l>       - reload list.
<C-o>       - change to normal mode.
<Down>      - select next line.
<Up>        - select previous line.
<Left>      - move cursor left.
<Right>     - move cursor right.
<End>       - move cursor to end of prompt.
<C-e>       - same as <End>.
<Home>      - move cursor to start of prompt.
<C-a>       - same as <Home>.
<C-f>       - scroll window forward.
<C-b>       - scroll window backward.
<Backspace> - remove previous character of cursor.
<C-h>       - remove previous character of cursor.
<C-w>       - remove previous word of cursor.
<C-u>       - remove characters before cursor.
<C-n>       - navigate to next input in history.
<C-p>       - navigate to previous input in history.
<C-s>       - switch matcher for filter items.
<C-r>       - insert content from Vim register.
<Tab>       - select action.

Default mappings on normal mode:

<Esc>       - cancel list session.
<C-c>       - stop source from fetching more items.
<C-l>       - reload list.
<C-a>       - mark all visible items selected.
<C-o>       - jump to original window on list create.
<Tab>       - select action.
<C-e> 	    - scroll preview window down.
<C-y> 	    - scroll preview window up.
<Space>     - toggle select of current item.
i,I,o,O,a,A - change to insert mode.
p           - preview action.
:           - cancel list session without closing window.
?           - show help of current list.
t           - do 'tabe' action.
d           - do 'drop' action.
s           - do 'split' action.

Use |coc-list-mappings-custom| to override default mappings.

							*coc-list-mappings-custom*

Configurations `"list.normalMappings"` and `"list.insertMappings"` are used
for customizing the list key-mappings, ex: >

	"list.insertMappings": {
		"<C-r>": "do:refresh",
		"<C-f>": "feedkeys:\\<C-f>",
		"<C-b>": "feedkeys:\\<C-b>",
		"<C-n>": "normal:j",
		"<C-p>": "normal:k",
		"<C-t>": "action:tabe",
		"<C-x>": "call:MyFunc",
		// paste yanked text to prompt
		"<C-v>": "eval:@@"
	}
	"list.normalMappings": {
		"c": "expr:MyExprFunc"
		"d": "action:delete"
	}
<
Note: you should only use mappings that start with `<C-` or `<A-` for insert
mappings.

Note: <Esc> can't be remapped for other actions.

The mapping expression should be `command:arguments`, available commands:

'do' - special actions provided by coc list, including:
	'refresh'       - reload list.
	'selectall'     - mark all visible items selected.
	'switch'        - switch matcher used for filter items.
	'exit'          - exit list session.
	'stop'          - stop loading task.
	'cancel'        - cancel list session but leave list window open.
	'toggle'        - toggle selection of current item.
	'togglemode'    - toggle between insert and normal mode.
	'previous'      - move cursor to previous item.
	'next'          - move cursor to next item.
	'defaultaction' - execute default action.
	'jumpback'      - stop prompt and jump back to original window.
	'previewup'     - scroll preview window up.
	'previewdown'   - scroll preview window down.
	'help'          - show help.
'prompt' - do prompt action, including:
	'previous' - change to previous input in history.
	'next'           - change to next input in history.
	'start'          - move cursor to start.
	'end'            - move cursor to end.
	'left'           - move cursor left.
	'right'          - move cursor right.
	'deleteforward'  - remove previous character.
	'deletebackward' - remove next character.
	'removetail'     - remove characters afterwards.
	'removeahead'    - remove character ahead.
	'insertregister' - insert content from Vim register.
	'paste'          - append text from system clipboard to prompt.
'eval'     - append text to prompt from result of VimL expression.
'action'   - execute action of list, use <tab> to find available actions.
'feedkeys' - feedkeys to list window, use `\\` in JSON to escape special characters.
'normal'   - execute normal command in list window.
'normal!'  - execute normal command without remap.
'command'  - execute command.
'call'     - call Vim function with |coc-list-context| as only argument.
'expr'     - same as 'call' but expect the function return action name.

							*coc-list-context*

Context argument contains the following properties:

'name'    - name of the list, ex: `'location'`.
'args'    - arguments of the list.
'input'   - current input of prompt.
'winid'   - window id on list activated.
'bufnr'   - buffer number on list activated.
'targets' - list of selected targets, checkout |coc-list-target| for properties.

							*coc-list-target*

Target contains the following properties:

'label'      - mandatory property that is shown in the buffer.
'filtertext' - optional filter text used for filtering items.
'location'   - optional location of item, check out https://bit.ly/2Rtb6Bo
'data'       - optional additional properties.

------------------------------------------------------------------------------

LIST SOURCES						*coc-list-sources*

------------------------------------------------------------------------------

location						*coc-list-location*

	Last jump locations.

	Actions:

	- 'preview' : preview location in preview window.
	- 'open': open location by use
		`"coc.preferences.jumpCommand"`, default action
	- 'tabe': Use |:tabe| to open location.
	- 'drop': Use |:drop| to open location.
	- 'vsplit': Use |:vsplit| to open location.
	- 'split': Use |:split| to open location.
	- 'quickfix': Add selected items to Vim's quickfix.

extensions						*coc-list-extensions*

	Manage coc extensions.

	Actions:

	- 'toggle' activate/deactivate extension, default action.
	- 'disable' disable extension.
	- 'enable' enable extension.
	- 'lock' lock/unlock extension to current version.
	- 'doc' view extension's README doc.
	- 'fix' fix dependencies in terminal buffer.
	- 'reload' reload extension.
	- 'uninstall' uninstall extension.

diagnostics						*coc-list-diagnostics*

	All diagnostics for the workspace.

	Actions:

	- Same as |coc-list-location|

outline							*coc-list-outline*

	Symbols in the current document.

	Actions:

	- Same as |coc-list-location|

symbols							*coc-list-symbols*

	Search workspace symbols.

	Actions:

	- Same as |coc-list-location|

services						*coc-list-services*

	Manage registered services.

	Actions:

	- 'toggle': toggle service state, default action.

commands						*coc-list-commands*

	Workspace commands.

	Actions:

	- 'run': run selected command, default action.

links							*coc-list-links*

	Links in the current document.

	Actions:

	- 'open': open the link, default action.
	- 'jump': jump to link definition.

sources							*coc-list-completion-sources*

	Available completion sources.

	Actions:

	- 'toggle': activate/deactivate source, default action.
	- 'refresh': refresh source.
	- 'open': open the file where source defined.

lists							*coc-list-lists*

	Get available lists.

	Actions:

	- 'open': open selected list, default action.

==============================================================================

STATUSLINE SUPPORT					*coc-status*

Diagnostics info and other status info contributed by extensions could be
shown in statusline.

The easiest way is add `%{coc#status()}` to your 'statusline' option. Ex: >

	set statusline^=%{coc#status()}
>
------------------------------------------------------------------------------

							*coc-status-manual*

Create function:
>
	function! StatusDiagnostic() abort
	  let info = get(b:, 'coc_diagnostic_info', {})
	  if empty(info) | return '' | endif
	  let msgs = []
	  if get(info, 'error', 0)
	    call add(msgs, 'E' . info['error'])
	  endif
	  if get(info, 'warning', 0)
	    call add(msgs, 'W' . info['warning'])
	  endif
	  return join(msgs, ' ') . ' ' . get(g:, 'coc_status', '')
	endfunction
<
Add `%{StatusDiagnostic()}` to your 'statusline' option.

------------------------------------------------------------------------------

							*coc-status-airline*

With vim-airline: https://github.com/vim-airline/vim-airline

Error and warning display should work in vim-airline out of box.

Disable vim-airline integration:
>
	let g:airline#extensions#coc#enabled = 0
<
Change error symbol:
>
	let airline#extensions#coc#error_symbol = 'Error:'
<
Change warning symbol:
>
	let airline#extensions#coc#warning_symbol = 'Warning:'
<
Change error format:
>
	let airline#extensions#coc#stl_format_err = '%E{[%e(#%fe)]}'
<
Change warning format:
>
	let airline#extensions#coc#stl_format_warn = '%W{[%w(#%fw)]}'
<
------------------------------------------------------------------------------
							*coc-status-lightline*

With lightline.vim: https://github.com/itchyny/lightline.vim

Use configuration like: >

  let g:lightline = {
	\ 'colorscheme': 'wombat',
	\ 'active': {
	\   'left': [ [ 'mode', 'paste' ],
	\             [ 'cocstatus', 'readonly', 'filename', 'modified' ] ]
	\ },
	\ 'component_function': {
	\   'cocstatus': 'coc#status'
	\ },
	\ }

  " Use auocmd to force lightline update.
  autocmd User CocStatusChange,CocDiagnosticChange call lightline#update()
<
==============================================================================
CUSTOM SOURCE						*coc-custom-source*

Creating a custom source in VimL is supported.

Check out https://github.com/neoclide/coc.nvim/wiki/Create-custom-source

==============================================================================
FAQ							*coc-faq*

------------------------------------------------------------------------------
Q:	I got the error message with xxx provider not found.

A:	It means you don't have coc extension or languageserver that provide
	this feature, you have to install extension for it or configure
	languageserver.

	Note some languageserver may not have that feature supported, please
	checkout it's documentation.

Q:	Syntax highlight on float/popup doesn't looks right.

A:	On neovim, coc.nvim uses background neovim instance which load syntax
	plugins only for generate highlights, it may not what you would expect.

Q: 	I don't have float/popup window shown up.

A: 	For vim8,  make sure `echo has('textprop') && has('patch-8.1.1719')`
	echo 1. For neovim, you need neovim >= 0.4.3.


==============================================================================
vim:tw=78:nosta:noet:ts=8:sts=0:ft=help:noet:fen:fdm=marker: