Full Code of neoclide/coc.nvim for AI

gitextract_xmsz3i2m/

├── .all-contributorsrc
├── .editorconfig
├── .github/
│   ├── .codecov.yml
│   ├── FUNDING.yml
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   └── feature_request.md
│   └── workflows/
│       ├── ci.yml
│       ├── lint.yml
│       └── release.yml
├── .gitignore
├── .ignore
├── .npmignore
├── .prettierignore
├── .prettierrc
├── .swcrc
├── .vim/
│   └── coc-settings.json
├── Backers.md
├── CONTRIBUTING.md
├── LICENSE.md
├── README.md
├── autoload/
│   ├── coc/
│   │   ├── api.vim
│   │   ├── client.vim
│   │   ├── color.vim
│   │   ├── compat.vim
│   │   ├── cursor.vim
│   │   ├── dialog.vim
│   │   ├── dict.vim
│   │   ├── float.vim
│   │   ├── highlight.vim
│   │   ├── hlgroup.vim
│   │   ├── inline.vim
│   │   ├── list.vim
│   │   ├── math.vim
│   │   ├── notify.vim
│   │   ├── prompt.vim
│   │   ├── pum.vim
│   │   ├── rpc.vim
│   │   ├── snippet.vim
│   │   ├── string.vim
│   │   ├── task.vim
│   │   ├── terminal.vim
│   │   ├── text.vim
│   │   ├── ui.vim
│   │   ├── util.vim
│   │   ├── vim9.vim
│   │   ├── vtext.vim
│   │   └── window.vim
│   ├── coc.vim
│   └── health/
│       └── coc.vim
├── bin/
│   ├── fuzzy.wasm
│   ├── prompt.js
│   ├── strwidth.wasm
│   └── terminateProcess.sh
├── data/
│   └── schema.json
├── doc/
│   ├── coc-api.txt
│   ├── coc-config.txt
│   ├── coc-example-config.lua
│   ├── coc-example-config.vim
│   └── coc.txt
├── esbuild.js
├── eslint.config.mjs
├── history.md
├── jest.js
├── lua/
│   └── coc/
│       ├── diagnostic.lua
│       ├── highlight.lua
│       ├── text.lua
│       ├── util.lua
│       └── vtext.lua
├── package.json
├── plugin/
│   ├── coc.lua
│   └── coc.vim
├── release.sh
├── src/
│   ├── __tests__/
│   │   ├── autoload/
│   │   │   ├── coc/
│   │   │   │   └── source/
│   │   │   │       ├── email.vim
│   │   │   │       └── vim9.vim
│   │   │   ├── legacy.vim
│   │   │   └── vim9.vim
│   │   ├── client/
│   │   │   ├── configuration.test.ts
│   │   │   ├── connection.test.ts
│   │   │   ├── converter.test.ts
│   │   │   ├── diagnostics.test.ts
│   │   │   ├── dynamic.test.ts
│   │   │   ├── features.test.ts
│   │   │   ├── fileSystemWatcher.test.ts
│   │   │   ├── integration.test.ts
│   │   │   ├── progressPart.test.ts
│   │   │   ├── server/
│   │   │   │   ├── configServer.js
│   │   │   │   ├── crashOnShutdownServer.js
│   │   │   │   ├── crashServer.js
│   │   │   │   ├── customServer.js
│   │   │   │   ├── diagnosticServer.js
│   │   │   │   ├── dynamicServer.js
│   │   │   │   ├── errorServer.js
│   │   │   │   ├── eventServer.js
│   │   │   │   ├── fileWatchServer.js
│   │   │   │   ├── nullServer.js
│   │   │   │   ├── testDocuments.js
│   │   │   │   ├── testFileWatcher.js
│   │   │   │   ├── testInitializeResult.js
│   │   │   │   ├── testServer.js
│   │   │   │   └── timeoutOnShutdownServer.js
│   │   │   ├── textSynchronization.test.ts
│   │   │   ├── utils.test.ts
│   │   │   └── workspaceFolder.test.ts
│   │   ├── coc-settings.json
│   │   ├── completion/
│   │   │   ├── basic.test.ts
│   │   │   ├── float.test.ts
│   │   │   ├── language.test.ts
│   │   │   ├── sources.test.ts
│   │   │   └── util.test.ts
│   │   ├── configuration/
│   │   │   ├── configurationModel.test.ts
│   │   │   ├── configurations.test.ts
│   │   │   ├── settings.json
│   │   │   └── util.test.ts
│   │   ├── core/
│   │   │   ├── autocmds.test.ts
│   │   │   ├── documents.test.ts
│   │   │   ├── editors.test.ts
│   │   │   ├── fileSystemWatcher.test.ts
│   │   │   ├── files.test.ts
│   │   │   ├── funcs.test.ts
│   │   │   ├── keymaps.test.ts
│   │   │   ├── locations.test.ts
│   │   │   ├── terminals.test.ts
│   │   │   ├── ui.test.ts
│   │   │   └── workspaceFolder.test.ts
│   │   ├── handler/
│   │   │   ├── callHierarchy.test.ts
│   │   │   ├── codeActions.test.ts
│   │   │   ├── codelens.test.ts
│   │   │   ├── commands.test.ts
│   │   │   ├── documentColors.test.ts
│   │   │   ├── documentLinks.test.ts
│   │   │   ├── fold.test.ts
│   │   │   ├── format.test.ts
│   │   │   ├── highlights.test.ts
│   │   │   ├── hover.test.ts
│   │   │   ├── index.test.ts
│   │   │   ├── inlayHint.test.ts
│   │   │   ├── inline.test.ts
│   │   │   ├── inlineCompletion.test.ts
│   │   │   ├── inlineValue.test.ts
│   │   │   ├── linkedEditing.test.ts
│   │   │   ├── locations.test.ts
│   │   │   ├── outline.test.ts
│   │   │   ├── parser.ts
│   │   │   ├── refactor.test.ts
│   │   │   ├── rename.test.ts
│   │   │   ├── search.test.ts
│   │   │   ├── selectionRange.test.ts
│   │   │   ├── semanticTokens.test.ts
│   │   │   ├── signature.test.ts
│   │   │   ├── symbols.test.ts
│   │   │   ├── typeHierarchy.test.ts
│   │   │   └── workspace.test.ts
│   │   ├── helper.ts
│   │   ├── list/
│   │   │   ├── commandTask.test.ts
│   │   │   ├── history.test.ts
│   │   │   ├── manager.test.ts
│   │   │   ├── mappings.test.ts
│   │   │   ├── session.test.ts
│   │   │   ├── source-funcs.test.ts
│   │   │   ├── sources.test.ts
│   │   │   ├── ui.test.ts
│   │   │   └── worker.test.ts
│   │   ├── markdown/
│   │   │   ├── index.test.ts
│   │   │   └── renderer.test.ts
│   │   ├── memos.json
│   │   ├── modules/
│   │   │   ├── attach.test.ts
│   │   │   ├── chars.test.ts
│   │   │   ├── cursors.test.ts
│   │   │   ├── db.test.ts
│   │   │   ├── diagnosticBuffer.test.ts
│   │   │   ├── diagnosticCollection.test.ts
│   │   │   ├── diagnosticManager.test.ts
│   │   │   ├── dialog.test.ts
│   │   │   ├── document.test.ts
│   │   │   ├── events.test.ts
│   │   │   ├── extensionInstaller.test.ts
│   │   │   ├── extensionManager.test.ts
│   │   │   ├── extensionModules.test.ts
│   │   │   ├── extensions.test.ts
│   │   │   ├── fetch.test.ts
│   │   │   ├── filter.test.ts
│   │   │   ├── floatFactory.test.ts
│   │   │   ├── fs.test.ts
│   │   │   ├── fuzzyMatch.test.ts
│   │   │   ├── highlighter.test.ts
│   │   │   ├── line.test.ts
│   │   │   ├── logger.test.ts
│   │   │   ├── map.test.ts
│   │   │   ├── memos.test.ts
│   │   │   ├── menu.test.ts
│   │   │   ├── outputChannel.test.ts
│   │   │   ├── picker.test.ts
│   │   │   ├── plugin.test.ts
│   │   │   ├── quickpick.test.ts
│   │   │   ├── regions.test.ts
│   │   │   ├── sandbox/
│   │   │   │   └── log.js
│   │   │   ├── semanticTokensBuilder.test.ts
│   │   │   ├── server.js
│   │   │   ├── services.test.ts
│   │   │   ├── sources.test.ts
│   │   │   ├── strWidth.test.ts
│   │   │   ├── task.test.ts
│   │   │   ├── terminal.test.ts
│   │   │   ├── util.test.ts
│   │   │   ├── window.test.ts
│   │   │   └── workspace.test.ts
│   │   ├── npm
│   │   ├── rg
│   │   ├── sample/
│   │   │   └── .vim/
│   │   │       └── coc-settings.json
│   │   ├── snippets/
│   │   │   ├── manager.test.ts
│   │   │   ├── parser.test.ts
│   │   │   ├── session.test.ts
│   │   │   └── snippet.test.ts
│   │   ├── tree/
│   │   │   ├── basicProvider.test.ts
│   │   │   └── treeView.test.ts
│   │   ├── ultisnips.py
│   │   ├── vim.test.ts
│   │   └── vimrc
│   ├── attach.ts
│   ├── commands.ts
│   ├── completion/
│   │   ├── complete.ts
│   │   ├── floating.ts
│   │   ├── index.ts
│   │   ├── keywords.ts
│   │   ├── match.ts
│   │   ├── native/
│   │   │   ├── around.ts
│   │   │   ├── buffer.ts
│   │   │   └── file.ts
│   │   ├── pum.ts
│   │   ├── source-language.ts
│   │   ├── source-vim.ts
│   │   ├── source.ts
│   │   ├── sources.ts
│   │   ├── types.ts
│   │   ├── util.ts
│   │   └── wordDistance.ts
│   ├── configuration/
│   │   ├── configuration.ts
│   │   ├── event.ts
│   │   ├── index.ts
│   │   ├── model.ts
│   │   ├── parser.ts
│   │   ├── registry.ts
│   │   ├── shape.ts
│   │   ├── types.ts
│   │   └── util.ts
│   ├── core/
│   │   ├── autocmds.ts
│   │   ├── channels.ts
│   │   ├── contentProvider.ts
│   │   ├── dialogs.ts
│   │   ├── documents.ts
│   │   ├── editors.ts
│   │   ├── fileSystemWatcher.ts
│   │   ├── files.ts
│   │   ├── funcs.ts
│   │   ├── highlights.ts
│   │   ├── keymaps.ts
│   │   ├── notifications.ts
│   │   ├── terminals.ts
│   │   ├── ui.ts
│   │   ├── watchers.ts
│   │   ├── watchman.ts
│   │   └── workspaceFolder.ts
│   ├── cursors/
│   │   ├── index.ts
│   │   ├── session.ts
│   │   ├── textRange.ts
│   │   └── util.ts
│   ├── diagnostic/
│   │   ├── buffer.ts
│   │   ├── collection.ts
│   │   ├── manager.ts
│   │   └── util.ts
│   ├── events.ts
│   ├── extension/
│   │   ├── index.ts
│   │   ├── installer.ts
│   │   ├── manager.ts
│   │   ├── stat.ts
│   │   └── ui.ts
│   ├── handler/
│   │   ├── callHierarchy.ts
│   │   ├── codeActions.ts
│   │   ├── codelens/
│   │   │   ├── buffer.ts
│   │   │   └── index.ts
│   │   ├── colors/
│   │   │   ├── colorBuffer.ts
│   │   │   └── index.ts
│   │   ├── commands.ts
│   │   ├── fold.ts
│   │   ├── format.ts
│   │   ├── highlights.ts
│   │   ├── hover.ts
│   │   ├── index.ts
│   │   ├── inlayHint/
│   │   │   ├── buffer.ts
│   │   │   └── index.ts
│   │   ├── inline.ts
│   │   ├── linkedEditing.ts
│   │   ├── links.ts
│   │   ├── locations.ts
│   │   ├── refactor/
│   │   │   ├── buffer.ts
│   │   │   ├── changes.ts
│   │   │   ├── index.ts
│   │   │   └── search.ts
│   │   ├── rename.ts
│   │   ├── selectionRange.ts
│   │   ├── semanticTokens/
│   │   │   ├── buffer.ts
│   │   │   └── index.ts
│   │   ├── signature.ts
│   │   ├── symbols/
│   │   │   ├── buffer.ts
│   │   │   ├── index.ts
│   │   │   ├── outline.ts
│   │   │   └── util.ts
│   │   ├── typeHierarchy.ts
│   │   ├── types.ts
│   │   ├── util.ts
│   │   └── workspace.ts
│   ├── index.ts
│   ├── language-client/
│   │   ├── LICENSE.txt
│   │   ├── callHierarchy.ts
│   │   ├── client.ts
│   │   ├── codeAction.ts
│   │   ├── codeLens.ts
│   │   ├── colorProvider.ts
│   │   ├── completion.ts
│   │   ├── configuration.ts
│   │   ├── declaration.ts
│   │   ├── definition.ts
│   │   ├── diagnostic.ts
│   │   ├── documentHighlight.ts
│   │   ├── documentLink.ts
│   │   ├── documentSymbol.ts
│   │   ├── executeCommand.ts
│   │   ├── features.ts
│   │   ├── fileOperations.ts
│   │   ├── fileSystemWatcher.ts
│   │   ├── foldingRange.ts
│   │   ├── formatting.ts
│   │   ├── hover.ts
│   │   ├── implementation.ts
│   │   ├── index.ts
│   │   ├── inlayHint.ts
│   │   ├── inlineCompletion.ts
│   │   ├── inlineValue.ts
│   │   ├── linkedEditingRange.ts
│   │   ├── progress.ts
│   │   ├── progressPart.ts
│   │   ├── reference.ts
│   │   ├── rename.ts
│   │   ├── selectionRange.ts
│   │   ├── semanticTokens.ts
│   │   ├── signatureHelp.ts
│   │   ├── textDocumentContent.ts
│   │   ├── textSynchronization.ts
│   │   ├── typeDefinition.ts
│   │   ├── typeHierarchy.ts
│   │   ├── utils/
│   │   │   ├── async.ts
│   │   │   ├── codeConverter.ts
│   │   │   ├── errorHandler.ts
│   │   │   ├── index.ts
│   │   │   ├── logger.ts
│   │   │   └── uuid.ts
│   │   ├── workspaceFolders.ts
│   │   └── workspaceSymbol.ts
│   ├── languages.ts
│   ├── list/
│   │   ├── basic.ts
│   │   ├── commandTask.ts
│   │   ├── configuration.ts
│   │   ├── db.ts
│   │   ├── formatting.ts
│   │   ├── history.ts
│   │   ├── manager.ts
│   │   ├── mappings.ts
│   │   ├── prompt.ts
│   │   ├── session.ts
│   │   ├── source/
│   │   │   ├── commands.ts
│   │   │   ├── diagnostics.ts
│   │   │   ├── extensions.ts
│   │   │   ├── folders.ts
│   │   │   ├── links.ts
│   │   │   ├── lists.ts
│   │   │   ├── location.ts
│   │   │   ├── notifications.ts
│   │   │   ├── outline.ts
│   │   │   ├── services.ts
│   │   │   ├── sources.ts
│   │   │   └── symbols.ts
│   │   ├── types.ts
│   │   ├── ui.ts
│   │   └── worker.ts
│   ├── logger/
│   │   ├── index.ts
│   │   └── log.ts
│   ├── markdown/
│   │   ├── index.ts
│   │   ├── renderer.ts
│   │   └── styles.ts
│   ├── model/
│   │   ├── bufferSync.ts
│   │   ├── chars.ts
│   │   ├── db.ts
│   │   ├── dialog.ts
│   │   ├── document.ts
│   │   ├── download.ts
│   │   ├── editInspect.ts
│   │   ├── fetch.ts
│   │   ├── floatFactory.ts
│   │   ├── fuzzyMatch.ts
│   │   ├── highlighter.ts
│   │   ├── input.ts
│   │   ├── line.ts
│   │   ├── memos.ts
│   │   ├── menu.ts
│   │   ├── mru.ts
│   │   ├── notification.ts
│   │   ├── outputChannel.ts
│   │   ├── picker.ts
│   │   ├── popup.ts
│   │   ├── progress.ts
│   │   ├── quickpick.ts
│   │   ├── regions.ts
│   │   ├── relativePattern.ts
│   │   ├── resolver.ts
│   │   ├── semanticTokensBuilder.ts
│   │   ├── status.ts
│   │   ├── strwidth.ts
│   │   ├── tabs.ts
│   │   ├── task.ts
│   │   ├── terminal.ts
│   │   ├── textdocument.ts
│   │   └── textline.ts
│   ├── plugin.ts
│   ├── provider/
│   │   ├── callHierarchyManager.ts
│   │   ├── codeActionManager.ts
│   │   ├── codeLensManager.ts
│   │   ├── declarationManager.ts
│   │   ├── definitionManager.ts
│   │   ├── documentColorManager.ts
│   │   ├── documentHighlightManager.ts
│   │   ├── documentLinkManager.ts
│   │   ├── documentSymbolManager.ts
│   │   ├── foldingRangeManager.ts
│   │   ├── formatManager.ts
│   │   ├── formatRangeManager.ts
│   │   ├── hoverManager.ts
│   │   ├── implementationManager.ts
│   │   ├── index.ts
│   │   ├── inlayHintManager.ts
│   │   ├── inlineCompletionItemManager.ts
│   │   ├── inlineValueManager.ts
│   │   ├── linkedEditingRangeManager.ts
│   │   ├── manager.ts
│   │   ├── onTypeFormatManager.ts
│   │   ├── referenceManager.ts
│   │   ├── renameManager.ts
│   │   ├── selectionRangeManager.ts
│   │   ├── semanticTokensManager.ts
│   │   ├── semanticTokensRangeManager.ts
│   │   ├── signatureManager.ts
│   │   ├── typeDefinitionManager.ts
│   │   ├── typeHierarchyManager.ts
│   │   └── workspaceSymbolsManager.ts
│   ├── services.ts
│   ├── snippets/
│   │   ├── eval.ts
│   │   ├── manager.ts
│   │   ├── parser.ts
│   │   ├── session.ts
│   │   ├── snippet.ts
│   │   ├── string.ts
│   │   ├── util.ts
│   │   └── variableResolve.ts
│   ├── tree/
│   │   ├── BasicDataProvider.ts
│   │   ├── LocationsDataProvider.ts
│   │   ├── TreeItem.ts
│   │   ├── TreeView.ts
│   │   ├── filter.ts
│   │   └── index.ts
│   ├── types.ts
│   ├── util/
│   │   ├── ansiparse.ts
│   │   ├── array.ts
│   │   ├── async.ts
│   │   ├── charCode.ts
│   │   ├── color.ts
│   │   ├── constants.ts
│   │   ├── convert.ts
│   │   ├── diff.ts
│   │   ├── errors.ts
│   │   ├── extensionRegistry.ts
│   │   ├── factory.ts
│   │   ├── filter.ts
│   │   ├── fs.ts
│   │   ├── fuzzy.ts
│   │   ├── index.ts
│   │   ├── is.ts
│   │   ├── jsonRegistry.ts
│   │   ├── jsonSchema.ts
│   │   ├── lodash.ts
│   │   ├── map.ts
│   │   ├── mutex.ts
│   │   ├── node.ts
│   │   ├── numbers.ts
│   │   ├── object.ts
│   │   ├── platform.ts
│   │   ├── position.ts
│   │   ├── processes.ts
│   │   ├── protocol.ts
│   │   ├── registry.ts
│   │   ├── sequence.ts
│   │   ├── string.ts
│   │   ├── textedit.ts
│   │   └── timing.ts
│   ├── window.ts
│   └── workspace.ts
├── tsconfig.json
└── typings/
    ├── LICENSE
    ├── Readme.md
    └── index.d.ts

SYMBOL INDEX (5337 symbols across 367 files)

FILE: bin/prompt.js
  function createSequences (line 43) | function createSequences(str) {
  function send (line 47) | function send(args) {
  function getKey (line 68) | function getKey(key) {

FILE: esbuild.js
  method setup (line 14) | setup(build) {
  function start (line 71) | async function start() {

FILE: src/__tests__/client/configuration.test.ts
  function createClient (line 9) | function createClient(section: string | string[] | undefined, middleware...

FILE: src/__tests__/client/connection.test.ts
  class TestStream (line 6) | class TestStream extends Duplex {
    method _write (line 7) | public _write(chunk: string, _encoding: string, done: () => void): void {
    method _read (line 12) | public _read(_size: number): void {

FILE: src/__tests__/client/converter.test.ts
  function createDocument (line 8) | function createDocument(): TextDocument {

FILE: src/__tests__/client/diagnostics.test.ts
  function getId (line 14) | function getId(uri: string): number {
  function createDocument (line 19) | function createDocument(id: number, version = 1): TextDocument {
  function createUri (line 24) | function createUri(id: number): URI {
  method pull (line 33) | pull(document) {
  method pullAsync (line 36) | pullAsync(document) {
  method pull (line 57) | pull(document) {
  method pullAsync (line 60) | pullAsync(document) {
  function createServer (line 141) | async function createServer(interFileDependencies: boolean, workspaceDia...
  function getUri (line 161) | function getUri(s: number | string): string {

FILE: src/__tests__/client/dynamic.test.ts
  function startServer (line 31) | async function startServer(opts: any = {}, middleware: lsclient.Middlewa...

FILE: src/__tests__/client/features.test.ts
  function rangeEqual (line 34) | function rangeEqual(range: Range, sl: number, sc: number, el: number, ec...
  function positionEqual (line 41) | function positionEqual(pos: Position, l: number, c: number): void {
  function colorEqual (line 46) | function colorEqual(color: Color, red: number, green: number, blue: numb...
  function uriEqual (line 53) | function uriEqual(actual: string, expected: string): void {
  function isArray (line 57) | function isArray<T>(value: Array<T> | undefined | null, clazz: any, leng...
  function isDefined (line 67) | function isDefined<T>(value: T | undefined | null): asserts value is Exc...
  function isFullDocumentDiagnosticReport (line 73) | function isFullDocumentDiagnosticReport(value: DocumentDiagnosticReport)...
  function ensureReferenceEdit (line 888) | function ensureReferenceEdit(edits: WorkspaceEdit, type: string, expecte...
  function ensureNotificationReceived (line 897) | async function ensureNotificationReceived(type: string, params: any) {
  class CrashClient (line 1558) | class CrashClient extends LanguageClient {
    method constructor (line 1563) | constructor(id: string, name: string, serverOptions: ServerOptions, cl...
    method handleConnectionClosed (line 1570) | protected async handleConnectionClosed(): Promise<void> {
  function createClient (line 1707) | function createClient(): LanguageClient {
  function checkServerStart (line 1798) | async function checkServerStart(client: LanguageClient, disposable: Disp...

FILE: src/__tests__/client/fileSystemWatcher.test.ts
  function createClient (line 9) | function createClient(fileEvents: IFileSystemWatcher | IFileSystemWatche...
  class CustomWatcher (line 29) | class CustomWatcher implements IFileSystemWatcher {
    method constructor (line 39) | constructor() {
    method fireCreate (line 42) | public fireCreate(uri: URI): void {
    method fireChange (line 46) | public fireChange(uri: URI): void {
    method fireDelete (line 50) | public fireDelete(uri: URI): void {
    method dispose (line 54) | public dispose() {

FILE: src/__tests__/client/integration.test.ts
  function testLanguageServer (line 36) | async function testLanguageServer(serverOptions: lsclient.ServerOptions,...
  function testServer (line 456) | async function testServer(serverOptions: lsclient.ServerOptions) {
  class SimpleStaticFeature (line 707) | class SimpleStaticFeature implements StaticFeature {
    method fillClientCapabilities (line 709) | public fillClientCapabilities(capabilities): void {
    method preInitialize (line 714) | public preInitialize(): void {
    method initialize (line 717) | public initialize(): void {
    method getState (line 719) | public getState(): FeatureState {
    method dispose (line 722) | public dispose(): void {
  function startServer (line 859) | async function startServer(handler: InitializationFailedHandler | undefi...

FILE: src/__tests__/client/progressPart.test.ts
  type ProgressType (line 6) | type ProgressType = WorkDoneProgressBegin | WorkDoneProgressReport | Wor...
  function createClient (line 23) | function createClient(): ProgressContext & { fire: (ev: ProgressType) =>...

FILE: src/__tests__/client/textSynchronization.test.ts
  function createClient (line 16) | function createClient(documentSelector: DocumentSelector | undefined | n...
  function loadBuffer (line 50) | async function loadBuffer(filepath: string): Promise<Document> {

FILE: src/__tests__/client/workspaceFolder.test.ts
  class TestLanguageClient (line 9) | class TestLanguageClient extends BaseLanguageClient {
    method createMessageTransports (line 10) | protected createMessageTransports(): Promise<MessageTransports> {
    method onRequest (line 13) | public onRequest(): Disposable {
  type MaybeFolders (line 20) | type MaybeFolders = proto.WorkspaceFolder[] | undefined
  class TestWorkspaceFoldersFeature (line 22) | class TestWorkspaceFoldersFeature extends WorkspaceFoldersFeature {
    method sendInitialEvent (line 23) | public sendInitialEvent(currentWorkspaceFolders: MaybeFolders): void {
    method initializeWithFolders (line 27) | public initializeWithFolders(currentWorkspaceFolders: MaybeFolders) {
  function testEvent (line 32) | function testEvent(initial: MaybeFolders, then: MaybeFolders, added: pro...
  function testNoEvent (line 53) | function testNoEvent(initial: MaybeFolders, then: MaybeFolders) {

FILE: src/__tests__/completion/basic.test.ts
  function triggerCompletion (line 32) | function triggerCompletion(source: string): void {
  function pumvisible (line 35) | async function pumvisible(): Promise<boolean> {
  function create (line 40) | async function create(items: string[] | VimCompleteItem[], trigger = tru...

FILE: src/__tests__/completion/float.test.ts
  function createFloat (line 118) | async function createFloat(config: Partial<FloatConfig>, docs = [{ filet...
  function getFloat (line 129) | async function getFloat(): Promise<number> {
  function getRelated (line 134) | async function getRelated(winid: number, kind: string): Promise<number> {

FILE: src/__tests__/completion/language.test.ts
  function createCompletionItem (line 33) | function createCompletionItem(word: string): CompletionItem {
  function getDetailContent (line 176) | async function getDetailContent(): Promise<string | undefined> {
  function start (line 611) | async function start(item: CompletionItem, itemDefaults: ItemDefaults, t...

FILE: src/__tests__/completion/sources.test.ts
  function createSource (line 71) | function createSource(opt: SourceConfig): Source {
  function makeid (line 77) | function makeid(length) {
  function createSourceFile (line 192) | function createSourceFile(name: string, content: string): string {

FILE: src/__tests__/completion/util.test.ts
  function getSource (line 32) | function getSource(): ISource {
  function createOption (line 149) | function createOption(bufnr: number, linenr: number, line: string, col: ...
  function create (line 262) | function create(inputStart: number, option: ConvertOption, opt: OptionFo...
  function score (line 363) | function score(word: string, input: string): number {
  function assertMatch (line 436) | function assertMatch(word: string, input: string, res: [number, Readonly...

FILE: src/__tests__/configuration/configurationModel.test.ts
  function createNode (line 24) | function createNode(id: string): IConfigurationNode {
  function length (line 28) | function length(obj: object): number {
  function toConfigurationModel (line 122) | function toConfigurationModel(content: any): ConfigurationModel {

FILE: src/__tests__/configuration/configurations.test.ts
  function U (line 20) | function U(fsPath: string): string {
  function createConfigurations (line 24) | function createConfigurations(): Configurations {
  function generateTmpDir (line 35) | function generateTmpDir(): string {
  method root (line 124) | get root() {

FILE: src/__tests__/core/editors.test.ts
  function assertEditor (line 64) | function assertEditor(editor: TextEditor, tabpagenr: number, winid: numb...

FILE: src/__tests__/core/fileSystemWatcher.test.ts
  function wait (line 29) | function wait(ms: number): Promise<any> {
  function createFileChange (line 37) | function createFileChange(file: string, isNew = true, exists = true): Fi...
  function sendResponse (line 48) | function sendResponse(data: any): void {
  function sendSubscription (line 52) | function sendSubscription(uid: string, root: string, files: FileChangeIt...
  function createWatcher (line 241) | async function createWatcher(pattern: GlobPattern, ignoreCreateEvents = ...

FILE: src/__tests__/core/files.test.ts
  function testThrow (line 38) | function testThrow(fn: () => void) {
  function assertEdit (line 448) | async function assertEdit(confirm: boolean, description: string | undefi...
  function inspect (line 513) | async function inspect(edit: WorkspaceEdit): Promise<Buffer> {

FILE: src/__tests__/core/locations.test.ts
  function createLocations (line 26) | function createLocations(): Location[] {

FILE: src/__tests__/core/workspaceFolder.test.ts
  function updateConfiguration (line 19) | function updateConfiguration(key: string, value: any, defaults: any): vo...
  function assertAsRelativePath (line 48) | function assertAsRelativePath(input: string | URI, expected: string, inc...

FILE: src/__tests__/handler/callHierarchy.test.ts
  function createCallItem (line 29) | function createCallItem(name: string, kind: SymbolKind, uri: string, ran...
  method prepareCallHierarchy (line 61) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 64) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 67) | provideCallHierarchyOutgoingCalls() {
  method prepareCallHierarchy (line 79) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 82) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 88) | provideCallHierarchyOutgoingCalls() {
  method prepareCallHierarchy (line 112) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 115) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 118) | provideCallHierarchyOutgoingCalls() {
  method prepareCallHierarchy (line 135) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 138) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 147) | provideCallHierarchyOutgoingCalls() {
  method prepareCallHierarchy (line 197) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 200) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 203) | provideCallHierarchyOutgoingCalls() {
  method prepareCallHierarchy (line 240) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 243) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 249) | provideCallHierarchyOutgoingCalls() {
  method prepareCallHierarchy (line 285) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 288) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 294) | provideCallHierarchyOutgoingCalls() {
  method prepareCallHierarchy (line 330) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 333) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 336) | provideCallHierarchyOutgoingCalls() {
  method prepareCallHierarchy (line 376) | prepareCallHierarchy() {
  method provideCallHierarchyIncomingCalls (line 379) | provideCallHierarchyIncomingCalls() {
  method provideCallHierarchyOutgoingCalls (line 382) | provideCallHierarchyOutgoingCalls() {

FILE: src/__tests__/handler/codelens.test.ts
  function createBufferWithCodeLens (line 38) | async function createBufferWithCodeLens(): Promise<CodeLensBuffer> {

FILE: src/__tests__/handler/documentColors.test.ts
  function getColor (line 66) | function getColor(r: number, g: number, b: number): Color {

FILE: src/__tests__/handler/documentLinks.test.ts
  method provideDocumentLinks (line 79) | provideDocumentLinks(_doc, _token) {
  method resolveDocumentLink (line 84) | resolveDocumentLink(link) {
  method provideDocumentLinks (line 100) | provideDocumentLinks(_doc, _token) {
  method resolveDocumentLink (line 103) | resolveDocumentLink() {
  method provideDocumentLinks (line 118) | provideDocumentLinks(_doc, _token) {
  method resolveDocumentLink (line 121) | resolveDocumentLink(link, token) {
  method provideDocumentLinks (line 153) | provideDocumentLinks(_doc, _token) {
  method resolveDocumentLink (line 158) | resolveDocumentLink(link) {
  method provideDocumentLinks (line 176) | provideDocumentLinks(_doc, _token) {
  method provideDocumentLinks (line 189) | provideDocumentLinks(_doc, _token) {
  method resolveDocumentLink (line 194) | resolveDocumentLink(link) {

FILE: src/__tests__/handler/fold.test.ts
  method provideFoldingRanges (line 40) | provideFoldingRanges(_doc) {
  method provideFoldingRanges (line 51) | provideFoldingRanges(_doc) {
  method provideFoldingRanges (line 68) | provideFoldingRanges() {
  method provideFoldingRanges (line 73) | provideFoldingRanges() {
  method provideFoldingRanges (line 87) | provideFoldingRanges() {
  method provideFoldingRanges (line 92) | provideFoldingRanges() {
  method provideFoldingRanges (line 105) | provideFoldingRanges(_doc) {

FILE: src/__tests__/handler/highlights.test.ts
  function registerProvider (line 31) | function registerProvider(): void {
  function registerTimerProvider (line 51) | function registerTimerProvider(fn: Function, timeout: number): void {

FILE: src/__tests__/handler/hover.test.ts
  function getDocumentText (line 39) | async function getDocumentText(): Promise<string> {
  method provideDefinition (line 207) | provideDefinition() {
  method provideDefinition (line 227) | provideDefinition() {

FILE: src/__tests__/handler/inlayHint.test.ts
  function registerProvider (line 32) | async function registerProvider(content: string): Promise<Disposable> {
  function waitRefresh (line 55) | async function waitRefresh(bufnr: number) {

FILE: src/__tests__/handler/inline.test.ts
  function mockInlineInsert (line 40) | function mockInlineInsert(returnValue: boolean): void {

FILE: src/__tests__/handler/inlineCompletion.test.ts
  function registerProvider (line 30) | function registerProvider(): void {

FILE: src/__tests__/handler/linkedEditing.test.ts
  function registerProvider (line 32) | async function registerProvider(content: string, position: Position): Pr...
  function matches (line 49) | async function matches(): Promise<number> {

FILE: src/__tests__/handler/locations.test.ts
  function createLocation (line 37) | function createLocation(name: string, sl: number, sc: number, el: number...
  function createLocationLink (line 41) | function createLocationLink(name: string, sl: number, sc: number, el: nu...

FILE: src/__tests__/handler/outline.test.ts
  function getOutlineBuffer (line 49) | async function getOutlineBuffer(): Promise<Buffer | undefined> {
  function createBuffer (line 64) | async function createBuffer(code = defaultCode): Promise<Buffer> {

FILE: src/__tests__/handler/parser.ts
  class Parser (line 7) | class Parser {
    method constructor (line 13) | constructor(private _content: string, private showDetail = false) {
    method parse (line 18) | public parse(): DocumentSymbol[] {
    method parseToken (line 28) | private parseToken(): void {
    method findMatchedIndex (line 84) | private findMatchedIndex(start: number): number {
    method getLineRemain (line 99) | private getLineRemain(): string {
    method skipSpaces (line 109) | private skipSpaces(): void {

FILE: src/__tests__/handler/refactor.test.ts
  function createEdit (line 33) | function createEdit(uri: string): WorkspaceEdit {
  function assertSynchronized (line 40) | async function assertSynchronized(buf: RefactorBuffer) {
  function createChangeParams (line 61) | function createChangeParams(range: Range, text: string, original: string...
  function setup (line 231) | async function setup(): Promise<RefactorBuffer> {
  function setup (line 435) | async function setup(): Promise<RefactorBuffer> {
  function setup (line 468) | async function setup(): Promise<RefactorBuffer> {

FILE: src/__tests__/handler/rename.test.ts
  function getWordRangeAtPosition (line 21) | function getWordRangeAtPosition(doc: TextDocument, position: Position): ...
  function getSymbolRanges (line 44) | function getSymbolRanges(textDocument: TextDocument, word: string): Rang...

FILE: src/__tests__/handler/selectionRange.test.ts
  function getSelectedRange (line 55) | async function getSelectedRange(): Promise<Range> {

FILE: src/__tests__/handler/semanticTokens.test.ts
  function waitRefresh (line 133) | async function waitRefresh(tokenBuffer: SemanticTokensBuffer): Promise<v...
  function registerRangeProvider (line 147) | function registerRangeProvider(filetype: string, fn: (range: Range) => n...
  function registerProvider (line 157) | function registerProvider(): void {
  function createRustBuffer (line 176) | async function createRustBuffer(enableProvider = true): Promise<Buffer> {

FILE: src/__tests__/handler/signature.test.ts
  function registProvider (line 126) | function registProvider(): void {

FILE: src/__tests__/handler/symbols.test.ts
  function createBuffer (line 57) | async function createBuffer(code: string): Promise<Buffer> {

FILE: src/__tests__/handler/typeHierarchy.test.ts
  function createItem (line 33) | function createItem(name: string, kind?: SymbolKind, uri?: string, range...
  method prepareTypeHierarchy (line 182) | prepareTypeHierarchy() {
  method provideTypeHierarchySupertypes (line 185) | provideTypeHierarchySupertypes() {
  method provideTypeHierarchySubtypes (line 188) | provideTypeHierarchySubtypes() {
  method prepareTypeHierarchy (line 203) | prepareTypeHierarchy() {
  method provideTypeHierarchySupertypes (line 206) | provideTypeHierarchySupertypes() {
  method provideTypeHierarchySubtypes (line 209) | provideTypeHierarchySubtypes() {
  method prepareTypeHierarchy (line 233) | prepareTypeHierarchy() {
  method provideTypeHierarchySupertypes (line 236) | provideTypeHierarchySupertypes() {
  method provideTypeHierarchySubtypes (line 242) | provideTypeHierarchySubtypes() {

FILE: src/__tests__/handler/workspace.test.ts
  function checkFloat (line 38) | async function checkFloat(content: string) {

FILE: src/__tests__/helper.ts
  type CursorPosition (line 25) | interface CursorPosition {
  class Helper (line 47) | class Helper extends EventEmitter {
    method constructor (line 53) | constructor() {
    method workspace (line 58) | public get workspace(): Workspace {
    method completion (line 63) | public get completion(): Completion {
    method nvim (line 68) | public get nvim(): Neovim {
    method setup (line 72) | public async setup(init = true): Promise<Plugin> {
    method setupVim (line 94) | public async setupVim(): Promise<void> {
    method listenOnVim (line 128) | private async listenOnVim(server: Server): Promise<string> {
    method reset (line 152) | public async reset(): Promise<void> {
    method shutdown (line 166) | public async shutdown(): Promise<void> {
    method wait (line 176) | public wait(ms = 30): Promise<void> {
    method waitPrompt (line 184) | public async waitPrompt(): Promise<void> {
    method waitPromptWin (line 193) | public async waitPromptWin(): Promise<number> {
    method waitFloat (line 202) | public async waitFloat(): Promise<number> {
    method doAction (line 211) | public async doAction(method: string, ...args: any[]): Promise<any> {
    method items (line 215) | public async items(): Promise<DurationCompleteItem[]> {
    method waitPopup (line 219) | public async waitPopup(): Promise<void> {
    method confirmCompletion (line 226) | public async confirmCompletion(idx: number): Promise<void> {
    method visible (line 230) | public async visible(word: string, source?: string): Promise<boolean> {
    method edit (line 240) | public async edit(file?: string): Promise<Buffer> {
    method createDocument (line 250) | public async createDocument(name?: string): Promise<Document> {
    method listInput (line 257) | public async listInput(input: string): Promise<void> {
    method getCmdline (line 261) | public async getCmdline(lnum?: number): Promise<string> {
    method updateConfiguration (line 272) | public updateConfiguration(key: string, value: any, disposables?: Disp...
    method getMatches (line 283) | public async getMatches(hlGroup: string): Promise<any[]> {
    method mockFunction (line 298) | public async mockFunction(name: string, result: string | number | any)...
    method getFloat (line 306) | public async getFloat(kind?: string): Promise<Window> {
    method getWinLines (line 316) | public async getWinLines(winid: number): Promise<string[]> {
    method waitFor (line 320) | public async waitFor<T>(method: string, args: any[], value: T): Promis...
    method waitNotification (line 336) | public async waitNotification(event: string): Promise<void> {
    method waitValue (line 353) | public async waitValue<T>(fn: () => ProviderResult<T>, value: T): Prom...
    method createNullChannel (line 368) | public createNullChannel(): OutputChannel {
    method generateRandomHash (line 372) | public generateRandomHash(algorithm = 'sha256') {
  function createTmpFile (line 381) | async function createTmpFile(content: string, disposables?: Disposable[]...
  function makeLine (line 396) | function makeLine(length) {
  function getPort (line 408) | function getPort(): Promise<number> {

FILE: src/__tests__/list/commandTask.test.ts
  class DataList (line 10) | class DataList extends BasicList {
    method loadItems (line 12) | public async loadItems(_context: ListContext): Promise<ListTask> {
  class SleepList (line 28) | class SleepList extends BasicList {
    method loadItems (line 30) | public loadItems(_context: ListContext): Promise<ListTask> {
  class StderrList (line 43) | class StderrList extends BasicList {
    method loadItems (line 45) | public async loadItems(_context: ListContext): Promise<ListTask> {
  class ErrorTask (line 60) | class ErrorTask extends BasicList {
    method loadItems (line 62) | public async loadItems(_context: ListContext): Promise<ListTask> {

FILE: src/__tests__/list/history.test.ts
  function createTmpDir (line 8) | function createTmpDir(): string {

FILE: src/__tests__/list/manager.test.ts
  function getFloats (line 32) | async function getFloats(): Promise<Window[]> {
  function setMouseEvent (line 234) | async function setMouseEvent(line: number): Promise<void> {

FILE: src/__tests__/list/mappings.test.ts
  class TestList (line 13) | class TestList extends BasicList {
    method loadItems (line 18) | public loadItems(_context: ListContext, token: CancellationToken): Pro...
  function waitPreviewWindow (line 52) | async function waitPreviewWindow(): Promise<void> {
  method loadItems (line 74) | async loadItems(_context, _token): Promise<ListItem[]> {
  function session (line 734) | async function session(input: string): Promise<void> {

FILE: src/__tests__/list/session.test.ts
  class SimpleList (line 15) | class SimpleList extends BasicList {
    method constructor (line 22) | constructor() {
    method loadItems (line 37) | public loadItems(): Promise<ListItem[]> {
  function create (line 248) | async function create(len: number): Promise<ListSession> {

FILE: src/__tests__/list/source-funcs.test.ts
  class SimpleList (line 27) | class SimpleList extends BasicList {
    method constructor (line 30) | constructor() {
    method loadItems (line 33) | public loadItems(): Promise<ListItem[]> {

FILE: src/__tests__/list/sources.test.ts
  class OptionList (line 34) | class OptionList extends BasicList {
    method constructor (line 48) | constructor() {
    method loadItems (line 52) | public loadItems(_context: ListContext, _token: CancellationToken): Pr...
  class SimpleList (line 58) | class SimpleList extends BasicList {
    method constructor (line 61) | constructor() {
    method loadItems (line 67) | public loadItems(): Promise<ListItem[]> {
  function createContext (line 74) | async function createContext(option: Partial<ListOptions>): Promise<List...
  function doPreview (line 259) | async function doPreview(opts: PreviewOptions): Promise<number> {
  function createDiagnostic (line 477) | function createDiagnostic(msg: string, range?: Range, severity?: Diagnos...
  function createDocument (line 482) | async function createDocument(name?: string): Promise<Document> {
  function createService (line 750) | function createService(name: string): IServiceProvider {

FILE: src/__tests__/list/ui.test.ts
  class SimpleList (line 14) | class SimpleList extends BasicList {
    method constructor (line 16) | constructor() {
    method loadItems (line 22) | public loadItems(): Promise<ListItem[]> {
  class SlowTask (line 29) | class SlowTask extends EventEmitter implements ListTask {
    method constructor (line 31) | constructor() {
    method dispose (line 49) | public dispose(): void {
  function mockMouse (line 129) | async function mockMouse(winid: number, lnum: number): Promise<void> {

FILE: src/__tests__/list/worker.test.ts
  class DataList (line 14) | class DataList extends BasicList {
    method loadItems (line 16) | public loadItems(): Promise<ListItem[]> {
  class EmptyList (line 21) | class EmptyList extends BasicList {
    method loadItems (line 23) | public loadItems(): Promise<ListItem[]> {
  class IntervalTaskList (line 32) | class IntervalTaskList extends BasicList {
    method loadItems (line 35) | public loadItems(_context: ListContext, token: CancellationToken): Pro...
  class DelayTask (line 53) | class DelayTask extends BasicList {
    method loadItems (line 56) | public loadItems(_context: ListContext, token: CancellationToken): Pro...
  class InteractiveList (line 78) | class InteractiveList extends BasicList {
    method loadItems (line 81) | public loadItems(context: ListContext, _token: CancellationToken): Pro...
  class ErrorList (line 88) | class ErrorList extends BasicList {
    method loadItems (line 91) | public loadItems(_context: ListContext, _token: CancellationToken): Pr...
  class ErrorTaskList (line 96) | class ErrorTaskList extends BasicList {
    method loadItems (line 98) | public loadItems(_context: ListContext, _token: CancellationToken): Pr...

FILE: src/__tests__/markdown/renderer.test.ts
  function parse (line 11) | function parse(text: string): AnsiResult {

FILE: src/__tests__/modules/cursors.test.ts
  function rangeCount (line 34) | async function rangeCount(): Promise<number> {
  function edit (line 313) | function edit(sl: number, sc: number, el: number, ec: number, text: stri...
  function assertEdits (line 318) | async function assertEdits(edits: TextEdit[], characters: number[], line...
  function setup (line 453) | async function setup(): Promise<CursorsSession> {
  function setup (line 675) | async function setup(): Promise<void> {
  function hasKeymap (line 687) | async function hasKeymap(key): Promise<boolean> {

FILE: src/__tests__/modules/diagnosticBuffer.test.ts
  function createDiagnosticBuffer (line 9) | async function createDiagnosticBuffer(): Promise<DiagnosticBuffer> {
  function createDiagnostic (line 14) | function createDiagnostic(msg: string, range?: Range, severity?: Diagnos...
  function getExtmarkers (line 19) | async function getExtmarkers(bufnr: number, ns: number): Promise<[number...

FILE: src/__tests__/modules/diagnosticCollection.test.ts
  function createDiagnostic (line 4) | function createDiagnostic(msg: string, range?: Range): Diagnostic {

FILE: src/__tests__/modules/diagnosticManager.test.ts
  function createDiagnostic (line 16) | function createDiagnostic(msg: string, range?: Range, severity?: Diagnos...
  function createDocument (line 37) | async function createDocument(name?: string): Promise<Document> {

FILE: src/__tests__/modules/document.test.ts
  function createTextDocument (line 16) | function createTextDocument(lines: string[], eol = true): LinesTextDocum...
  function setLines (line 20) | async function setLines(doc: Document, lines: string[]): Promise<void> {
  function assertDocument (line 673) | async function assertDocument(fn: (doc: Document) => Promise<void>): Pro...

FILE: src/__tests__/modules/extensionManager.test.ts
  function createFolder (line 37) | function createFolder(): string {
  function create (line 88) | function create(folder = createFolder(), activate = false): ExtensionMan...
  function createExtension (line 96) | function createExtension(folder: string, packageJSON: ExtensionJson, cod...
  function createGlobalExtension (line 105) | function createGlobalExtension(name: string, contributes?: any): string {
  function createExtension (line 197) | async function createExtension(manager: ExtensionManager, ...events: str...

FILE: src/__tests__/modules/extensionModules.test.ts
  function createFolder (line 32) | function createFolder(): string {
  function testErrors (line 144) | function testErrors(data: any, version: string, count, createJs = false)...
  function createDB (line 184) | function createDB(folder: string, data: any): string {
  function create (line 191) | function create(): [ExtensionStat, string] {

FILE: src/__tests__/modules/fetch.test.ts
  function createServer (line 34) | async function createServer(): Promise<number> {

FILE: src/__tests__/modules/filter.test.ts
  function assertMatches (line 5) | function assertMatches(pattern: string, word: string, decoratedWord: str...
  function assertTopScore (line 22) | function assertTopScore(filter: typeof fuzzyScore, pattern: string, expe...

FILE: src/__tests__/modules/fs.test.ts
  function wait (line 8) | function wait(ms: number): Promise<void> {

FILE: src/__tests__/modules/fuzzyMatch.test.ts
  function makeid (line 168) | function makeid(length) {

FILE: src/__tests__/modules/picker.test.ts
  function inputChar (line 26) | async function inputChar(ch: string): Promise<void> {
  function getSigns (line 131) | function getSigns(): Promise<any> {

FILE: src/__tests__/modules/quickpick.test.ts
  type Item (line 9) | type Item = QuickPickItem | string
  function getTitleLine (line 29) | async function getTitleLine(): Promise<string> {
  function testQuickPick (line 195) | async function testQuickPick(items: Item[], canPickMany: boolean, cancel...

FILE: src/__tests__/modules/semanticTokensBuilder.test.ts
  function toArr (line 4) | function toArr(uint32Arr: ReadonlyArray<number>): number[] {
  function deepStrictEqual (line 12) | function deepStrictEqual(one: any, two: any): void {

FILE: src/__tests__/modules/services.test.ts
  function toConfig (line 36) | function toConfig(c: Partial<LanguageServerConfig>): LanguageServerConfig {

FILE: src/__tests__/modules/util.test.ts
  function createTextDocument (line 41) | function createTextDocument(lines: string[]): LinesTextDocument {
  function toEdit (line 45) | function toEdit(sl, sc, el, ec, text): TextEdit {
  function fn (line 177) | function fn() {}
  method wait (line 187) | wait() {}
  function createEdit (line 251) | function createEdit(uri: string): WorkspaceEdit {
  function addPosition (line 257) | function addPosition(position: Position, line: number, character: number...
  function assertNext (line 792) | function assertNext(text: string, index: number, res: [number, string] |...
  function testColorHighlight (line 978) | function testColorHighlight(highlight: string, hlGroup: string, markdown...
  function compare (line 1036) | function compare(a: string): string {
  function values (line 1107) | function values(item: { [key: string]: number[] }): number[] {
  function addPosition (line 1123) | function addPosition(position: Position, line: number, character: number...
  function diffLines (line 1620) | function diffLines(oldStr: string, newStr: string): diff.ChangedLines {
  function blockMilliseconds (line 1764) | function blockMilliseconds(ms: number): void {

FILE: src/__tests__/modules/window.test.ts
  type FileNode (line 18) | interface FileNode {
  function ensureNotification (line 312) | async function ensureNotification(idx: number): Promise<void> {
  function createFile (line 652) | async function createFile(content = 'foo\nbar'): Promise<Buffer> {
  function setHighlights (line 657) | async function setHighlights(hls: HighlightItem[]): Promise<void> {

FILE: src/__tests__/modules/workspace.test.ts
  function doRename (line 307) | async function doRename() {

FILE: src/__tests__/snippets/parser.test.ts
  function assertText (line 104) | function assertText(value: string, expected: string, ultisnip = false) {
  function assertMarker (line 110) | function assertMarker(input: TextmateSnippet | Marker[] | string, ...cto...
  function assertTextAndMarker (line 129) | function assertTextAndMarker(value: string, escaped: string, ...ctors: F...
  function assertEscaped (line 134) | function assertEscaped(value: string, expected: string) {
  function assertTextsnippetString (line 693) | function assertTextsnippetString(input: string, expected: string): void {
  function assertIdent (line 715) | function assertIdent(input: string): void {
  function assertLen (line 941) | function assertLen(template: string, ...lengths: number[]): void {
  function assertParent (line 1102) | function assertParent(marker: Marker) {

FILE: src/__tests__/snippets/session.test.ts
  function createSession (line 29) | async function createSession(enableHighlight = false, preferComplete = f...
  function start (line 48) | async function start(inserted: string, range = defaultRange, select = tr...
  function getCursorRange (line 55) | async function getCursorRange(): Promise<Range> {
  function checkRanges (line 252) | async function checkRanges(snippet: string, results: any) {

FILE: src/__tests__/snippets/snippet.test.ts
  function createSnippet (line 31) | async function createSnippet(snippet: string | TextmateSnippet, opts?: U...
  function assertResult (line 167) | async function assertResult(snip: string, resolved: string, opts?: UltiS...
  function assertPyxValue (line 172) | async function assertPyxValue(code: string, res: any) {
  function assertUpdate (line 590) | async function assertUpdate(text: string, value: string, result: string,...
  function assertThrow (line 766) | function assertThrow(fn: () => void) {
  function assertText (line 777) | function assertText(r: number[], text: string, pos: [number, number], re...
  function assertText (line 787) | function assertText(r: number[], text: string, pos: [number, number], re...

FILE: src/__tests__/tree/basicProvider.test.ts
  type NodeDef (line 10) | type NodeDef = [string, NodeDef[]?]
  type CustomNode (line 12) | interface CustomNode extends TreeNode {
  function createNode (line 23) | function createNode(label: string, children?: TreeNode[], key?: string, ...
  function createLabels (line 37) | function createLabels(data: ReadonlyArray<TreeNode>): string[] {
  function findNode (line 53) | function findNode(label: string, nodes: ReadonlyArray<TreeNode>): TreeNo...
  function createNodes (line 66) | function createNodes(defs: NodeDef[]): TreeNode[] {

FILE: src/__tests__/tree/treeView.test.ts
  type NodeDef (line 15) | type NodeDef = [string, NodeDef[]?]
  function createNode (line 42) | function createNode(label: string, children?: TreeNode[], key?: string, ...
  function createTreeView (line 50) | function createTreeView(defs: NodeDef[], opts: Partial<TreeViewOptions<T...
  function updateData (line 63) | function updateData(defs: NodeDef[], reset = false) {
  function makeUpdateUIThrowError (line 68) | function makeUpdateUIThrowError() {
  function checkLines (line 83) | async function checkLines(arr: string[]): Promise<void> {
  function waitVisibilityEvent (line 166) | function waitVisibilityEvent(visible: boolean): Promise<void> {
  function getSingns (line 334) | async function getSingns() {
  function createFilterTreeView (line 996) | async function createFilterTreeView(opts: Partial<ProviderOptions<TreeNo...

FILE: src/__tests__/ultisnips.py
  function coc_UltiSnips_create (line 2) | def coc_UltiSnips_create():

FILE: src/__tests__/vim.test.ts
  function disposeAll (line 17) | function disposeAll(disposables: Disposable[]): void {
  function createTmpFile (line 44) | async function createTmpFile(content: string, disposables?: Disposable[]...
  function shouldEqual (line 865) | async function shouldEqual(doc, synced = false): Promise<void> {
  function assertBuffer (line 959) | async function assertBuffer(lines: string[], hls: [string, number, numbe...

FILE: src/attach.ts
  constant ACTIONS_NO_WAIT (line 15) | const ACTIONS_NO_WAIT = ['installExtensions', 'updateExtensions']
  constant NO_ERROR_REQUEST (line 18) | const NO_ERROR_REQUEST = ['doAutocmd', 'CocAutocmd']

FILE: src/commands.ts
  type Command (line 15) | interface Command {
  class CommandItem (line 20) | class CommandItem implements Disposable, Command {
    method constructor (line 21) | constructor(
    method execute (line 29) | public execute(...args: any[]): void | Promise<any> {
    method dispose (line 34) | public dispose(): void {
  class CommandManager (line 42) | class CommandManager implements Disposable {
    method commandList (line 48) | public get commandList(): { id: string, title: string }[] {
    method dispose (line 60) | public dispose(): void {
    method execute (line 67) | public execute(command: VCommand): Promise<any> {
    method register (line 71) | public register<T extends Command>(command: T, internal: boolean, desc...
    method has (line 79) | public has(id: string): boolean {
    method unregister (line 83) | public unregister(id: string): void {
    method registerCommand (line 101) | public registerCommand<T>(id: string, impl: (...args: any[]) => T | Pr...
    method executeCommand (line 123) | public executeCommand<T>(command: string, ...rest: any[]): Promise<T> {
    method fireCommand (line 132) | public async fireCommand(id: string, ...args: any[]): Promise<unknown> {
    method addRecent (line 143) | public async addRecent(cmd: string, repeat: boolean): Promise<void> {
    method repeatCommand (line 148) | public async repeatCommand(): Promise<void> {

FILE: src/completion/complete.ts
  constant MAX_DISTANCE (line 18) | const MAX_DISTANCE = 2 << 20
  constant MIN_TIMEOUT (line 19) | const MIN_TIMEOUT = 50
  constant MAX_TIMEOUT (line 20) | const MAX_TIMEOUT = 15000
  constant MAX_TRIGGER_WAIT (line 21) | const MAX_TRIGGER_WAIT = 200
  constant WORD_SOURCES (line 23) | const WORD_SOURCES = new Set(['buffer', 'around', 'word'])
  type CompleteResultToFilter (line 25) | interface CompleteResultToFilter {
  class Complete (line 30) | class Complete {
    method constructor (line 49) | constructor(public option: CompleteOption,
    method nvim (line 60) | private get nvim(): Neovim {
    method getTrigger (line 65) | public getTrigger(character: number): string {
    method fireRefresh (line 72) | private fireRefresh(waitTime: number): void {
    method totalLength (line 86) | private get totalLength(): number {
    method resolveItem (line 94) | public resolveItem(item: DurationCompleteItem | undefined): { source: ...
    method isCompleting (line 99) | public get isCompleting(): boolean {
    method input (line 103) | public get input(): string {
    method isEmpty (line 107) | public get isEmpty(): boolean {
    method hasInComplete (line 111) | private get hasInComplete(): boolean {
    method getIncompleteSources (line 118) | public getIncompleteSources(): ISource[] {
    method doComplete (line 125) | public async doComplete(): Promise<boolean> {
    method completeSources (line 158) | private async completeSources(sources: ReadonlyArray<ISource>, tokenSo...
    method completeSource (line 197) | private async completeSource(source: ISource, range: Range, token: Can...
    method completeInComplete (line 257) | public async completeInComplete(resumeInput: string): Promise<undefine...
    method filterItems (line 277) | public filterItems(input: string): DurationCompleteItem[] | undefined {
    method filterResults (line 332) | public async filterResults(input: string): Promise<DurationCompleteIte...
    method limitCompleteItems (line 342) | private limitCompleteItems(items: DurationCompleteItem[]): DurationCom...
    method getDefaultRange (line 359) | private getDefaultRange(): Range {
    method createTokenSource (line 367) | private createTokenSource(isIncomplete: boolean): CancellationTokenSou...
    method cancelInComplete (line 377) | private cancelInComplete(): void {
    method cancel (line 386) | public cancel(): void {
    method dispose (line 396) | public dispose(): void {
  function sortItems (line 403) | function sortItems(emptyInput: boolean, defaultSortMethod: SortMethod, a...

FILE: src/completion/floating.ts
  constant RESOLVE_TIMEOUT (line 13) | const RESOLVE_TIMEOUT = getConditionValue(500, 50)
  class Floating (line 15) | class Floating {
    method constructor (line 17) | constructor(private config: { floatConfig: FloatConfig }) {
    method resolveItem (line 20) | public async resolveItem(source: ISource, item: CompleteItem, opt: Com...
    method show (line 38) | public show(docs: Documentation[]): void {
    method close (line 65) | public close(): void {
    method cancel (line 70) | public cancel(): void {
    method requestWithToken (line 77) | private requestWithToken(fn: (token: CancellationToken) => Promise<voi...

FILE: src/completion/index.ts
  constant TRIGGER_TIMEOUT (line 28) | const TRIGGER_TIMEOUT = getConditionValue(200, 20)
  constant CURSORMOVE_DEBOUNCE (line 29) | const CURSORMOVE_DEBOUNCE = getConditionValue(20, 20)
  class Completion (line 31) | class Completion implements Disposable {
    method nvim (line 46) | private get nvim(): Neovim {
    method init (line 50) | public init(): void {
    method mru (line 92) | public get mru(): MruLoader {
    method onCursorMovedI (line 96) | public onCursorMovedI(bufnr: number, cursor: [number, number], hasInse...
    method option (line 111) | public get option(): CompleteOption {
    method isActivated (line 116) | public get isActivated(): boolean {
    method selectedItem (line 120) | public get selectedItem(): DurationCompleteItem | undefined {
    method selectedCompletionInfo (line 125) | public get selectedCompletionInfo(): SelectedCompletionInfo | undefined {
    method loadLocalConfig (line 136) | private loadLocalConfig(doc?: Document): void {
    method loadConfiguration (line 163) | public loadConfiguration(e?: IConfigurationChangeEvent): CompleteConfig {
    method startCompletion (line 191) | public async startCompletion(opt?: { source?: string, col?: number }):...
    method _startCompletion (line 204) | private async _startCompletion(option: CompleteOption, sourceList?: IS...
    method hasIndentChange (line 232) | public hasIndentChange(info: InsertChange): boolean {
    method onTextChangedI (line 241) | private async onTextChangedI(bufnr: number, info: InsertChange): Promi...
    method getTriggerSources (line 325) | private getTriggerSources(doc: Document, pretext: string): ISource[] {
    method triggerCompletion (line 331) | private async triggerCompletion(doc: Document, info: InsertChange, sou...
    method getCompleteOption (line 347) | private getCompleteOption(doc: Document, info: InsertChange, manual = ...
    method addMruItem (line 374) | public addMruItem(): void {
    method cancelAndClose (line 381) | public cancelAndClose(close = true): void {
    method _onFinish (line 389) | private _onFinish(kind: CompleteFinishKind, close: boolean) {
    method stop (line 400) | public async stop(kind: CompleteFinishKind, close = false): Promise<vo...
    method confirmCompletion (line 413) | private async confirmCompletion(source: ISource, item: CompleteItem, o...
    method onInsertEnter (line 421) | private async onInsertEnter(bufnr: number): Promise<void> {
    method shouldTrigger (line 430) | public shouldTrigger(doc: Document, pre: string): boolean {
    method filterResults (line 438) | public async filterResults(info?: InsertChange): Promise<void> {
    method cancel (line 468) | public cancel(): void {
    method dispose (line 482) | public dispose(): void {

FILE: src/completion/keywords.ts
  class KeywordsBuffer (line 12) | class KeywordsBuffer implements SyncItem {
    method constructor (line 17) | constructor(private doc: Document, private segmenterLocales: string) {
    method getWords (line 27) | public getWords(): string[] {
    method cancel (line 39) | public cancel(): void {
    method parseWords (line 46) | public async parseWords(segmenterLocales: string | null): Promise<void> {
    method bufnr (line 57) | public get bufnr(): number {
    method gitIgnored (line 61) | public get gitIgnored(): boolean {
    method onCompleteDone (line 65) | public onCompleteDone(idx: number): void {
    method onChange (line 71) | public onChange(e: DidChangeTextDocumentParams): void {
    method matchWords (line 84) | public *matchWords(line: number): Iterable<string> {
    method dispose (line 96) | public dispose(): void {

FILE: src/completion/match.ts
  type MatchResult (line 9) | type MatchResult = [number, ReadonlyArray<number>] | undefined
  function caseScore (line 11) | function caseScore(input: number, curr: number, divide = 1): number {
  function matchScore (line 30) | function matchScore(word: string, input: Uint16Array): number {
  function matchScoreWithPositions (line 36) | function matchScoreWithPositions(word: string, input: Uint16Array): [num...
  function nextScore (line 44) | function nextScore(codes: Uint16Array, index: number, inputCodes: Uint16...

FILE: src/completion/native/around.ts
  class Around (line 9) | class Around extends Source {
    method constructor (line 10) | constructor(private keywords: BufferSync<KeywordsBuffer>) {
    method doComplete (line 14) | public async doComplete(opt: CompleteOption, token: CancellationToken)...
  function register (line 34) | function register(sourceMap: Map<string, ISource>, keywords: BufferSync<...

FILE: src/completion/native/buffer.ts
  class Buffer (line 9) | class Buffer extends Source {
    method constructor (line 10) | constructor(private keywords: BufferSync<KeywordsBuffer>) {
    method ignoreGitignore (line 14) | public get ignoreGitignore(): boolean {
    method doComplete (line 18) | public async doComplete(opt: CompleteOption, token: CancellationToken)...
  function register (line 41) | function register(sourceMap: Map<string, ISource>, keywords: BufferSync<...

FILE: src/completion/native/file.ts
  type PathOption (line 14) | interface PathOption {
  function resolveEnvVariables (line 21) | function resolveEnvVariables(str: string, env = process.env): string {
  function getLastPart (line 33) | function getLastPart(text: string): string | null {
  function getFileItem (line 52) | async function getFileItem(root: string, filename: string): Promise<VimC...
  function filterFiles (line 64) | function filterFiles(files: string[], ignoreHidden: boolean, ignorePatte...
  function getDirectory (line 74) | function getDirectory(pathstr: string, root: string): string {
  function getItemsFromRoot (line 79) | async function getItemsFromRoot(pathstr: string, root: string, ignoreHid...
  class File (line 93) | class File extends Source {
    method constructor (line 94) | constructor(public isWindows: boolean) {
    method triggerCharacters (line 101) | public get triggerCharacters(): string[] {
    method getPathOption (line 106) | private getPathOption(opt: CompleteOption): PathOption | null {
    method shouldTrim (line 120) | public shouldTrim(ext: string): boolean {
    method getRoot (line 125) | public async getRoot(pathstr: string, part: string, filepath: string, ...
    method doComplete (line 148) | public async doComplete(opt: CompleteOption, token: CancellationToken)...
  function register (line 176) | function register(sourceMap: Map<string, ISource>): void {

FILE: src/completion/pum.ts
  type PumDimension (line 14) | interface PumDimension {
  type HighlightRange (line 23) | interface HighlightRange {
  type LabelWithDetail (line 29) | interface LabelWithDetail {
  type BuildConfig (line 34) | interface BuildConfig {
  type PumConfig (line 42) | interface PumConfig {
  type PopupMenuConfig (line 55) | interface PopupMenuConfig {
  type HighlightGroups (line 75) | enum HighlightGroups {
  type PumItems (line 83) | enum PumItems {
  class PopupMenu (line 90) | class PopupMenu {
    method constructor (line 93) | constructor(
    method nvim (line 99) | private get nvim(): Neovim {
    method search (line 103) | public get search(): string {
    method reset (line 107) | public reset(): void {
    method pumConfig (line 112) | public get pumConfig(): PumConfig {
    method stringWidth (line 131) | private stringWidth(text: string, cache = false): number {
    method show (line 135) | public show(items: DurationCompleteItem[], search: string, option: Com...
    method getLabel (line 221) | private getLabel(item: DurationCompleteItem): LabelWithDetail {
    method adjustAbbrWidth (line 247) | private adjustAbbrWidth(config: BuildConfig): void {
    method buildItem (line 267) | private buildItem(input: string, lowInput: string, item: DurationCompl...
    method fillWidth (line 363) | public fillWidth(text: string, width: number): string {
  function positionHighlights (line 372) | function positionHighlights(hls: HighlightItem[], label: string, positio...
  function getInsertWord (line 386) | function getInsertWord(word: string, codes: number[], start: number): st...
  function prefixWord (line 399) | function prefixWord(word: string, character: number, line: string, minCh...

FILE: src/completion/source-language.ts
  type TriggerContext (line 22) | interface TriggerContext {
  class LanguageSource (line 28) | class LanguageSource implements ISource<CompletionItem> {
    method constructor (line 37) | constructor(
    method enable (line 48) | public get enable(): boolean {
    method toggle (line 52) | public toggle(): void {
    method shouldCommit (line 56) | public shouldCommit(item: CompletionItem, character: string): boolean {
    method doComplete (line 62) | public async doComplete(option: CompleteOption, token: CancellationTok...
    method onCompleteResolve (line 80) | public onCompleteResolve(item: CompletionItem, opt: CompleteOption | u...
    method onCompleteDone (line 121) | public async onCompleteDone(item: CompletionItem, opt: CompleteDoneOpt...
    method applyTextEdit (line 141) | private async applyTextEdit(doc: Document, additionalEdits: boolean, i...
    method getTriggerKind (line 176) | private getTriggerKind(opt: CompleteOption): CompletionTriggerKind {
  function getUltisnipOption (line 189) | function getUltisnipOption(item: CompletionItem): UltiSnippetOption | un...
  function fixIndent (line 194) | function fixIndent(line: string, currline: string, range: Range): number {
  function fixTextEdit (line 204) | function fixTextEdit(character: number, edit: TextEdit | InsertReplaceEd...

FILE: src/completion/source-vim.ts
  function getMethodName (line 12) | function getMethodName(name: string, names: ReadonlyArray<string>): stri...
  function checkInclude (line 19) | function checkInclude(name: string, fns: ReadonlyArray<string>): boolean {
  class VimSource (line 25) | class VimSource extends Source {
    method callOptionalFunc (line 27) | private async callOptionalFunc(fname: string, args: any[], isNotify = ...
    method checkComplete (line 35) | public async checkComplete(opt: CompleteOption): Promise<boolean> {
    method refresh (line 43) | public async refresh(): Promise<void> {
    method insertSnippet (line 47) | public async insertSnippet(insertText: string, opt: CompleteOption): P...
    method onCompleteDone (line 57) | public async onCompleteDone(item: ExtendedCompleteItem, opt: CompleteO...
    method onEnter (line 65) | public onEnter(bufnr: number): void {
    method doComplete (line 77) | public async doComplete(opt: CompleteOption, token: CancellationToken)...

FILE: src/completion/source.ts
  constant WORD_PREFIXES (line 15) | const WORD_PREFIXES = ['_', '$', '-']
  constant WORD_PREFIXES_CODE (line 16) | const WORD_PREFIXES_CODE = [95, 36, 45]
  constant MAX_DURATION (line 17) | const MAX_DURATION = getConditionValue(80, 20)
  constant MAX_COUNT (line 18) | const MAX_COUNT = 50
  type SourceConfiguration (line 20) | interface SourceConfiguration {
  class Source (line 31) | class Source implements ISource<ExtendedCompleteItem> {
    method constructor (line 46) | constructor(option: Partial<SourceConfig>) {
    method nvim (line 66) | protected get nvim(): Neovim {
    method priority (line 73) | public get priority(): number {
    method triggerPatterns (line 77) | public get triggerPatterns(): RegExp[] | null {
    method triggerOnly (line 86) | public get triggerOnly(): boolean {
    method triggerCharacters (line 92) | public get triggerCharacters(): string[] {
    method firstMatch (line 96) | public get firstMatch(): boolean {
    method remoteFns (line 100) | public get remoteFns(): string[] {
    method shortcut (line 104) | public get shortcut(): string {
    method enable (line 109) | public get enable(): boolean {
    method filetypes (line 114) | public get filetypes(): string[] | null {
    method disableSyntaxes (line 118) | public get disableSyntaxes(): string[] {
    method getConfig (line 122) | public getConfig<T>(key: string, defaultValue?: T): T | null {
    method toggle (line 128) | public toggle(): void {
    method menu (line 132) | public get menu(): string {
    method checkComplete (line 136) | public async checkComplete(opt: CompleteOption): Promise<boolean> {
    method refresh (line 149) | public async refresh(): Promise<void> {
    method onCompleteDone (line 154) | public async onCompleteDone(item: ExtendedCompleteItem, opt: CompleteO...
    method doComplete (line 159) | public async doComplete(opt: CompleteOption, token: CancellationToken)...
    method onCompleteResolve (line 166) | public async onCompleteResolve(item: ExtendedCompleteItem, opt: Comple...
    method getResults (line 174) | public async getResults(iterables: Iterable<string>[], input: string, ...
    method dispose (line 213) | public dispose(): void {
  function firstMatchFuzzy (line 218) | function firstMatchFuzzy(firstCode: number, ascii: boolean, word: string) {

FILE: src/completion/sources.ts
  type VimSourceConfig (line 25) | interface VimSourceConfig {
  class Sources (line 35) | class Sources {
    method init (line 41) | public init(): void {
    method nvim (line 60) | private get nvim(): Neovim {
    method getKeywordsBuffer (line 64) | public getKeywordsBuffer(bufnr: number): KeywordsBuffer {
    method createNativeSources (line 68) | private createNativeSources(): void {
    method createLanguageSource (line 77) | public createLanguageSource(
    method createVimSourceExtension (line 103) | public async createVimSourceExtension(filepath: string): Promise<void> {
    method createRemoteSources (line 203) | private createRemoteSources(): void {
    method createVimSources (line 210) | public async createVimSources(pluginPath: string): Promise<void> {
    method names (line 222) | public get names(): string[] {
    method sources (line 226) | public get sources(): ISource[] {
    method has (line 230) | public has(name): boolean {
    method getSource (line 234) | public getSource(name: string): ISource | null {
    method shouldCommit (line 238) | public shouldCommit(source: ISource | undefined, item: CompleteItem | ...
    method getSources (line 246) | public getSources(opt: CompleteOption): ISource[] {
    method getNormalSources (line 258) | public getNormalSources(filetype: string, uri: string): ISource[] {
    method checkTrigger (line 269) | private checkTrigger(source: ISource, pre: string, character: string):...
    method shouldTrigger (line 280) | public shouldTrigger(pre: string, filetype: string, uri: string): bool...
    method getTriggerSources (line 284) | public getTriggerSources(pre: string, filetype: string, uri: string, d...
    method addSource (line 299) | public addSource(source: ISource): Disposable {
    method removeSource (line 310) | public removeSource(source: ISource | string): void {
    method refresh (line 317) | public async refresh(name?: string): Promise<void> {
    method toggleSource (line 327) | public toggleSource(name: string): void {
    method sourceStats (line 334) | public sourceStats(): SourceStat[] {
    method onDocumentEnter (line 353) | private onDocumentEnter(bufnr: number): void {
    method createSource (line 362) | public createSource(config: SourceConfig): Disposable {
    method dispose (line 371) | public dispose(): void {
  function logError (line 376) | function logError(err: any): void {
  function getSourceType (line 380) | function getSourceType(sourceType: SourceType): string {

FILE: src/completion/types.ts
  type EditRange (line 6) | type EditRange = Range | { insert: Range, replace: Range }
  type ItemDefaults (line 8) | interface ItemDefaults {
  type CompleteOption (line 19) | interface CompleteOption {
  type CompleteDoneOption (line 39) | interface CompleteDoneOption extends CompleteOption {
  type DurationCompleteItem (line 46) | interface DurationCompleteItem {
  type VimCompleteItem (line 78) | interface VimCompleteItem {
  type ExtendedCompleteItem (line 91) | interface ExtendedCompleteItem extends VimCompleteItem {
  type InsertMode (line 102) | enum InsertMode {
  type CompleteConfig (line 107) | interface CompleteConfig {
  type SortMethod (line 131) | enum SortMethod {
  type CompleteItem (line 140) | type CompleteItem = ExtendedCompleteItem | CompletionItem
  type CompleteResult (line 142) | interface CompleteResult<T extends CompleteItem> {
  type CompleteFinishKind (line 149) | enum CompleteFinishKind {
  type CompleteDoneItem (line 155) | type CompleteDoneItem = CompleteItem & {
  type SourceType (line 161) | enum SourceType {
  type SourceStat (line 167) | interface SourceStat {
  type SourceConfig (line 178) | interface SourceConfig<T extends ExtendedCompleteItem = ExtendedComplete...
  type ISource (line 197) | interface ISource<T extends CompleteItem = CompleteItem> {

FILE: src/completion/util.ts
  type MruItem (line 18) | type MruItem = Pick<Readonly<DurationCompleteItem>, 'kind' | 'filterText...
  type PartialOption (line 19) | type PartialOption = Pick<CompleteOption, 'col' | 'colnr' | 'line' | 'po...
  type OptionForWord (line 20) | type OptionForWord = Pick<Readonly<CompleteOption>, 'line' | 'position'>
  type Selection (line 22) | enum Selection {
  constant INVALID_WORD_CHARS (line 28) | const INVALID_WORD_CHARS = [CharCode.LineFeed, CharCode.CarriageReturn]
  constant MAX_CODE_POINT (line 31) | const MAX_CODE_POINT = 1114111
  constant MAX_MRU_ITEMS (line 32) | const MAX_MRU_ITEMS = 100
  constant DEFAULT_HL_GROUP (line 33) | const DEFAULT_HL_GROUP = 'CocSymbolDefault'
  type ConvertOption (line 35) | interface ConvertOption {
  function useAscii (line 72) | function useAscii(input: string): boolean {
  function getKindText (line 76) | function getKindText(kind: string | CompletionItemKind, kindMap: Map<Com...
  function getKindHighlight (line 80) | function getKindHighlight(kind: string | number): string {
  function getPriority (line 84) | function getPriority(source: ISource, defaultValue: number): number {
  function getDetail (line 91) | function getDetail(item: CompletionItem, filetype: string): { filetype: ...
  function deltaCount (line 107) | function deltaCount(info: InsertChange): number {
  function toCompleteDoneItem (line 118) | function toCompleteDoneItem(selected: DurationCompleteItem | undefined, ...
  function getDocumentations (line 131) | function getDocumentations(completeItem: CompleteItem, filetype: string,...
  function getResumeInput (line 159) | function getResumeInput(option: PartialOption | undefined, pretext: stri...
  function checkIgnoreRegexps (line 174) | function checkIgnoreRegexps(ignoreRegexps: ReadonlyArray<string>, input:...
  function createKindMap (line 185) | function createKindMap(labels: { [key: string]: string }): Map<Completio...
  function indentChanged (line 215) | function indentChanged(event: { word: string } | undefined, cursor: [num...
  function shouldStop (line 224) | function shouldStop(bufnr: number, info: InsertChange, option: Pick<Comp...
  function getInput (line 233) | function getInput(chars: Chars, pre: string, asciiCharactersOnly: boolea...
  function isWordCode (line 248) | function isWordCode(chars: Chars, code: number, asciiCharactersOnly: boo...
  function shouldIndent (line 255) | function shouldIndent(indentkeys: string, pretext: string): boolean {
  function highlightOffset (line 278) | function highlightOffset<T extends { filterText: string, abbr: string }>...
  function emptLabelDetails (line 286) | function emptLabelDetails(labelDetails: CompletionItemLabelDetails): boo...
  function isSnippetItem (line 291) | function isSnippetItem(item: CompletionItem, itemDefaults: ItemDefaults)...
  function hasAction (line 299) | function hasAction(item: CompletionItem, itemDefaults: ItemDefaults) {
  function toValidWord (line 303) | function toValidWord(snippet: string, excludes: number[]): string {
  function snippetToWord (line 313) | function snippetToWord(text: string, kind: CompletionItemKind | undefine...
  function getWord (line 325) | function getWord(item: CompletionItem, itemDefaults: ItemDefaults): stri...
  function getReplaceRange (line 333) | function getReplaceRange(item: CompletionItem, defaultRange: EditRange |...
  class Converter (line 353) | class Converter {
    method constructor (line 361) | constructor(
    method getPrevious (line 374) | public getPrevious(character: number): string {
    method getAfter (line 384) | public getAfter(character: number): string {
    method fixFollow (line 394) | public fixFollow(word: string, isSnippet: boolean, endCharacter: numbe...
    method getDelta (line 406) | private getDelta(filterText: string, character: number): number {
    method convertToDurationItem (line 414) | public convertToDurationItem(item: CompleteItem): DurationCompleteItem...
    method convertVimCompleteItem (line 423) | private convertVimCompleteItem(item: ExtendedCompleteItem): DurationCo...
    method convertLspCompleteItem (line 460) | private convertLspCompleteItem(item: CompletionItem): DurationComplete...
  function toItemKey (line 502) | function toItemKey(item: MruItem): string {
  class MruLoader (line 509) | class MruLoader {
    method getScore (line 514) | public getScore(input: string, item: MruItem, selection: Selection): n...
    method add (line 522) | public add(prefix: string, item: MruItem): void {
    method clear (line 534) | public clear(): void {

FILE: src/completion/wordDistance.ts
  method distance (line 16) | public distance() { return 0 }
  method create (line 19) | public static async create(localityBonus: boolean, opt: Pick<CompleteOpt...

FILE: src/configuration/configuration.ts
  type IConfigurationValue (line 10) | interface IConfigurationValue<T> {
  class FolderConfigutions (line 25) | class FolderConfigutions {
    method keys (line 28) | public get keys(): Iterable<string> {
    method has (line 32) | public has(folder: string): boolean {
    method set (line 39) | public set(folder: string, model: ConfigurationModel): void {
    method get (line 44) | public get(folder: string): ConfigurationModel | undefined {
    method delete (line 49) | public delete(folder: string): void {
    method forEach (line 54) | public forEach(fn: (model: ConfigurationModel, key: string) => void): ...
    method getConfigurationByResource (line 58) | public getConfigurationByResource(uri: string): { folder: string, mode...
  class Configuration (line 73) | class Configuration {
    method constructor (line 78) | constructor(
    method updateValue (line 87) | public updateValue(key: string, value: any, overrides: IConfigurationO...
    method hasFolder (line 108) | public hasFolder(folder: string): boolean {
    method addFolderConfiguration (line 112) | public addFolderConfiguration(folder: string, model: ConfigurationMode...
    method deleteFolderConfiguration (line 119) | public deleteFolderConfiguration(fsPath: string): void {
    method getWorkspaceConsolidateConfiguration (line 123) | private getWorkspaceConsolidateConfiguration(): ConfigurationModel {
    method getFolderConfigurationModelForResource (line 135) | public getFolderConfigurationModelForResource(uri: string): Configurat...
    method resolveFolder (line 144) | public resolveFolder(uri: string): string | undefined {
    method getConsolidatedConfigurationModel (line 158) | private getConsolidatedConfigurationModel(overrides: IConfigurationOve...
    method getValue (line 176) | public getValue(section: string | undefined, overrides: IConfiguration...
    method inspect (line 181) | public inspect<C>(key: string, overrides: IConfigurationOverrides): IC...
    method defaults (line 211) | public get defaults(): ConfigurationModel {
    method user (line 215) | public get user(): ConfigurationModel {
    method workspace (line 219) | public get workspace(): ConfigurationModel {
    method memory (line 223) | public get memory(): ConfigurationModel {
    method getConfigurationModel (line 227) | public getConfigurationModel(target: ConfigurationTarget, folder?: str...
    method updateFolderConfiguration (line 242) | public updateFolderConfiguration(folder: string, model: ConfigurationM...
    method updateUserConfiguration (line 246) | public updateUserConfiguration(model: ConfigurationModel): void {
    method updateWorkspaceConfiguration (line 251) | public updateWorkspaceConfiguration(model: ConfigurationModel): void {
    method updateDefaultConfiguration (line 256) | public updateDefaultConfiguration(model: ConfigurationModel): void {
    method updateMemoryConfiguration (line 261) | public updateMemoryConfiguration(model: ConfigurationModel): void {
    method compareAndUpdateMemoryConfiguration (line 266) | public compareAndUpdateMemoryConfiguration(memory: ConfigurationModel)...
    method compareAndUpdateUserConfiguration (line 275) | public compareAndUpdateUserConfiguration(user: ConfigurationModel): IC...
    method compareAndUpdateDefaultConfiguration (line 284) | public compareAndUpdateDefaultConfiguration(defaults: ConfigurationMod...
    method compareAndUpdateWorkspaceConfiguration (line 306) | public compareAndUpdateWorkspaceConfiguration(workspaceConfiguration: ...
    method compareAndUpdateFolderConfiguration (line 315) | public compareAndUpdateFolderConfiguration(folder: string, folderConfi...
    method compareAndDeleteFolderConfiguration (line 325) | public compareAndDeleteFolderConfiguration(folder: string): IConfigura...
    method allKeys (line 333) | public allKeys(): string[] {
    method toData (line 342) | public toData(): IConfigurationData {
    method parse (line 357) | public static parse(data: IConfigurationData): Configuration {
    method parseConfigurationModel (line 369) | private static parseConfigurationModel(model: IConfigurationModel): Co...
  function compare (line 374) | function compare(from: ConfigurationModel | undefined, to: Configuration...

FILE: src/configuration/event.ts
  class ConfigurationChangeEvent (line 8) | class ConfigurationChangeEvent implements IConfigurationChangeEvent {
    method constructor (line 15) | constructor(public readonly change: IConfigurationChange,
    method previousConfiguration (line 29) | private get previousConfiguration(): Configuration | undefined {
    method affectsConfiguration (line 36) | public affectsConfiguration(section: string, scope?: ConfigurationReso...
    method doesAffectedKeysTreeContains (line 49) | private doesAffectedKeysTreeContains(affectedKeysTree: any, section: s...
  class AllKeysConfigurationChangeEvent (line 63) | class AllKeysConfigurationChangeEvent extends ConfigurationChangeEvent {
    method constructor (line 64) | constructor(configuration: Configuration, source: ConfigurationTarget) {

FILE: src/configuration/index.ts
  type ConfigurationErrorEvent (line 34) | interface ConfigurationErrorEvent {
  type MarkdownPreference (line 39) | interface MarkdownPreference {
  class Configurations (line 44) | class Configurations {
    method constructor (line 58) | constructor(
    method initialConfiguration (line 76) | public get initialConfiguration(): WorkspaceConfiguration {
    method markdownPreference (line 80) | public get markdownPreference(): MarkdownPreference {
    method errors (line 88) | public get errors(): Map<string, Diagnostic[]> {
    method configuration (line 92) | public get configuration(): Configuration {
    method flushConfigurations (line 96) | public flushConfigurations(): void {
    method updateConfigurations (line 102) | public updateConfigurations(add: IConfigurationNode[], remove?: IConfi...
    method loadDefaultConfigurations (line 114) | private loadDefaultConfigurations(): ConfigurationModel {
    method getDescription (line 159) | public getDescription(key: string): string | undefined {
    method getJSONSchema (line 164) | public getJSONSchema(uri: string): IJSONSchema | undefined {
    method parseConfigurationModel (line 191) | public parseConfigurationModel(filepath: string | undefined, fileconte...
    method folderToConfigfile (line 207) | public folderToConfigfile(folder: string): string | undefined {
    method updateMemoryConfig (line 215) | public updateMemoryConfig(props: { [key: string]: any }): void {
    method addFolderFile (line 240) | public addFolderFile(configFilePath: string, fromCwd = false, resource...
    method watchFile (line 256) | private watchFile(filepath: string, target: ConfigurationTarget): void {
    method changeConfiguration (line 270) | public changeConfiguration(target: ConfigurationTarget, model: Configu...
    method getDefaultResource (line 299) | public getDefaultResource(): string | undefined {
    method getConfiguration (line 308) | public getConfiguration(section?: string, scope?: ConfigurationResourc...
    method locateFolderConfigution (line 392) | public locateFolderConfigution(uri: string): boolean {
    method resolveWorkspaceFolderForResource (line 411) | public resolveWorkspaceFolderForResource(resource?: string): string | ...
    method reset (line 433) | public reset(): void {
    method dispose (line 440) | public dispose(): void {

FILE: src/configuration/model.ts
  class ConfigurationModel (line 8) | class ConfigurationModel implements IConfigurationModel {
    method constructor (line 13) | constructor(
    method contents (line 19) | public get contents(): any {
    method overrides (line 23) | public get overrides(): IOverrides[] {
    method keys (line 27) | public get keys(): string[] {
    method isFrozen (line 31) | public get isFrozen(): boolean {
    method checkAndFreeze (line 35) | private checkAndFreeze<T>(data: T): T {
    method isEmpty (line 42) | public isEmpty(): boolean {
    method clone (line 46) | public clone(): ConfigurationModel {
    method toJSON (line 50) | public toJSON(): IConfigurationModel {
    method getValue (line 58) | public getValue<V>(section?: string): V {
    method getOverrideValue (line 65) | public getOverrideValue<V>(section: string | undefined, overrideIdenti...
    method getKeysForOverrideIdentifier (line 72) | public getKeysForOverrideIdentifier(identifier: string): string[] {
    method getAllOverrideIdentifiers (line 82) | public getAllOverrideIdentifiers(): string[] {
    method override (line 90) | public override(identifier: string): ConfigurationModel {
    method merge (line 99) | public merge(...others: ConfigurationModel[]): ConfigurationModel {
    method freeze (line 129) | public freeze(): ConfigurationModel {
    method mergeContents (line 134) | private mergeContents(source: any, target: any): void {
    method setValue (line 148) | public setValue(key: string, value: any) {
    method removeValue (line 153) | public removeValue(key: string): void {
    method addKey (line 159) | private addKey(key: string): void {
    method removeKey (line 169) | private removeKey(key: string): boolean {
    method createOverrideConfigurationModel (line 178) | private createOverrideConfigurationModel(identifier: string): Configur...
    method getContentsForOverrideIdentifier (line 209) | private getContentsForOverrideIdentifier(identifier: string): any {

FILE: src/configuration/parser.ts
  type ConfigurationParseOptions (line 9) | interface ConfigurationParseOptions {
  type ConfigurationParseError (line 14) | interface ConfigurationParseError {
  class ConfigurationModelParser (line 21) | class ConfigurationModelParser {
    method constructor (line 26) | constructor(protected readonly _name: string) {}
    method configurationModel (line 28) | public get configurationModel(): ConfigurationModel {
    method errors (line 32) | public get errors(): Diagnostic[] {
    method parse (line 36) | public parse(content: string | null | undefined, options?: Configurati...
    method parseRaw (line 43) | public parseRaw(raw: any, options?: ConfigurationParseOptions): void {
    method doParseContent (line 50) | private doParseContent(content: string): any {
    method doParseRaw (line 111) | protected doParseRaw(raw: any, _options?: ConfigurationParseOptions): ...
    method toOverrides (line 121) | private toOverrides(raw: any, conflictReporter: (message: string) => v...

FILE: src/configuration/registry.ts
  constant EXCLUDE_KEYS (line 10) | const EXCLUDE_KEYS = ['log-path', 'logPath']
  type IConfigurationPropertySchema (line 16) | interface IConfigurationPropertySchema extends IJSONSchema {
  type IExtensionInfo (line 37) | interface IExtensionInfo {
  type IConfigurationNode (line 42) | interface IConfigurationNode {
  type IRegisteredConfigurationPropertySchema (line 49) | type IRegisteredConfigurationPropertySchema = IConfigurationPropertySche...
  type IConfigurationRegistry (line 55) | interface IConfigurationRegistry {
  type IConfigurationDefaultOverride (line 102) | interface IConfigurationDefaultOverride {
  class ConfigurationRegistry (line 116) | class ConfigurationRegistry implements IConfigurationRegistry {
    method constructor (line 125) | constructor() {
    method registerConfiguration (line 133) | public registerConfiguration(configuration: IConfigurationNode, valida...
    method registerConfigurations (line 137) | public registerConfigurations(configurations: IConfigurationNode[], va...
    method deregisterConfigurations (line 145) | public deregisterConfigurations(configurations: IConfigurationNode[]):...
    method updateConfigurations (line 153) | public updateConfigurations({ add, remove }: { add: IConfigurationNode...
    method doRegisterConfigurations (line 163) | private doRegisterConfigurations(configurations: IConfigurationNode[],...
    method doDeregisterConfigurations (line 172) | private doDeregisterConfigurations(configurations: IConfigurationNode[...
    method validateAndRegisterProperties (line 187) | private validateAndRegisterProperties(configuration: IConfigurationNod...
    method getConfigurationProperties (line 224) | public getConfigurationProperties(): IStringDictionary<IRegisteredConf...
    method getExcludedConfigurationProperties (line 228) | public getExcludedConfigurationProperties(): IStringDictionary<IRegist...
    method registerJSONConfiguration (line 232) | private registerJSONConfiguration(configuration: IConfigurationNode) {
    method updateSchema (line 242) | private updateSchema(key: string, property: IConfigurationPropertySche...
    method removeFromSchema (line 256) | private removeFromSchema(key: string, property: IConfigurationProperty...
    method registerOverridePropertyPatternKey (line 268) | private registerOverridePropertyPatternKey(): void {
    method updatePropertyDefaultValue (line 279) | private updatePropertyDefaultValue(key: string, property: IRegisteredC...
  function validateProperty (line 292) | function validateProperty(property: string, _schema: IRegisteredConfigur...

FILE: src/configuration/shape.ts
  type IFolderController (line 9) | interface IFolderController {
  type IConfigurationShape (line 13) | interface IConfigurationShape {
  class ConfigurationProxy (line 22) | class ConfigurationProxy implements IConfigurationShape {
    method constructor (line 24) | constructor(private resolver: IFolderController, private _test = globa...
    method root (line 27) | public get root(): string | undefined {
    method modifyConfiguration (line 31) | public async modifyConfiguration(fsPath: string, key: string, value?: ...
    method getWorkspaceFolder (line 44) | public getWorkspaceFolder(resource: string): URI | undefined {

FILE: src/configuration/types.ts
  type IStringDictionary (line 9) | type IStringDictionary<V> = Record<string, V>
  type ConfigurationTarget (line 11) | enum ConfigurationTarget {
  type IConfigurationChange (line 19) | interface IConfigurationChange {
  type ConfigurationUpdateTarget (line 24) | enum ConfigurationUpdateTarget {
  type ConfigurationScope (line 30) | const enum ConfigurationScope {
  type ConfigurationResourceScope (line 49) | type ConfigurationResourceScope = string | null | URI | TextDocument | W...
  type IConfigurationChangeEvent (line 51) | interface IConfigurationChangeEvent {
  type ConfigurationInspect (line 58) | interface ConfigurationInspect<T> {
  type IConfigurationOverrides (line 66) | interface IConfigurationOverrides {
  type IOverrides (line 71) | interface IOverrides {
  type IConfigurationModel (line 77) | interface IConfigurationModel {
  type IConfigurationData (line 83) | interface IConfigurationData {
  type WorkspaceConfiguration (line 91) | interface WorkspaceConfiguration {

FILE: src/configuration/util.ts
  type IConfigurationCompareResult (line 13) | interface IConfigurationCompareResult {
  constant OVERRIDE_IDENTIFIER_PATTERN (line 20) | const OVERRIDE_IDENTIFIER_PATTERN = `\\[([^\\]]+)\\]`
  constant OVERRIDE_IDENTIFIER_REGEX (line 21) | const OVERRIDE_IDENTIFIER_REGEX = new RegExp(OVERRIDE_IDENTIFIER_PATTERN...
  constant OVERRIDE_PROPERTY_PATTERN (line 22) | const OVERRIDE_PROPERTY_PATTERN = `^(${OVERRIDE_IDENTIFIER_PATTERN})+$`
  constant OVERRIDE_PROPERTY_REGEX (line 23) | const OVERRIDE_PROPERTY_REGEX = new RegExp(OVERRIDE_PROPERTY_PATTERN)
  function expand (line 28) | function expand(input: string): string {
  function expandObject (line 47) | function expandObject(obj: any): any {
  function convertTarget (line 60) | function convertTarget(updateTarget: ConfigurationUpdateTarget): Configu...
  function scopeToOverrides (line 75) | function scopeToOverrides(scope: ConfigurationResourceScope): IConfigura...
  function overrideIdentifiersFromKey (line 89) | function overrideIdentifiersFromKey(key: string): string[] {
  function getOrSet (line 104) | function getOrSet<K, V>(map: Map<K, V>, key: K, value: V): V {
  function mergeChanges (line 114) | function mergeChanges(...changes: IConfigurationChange[]): IConfiguratio...
  function mergeConfigProperties (line 135) | function mergeConfigProperties(obj: any): any {
  function convertErrors (line 158) | function convertErrors(content: string, errors: ParseError[]): Diagnosti...
  function toValuesTree (line 168) | function toValuesTree(properties: { [qualifiedKey: string]: any }, confl...
  function addToValueTree (line 176) | function addToValueTree(settingsTreeRoot: any, key: string, value: any, ...
  function removeFromValueTree (line 208) | function removeFromValueTree(valueTree: any, key: string): void {
  function doRemoveFromValueTree (line 213) | function doRemoveFromValueTree(valueTree: any, segments: string[]): void {
  function getConfigurationValue (line 232) | function getConfigurationValue<T>(
  function toJSONObject (line 252) | function toJSONObject(obj: any): any {
  function compareConfigurationContents (line 272) | function compareConfigurationContents(to: { keys: string[]; contents: an...
  function getDefaultValue (line 295) | function getDefaultValue(type: string | string[] | undefined): any {
  function lookUp (line 315) | function lookUp(tree: any, key: string): any {

FILE: src/core/autocmds.ts
  type AutocmdOption (line 11) | interface AutocmdOption {
  type AutocmdOptionWithStack (line 22) | interface AutocmdOptionWithStack extends Autocmd {
  class AutocmdItem (line 26) | class AutocmdItem {
    method constructor (line 28) | constructor(
    method extensiionName (line 34) | public get extensiionName(): string {
  function toAutocmdOption (line 43) | function toAutocmdOption(item: AutocmdItem): AutocmdOption {
  class Autocmds (line 57) | class Autocmds implements Disposable {
    method attach (line 62) | public attach(nvim: Neovim): void {
    method doAutocmd (line 66) | public async doAutocmd(id: number, args: any[], timeout = 1000): Promi...
    method registerAutocmd (line 95) | public registerAutocmd(autocmd: AutocmdOptionWithStack): Disposable {
    method createAutocmd (line 107) | private createAutocmd(item: AutocmdItem): void {
    method removeExtensionAutocmds (line 125) | public removeExtensionAutocmds(extensiionName: string): void {
    method dispose (line 140) | public dispose(): void {
  function createCommand (line 148) | function createCommand(id: number, event: string, autocmd: Autocmd): str...

FILE: src/core/channels.ts
  class Channels (line 10) | class Channels {
    method constructor (line 14) | constructor() {
    method getProvider (line 27) | public getProvider(nvim: Neovim): TextDocumentContentProvider {
    method names (line 47) | public get names(): string[] {
    method get (line 51) | public get(channelName: string): BufferChannel | null {
    method create (line 55) | public create(name: string, nvim: Neovim): OutputChannel | null {
    method show (line 64) | public show(name: string, cmd: string, preserveFocus?: boolean): void {
    method dispose (line 70) | public dispose(): void {

FILE: src/core/contentProvider.ts
  class ContentProvider (line 11) | class ContentProvider implements Disposable {
    method constructor (line 17) | constructor(
    method attach (line 22) | public attach(nvim: Neovim): void {
    method schemes (line 27) | public get schemes(): string[] {
    method onBufReadCmd (line 31) | public async onBufReadCmd(scheme: string, uri: string): Promise<void> {
    method resetAutocmds (line 47) | private resetAutocmds(): void {
    method registerTextDocumentContentProvider (line 57) | public registerTextDocumentContentProvider(scheme: string, provider: T...
    method dispose (line 83) | public dispose(): void {
  function getAutocmdCommand (line 90) | function getAutocmdCommand(scheme: string): string {

FILE: src/core/dialogs.ts
  type Item (line 20) | type Item = QuickPickItem | string
  type InputOptions (line 21) | type InputOptions = Pick<InputPreference, 'borderhighlight' | 'position'...
  type QuickPickConfig (line 23) | interface QuickPickConfig<T extends QuickPickItem> {
  type QuickPickOptions (line 35) | interface QuickPickOptions {
  type MenuOption (line 54) | type MenuOption = {
  class Dialogs (line 71) | class Dialogs {
    method constructor (line 75) | constructor() {
    method showDialog (line 78) | public async showDialog(config: DialogConfig): Promise<Dialog | null> {
    method showPrompt (line 86) | public async showPrompt(title: string): Promise<boolean> {
    method createQuickPick (line 92) | public async createQuickPick<T extends QuickPickItem>(config: QuickPic...
    method showMenuPicker (line 100) | public async showMenuPicker(items: string[] | MenuItem[], option?: Men...
    method showQuickPick (line 121) | public async showQuickPick(itemsOrItemsPromise: Item[] | Promise<Item[...
    method showPickerDialog (line 148) | public async showPickerDialog(items: any, title: string, token?: Cance...
    method requestInput (line 168) | public async requestInput(title: string, env: Env, value?: string, opt...
    method requestInputList (line 194) | public async requestInputList(prompt: string, items: string[]): Promis...
    method createInputBox (line 202) | public async createInputBox(title: string, value: string | undefined, ...
    method inputPreference (line 208) | private get inputPreference(): InputPreference {
    method dialogPreference (line 218) | private get dialogPreference(): DialogPreferences {

FILE: src/core/documents.ts
  type StateInfo (line 29) | interface StateInfo {
  type DocumentsConfig (line 36) | interface DocumentsConfig {
  class Documents (line 47) | class Documents implements Disposable {
    method constructor (line 73) | constructor(
    method attach (line 82) | public async attach(nvim: Neovim, env: Env): Promise<void> {
    method onTextChange (line 130) | private onTextChange(bufnr: number): void {
    method getConfiguration (line 135) | private getConfiguration(e?: IConfigurationChangeEvent): void {
    method bufnr (line 148) | public get bufnr(): number {
    method root (line 152) | public get root(): string {
    method cwd (line 156) | public get cwd(): string {
    method documents (line 160) | public get documents(): Document[] {
    method getCurrentUri (line 164) | public async getCurrentUri(): Promise<string | undefined> {
    method attached (line 170) | public *attached(schema?: string): Iterable<Document> {
    method bufnrs (line 178) | public get bufnrs(): Iterable<number> {
    method detach (line 182) | public detach(): void {
    method resolveRoot (line 189) | public resolveRoot(rootPatterns: string[], requireRootPattern = false)...
    method textDocuments (line 204) | public get textDocuments(): LinesTextDocument[] {
    method getDocument (line 212) | public getDocument(uri: number | string, caseInsensitive = platform.is...
    method expand (line 229) | public expand(input: string): string {
    method document (line 283) | public get document(): Promise<Document | undefined> {
    method resolveCurrent (line 307) | private resolveCurrent(document: Document | undefined): void {
    method uri (line 316) | public get uri(): string {
    method filetypes (line 328) | public get filetypes(): Set<string> {
    method getLanguageId (line 339) | public getLanguageId(filepath: string): string {
    method getLines (line 351) | public async getLines(uri: string): Promise<readonly string[]> {
    method languageIds (line 367) | public get languageIds(): Set<string> {
    method getFormatOptions (line 378) | public async getFormatOptions(uri?: string | number): Promise<Formatti...
    method getBufnr (line 384) | public getBufnr(uri?: string): number {
    method createDocument (line 393) | public async createDocument(bufnr: number): Promise<Document | undefin...
    method onBufCreate (line 419) | public async onBufCreate(bufnr: number): Promise<void> {
    method _createDocument (line 424) | private _createDocument(opts: BufferOption): Document {
    method onBufEnter (line 445) | private onBufEnter(bufnr: number): void {
    method onBufUnload (line 454) | private onBufUnload(bufnr: number): void {
    method onBufDetach (line 459) | private async onBufDetach(bufnr: number, checkReload = true): Promise<...
    method detachBuffer (line 468) | public detachBuffer(bufnr: number): void {
    method onBufWritePost (line 479) | private async onBufWritePost(bufnr: number, changedtick: number): Prom...
    method onBufWritePre (line 487) | private async onBufWritePre(bufnr: number, bufname: string, changedtic...
    method tryFormatOnSave (line 553) | public async tryFormatOnSave(document: Document): Promise<void> {
    method tryCodeActionsOnSave (line 575) | public async tryCodeActionsOnSave(doc: Document): Promise<boolean> {
    method shouldFormatOnSave (line 590) | public shouldFormatOnSave(document: Document): boolean {
    method onFileTypeChange (line 606) | public onFileTypeChange(filetype: string, bufnr: number): void {
    method getQuickfixList (line 621) | public async getQuickfixList(locations: LocationWithTarget[]): Promise...
    method showLocations (line 654) | public async showLocations(locations: LocationWithTarget[]): Promise<v...
    method fixUnixPrefix (line 676) | public fixUnixPrefix(filepath: string): string {
    method getQuickfixItem (line 684) | public async getQuickfixItem(loc: LocationWithTarget | LocationLink, t...
    method getLine (line 717) | public async getLine(uri: string, line: number): Promise<string> {
    method readFile (line 729) | public async readFile(uri: string): Promise<string> {
    method clearTimer (line 741) | private clearTimer(bufnr: number): void {
    method convertFiletype (line 746) | public convertFiletype(filetype: string): string {
    method reset (line 763) | public reset(): void {
    method changeRoot (line 772) | private changeRoot(dir: string): void {
    method dispose (line 776) | public dispose(): void {

FILE: src/core/editors.ts
  type EditorOption (line 16) | interface EditorOption {
  type EditorInfo (line 27) | interface EditorInfo {
  type TextEditor (line 34) | interface TextEditor {
  function renamed (line 46) | function renamed(editor: TextEditor, info: EditorInfo): boolean {
  class Editors (line 54) | class Editors {
    method constructor (line 69) | constructor(private documents: Documents) {
    method activeTextEditor (line 72) | public get activeTextEditor(): TextEditor | undefined {
    method visibleTextEditors (line 76) | public get visibleTextEditors(): TextEditor[] {
    method getFormatOptions (line 80) | public getFormatOptions(bufnr: number | string): FormattingOptions | u...
    method getBufWinids (line 87) | public getBufWinids(bufnr: number): number[] {
    method onChangeCurrent (line 95) | private onChangeCurrent(editor: TextEditor | undefined): void {
    method attach (line 103) | public async attach(nvim: Neovim): Promise<void> {
    method checkTabs (line 146) | public checkTabs(ids: number[]): void {
    method checkUnloadedBuffers (line 161) | public checkUnloadedBuffers(bufnrs: number[]): void {
    method checkEditors (line 169) | public async checkEditors(): Promise<void> {
    method cleanUpEditors (line 204) | public cleanUpEditors(winids: Set<number>): boolean {
    method createTextEditor (line 215) | private async createTextEditor(winid: number): Promise<boolean> {
    method fromOptions (line 239) | private fromOptions(opts: EditorOption): TextEditor {

FILE: src/core/fileSystemWatcher.ts
  constant WATCHMAN_COMMAND (line 14) | const WATCHMAN_COMMAND = 'watchman'
  type RenameEvent (line 16) | interface RenameEvent {
  class FileSystemWatcherManager (line 21) | class FileSystemWatcherManager {
    method constructor (line 30) | constructor(
    method attach (line 37) | public attach(channel: OutputChannel): void {
    method waitClient (line 61) | public waitClient(root: string): Promise<Watchman> {
    method createClient (line 73) | public async createClient(root: string, skipCheck = false): Promise<Wa...
    method getWatchmanPath (line 94) | public async getWatchmanPath(): Promise<string> {
    method has (line 102) | private has(root: string): boolean {
    method createFileSystemWatcher (line 108) | public createFileSystemWatcher(globPattern: GlobPattern, ignoreCreateE...
    method dispose (line 122) | public dispose(): void {
  class FileSystemWatcher (line 136) | class FileSystemWatcher implements IFileSystemWatcher {
    method constructor (line 150) | constructor(
    method listen (line 158) | public listen(root: string, client: Watchman): void {
    method dispose (line 230) | public dispose(): void {

FILE: src/core/files.ts
  type LinesChange (line 26) | interface LinesChange {
  type TextDocumentWillSaveEvent (line 40) | interface TextDocumentWillSaveEvent {
  type FileWillRenameEvent (line 71) | interface FileWillRenameEvent {
  type FileRenameEvent (line 101) | interface FileRenameEvent {
  type FileWillCreateEvent (line 116) | interface FileWillCreateEvent {
  type FileCreateEvent (line 151) | interface FileCreateEvent {
  type FileWillDeleteEvent (line 166) | interface FileWillDeleteEvent {
  type FileDeleteEvent (line 196) | interface FileDeleteEvent {
  type WaitUntilEvent (line 204) | interface WaitUntilEvent {
  class Files (line 208) | class Files {
    method constructor (line 227) | constructor(
    method attach (line 235) | public attach(nvim: Neovim, env: Env, window: Window): void {
    method openTextDocument (line 241) | public async openTextDocument(uri: URI | string): Promise<Document> {
    method jumpTo (line 257) | public async jumpTo(uri: string | URI, position?: Position | null, ope...
    method openResource (line 298) | public async openResource(uri: string): Promise<void> {
    method loadResource (line 312) | public async loadResource(uri: string, cmd?: string): Promise<Document> {
    method loadResources (line 336) | public async loadResources(uris: string[]): Promise<(Document | undefi...
    method createFile (line 351) | public async createFile(filepath: string, opts: CreateFileOptions = {}...
    method deleteFile (line 403) | public async deleteFile(filepath: string, opts: DeleteFileOptions = {}...
    method renameFile (line 462) | public async renameFile(oldPath: string, newPath: string, opts: Rename...
    method promptAnnotations (line 501) | private async promptAnnotations(documentChanges: DocumentChange[], cha...
    method applyEdit (line 519) | public async applyEdit(edit: WorkspaceEdit, nested?: boolean): Promise...
    method undoChanges (line 591) | private async undoChanges(recovers: RecoverFunc[]): Promise<void> {
    method inspectEdit (line 598) | public async inspectEdit(): Promise<void> {
    method undoWorkspaceEdit (line 607) | public async undoWorkspaceEdit(): Promise<void> {
    method redoWorkspaceEdit (line 617) | public async redoWorkspaceEdit(): Promise<void> {
    method validateChanges (line 627) | public validateChanges(documentChanges: ReadonlyArray<DocumentChange>)...
    method findFiles (line 649) | public async findFiles(include: GlobPattern, exclude?: GlobPattern | n...
    method fireWaitUntilEvent (line 697) | private async fireWaitUntilEvent<T extends WaitUntilEvent>(emitter: Em...
  function fileMatch (line 720) | function fileMatch(root: string, relpath: string, pattern: GlobPattern):...
  function fsPath (line 731) | function fsPath(uri: string): string {

FILE: src/core/funcs.ts
  constant NAME_SPACE (line 14) | let NAME_SPACE = 2000
  type PartialEnv (line 20) | interface PartialEnv {
  function has (line 33) | function has(env: PartialEnv, feature: string): boolean {
  function convertVersion (line 52) | function convertVersion(version: string): string {
  function callAsync (line 57) | function callAsync<T>(nvim: Neovim, method: string, args: any[]): Promis...
  function createNameSpace (line 67) | function createNameSpace(name: string): number {
  function getWatchmanPath (line 77) | function getWatchmanPath(configurations: Configurations): string | null {
  function findUp (line 82) | async function findUp(nvim: Neovim, cwd: string, filename: string | stri...
  function resolveModule (line 96) | function resolveModule(name: string): Promise<string> {
  function score (line 100) | function score(selector: DocumentSelector | DocumentFilter | string, uri...

FILE: src/core/highlights.ts
  type HighlightItemResult (line 6) | type HighlightItemResult = [string, number, number, number, number?]
  type HighlightItemDef (line 7) | type HighlightItemDef = [string, number, number, number, number?, number...
  type HighlightDiff (line 9) | interface HighlightDiff {
  function convertHighlightItem (line 15) | function convertHighlightItem(item: HighlightItem): HighlightItemDef {
  function isSame (line 19) | function isSame(item: HighlightItem, curr: HighlightItemResult): boolean {
  class Highlights (line 23) | class Highlights {
    method diffHighlights (line 26) | public async diffHighlights(bufnr: number, ns: string, items: Highligh...
    method applyDiffHighlights (line 99) | public async applyDiffHighlights(bufnr: number, ns: string, priority: ...

FILE: src/core/keymaps.ts
  type MapMode (line 10) | type MapMode = 'n' | 'i' | 'v' | 'x' | 's' | 'o' | '!' | 't' | 'c' | 'l'
  type LocalMode (line 11) | type LocalMode = 'n' | 'i' | 'v' | 's' | 'x'
  type KeymapCallback (line 12) | type KeymapCallback = () => Promise<string> | string | void | Promise<void>
  function getKeymapModifier (line 14) | function getKeymapModifier(mode: MapMode, cmd?: boolean): string {
  function getBufnr (line 22) | function getBufnr(buffer: number | boolean): number {
  class Keymaps (line 26) | class Keymaps {
    method attach (line 30) | public attach(nvim: Neovim): void {
    method doKeymap (line 34) | public async doKeymap(key: string, defaultReturn: string): Promise<str...
    method registerKeymap (line 50) | public registerKeymap(modes: MapMode[], name: string, fn: KeymapCallba...
    method registerExprKeymap (line 82) | public registerExprKeymap(mode: MapMode, lhs: string, fn: KeymapCallba...
    method registerLocalKeymap (line 109) | public registerLocalKeymap(bufnr: number, mode: LocalMode, lhs: string...
  function toKeymapOption (line 134) | function toKeymapOption(option: KeymapOption | boolean): KeymapOption {

FILE: src/core/notifications.ts
  type MessageKind (line 16) | type MessageKind = 'Error' | 'Warning' | 'Info'
  type NotificationItem (line 18) | interface NotificationItem {
  type NotificationConfiguration (line 24) | interface NotificationConfiguration {
  type ProgressOptions (line 41) | interface ProgressOptions {
  class Notifications (line 60) | class Notifications {
    method constructor (line 66) | constructor(private dialogs: Dialogs) {
    method getCurrentTimestamp (line 69) | private getCurrentTimestamp(): string {
    method _showMessage (line 82) | public async _showMessage<T extends MessageItem | string>(kind: Messag...
    method history (line 127) | public get history(): NotificationItem[] {
    method clearHistory (line 131) | public clearHistory(): void {
    method createNotification (line 135) | public createNotification(kind: NotificationKind, message: string, ite...
    method showConfirm (line 153) | public async showConfirm<T extends MessageItem | string>(message: stri...
    method showMenuPicker (line 160) | public async showMenuPicker<T extends MessageItem | string>(title: str...
    method showNotification (line 171) | public async showNotification(config: NotificationConfig, stack: strin...
    method echoMessages (line 176) | public echoMessages(msg: string, messageType: MsgTypes): void {
    method withProgress (line 181) | public async withProgress<R>(options: ProgressOptions, task: (progress...
    method createStatusLineProgress (line 199) | private async createStatusLineProgress<R>(options: ProgressOptions, ta...
    method enableMessageDialog (line 217) | private get enableMessageDialog(): boolean {
    method messageDialogKind (line 221) | private get messageDialogKind(): string {
    method messageReportKind (line 225) | private get messageReportKind(): string {
    method getNotificationPreference (line 229) | private getNotificationPreference(source?: string, isProgress = false)...

FILE: src/core/terminals.ts
  type TerminalResult (line 9) | interface TerminalResult {
  type OpenTerminalOption (line 15) | interface OpenTerminalOption {
  class Terminals (line 34) | class Terminals {
    method constructor (line 42) | constructor() {
    method terminals (line 59) | public get terminals(): ReadonlyArray<TerminalModel> {
    method createTerminal (line 63) | public async createTerminal(nvim: Neovim, opts: TerminalOptions): Prom...
    method runTerminalCommand (line 76) | public async runTerminalCommand(nvim: Neovim, cmd: string, cwd: string...
    method openTerminal (line 80) | public async openTerminal(nvim: Neovim, cmd: string, opts?: OpenTermin...
    method reset (line 84) | public reset(): void {
    method dispose (line 91) | public dispose(): void {

FILE: src/core/ui.ts
  type ScreenPosition (line 10) | interface ScreenPosition {
  type MsgTypes (line 16) | type MsgTypes = 'error' | 'warning' | 'more'
  type MessageLevel (line 18) | enum MessageLevel {
  function getCursorPosition (line 24) | async function getCursorPosition(nvim: Neovim): Promise<Position> {
  function getVisibleRanges (line 30) | async function getVisibleRanges(nvim: Neovim, bufnr: number, winid?: num...
  function getLineAndPosition (line 40) | async function getLineAndPosition(nvim: Neovim): Promise<{ text: string,...
  function createFloatFactory (line 45) | function createFloatFactory(nvim: Neovim, conf: FloatWinConfig, defaults...
  function showPrompt (line 76) | async function showPrompt(nvim: Neovim, title: string): Promise<boolean> {
  function moveTo (line 85) | async function moveTo(nvim: Neovim, position: Position, redraw: boolean)...
  function getOffset (line 95) | async function getOffset(nvim: Neovim): Promise<number> {
  function getCursorScreenPosition (line 104) | async function getCursorScreenPosition(nvim: Neovim): Promise<ScreenPosi...
  function echoLines (line 109) | async function echoLines(nvim: Neovim, env: { cmdheight: number, columns...
  function echoMessages (line 130) | function echoMessages(nvim: Neovim, msg: string, messageType: MsgTypes, ...
  function toMessageLevel (line 149) | function toMessageLevel(level: string): MessageLevel {
  function getSelection (line 163) | async function getSelection(nvim: Neovim, mode: string): Promise<Range |...
  function selectRange (line 177) | async function selectRange(nvim: Neovim, range: Range, redraw: boolean):...

FILE: src/core/watchers.ts
  class Watchers (line 12) | class Watchers implements Disposable {
    method constructor (line 17) | constructor() {
    method options (line 46) | public get options(): string[] {
    method attach (line 50) | public attach(nvim: Neovim, _env: Env): void {
    method watchOption (line 57) | public watchOption(key: string, callback: (oldValue: any, newValue: an...
    method watchGlobal (line 78) | public watchGlobal(key: string, callback: (oldValue: any, newValue: an...
    method dispose (line 96) | public dispose(): void {

FILE: src/core/watchman.ts
  type WatchResponse (line 11) | interface WatchResponse {
  type FileChangeItem (line 18) | interface FileChangeItem {
  type FileChange (line 27) | interface FileChange {
  type ChangeCallback (line 33) | type ChangeCallback = (FileChange) => void
  class Watchman (line 39) | class Watchman {
    method constructor (line 46) | constructor(binaryPath: string, private channel?: OutputChannel) {
    method root (line 54) | public get root(): string {
    method checkCapability (line 58) | public checkCapability(): Promise<boolean> {
    method watchProject (line 75) | public async watchProject(root: string): Promise<boolean> {
    method command (line 111) | private command(args: any[]): Promise<any> {
    method subscribe (line 122) | public subscribe(globPattern: string, cb: ChangeCallback): Disposable {
    method dispose (line 141) | public dispose(): void {
    method appendOutput (line 148) | private appendOutput(message: string, type = "Info"): void {
    method createClient (line 154) | public static async createClient(binaryPath: string, root: string, cha...

FILE: src/core/workspaceFolder.ts
  type PatternType (line 20) | enum PatternType {
  function toWorkspaceFolder (line 30) | function toWorkspaceFolder(fsPath: string): WorkspaceFolder | undefined {
  type WorkspaceConfig (line 43) | interface WorkspaceConfig {
  class WorkspaceFolderController (line 52) | class WorkspaceFolderController {
    method constructor (line 60) | constructor(private configurations: Configurations) {
    method updateConfiguration (line 74) | private updateConfiguration(): void {
    method updateServerRootPatterns (line 88) | private updateServerRootPatterns(): void {
    method cancelAll (line 101) | public cancelAll(): void {
    method setWorkspaceFolders (line 107) | public setWorkspaceFolders(folders: string[] | undefined): void {
    method getWorkspaceFolder (line 113) | public getWorkspaceFolder(uri: URI): WorkspaceFolder | undefined {
    method getRelativePath (line 122) | public getRelativePath(pathOrUri: string | URI, includeWorkspace?: boo...
    method workspaceFolders (line 146) | public get workspaceFolders(): ReadonlyArray<WorkspaceFolder> {
    method addRootPattern (line 150) | public addRootPattern(filetype: string, rootPatterns: string[]): void {
    method resolveRoot (line 160) | public resolveRoot(document: Document, cwd: string, fireEvent: boolean...
    method addWorkspaceFolder (line 186) | public addWorkspaceFolder(folder: string, fireEvent: boolean): Workspa...
    method renameWorkspaceFolder (line 201) | public renameWorkspaceFolder(oldPath: string, newPath: string): void {
    method removeWorkspaceFolder (line 214) | public removeWorkspaceFolder(fsPath: string): void {
    method onDocumentDetach (line 226) | public onDocumentDetach(uris: URI[]): void {
    method getRootPatterns (line 244) | public getRootPatterns(document: Document, patternType: PatternType): ...
    method reset (line 250) | public reset(): void {
    method getServerRootPatterns (line 258) | public getServerRootPatterns(filetype: string): string[] {
    method checkFolder (line 264) | public checkFolder(dir: string, patterns: string[], token?: Cancellati...
    method checkPatterns (line 268) | public async checkPatterns(folders: ReadonlyArray<WorkspaceFolder>, pa...

FILE: src/cursors/index.ts
  type CursorPosition (line 13) | type CursorPosition = [number, number, number, number]
  class Cursors (line 15) | class Cursors {
    method constructor (line 19) | constructor(private nvim: Neovim) {
    method loadConfiguration (line 33) | private loadConfiguration(e?: IConfigurationChangeEvent): void {
    method cancel (line 40) | public cancel(uri: number | string): void {
    method getSession (line 47) | public getSession(bufnr: number): CursorSession | undefined {
    method isActivated (line 51) | public async isActivated(): Promise<boolean> {
    method select (line 56) | public async select(bufnr: number, kind: string, mode: string): Promis...
    method createSession (line 115) | public createSession(doc: Document): CursorSession {
    method addRanges (line 129) | public async addRanges(ranges: Range[]): Promise<boolean> {
    method reset (line 137) | public reset(): void {

FILE: src/cursors/session.ts
  type CursorsConfig (line 19) | interface CursorsConfig {
  type DiffItem (line 26) | interface DiffItem {
  class CursorSession (line 35) | class CursorSession {
    method constructor (line 44) | constructor(private nvim: Neovim, private doc: Document, private confi...
    method checkRanges (line 84) | public checkRanges(): void {
    method addRange (line 93) | public addRange(range: Range): void {
    method addRanges (line 110) | public addRanges(ranges: Range[]): boolean {
    method createRange (line 124) | private createRange(range: Range): void {
    method onChange (line 131) | public async onChange(e: DidChangeTextDocumentParams): Promise<void> {
    method validChange (line 185) | public validChange(range: Range, text: string): boolean {
    method range (line 194) | public get range(): Range {
    method doHighlights (line 200) | private doHighlights(): void {
    method currentRanges (line 219) | public get currentRanges(): Range[] {
    method cancel (line 226) | public cancel(): void {
    method dispose (line 241) | public dispose(): void {
    method applySingleEdit (line 250) | private async applySingleEdit(textRange: TextRange, edit: TextEdit): P...
    method applyComposedEdit (line 271) | public applyComposedEdit(originalLines: string[], newLines: string[]):...
  function surroundChanges (line 379) | function surroundChanges(changes: DiffItem[], len: number): boolean {

FILE: src/cursors/textRange.ts
  class TextRange (line 7) | class TextRange {
    method constructor (line 12) | constructor(line: number, character: number, text: string) {
    method position (line 18) | public get position(): Position {
    method line (line 22) | public get line(): number {
    method text (line 26) | public get text(): string {
    method range (line 30) | public get range(): Range {
    method textEdit (line 34) | public get textEdit(): TextEdit {
    method applyChange (line 41) | public applyChange(change: SurroundChange | TextChange): void {
    method applySurroundChange (line 49) | public applySurroundChange(change: SurroundChange): void {
    method applyTextChange (line 60) | public applyTextChange(change: TextChange): void {
    method move (line 73) | public move(delta: number): void {
    method adjustFromEdit (line 81) | public adjustFromEdit(edit: TextEdit): number {
    method isBefore (line 91) | public isBefore(range: TextRange): boolean {

FILE: src/cursors/util.ts
  type TextChange (line 9) | interface TextChange {
  type SurroundChange (line 16) | interface SurroundChange {
  function splitRange (line 34) | function splitRange(doc: Document, range: Range): Range[] {
  function getVisualRanges (line 49) | function getVisualRanges(doc: Document, range: Range): Range[] {
  function isSurroundChange (line 61) | function isSurroundChange(change: TextChange | SurroundChange): change i...
  function isTextChange (line 65) | function isTextChange(change: TextChange | SurroundChange): change is Te...
  function getDelta (line 69) | function getDelta(change: TextChange | SurroundChange): number {
  function getChange (line 76) | function getChange(r: TextRange, range: Range, newText: string): TextCha...
  function getBeforeCount (line 104) | function getBeforeCount(textRange: TextRange, ranges: TextRange[], exclu...

FILE: src/diagnostic/buffer.ts
  constant NAMESPACE (line 21) | const NAMESPACE = 'diagnostic'
  type DiagnosticInfo (line 25) | interface DiagnosticInfo {
  type SignItem (line 35) | interface SignItem {
  class DiagnosticBuffer (line 56) | class DiagnosticBuffer implements SyncItem {
    method constructor (line 65) | constructor(
    method _autoRefresh (line 87) | private get _autoRefresh(): boolean {
    method config (line 91) | public get config(): Readonly<DiagnosticConfig> {
    method loadConfiguration (line 95) | public loadConfiguration(): void {
    method setState (line 148) | public async setState(enable: boolean): Promise<void> {
    method dirty (line 159) | public get dirty(): boolean {
    method bufnr (line 163) | public get bufnr(): number {
    method uri (line 167) | public get uri(): string {
    method onChange (line 171) | public onChange(e: DidChangeTextDocumentParams): void {
    method onTextChange (line 185) | public onTextChange(): void {
    method displayByAle (line 190) | private get displayByAle(): boolean {
    method displayByVimDiagnostic (line 194) | private get displayByVimDiagnostic(): boolean {
    method clearHighlight (line 198) | public clearHighlight(collection: string): void {
    method clearSigns (line 202) | private clearSigns(collection: string): void {
    method diagnostics (line 206) | private get diagnostics(): Diagnostic[] {
    method buffer (line 214) | private get buffer(): Buffer {
    method refreshAle (line 218) | private refreshAle(collection: string, diagnostics: ReadonlyArray<Diag...
    method update (line 239) | public async update(collection: string, diagnostics: ReadonlyArray<Dia...
    method checkFloat (line 260) | private async checkFloat(): Promise<void> {
    method reset (line 272) | public async reset(diagnostics: { [collection: string]: Diagnostic[] }...
    method onCursorHold (line 286) | public async onCursorHold(lnum: number, col: number): Promise<void> {
    method echoMessage (line 295) | public async echoMessage(truncate = false, position: Position, target?...
    method showVirtualTextCurrentLine (line 321) | public async showVirtualTextCurrentLine(lnum: number): Promise<boolean> {
    method showFloat (line 330) | public async showFloat(diagnostics: DiagnosticWithFileType[], target =...
    method getDiagnosticInfo (line 393) | private async getDiagnosticInfo(force?: boolean): Promise<DiagnosticIn...
    method refresh (line 409) | private refresh(diagnosticsMap: Map<string, ReadonlyArray<Diagnostic>>...
    method updateLocationList (line 444) | public updateLocationList(winid: number, title: string): void {
    method toLocationListItems (line 450) | public toLocationListItems(diagnostics: Diagnostic[]): LocationListIte...
    method addSigns (line 462) | public addSigns(collection: string, diagnostics: ReadonlyArray<Diagnos...
    method setDiagnosticInfo (line 487) | public setDiagnosticInfo(full = false): void {
    method showVirtualText (line 536) | public showVirtualText(lnum: number): void {
    method updateHighlights (line 580) | public updateHighlights(collection: string, diagnostics: ReadonlyArray...
    method _refresh (line 593) | private async _refresh(dirtyOnly: boolean): Promise<void> {
    method getHighlightItems (line 609) | public getHighlightItems(diagnostics: ReadonlyArray<Diagnostic>): High...
    method clear (line 630) | public clear(): void {
    method getDiagnosticsAt (line 657) | public getDiagnosticsAt(pos: Position, checkCurrentLine: boolean): Dia...
    method getDiagnosticsAtPosition (line 670) | public getDiagnosticsAtPosition(pos: Position): Diagnostic[] {
    method isEnabled (line 688) | public async isEnabled(): Promise<boolean> {
    method dispose (line 695) | public dispose(): void {

FILE: src/diagnostic/collection.ts
  class DiagnosticCollection (line 9) | class DiagnosticCollection {
    method constructor (line 14) | constructor(
    method set (line 21) | public set(entries: [string, Diagnostic[] | undefined][] | string, dia...
    method delete (line 58) | public delete(uri: string): void {
    method clear (line 63) | public clear(): void {
    method forEach (line 72) | public forEach(callback: (uri: string, diagnostics: Diagnostic[], coll...
    method entries (line 79) | public entries(): IterableIterator<[string, Diagnostic[]]> {
    method get (line 83) | public get(uri: string): Diagnostic[] {
    method has (line 88) | public has(uri: string): boolean {
    method dispose (line 92) | public dispose(): void {

FILE: src/diagnostic/manager.ts
  type DiagnosticEventParams (line 21) | interface DiagnosticEventParams {
  type DiagnosticSignConfig (line 27) | interface DiagnosticSignConfig {
  type DiagnosticItem (line 36) | interface DiagnosticItem {
  type PrepareResult (line 51) | interface PrepareResult {
  class DiagnosticManager (line 58) | class DiagnosticManager implements Disposable {
    method init (line 67) | public init(): void {
    method checkConfigurationErrors (line 126) | public checkConfigurationErrors(): void {
    method defineSigns (line 138) | public defineSigns(config: DiagnosticSignConfig): void {
    method getItem (line 151) | public getItem(bufnr: number): DiagnosticBuffer | undefined {
    method setLocationlist (line 158) | public async setLocationlist(bufnr: number): Promise<void> {
    method create (line 172) | public create(name: string): DiagnosticCollection {
    method getSortedRanges (line 190) | public getSortedRanges(uri: string, minLevel: number | undefined, seve...
    method getDiagnostics (line 220) | public getDiagnostics(buf: DiagnosticBuffer): { [collection: string]: ...
    method getDiagnosticsByCollection (line 232) | public getDiagnosticsByCollection(buf: DiagnosticBuffer, collection: D...
    method getDiagnosticsInRange (line 256) | public getDiagnosticsInRange(document: TextDocumentIdentifier, range: ...
    method preview (line 271) | public async preview(): Promise<void> {
    method prepareJump (line 288) | private async prepareJump(severity?: string): Promise<PrepareResult | ...
    method jumpPrevious (line 307) | public async jumpPrevious(severity?: string): Promise<void> {
    method jumpNext (line 331) | public async jumpNext(severity?: string): Promise<void> {
    method getDiagnosticList (line 361) | public async getDiagnosticList(): Promise<DiagnosticItem[]> {
    method getBufferAndPosition (line 416) | private async getBufferAndPosition(): Promise<[DiagnosticBuffer, Posit...
    method getCurrentDiagnostics (line 424) | public async getCurrentDiagnostics(): Promise<Diagnostic[] | undefined> {
    method echoCurrentMessage (line 430) | public async echoCurrentMessage(target?: string): Promise<void> {
    method jumpRelated (line 437) | public async jumpRelated(): Promise<void> {
    method relatedInformation (line 448) | public async relatedInformation(): Promise<Location[]> {
    method reset (line 455) | public reset(): void {
    method dispose (line 464) | public dispose(): void {
    method nvim (line 474) | private get nvim(): Neovim {
    method getCollectionByName (line 478) | public getCollectionByName(name: string): DiagnosticCollection {
    method getCollections (line 482) | private getCollections(uri: string): DiagnosticCollection[] {
    method toggleDiagnostic (line 486) | public async toggleDiagnostic(enable?: number): Promise<void> {
    method toggleDiagnosticBuffer (line 493) | public async toggleDiagnosticBuffer(bufnr?: number, enable?: number): ...
    method refreshBuffer (line 506) | public async refreshBuffer(uri: string | number): Promise<boolean> {
    method refresh (line 516) | public async refresh(bufnr?: number): Promise<void> {

FILE: src/diagnostic/util.ts
  type LocationListItem (line 9) | interface LocationListItem {
  type DiagnosticHighlight (line 19) | enum DiagnosticHighlight {
  type DiagnosticConfig (line 31) | interface DiagnosticConfig {
  function formatDiagnostic (line 68) | function formatDiagnostic(format: string, diagnostic: Diagnostic): string {
  function getSeverityName (line 78) | function getSeverityName(severity: DiagnosticSeverity): string {
  function getSeverityType (line 91) | function getSeverityType(severity: DiagnosticSeverity): string {
  function severityLevel (line 104) | function severityLevel(level: string | null | undefined): number | undef...
  function getNameFromSeverity (line 120) | function getNameFromSeverity(severity: DiagnosticSeverity): string {
  function getLocationListItem (line 135) | function getLocationListItem(bufnr: number, diagnostic: Diagnostic, line...
  function sortDiagnostics (line 154) | function sortDiagnostics(a: Diagnostic, b: Diagnostic): number {
  function getHighlightGroup (line 163) | function getHighlightGroup(diagnostic: Diagnostic): DiagnosticHighlight[] {
  function adjustDiagnostics (line 190) | function adjustDiagnostics(diagnostics: ReadonlyArray<Diagnostic>, edit:...

FILE: src/events.ts
  type Result (line 14) | type Result = void | Promise<void>
  type PopupChangeEvent (line 16) | interface PopupChangeEvent {
  type VisibleEvent (line 30) | interface VisibleEvent {
  type ModeChangedEvent (line 39) | interface ModeChangedEvent {
  type InsertChange (line 44) | interface InsertChange {
  type EventName (line 57) | enum EventName {
  type BufEvents (line 79) | type BufEvents = 'BufHidden' | 'BufEnter' | 'BufRename'
  type EmptyEvents (line 83) | type EmptyEvents = 'FocusGained' | 'ColorScheme' | 'FocusLost' | 'Insert...
  type InsertChangeEvents (line 85) | type InsertChangeEvents = 'TextChangedP' | 'TextChangedI'
  type TaskEvents (line 87) | type TaskEvents = 'TaskExit' | 'TaskStderr' | 'TaskStdout'
  type WindowEvents (line 89) | type WindowEvents = 'WinLeave' | 'WinEnter' | 'WinClosed'
  type TabEvents (line 91) | type TabEvents = 'TabNew' | 'TabClosed'
  type AllEvents (line 93) | type AllEvents = BufEvents | EmptyEvents | CursorEvents | TaskEvents | W...
  type CursorEvents (line 99) | type CursorEvents = CursorHoldEvents | CursorMoveEvents
  type CursorHoldEvents (line 100) | type CursorHoldEvents = 'CursorHold' | 'CursorHoldI'
  type CursorMoveEvents (line 101) | type CursorMoveEvents = 'CursorMoved' | 'CursorMovedI'
  type OptionValue (line 103) | type OptionValue = string | number | boolean
  type CursorPosition (line 105) | interface CursorPosition {
  type LatestInsert (line 112) | interface LatestInsert {
  class Events (line 118) | class Events {
    method requesting (line 138) | public set requesting(val: boolean) {
    method requesting (line 142) | public get requesting(): boolean {
    method ready (line 146) | public get ready(): boolean {
    method mode (line 150) | public get mode(): string {
    method pumInserted (line 154) | public get pumInserted(): boolean {
    method fireVisibleEvent (line 158) | private fireVisibleEvent(ev: VisibleEvent): void {
    method clearVisibleTimer (line 168) | private clearVisibleTimer(winid: number): void {
    method completing (line 176) | public set completing(completing: boolean) {
    method completing (line 182) | public get completing(): boolean {
    method cursor (line 186) | public get cursor(): CursorPosition {
    method bufnr (line 190) | public get bufnr(): number {
    method pumvisible (line 194) | public get pumvisible(): boolean {
    method pumAlignTop (line 198) | public get pumAlignTop(): boolean {
    method insertMode (line 202) | public get insertMode(): boolean {
    method lastChangeTs (line 206) | public get lastChangeTs(): number {
    method race (line 213) | public race(events: AllEvents[], token?: number | CancellationToken): ...
    method fire (line 239) | public async fire(event: string, args: any[]): Promise<void> {
    method on (line 381) | public on(event: AllEvents[] | AllEvents, handler: (...args: any[]) =>...
    method once (line 429) | public once(event: AllEvents, handler: (...args: any[]) => Result, thi...

FILE: src/extension/index.ts
  type PropertyScheme (line 24) | interface PropertyScheme {
  type UpdateSettings (line 33) | interface UpdateSettings {
  constant EXTENSIONS_FOLDER (line 39) | const EXTENSIONS_FOLDER = path.join(dataHome, 'extensions')
  class Extensions (line 42) | class Extensions {
    method constructor (line 47) | constructor() {
    method checkRecommendation (line 85) | public async checkRecommendation(workspaceFolder: WorkspaceFolder | un...
    method getUpdateSettings (line 109) | public getUpdateSettings(): UpdateSettings {
    method init (line 119) | public async init(runtimepath: string): Promise<void> {
    method activateExtensions (line 128) | public async activateExtensions(): Promise<void> {
    method onDidLoadExtension (line 146) | public get onDidLoadExtension(): Event<Extension<API>> {
    method onDidActiveExtension (line 150) | public get onDidActiveExtension(): Event<Extension<API>> {
    method onDidUnloadExtension (line 154) | public get onDidUnloadExtension(): Event<string> {
    method outputChannel (line 158) | private get outputChannel(): OutputChannel {
    method all (line 165) | public get all(): Extension<API>[] {
    method has (line 169) | public has(id: string): boolean {
    method getExtension (line 173) | public getExtension(id: string): ExtensionItem | undefined {
    method getExtensionById (line 177) | public getExtensionById(extensionId: string): Extension<API> | undefin...
    method schemes (line 185) | public get schemes(): { [key: string]: PropertyScheme } {
    method addSchemeProperty (line 192) | public addSchemeProperty(key: string, def: PropertyScheme): void {
    method getExtensionState (line 199) | public getExtensionState(id: string): ExtensionState {
    method isActivated (line 203) | public isActivated(id: string): boolean {
    method call (line 208) | public async call(id: string, method: string, args: any[]): Promise<an...
    method npm (line 212) | public get npm(): string {
    method createInstallerUI (line 222) | private createInstallerUI(isUpdate: boolean, silent: boolean, updateUI...
    method createInstaller (line 226) | public createInstaller(npm: string, def: string): IInstaller {
    method installExtensions (line 233) | public async installExtensions(list: string[]): Promise<void> {
    method updateExtensions (line 265) | public async updateExtensions(silent = false, updateUIInTab = false): ...
    method getExtensionStates (line 305) | public async getExtensionStates(): Promise<ExtensionInfo[]> {
    method globalExtensions (line 312) | public async globalExtensions(): Promise<ExtensionToLoad[]> {
    method globalExtensionStats (line 327) | public globalExtensionStats(): ExtensionInfo[] {
    method runtimeExtensionStats (line 357) | public runtimeExtensionStats(runtimepaths: string[]): ExtensionInfo[] {
    method cleanModulesFolder (line 387) | public cleanModulesFolder(): void {
    method dispose (line 404) | public dispose(): void {
  function toUrl (line 409) | function toUrl(val: string): string {

FILE: src/extension/installer.ts
  type Info (line 15) | interface Info {
  type Dependencies (line 22) | type Dependencies = Record<string, string>
  type InstallResult (line 24) | interface InstallResult {
  function registryUrl (line 32) | function registryUrl(home = os.homedir()): URL {
  function isNpmCommand (line 54) | function isNpmCommand(exePath: string): boolean {
  function isYarn (line 59) | function isYarn(exePath: string) {
  function isPnpm (line 64) | function isPnpm(exePath: string) {
  function isSymbolicLink (line 69) | function isSymbolicLink(folder: string): boolean {
  type IInstaller (line 79) | interface IInstaller {
  class Installer (line 85) | class Installer extends EventEmitter implements IInstaller {
    method constructor (line 89) | constructor(
    method info (line 109) | public get info() {
    method getInfo (line 113) | public async getInfo(): Promise<Info> {
    method getInfoFromUri (line 132) | public async getInfoFromUri(): Promise<Info> {
    method log (line 158) | private log(msg: string, isProgress = false): void {
    method install (line 162) | public async install(): Promise<InstallResult> {
    method update (line 175) | public async update(url?: string): Promise<string | undefined> {
    method getInstallArguments (line 204) | public getInstallArguments(exePath: string, url: string | undefined): ...
    method readLines (line 231) | private readLines(key: string, stream: NodeJS.ReadableStream): void {
    method installDependencies (line 240) | public installDependencies(folder: string, dependencies: string[]): Pr...
    method doInstall (line 266) | public async doInstall(info: Info, installing: Set<string> = new Set()...
    method download (line 316) | public async download(url: string, options: DownloadOptions): Promise<...
    method fetch (line 320) | public async fetch(url: string | URL, options: FetchOptions = {}): Pro...
  function getDependencies (line 325) | function getDependencies(obj: { dependencies?: { [key: string]: string }...
  function getExtensionDependencies (line 329) | function getExtensionDependencies(obj: { extensionDependencies?: string[...

FILE: src/extension/manager.ts
  type ExportExtension (line 26) | interface ExportExtension {
  type ExtensionState (line 40) | type ExtensionState = 'disabled' | 'loaded' | 'activated' | 'unknown'
  type ExtensionType (line 43) | enum ExtensionType {
  type ActivateEvents (line 50) | enum ActivateEvents {
  type ExtensionInfo (line 57) | interface ExtensionInfo {
  type ExtensionToLoad (line 70) | type ExtensionToLoad = Pick<Readonly<ExtensionInfo>, 'root' | 'packageJS...
  type Extension (line 72) | interface Extension<T> {
  type API (line 83) | type API = { [index: string]: any } | void | null | undefined
  type ExtensionItem (line 85) | interface ExtensionItem {
  class ExtensionManager (line 105) | class ExtensionManager {
    method constructor (line 119) | constructor(public readonly states: ExtensionStat, private folder: str...
    method activateExtensions (line 123) | public activateExtensions(): Promise<PromiseSettledResult<void>[]> {
    method loadFileExtensions (line 142) | public async loadFileExtensions(): Promise<void> {
    method attachEvents (line 150) | public attachEvents(): void {
    method cleanExtensions (line 190) | public async cleanExtensions(): Promise<string[]> {
    method tryActivateExtensions (line 196) | public tryActivateExtensions(event: string, check: (activationEvents: ...
    method checkAutoActivate (line 209) | private async checkAutoActivate(packageJSON: ExtensionJson): Promise<b...
    method has (line 240) | public has(id: string): boolean {
    method getExtension (line 244) | public getExtension(id: string): ExtensionItem | undefined {
    method loadedExtensions (line 248) | public get loadedExtensions(): string[] {
    method all (line 252) | public get all(): Extension<API>[] {
    method activate (line 260) | public async activate(id: string, activating: Set<string> = new Set())...
    method deactivate (line 285) | public async deactivate(id: string): Promise<void> {
    method loadExtension (line 294) | public async loadExtension(folder: string | string[], noActive = false...
    method unloadExtension (line 320) | public async unloadExtension(id: string): Promise<void> {
    method reloadExtension (line 329) | public async reloadExtension(id: string): Promise<void> {
    method call (line 341) | public async call(id: string, method: string, args: any[]): Promise<an...
    method registContribution (line 355) | public registContribution(id: string, packageJSON: any, directory: str...
    method getExtensionState (line 405) | public getExtensionState(id: string): ExtensionState {
    method autoActivate (line 414) | public async autoActivate(id: string, extension: Extension<API>): Prom...
    method loadExtensionFile (line 423) | public async loadExtensionFile(filepath: string, noActive = false): Pr...
    method registerExtensions (line 441) | public registerExtensions(stats: ExtensionToLoad[]): void {
    method registerExtension (line 452) | public async registerExtension(root: string, packageJSON: ExtensionJso...
    method unregistContribution (line 538) | public unregistContribution(id: string): void {
    method registerInternalExtension (line 548) | public async registerInternalExtension(extension: Extension<API>, deac...
    method uninstallExtensions (line 567) | public async uninstallExtensions(ids: string[]): Promise<void> {
    method toggleExtension (line 583) | public async toggleExtension(id: string): Promise<void> {
    method watchExtension (line 606) | public async watchExtension(id: string): Promise<void> {
    method load (line 630) | public async load(filepath: string, active: boolean): Promise<ExportEx...
    method dispose (line 664) | public dispose(): void {
  function getEvents (line 669) | function getEvents(activationEvents: string[] | undefined): string[] {
  function getOnCommandList (line 678) | function getOnCommandList(activationEvents: string[] | undefined): strin...
  function checkLanguageId (line 687) | function checkLanguageId(document: { languageId: string, filetype: strin...
  function checkCommand (line 698) | function checkCommand(command: string, activationEvents: string[]): bool...
  function checkFileSystem (line 709) | function checkFileSystem(uri: string, activationEvents: string[]): boole...
  function getActivationEvents (line 721) | function getActivationEvents(json: ExtensionJson): string[] {
  function toWorkspaceContainsPatterns (line 728) | function toWorkspaceContainsPatterns(activationEvents: string[]): string...

FILE: src/extension/stat.ts
  type DataBase (line 9) | interface DataBase {
  type PackageJson (line 19) | interface PackageJson {
  type ExtensionJson (line 28) | interface ExtensionJson {
  type ExtensionStatus (line 40) | enum ExtensionStatus {
  constant ONE_DAY (line 46) | const ONE_DAY = 24 * 60 * 60 * 1000
  constant DISABLE_PROMPT_KEY (line 47) | const DISABLE_PROMPT_KEY = 'disablePrompt'
  class ExtensionStat (line 52) | class ExtensionStat {
    method constructor (line 57) | constructor(private folder: string) {
    method migrate (line 65) | private migrate(): void {
    method addNoPromptFolder (line 90) | public addNoPromptFolder(uri: string): void {
    method shouldPrompt (line 97) | public shouldPrompt(uri: string): boolean {
    method reset (line 103) | public reset(): void {
    method activated (line 107) | public *activated(): Iterable<string> {
    method addLocalExtension (line 116) | public addLocalExtension(name: string, folder: string): void {
    method getFolder (line 120) | public getFolder(name: string): string | undefined {
    method getExtensionsStat (line 125) | public getExtensionsStat(): Record<string, ExtensionStatus> {
    method hasExtension (line 139) | public hasExtension(id: string): boolean {
    method addExtension (line 143) | public addExtension(id: string, val: string): void {
    method removeExtension (line 151) | public removeExtension(id: string): void {
    method isDisabled (line 161) | public isDisabled(id: string): boolean {
    method lockedExtensions (line 165) | public get lockedExtensions(): string[] {
    method disabledExtensions (line 169) | public get disabledExtensions(): string[] {
    method dependencies (line 173) | public get dependencies(): { [key: string]: string } {
    method setDisable (line 178) | public setDisable(id: string, disable: boolean): void {
    method setLocked (line 187) | public setLocked(id: string, locked: boolean): void {
    method setLastUpdate (line 196) | public setLastUpdate(): void {
    method shouldUpdate (line 200) | public shouldUpdate(opt: string): boolean {
    method globalIds (line 207) | public get globalIds(): ReadonlyArray<string> {
    method filterGlobalExtensions (line 215) | public filterGlobalExtensions(names: string[] | undefined): string[] {
    method update (line 246) | private update(key: keyof PackageJson, value: any): void {
    method jsonFile (line 252) | private get jsonFile(): string {
  function toInterval (line 257) | function toInterval(opt: string): number {
  function validExtensionFolder (line 261) | function validExtensionFolder(folder: string, version: string): boolean {
  function getEntryFile (line 267) | function getEntryFile(main: string | undefined): string {
  function loadGlobalJsonAsync (line 273) | async function loadGlobalJsonAsync(folder: string, version: string): Pro...
  function loadExtensionJson (line 290) | function loadExtensionJson(folder: string, version: string, errors: stri...
  function getExtensionName (line 324) | function getExtensionName(def: string): string {
  function checkExtensionRoot (line 330) | function checkExtensionRoot(root: string): boolean {
  function getJsFiles (line 352) | async function getJsFiles(folder: string): Promise<string[]> {
  function loadJson (line 358) | function loadJson(filepath: string): object {

FILE: src/extension/ui.ts
  type State (line 14) | enum State {
  type InstallSettings (line 21) | interface InstallSettings {
  type InstallUI (line 26) | interface InstallUI {
  class InstallChannel (line 33) | class InstallChannel implements InstallUI {
    method constructor (line 34) | constructor(private settings: InstallSettings, private channel: Output...
    method isUpdate (line 37) | private get isUpdate(): boolean {
    method getText (line 41) | public getText(): string {
    method start (line 45) | public start(names: string[]): void {
    method addMessage (line 49) | public addMessage(name: string, msg: string, isProgress?: boolean): vo...
    method startProgress (line 55) | public startProgress(name: string): void {
    method finishProgress (line 59) | public finishProgress(name: string, succeed?: boolean): void {
  class InstallBuffer (line 70) | class InstallBuffer implements InstallUI {
    method constructor (line 79) | constructor(private settings: InstallSettings) {
    method start (line 100) | public async start(names: string[]): Promise<void> {
    method addMessage (line 109) | public addMessage(name: string, msg: string): void {
    method startProgress (line 117) | public startProgress(name: string): void {
    method finishProgress (line 121) | public finishProgress(name: string, succeed?: boolean): void {
    method remains (line 125) | public get remains(): number {
    method getLinesAndHighlights (line 136) | private getLinesAndHighlights(start: number): { lines: string[], highl...
    method getMessages (line 172) | public getMessages(line: number): string[] {
    method stopped (line 177) | public get stopped(): boolean {
    method isUpdate (line 181) | private get isUpdate(): boolean {
    method draw (line 186) | public draw(): void {
    method highlight (line 203) | private highlight(): void {
    method show (line 210) | private async show(): Promise<void> {
    method dispose (line 226) | public dispose(): void {

FILE: src/handler/callHierarchy.ts
  type CallHierarchyDataItem (line 20) | interface CallHierarchyDataItem extends CallHierarchyItem {
  type CallHierarchyConfig (line 27) | interface CallHierarchyConfig {
  type ShowHierarchyAction (line 33) | enum ShowHierarchyAction {
  type CallHierarchyProvider (line 38) | interface CallHierarchyProvider extends TreeDataProvider<CallHierarchyDa...
  function toCallHierarchyItem (line 46) | function toCallHierarchyItem(item: CallHierarchyDataItem): CallHierarchy...
  function isCallHierarchyItem (line 50) | function isCallHierarchyItem(item: any): item is CallHierarchyItem {
  constant HIGHLIGHT_GROUP (line 55) | const HIGHLIGHT_GROUP = 'CocSelectedRange'
  class CallHierarchyHandler (line 57) | class CallHierarchyHandler {
    method constructor (line 62) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method loadConfiguration (line 108) | private loadConfiguration(e?: IConfigurationChangeEvent): void {
    method createProvider (line 119) | private createProvider(rootItems: CallHierarchyDataItem[], doc: TextDo...
    method getChildren (line 140) | private async getChildren(doc: TextDocument, item: CallHierarchyDataIt...
    method prepare (line 153) | private async prepare(doc: TextDocument, position: Position, token: Ca...
    method getCallHierarchyItems (line 161) | private async getCallHierarchyItems(item: CallHierarchyItem | undefine...
    method getIncoming (line 174) | public async getIncoming(item?: CallHierarchyItem): Promise<CallHierar...
    method getOutgoing (line 178) | public async getOutgoing(item?: CallHierarchyItem): Promise<CallHierar...
    method showCallHierarchyTree (line 182) | public async showCallHierarchyTree(kind: 'incoming' | 'outgoing'): Pro...
    method dispose (line 208) | public dispose(): void {
  function getTitle (line 214) | function getTitle(kind: string): string {

FILE: src/handler/codeActions.ts
  class CodeActions (line 21) | class CodeActions {
    method constructor (line 22) | constructor(
    method executeCodeActions (line 37) | public async executeCodeActions(doc: Document, range: Range | undefine...
    method codeActionRange (line 71) | public async codeActionRange(start: number, end: number, only?: string...
    method organizeImport (line 87) | public async organizeImport(): Promise<boolean> {
    method getCodeActions (line 98) | public async getCodeActions(doc: Document, range?: Range, only?: CodeA...
    method floatActions (line 123) | private get floatActions(): boolean {
    method doCodeAction (line 127) | public async doCodeAction(mode: string | null, only: CodeActionKind[] ...
    method getCurrentCodeActions (line 166) | public async getCurrentCodeActions(mode?: string, only?: CodeActionKin...
    method doQuickfix (line 177) | public async doQuickfix(): Promise<void> {
    method applyCodeAction (line 187) | public async applyCodeAction(action: CodeAction, token?: CancellationT...
  function shouldAutoApply (line 200) | function shouldAutoApply(only: CodeActionKind[] | string | undefined): b...
  function isQuickfix (line 208) | function isQuickfix(codeAction: CodeAction): boolean {

FILE: src/handler/codelens/buffer.ts
  type CodeLensInfo (line 20) | interface CodeLensInfo {
  type CodeLensConfig (line 25) | interface CodeLensConfig {
  type TextAlign (line 33) | enum TextAlign {
  constant CODELENS_HL (line 42) | const CODELENS_HL = 'CocCodeLens'
  constant NORMAL_HL (line 43) | const NORMAL_HL = 'Normal'
  class CodeLensBuffer (line 48) | class CodeLensBuffer implements SyncItem {
    method constructor (line 55) | constructor(
    method config (line 68) | public get config(): CodeLensConfig {
    method loadConfiguration (line 74) | public loadConfiguration(): void {
    method toggleDisplay (line 85) | public async toggleDisplay(): Promise<void> {
    method bufnr (line 97) | public get bufnr(): number {
    method onChange (line 101) | public onChange(e: DidChangeTextDocumentParams): void {
    method currentCodeLens (line 111) | public get currentCodeLens(): CodeLens[] | undefined {
    method hasProvider (line 115) | private get hasProvider(): boolean {
    method forceFetch (line 119) | public async forceFetch(): Promise<void> {
    method fetchCodeLenses (line 126) | public async fetchCodeLenses(): Promise<void> {
    method _resolveCodeLenses (line 155) | private async _resolveCodeLenses(): Promise<void> {
    method isChanged (line 185) | private get isChanged(): boolean {
    method setVirtualText (line 194) | private setVirtualText(codeLenses: CodeLens[]): void {
    method clear (line 235) | public clear(start = 0, end = -1): void {
    method doAction (line 241) | public async doAction(line: number): Promise<void> {
    method cancelFetch (line 251) | private cancelFetch(): void {
    method cancelResolve (line 259) | private cancelResolve(): void {
    method cancel (line 266) | private cancel(): void {
    method abandonResult (line 272) | public abandonResult(): void {
    method dispose (line 276) | public dispose(): void {
  function getTextAlign (line 282) | function getTextAlign(position: 'top' | 'eol' | 'right_align'): TextAlign {
  function getCommands (line 289) | function getCommands(line: number, codeLenses: CodeLens[] | undefined): ...

FILE: src/handler/codelens/index.ts
  class CodeLensManager (line 19) | class CodeLensManager {
    method constructor (line 22) | constructor(private nvim: Neovim) {
    method toggle (line 62) | public async toggle(bufnr: number): Promise<void> {
    method checkProvider (line 74) | public async checkProvider(): Promise<void> {
    method doAction (line 80) | public async doAction(): Promise<void> {
    method dispose (line 86) | public dispose(): void {

FILE: src/handler/colors/colorBuffer.ts
  constant NAMESPACE (line 16) | const NAMESPACE = 'color'
  type ColorRanges (line 18) | interface ColorRanges {
  type ColorConfig (line 23) | interface ColorConfig {
  class ColorBuffer (line 30) | class ColorBuffer implements SyncItem {
    method constructor (line 36) | constructor(
    method enable (line 47) | public get enable(): boolean {
    method updateDocumentConfig (line 53) | public updateDocumentConfig(): void {
    method toggle (line 65) | public toggle(): void {
    method hasProvider (line 75) | private get hasProvider(): boolean {
    method enabled (line 79) | public get enabled(): boolean {
    method onChange (line 87) | public onChange(): void {
    method buffer (line 92) | public get buffer(): Buffer {
    method colors (line 96) | public get colors(): ColorInformation[] {
    method hasColor (line 100) | public hasColor(): boolean {
    method doHighlight (line 104) | public async doHighlight(): Promise<void> {
    method defineColors (line 128) | private defineColors(colors: ColorInformation[]): void {
    method hasColorAtPosition (line 138) | public hasColorAtPosition(position: Position): boolean {
    method clearHighlight (line 142) | public clearHighlight(): void {
    method cancel (line 148) | public cancel(): void {
    method dispose (line 155) | public dispose(): void {
  function getHighlightGroup (line 162) | function getHighlightGroup(color: Color): string {

FILE: src/handler/colors/index.ts
  class Colors (line 17) | class Colors {
    method constructor (line 22) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method loadConfiguration (line 66) | private loadConfiguration(e?: IConfigurationChangeEvent): void {
    method pickPresentation (line 81) | public async pickPresentation(): Promise<void> {
    method pickColor (line 99) | public async pickColor(): Promise<void> {
    method isEnabled (line 120) | public isEnabled(bufnr: number): boolean {
    method clearHighlight (line 125) | public clearHighlight(bufnr: number): void {
    method hasColor (line 130) | public hasColor(bufnr: number): boolean {
    method hasColorAtPosition (line 136) | public hasColorAtPosition(bufnr: number, position: Position): boolean {
    method highlightAll (line 142) | public highlightAll(): void {
    method doHighlight (line 148) | public async doHighlight(bufnr: number): Promise<void> {
    method getColorInformation (line 153) | public async getColorInformation(bufnr: number): Promise<ColorInformat...
    method dispose (line 169) | public dispose(): void {

FILE: src/handler/commands.ts
  function validCommand (line 8) | function validCommand(command: any): boolean {
  class Commands (line 12) | class Commands {
    method constructor (line 13) | constructor(private nvim: Neovim) {
    method addVimCommand (line 19) | public addVimCommand(cmd: { id: string; cmd: string; title?: string })...
    method getCommandList (line 29) | public getCommandList(): string[] {
    method repeat (line 33) | public async repeat(): Promise<void> {
    method runCommand (line 37) | public async runCommand(id?: string, ...args: any[]): Promise<unknown> {

FILE: src/handler/fold.ts
  class FoldHandler (line 7) | class FoldHandler {
    method constructor (line 8) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method fold (line 11) | public async fold(kind?: FoldingRangeKind): Promise<boolean> {

FILE: src/handler/format.ts
  type FormatPreferences (line 18) | interface FormatPreferences {
  class FormatHandler (line 24) | class FormatHandler {
    method constructor (line 26) | constructor(
    method setConfiguration (line 58) | private setConfiguration(e?: IConfigurationChangeEvent): void {
    method shouldFormatOnType (line 70) | public shouldFormatOnType(filetype: string): boolean {
    method tryFormatOnType (line 75) | public async tryFormatOnType(ch: string, doc: Document): Promise<boole...
    method formatCurrentBuffer (line 98) | public async formatCurrentBuffer(): Promise<boolean> {
    method formatCurrentRange (line 103) | public async formatCurrentRange(mode: string): Promise<number> {
    method documentFormat (line 108) | public async documentFormat(doc: Document): Promise<boolean> {
    method handleEnter (line 125) | public async handleEnter(bufnr: number): Promise<void> {
    method logProvider (line 161) | public logProvider(bufnr: number, edits: TextEdit[] | undefined): void {
    method documentRangeFormat (line 167) | public async documentRangeFormat(doc: Document, mode?: string): Promis...

FILE: src/handler/highlights.ts
  type HighlightConfig (line 16) | interface HighlightConfig {
  class Highlights (line 26) | class Highlights {
    method constructor (line 32) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method loadConfiguration (line 56) | private loadConfiguration(e?: IConfigurationChangeEvent): void {
    method isEnabled (line 67) | public isEnabled(bufnr: number, cursors: number): boolean {
    method clearHighlights (line 74) | public clearHighlights(): void {
    method highlight (line 83) | public async highlight(): Promise<void> {
    method jumpSymbol (line 110) | public async jumpSymbol(direction: 'previous' | 'next'): Promise<void> {
    method getSymbolsRanges (line 133) | public async getSymbolsRanges(): Promise<Range[]> {
    method hasHighlights (line 143) | public hasHighlights(winid: number): boolean {
    method getHighlights (line 147) | public async getHighlights(doc: Document, position: Position): Promise...
    method cancel (line 163) | private cancel(): void {
    method dispose (line 171) | public dispose(): void {

FILE: src/handler/hover.ts
  type HoverConfig (line 21) | interface HoverConfig {
  type HoverLocation (line 28) | interface HoverLocation {
  class HoverHandler (line 36) | class HoverHandler {
    method constructor (line 43) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method registerProvider (line 56) | private registerProvider(): void {
    method loadConfiguration (line 75) | private loadConfiguration(e?: IConfigurationChangeEvent): void {
    method onHover (line 90) | public async onHover(hoverTarget?: HoverTarget): Promise<boolean> {
    method definitionHover (line 112) | public async definitionHover(hoverTarget: HoverTarget): Promise<boolea...
    method previewHover (line 140) | private async previewHover(hovers: (Hover | Documentation)[], target?:...
    method getHover (line 190) | public async getHover(loc?: HoverLocation): Promise<string[]> {
    method dispose (line 224) | public dispose(): void {
  function addDefinitions (line 230) | async function addDefinitions(hovers: (Hover | Documentation)[], definit...
  function addDocument (line 245) | function addDocument(docs: Documentation[], text: string, filetype: stri...
  function isDocumentation (line 254) | function isDocumentation(obj: any): obj is Documentation {
  function readLines (line 259) | async function readLines(uri: string, start: number, end: number): Promi...

FILE: src/handler/index.ts
  type CurrentState (line 46) | interface CurrentState {
  class Handler (line 54) | class Handler implements HandlerDelegate {
    method constructor (line 82) | constructor(private nvim: Neovim) {
    method registerCommands (line 130) | private registerCommands(): void {
    method register (line 188) | private register<T>(key, handler: (...args: any[]) => T | Promise<T>):...
    method requestStatusItem (line 192) | private get requestStatusItem(): StatusBarItem {
    method labels (line 198) | private get labels(): { [key: string]: string } {
    method uri (line 203) | public get uri(): string | undefined {
    method getCurrentState (line 207) | public async getCurrentState(): Promise<CurrentState> {
    method addDisposable (line 219) | public addDisposable(disposable: Disposable): void {
    method checkProvider (line 226) | public checkProvider(id: ProviderName, document: TextDocumentMatch): v...
    method withRequestToken (line 232) | public async withRequestToken<T>(name: string, fn: (token: Cancellatio...
    method getIcon (line 271) | public getIcon(kind: SymbolKind): { text: string, hlGroup: string } {
    method getCodeActions (line 283) | public async getCodeActions(doc: Document, range?: Range, only?: CodeA...
    method applyCodeAction (line 288) | public async applyCodeAction(action: CodeAction): Promise<void> {
    method hasProvider (line 292) | public async hasProvider(id: string, bufnr?: number): Promise<boolean> {
    method dispose (line 299) | public dispose(): void {

FILE: src/handler/inlayHint/buffer.ts
  type InlayHintConfig (line 20) | interface InlayHintConfig {
  type VirtualTextItem (line 30) | interface VirtualTextItem extends VirtualTextOption {
  type InlayHintPosition (line 41) | enum InlayHintPosition {
  type RenderConfig (line 46) | interface RenderConfig {
  function getHighlightGroup (line 55) | function getHighlightGroup(kind: InlayHintKind): string {
  class InlayHintBuffer (line 70) | class InlayHintBuffer implements SyncItem {
    method constructor (line 80) | constructor(
    method config (line 87) | public get config(): InlayHintConfig {
    method loadConfiguration (line 93) | public loadConfiguration(): void {
    method onInsertLeave (line 117) | public onInsertLeave(): void {
    method onInsertEnter (line 122) | public onInsertEnter(): void {
    method current (line 128) | public get current(): ReadonlyArray<InlayHintWithProvider> {
    method enabled (line 132) | public get enabled(): boolean {
    method hasProvider (line 137) | private get hasProvider(): boolean {
    method configEnabled (line 141) | public get configEnabled(): boolean {
    method enable (line 147) | public enable() {
    method disable (line 153) | public disable() {
    method checkState (line 160) | private checkState(): void {
    method toggle (line 165) | public toggle(): void {
    method clearCache (line 173) | public clearCache(): void {
    method onTextChange (line 179) | public onTextChange(): void {
    method onChange (line 183) | public onChange(): void {
    method cancel (line 187) | public cancel(): void {
    method onVisible (line 194) | public onVisible(winid: number, region: Readonly<[number, number]>): v...
    method render (line 204) | public async render(config?: RenderConfig, delay?: number): Promise<vo...
    method renderAll (line 228) | private async renderAll(token: CancellationToken): Promise<void> {
    method renderRange (line 242) | public async renderRange(lines: [number, number], token: CancellationT...
    method request (line 255) | private async request(range: Range, token: CancellationToken): Promise...
    method setVirtualText (line 273) | public setVirtualText(range: Range, inlayHints: InlayHintWithProvider[...
    method clearVirtualText (line 320) | public clearVirtualText(): void {
    method dispose (line 324) | public dispose(): void {

FILE: src/handler/inlayHint/index.ts
  type StateMethods (line 14) | type StateMethods = 'enable' | 'disable' | 'toggle'
  class InlayHintHandler (line 16) | class InlayHintHandler {
    method constructor (line 19) | constructor(nvim: Neovim, handler: HandlerDelegate) {
    method setState (line 74) | public setState(method: StateMethods, bufnr?: number): void {
    method getItem (line 85) | public getItem(bufnr: number): InlayHintBuffer {

FILE: src/handler/inline.ts
  constant NAMESPACE (line 22) | const NAMESPACE = 'inlineSuggest'
  type InlineSuggestOption (line 24) | interface InlineSuggestOption {
  type InlineSuggestConfig (line 30) | interface InlineSuggestConfig {
  type AcceptKind (line 35) | type AcceptKind = 'all' | 'word' | 'line'
  function formatInsertText (line 37) | function formatInsertText(text: string, opts: FormattingOptions): string {
  function getInsertText (line 55) | function getInsertText(item: InlineCompletionItem, formatOptions: Format...
  function getInserted (line 64) | function getInserted(curr: string, synced: string, character: number): {...
  function getPumInserted (line 73) | function getPumInserted(document: Document, cursor: Position): string | ...
  function checkInsertedAtBeginning (line 82) | function checkInsertedAtBeginning(currentLine: string, triggerCharacter:...
  function fixRange (line 98) | function fixRange(range: Range | undefined, inserted: string | undefined...
  class InlineSession (line 103) | class InlineSession {
    method constructor (line 104) | constructor(
    method length (line 113) | public get length(): number {
    method selected (line 117) | public get selected(): InlineCompletionItem | undefined {
    method clearNamespace (line 121) | public clearNamespace(): void {
    method extra (line 128) | public get extra(): string {
    method nextIndex (line 132) | public get nextIndex(): number {
    method prevIndex (line 136) | public get prevIndex(): number {
  class InlineCompletion (line 141) | class InlineCompletion {
    method constructor (line 150) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method loadConfiguration (line 221) | private loadConfiguration(e?: IConfigurationChangeEvent): void {
    method supported (line 233) | public get supported(): boolean {
    method selected (line 237) | public get selected(): InlineCompletionItem | undefined {
    method visible (line 241) | public async visible(): Promise<boolean> {
    method vtextBufnr (line 246) | public get vtextBufnr(): number {
    method trigger (line 250) | public async trigger(bufnr: number, option?: InlineSuggestOption, dela...
    method accept (line 306) | public async accept(bufnr: number, kind: AcceptKind = 'all'): Promise<...
    method next (line 360) | public async next(bufnr: number): Promise<void> {
    method prev (line 364) | public async prev(bufnr: number): Promise<void> {
    method _navigate (line 368) | private async _navigate(next: boolean, bufnr: number): Promise<void> {
    method insertVtext (line 375) | public async insertVtext(item: InlineCompletionItem): Promise<void> {
    method cancel (line 408) | public cancel(): void {
    method dispose (line 421) | public dispose(): void {

FILE: src/handler/linkedEditing.ts
  class LinkedEditingHandler (line 21) | class LinkedEditingHandler {
    method constructor (line 29) | constructor(private nvim: Neovim, handler: HandlerDelegate) {
    method cancelEdit (line 58) | private cancelEdit(): void {
    method onChange (line 65) | public async onChange(e: DidChangeTextDocumentParams): Promise<void> {
    method applySingleEdit (line 92) | private async applySingleEdit(textRange: TextRange, edit: TextEdit): P...
    method doHighlights (line 115) | private doHighlights(): void {
    method _checkPosition (line 125) | private _checkPosition(bufnr: number, cursor: [number, number]): void {
    method enable (line 142) | public async enable(doc: Document, position: Position): Promise<void> {
    method cancel (line 157) | private cancel(): void {

FILE: src/handler/links.ts
  constant NAMESPACE (line 23) | const NAMESPACE = 'links'
  type LinkConfig (line 26) | interface LinkConfig {
  class Links (line 31) | class Links implements Disposable {
    method constructor (line 36) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method setConfiguration (line 58) | private setConfiguration(e?: IConfigurationChangeEvent): void {
    method showTooltip (line 69) | public async showTooltip(): Promise<void> {
    method getLinks (line 80) | public async getLinks(): Promise<ReadonlyArray<DocumentLink>> {
    method getCurrentLink (line 87) | public async getCurrentLink(): Promise<DocumentLink | undefined> {
    method openCurrentLink (line 117) | public async openCurrentLink(): Promise<boolean> {
    method openLink (line 126) | public async openLink(link: DocumentLink): Promise<void> {
    method getBuffer (line 131) | public getBuffer(bufnr: number): LinkBuffer | undefined {
    method cancel (line 135) | private cancel(): void {
    method dispose (line 142) | public dispose(): void {
  class LinkBuffer (line 147) | class LinkBuffer implements SyncItem {
    method constructor (line 154) | constructor(public readonly doc: Document) {
    method config (line 161) | public get config(): LinkConfig {
    method hasProvider (line 167) | private get hasProvider(): boolean {
    method updateDocumentConfig (line 171) | public updateDocumentConfig(): void {
    method onChange (line 179) | public onChange(e: DidChangeTextDocumentParams): void {
    method highlight (line 188) | public highlight(): void {
    method clearHighlight (line 202) | public clearHighlight(): void {
    method buffer (line 206) | public get buffer(): Buffer {
    method cancel (line 210) | public cancel(): void {
    method getLinks (line 218) | public async getLinks(): Promise<void> {
    method dispose (line 232) | public dispose(): void {
  function sameLinks (line 237) | function sameLinks(links: ReadonlyArray<DocumentLink>, other: ReadonlyAr...

FILE: src/handler/locations.ts
  type TagDefinition (line 16) | interface TagDefinition {
  type RequestFunc (line 22) | type RequestFunc<T> = (doc: TextDocument, position: Position, token: Can...
  class LocationsHandler (line 24) | class LocationsHandler {
    method constructor (line 25) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method request (line 28) | private async request<T>(method: ProviderName, fn: RequestFunc<T>): Pr...
    method definitions (line 37) | public async definitions(): Promise<Location[]> {
    method declarations (line 45) | public async declarations(): Promise<Location | Location[] | LocationL...
    method typeDefinitions (line 53) | public async typeDefinitions(): Promise<Location[]> {
    method implementations (line 61) | public async implementations(): Promise<Location[]> {
    method references (line 69) | public async references(excludeDeclaration?: boolean): Promise<Locatio...
    method gotoDefinition (line 77) | public async gotoDefinition(openCommand?: string | false): Promise<boo...
    method gotoDeclaration (line 85) | public async gotoDeclaration(openCommand?: string | false): Promise<bo...
    method gotoTypeDefinition (line 93) | public async gotoTypeDefinition(openCommand?: string | false): Promise...
    method gotoImplementation (line 101) | public async gotoImplementation(openCommand?: string | false): Promise...
    method gotoReferences (line 109) | public async gotoReferences(openCommand?: string | false, includeDecla...
    method getTagList (line 117) | public async getTagList(): Promise<TagDefinition[] | null> {
    method findLocations (line 153) | public async findLocations(id: string, method: string, params: any, op...
    method toLocations (line 166) | public toLocations(location: Location | LocationLink | Location[] | Lo...
    method handleLocations (line 214) | public async handleLocations(locations: LocationWithTarget[] | null | ...

FILE: src/handler/refactor/buffer.ts
  constant SEPARATOR (line 25) | const SEPARATOR = '\u3000'
  type LineChange (line 27) | interface LineChange {
  type FileRangeInfo (line 33) | interface FileRangeInfo {
  type FileChange (line 40) | interface FileChange extends FileRangeInfo {
  type FileRange (line 47) | interface FileRange {
  type FileRangeDef (line 57) | type FileRangeDef = Optional<FileRange, 'lines' | 'lnum'> & { end?: numb...
  type FileItem (line 59) | interface FileItem {
  type FileItemDef (line 64) | interface FileItemDef {
  type RefactorConfig (line 69) | interface RefactorConfig {
  type RefactorBufferOpts (line 77) | interface RefactorBufferOpts {
  class RefactorBuffer (line 83) | class RefactorBuffer {
    method constructor (line 91) | constructor(
    method showMenu (line 106) | public async showMenu(): Promise<void> {
    method fileItems (line 123) | public get fileItems(): FileItem[] {
    method getFileItem (line 127) | public getFileItem(uri: string): FileItem | undefined {
    method getFileRange (line 132) | public getFileRange(lnum: number): FileRange & { filepath: string } {
    method onChange (line 143) | public onChange(e: DidChangeTextDocumentParams): void {
    method diffChanges (line 216) | private diffChanges(original: string, text: string): TextEdit[] {
    method onDocumentChange (line 246) | private async onDocumentChange(e: DidChangeTextDocumentParams): Promis...
    method adjustLnums (line 296) | private adjustLnums(edits: TextEdit[]): void {
    method getFileChanges (line 308) | public async getFileChanges(): Promise<FileRangeInfo[]> {
    method splitOpen (line 346) | public async splitOpen(): Promise<void> {
    method searchCurrentRange (line 370) | public async searchCurrentRange(): Promise<FileRange & { filepath: str...
    method addFileItems (line 388) | public async addFileItems(items: FileItemDef[]): Promise<void> {
    method findRange (line 451) | public findRange(filepath: string, lnum: number): FileRange {
    method save (line 461) | public async save(): Promise<boolean> {
    method getLines (line 515) | private async getLines(fsPath: string, start: number, end: number): Pr...
    method getAbsolutePath (line 522) | private getAbsolutePath(filepath: string): string {
    method highlightLineNr (line 530) | private highlightLineNr(): void {
    method getDeleteRange (line 569) | public getDeleteRange(r: FileRange): Range {
    method getReplaceRange (line 592) | public getReplaceRange(r: FileRange): Range {
    method valid (line 612) | public get valid(): Promise<boolean> {
    method buffer (line 616) | public get buffer(): Buffer {
    method document (line 620) | public get document(): Document | null {
    method dispose (line 624) | public dispose(): void {
  function adjustRange (line 630) | function adjustRange(range: Range, offset: number): Range {
  function fixChangeParams (line 635) | function fixChangeParams(e: DidChangeTextDocumentParams): DidChangeTextD...

FILE: src/handler/refactor/changes.ts
  type LineInfo (line 4) | interface LineInfo {
  type DeleteChange (line 12) | type DeleteChange = Map<number, LineInfo>
  class Changes (line 14) | class Changes {
    method add (line 17) | public add(infos: LineInfo[]): void {
    method checkInsert (line 25) | public checkInsert(lnums: number[]): LineInfo[] | undefined {

FILE: src/handler/refactor/index.ts
  class Refactor (line 22) | class Refactor {
    method constructor (line 28) | constructor(
    method has (line 47) | public has(bufnr: number): boolean {
    method setConfiguration (line 51) | private setConfiguration(e?: IConfigurationChangeEvent): void {
    method doRefactor (line 66) | public async doRefactor(): Promise<void> {
    method search (line 89) | public async search(args: string[]): Promise<void> {
    method save (line 96) | public async save(bufnr: number): Promise<boolean> {
    method getBuffer (line 101) | public getBuffer(bufnr: number): RefactorBuffer {
    method createRefactorBuffer (line 108) | public async createRefactorBuffer(filetype?: string, conceal = false):...
    method fromLines (line 137) | public async fromLines(lines: string[]): Promise<RefactorBuffer> {
    method fromLocations (line 146) | public async fromLocations(locations: Location[], filetype?: string): ...
    method fromWorkspaceEdit (line 161) | public async fromWorkspaceEdit(edit: WorkspaceEdit, filetype?: string)...
    method getLineCount (line 208) | private async getLineCount(uri: string): Promise<number> {
    method reset (line 214) | public reset(): void {
    method dispose (line 221) | public dispose(): void {
  function adjustRange (line 228) | function adjustRange(range: Range, offset: number): Range {

FILE: src/handler/refactor/search.ts
  class Task (line 20) | class Task extends EventEmitter {
    method start (line 22) | public start(cmd: string, args: string[], cwd: string): void {
    method dispose (line 87) | public dispose(): void {
  class Search (line 94) | class Search {
    method constructor (line 96) | constructor(private nvim: Neovim, private cmd = 'rg') {
    method run (line 99) | public run(args: string[], cwd: string, refactorBuf: RefactorBuffer): ...
    method abort (line 181) | public abort(): void {
  function getPathFromArgs (line 187) | function getPathFromArgs(args: string[]): string | undefined {

FILE: src/handler/rename.ts
  class Rename (line 11) | class Rename {
    method constructor (line 12) | constructor(
    method getWordEdit (line 17) | public async getWordEdit(): Promise<WorkspaceEdit> {
    method rename (line 41) | public async rename(newName?: string): Promise<boolean> {

FILE: src/handler/selectionRange.ts
  class SelectionRangeHandler (line 11) | class SelectionRangeHandler {
    method constructor (line 13) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method getSelectionRanges (line 16) | public async getSelectionRanges(): Promise<SelectionRange[] | null> {
    method selectRange (line 25) | public async selectRange(visualmode: string, forward: boolean): Promis...

FILE: src/handler/semanticTokens/buffer.ts
  constant HLGROUP_PREFIX (line 22) | const HLGROUP_PREFIX = 'CocSem'
  constant NAMESPACE (line 23) | const NAMESPACE = 'semanticTokens'
  type TokenRange (line 25) | type TokenRange = [number, number, number] // line, startCol, endCol
  type SemanticTokensConfig (line 27) | interface SemanticTokensConfig {
  type SemanticTokenRange (line 34) | interface SemanticTokenRange {
  type SemanticTokensPreviousResult (line 42) | interface SemanticTokensPreviousResult {
  type RangeHighlights (line 48) | interface RangeHighlights {
  type StaticConfig (line 65) | interface StaticConfig {
  class SemanticTokensBuffer (line 69) | class SemanticTokensBuffer implements SyncItem {
    method constructor (line 80) | constructor(private nvim: Neovim, public readonly doc: Document, priva...
    method config (line 84) | public get config(): SemanticTokensConfig {
    method loadConfiguration (line 90) | public loadConfiguration(): void {
    method configEnabled (line 108) | public get configEnabled(): boolean {
    method bufnr (line 116) | public get bufnr(): number {
    method onChange (line 120) | public onChange(): void {
    method onTextChange (line 125) | public onTextChange(): void {
    method forceHighlight (line 130) | public async forceHighlight(): Promise<void> {
    method onShown (line 135) | public async onShown(winid: number): Promise<void> {
    method onWinScroll (line 140) | public async onWinScroll(winid: number): Promise<void> {
    method onCursorHold (line 157) | public async onCursorHold(winid: number, lnum: number): Promise<void> {
    method hasProvider (line 171) | public get hasProvider(): boolean {
    method hasLegend (line 176) | private get hasLegend(): boolean {
    method rangeProviderOnly (line 181) | public get rangeProviderOnly(): boolean {
    method shouldRangeHighlight (line 186) | public get shouldRangeHighlight(): boolean {
    method highlights (line 194) | public get highlights(): SemanticTokenRange[] | undefined {
    method buffer (line 199) | private get buffer(): Buffer {
    method enabled (line 203) | public get enabled(): boolean {
    method shouldHighlight (line 208) | private get shouldHighlight(): boolean {
    method checkState (line 215) | public checkState(): void {
    method getTokenRanges (line 220) | public async getTokenRanges(
    method addHighlightItems (line 258) | private addHighlightItems(highlights: SemanticTokenRange[], range: [nu...
    method toHighlightItems (line 288) | private toHighlightItems(highlights: ReadonlyArray<SemanticTokenRange>...
    method doHighlight (line 312) | public async doHighlight(forceFull = false, wait: number = debounceInt...
    method addHighlights (line 363) | private async addHighlights(highlights: ReadonlyArray<SemanticTokenRan...
    method sendRequest (line 379) | private async sendRequest<R>(fn: () => Promise<R>, token: Cancellation...
    method doRangeHighlight (line 398) | public async doRangeHighlight(winid: number, span: [number, number] | ...
    method highlightRegions (line 423) | public async highlightRegions(winid: number | undefined, token: Cancel...
    method requestRangeHighlights (line 437) | public async requestRangeHighlights(winid: number, span: [number, numb...
    method requestAllHighlights (line 461) | public async requestAllHighlights(token: CancellationToken, forceFull:...
    method clearHighlight (line 487) | public clearHighlight(): void {
    method onProviderChange (line 492) | public onProviderChange(): void {
    method cancel (line 502) | public cancel(rangeOnly = false): void {
    method reset (line 515) | private reset(): void {
    method dispose (line 522) | public dispose(): void {
  function toHighlightPart (line 529) | function toHighlightPart(token: string): string {

FILE: src/handler/semanticTokens/index.ts
  class SemanticTokens (line 20) | class SemanticTokens {
    method constructor (line 25) | constructor(private nvim: Neovim) {
    method setStaticConfiguration (line 94) | public setStaticConfiguration(): void {
    method inspectSemanticToken (line 99) | public async inspectSemanticToken(): Promise<void> {
    method closeFloat (line 152) | public closeFloat(): void {
    method getCurrentItem (line 156) | public async getCurrentItem(): Promise<SemanticTokensBuffer | undefine...
    method getItem (line 161) | public getItem(bufnr: number): SemanticTokensBuffer | undefined {
    method highlightCurrent (line 167) | public async highlightCurrent(): Promise<void> {
    method showHighlightInfo (line 176) | public async showHighlightInfo(): Promise<void> {
    method dispose (line 225) | public dispose(): void {

FILE: src/handler/signature.ts
  type SignatureConfig (line 19) | interface SignatureConfig {
  type SignaturePosition (line 28) | interface SignaturePosition {
  type SignaturePart (line 34) | interface SignaturePart {
  class Signature (line 41) | class Signature {
    method constructor (line 48) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method shouldAutoTrigger (line 84) | public shouldAutoTrigger(bufnr: number, character: string): boolean {
    method checkCursor (line 91) | private checkCursor(bufnr: number, cursor: [number, number]): void {
    method loadConfiguration (line 105) | public loadConfiguration(e?: IConfigurationChangeEvent): void {
    method triggerSignatureHelp (line 120) | public async triggerSignatureHelp(): Promise<boolean> {
    method _triggerSignatureHelp (line 126) | private async _triggerSignatureHelp(doc: Document, position: Position,...
    method showSignatureHelp (line 163) | private async showSignatureHelp(doc: Document, position: Position, sig...
    method echoSignature (line 219) | public echoSignature(signatureHelp: SignatureHelp): void {
    method dispose (line 278) | public dispose(): void {

FILE: src/handler/symbols/buffer.ts
  constant DEBEBOUNCE_INTERVAL (line 14) | const DEBEBOUNCE_INTERVAL = getConditionValue(500, 10)
  class SymbolsBuffer (line 16) | class SymbolsBuffer implements SyncItem {
    method constructor (line 24) | constructor(public readonly doc: Document, private autoUpdateBufnrs: S...
    method getSymbols (line 33) | public async getSymbols(): Promise<DocumentSymbol[]> {
    method onChange (line 44) | public onChange(e: DidChangeTextDocumentParams): void {
    method _fetchSymbols (line 52) | private async _fetchSymbols(): Promise<void> {
    method cancel (line 65) | public cancel(): void {
    method dispose (line 74) | public dispose(): void {

FILE: src/handler/symbols/index.ts
  class Symbols (line 20) | class Symbols {
    method constructor (line 26) | constructor(
    method autoUpdate (line 66) | public autoUpdate(bufnr: number): boolean {
    method labels (line 72) | public get labels(): { [key: string]: string } {
    method getWorkspaceSymbols (line 76) | public async getWorkspaceSymbols(input: string): Promise<WorkspaceSymb...
    method resolveWorkspaceSymbol (line 82) | public async resolveWorkspaceSymbol(symbolInfo: WorkspaceSymbol): Prom...
    method getDocumentSymbols (line 88) | public async getDocumentSymbols(bufnr?: number): Promise<SymbolInfo[] ...
    method getFunctionSymbol (line 100) | public async getFunctionSymbol(bufnr: number, position: Position): Pro...
    method getCurrentFunctionSymbol (line 124) | public async getCurrentFunctionSymbol(): Promise<string> {
    method selectSymbolRange (line 135) | public async selectSymbolRange(inner: boolean, visualmode: string, sup...
    method showOutline (line 175) | public async showOutline(keep?: number): Promise<void> {
    method hideOutline (line 179) | public async hideOutline(): Promise<void> {
    method hasOutline (line 183) | public hasOutline(bufnr: number): boolean {
    method dispose (line 187) | public dispose(): void {

FILE: src/handler/symbols/outline.ts
  type OutlineNode (line 19) | interface OutlineNode extends TreeNode {
  type OutlineConfig (line 25) | interface OutlineConfig {
  class SymbolsOutline (line 53) | class SymbolsOutline {
    method constructor (line 59) | constructor(
    method revealPosition (line 95) | private async revealPosition(bufnr: number, treeView: BasicTreeView<Ou...
    method loadConfiguration (line 102) | private loadConfiguration(e?: IConfigurationChangeEvent): void {
    method convertSymbolToNode (line 130) | private convertSymbolToNode(documentSymbol: DocumentSymbol, sortFn: (a...
    method setMessage (line 150) | private setMessage(bufnr: number, msg: string | undefined): void {
    method convertSymbols (line 158) | private convertSymbols(bufnr: number, symbols: DocumentSymbol[]): Outl...
    method onSymbolsUpdate (line 173) | public onSymbolsUpdate(bufnr: number, symbols: DocumentSymbol[]): void {
    method createProvider (line 178) | private createProvider(bufnr: number): BasicDataProvider<OutlineNode> {
    method getSortBy (line 258) | private getSortBy(bufnr: number): string {
    method showOutline (line 262) | private async showOutline(bufnr: number, tabId: number): Promise<Basic...
    method doPreview (line 336) | public async doPreview(bufnr: number, node: OutlineNode | undefined): ...
    method closePreview (line 354) | private closePreview(): void {
    method show (line 361) | public async show(keep?: number): Promise<void> {
    method has (line 384) | public has(bufnr: number): boolean {
    method hide (line 391) | public async hide(): Promise<void> {
    method dispose (line 397) | public dispose(): void {
  function getNodeByPosition (line 410) | function getNodeByPosition(position: Position, nodes: ReadonlyArray<Outl...

FILE: src/handler/symbols/util.ts
  type SymbolInfo (line 7) | interface SymbolInfo {
  function convertSymbols (line 21) | function convertSymbols(symbols: DocumentSymbol[]): SymbolInfo[] {
  function sortDocumentSymbols (line 29) | function sortDocumentSymbols(a: DocumentSymbol, b: DocumentSymbol): numb...
  function addDocumentSymbol (line 35) | function addDocumentSymbol(res: SymbolInfo[], sym: DocumentSymbol, level...

FILE: src/handler/typeHierarchy.ts
  type TypeHierarchyDataItem (line 20) | interface TypeHierarchyDataItem extends TypeHierarchyItem {
  type TypeHierarchyConfig (line 25) | interface TypeHierarchyConfig {
  type TypeHierarchyKind (line 31) | type TypeHierarchyKind = 'supertypes' | 'subtypes'
  type TypeHierarchyProvider (line 33) | interface TypeHierarchyProvider extends TreeDataProvider<TypeHierarchyDa...
  function toTypeHierarchyItem (line 41) | function toTypeHierarchyItem(item: TypeHierarchyDataItem): TypeHierarchy...
  class TypeHierarchyHandler (line 45) | class TypeHierarchyHandler {
    method constructor (line 51) | constructor(private nvim: Neovim, private handler: HandlerDelegate) {
    method loadConfiguration (line 72) | private loadConfiguration(e?: IConfigurationChangeEvent): void {
    method createProvider (line 83) | private createProvider(rootItems: TypeHierarchyDataItem[], winid: numb...
    method getChildren (line 106) | private async getChildren(item: TypeHierarchyDataItem, kind: TypeHiera...
    method prepare (line 117) | private async prepare(doc: TextDocument, position: Position): Promise<...
    method showTypeHierarchyTree (line 124) | public async showTypeHierarchyTree(kind: TypeHierarchyKind): Promise<v...
    method dispose (line 145) | public dispose(): void {
  function getTitle (line 151) | function getTitle(kind: TypeHierarchyKind): string {

FILE: src/handler/types.ts
  type CurrentState (line 7) | interface CurrentState {
  type HandlerDelegate (line 15) | interface HandlerDelegate {

FILE: src/handler/util.ts
  function toDocumentation (line 5) | function toDocumentation(doc: string | MarkupContent): Documentation {

FILE: src/handler/workspace.ts
  type RootPatterns (line 28) | interface RootPatterns {
  class WorkspaceHandler (line 34) | class WorkspaceHandler {
    method constructor (line 35) | constructor(
    method openLog (line 130) | public async openLog(): Promise<void> {
    method openLocalConfig (line 138) | public async openLocalConfig(): Promise<void> {
    method renameCurrent (line 166) | public async renameCurrent(): Promise<void> {
    method addWorkspaceFolder (line 179) | public addWorkspaceFolder(folder: string): void {
    method removeWorkspaceFolder (line 186) | public removeWorkspaceFolder(folder: string): void {
    method bufferCheck (line 193) | public async bufferCheck(): Promise<void> {
    method doAutocmd (line 224) | public async doAutocmd(id: number, args: any[]): Promise<void> {
    method getConfiguration (line 229) | public async getConfiguration(key: string): Promise<WorkspaceConfigura...
    method getRootPatterns (line 234) | public getRootPatterns(bufnr: number): RootPatterns | null {
    method ensureDocument (line 244) | public async ensureDocument(bufnr?: number): Promise<boolean> {
    method doKeymap (line 249) | public async doKeymap(key: string, defaultReturn = ''): Promise<string> {
    method snippetCheck (line 253) | public async snippetCheck(checkExpand: boolean, checkJump: boolean): P...
    method showInfo (line 265) | public async showInfo(): Promise<void> {

FILE: src/index.ts
  method nvim (line 74) | get nvim() {

FILE: src/language-client/callHierarchy.ts
  type PrepareCallHierarchySignature (line 11) | interface PrepareCallHierarchySignature {
  type CallHierarchyIncomingCallsSignature (line 15) | interface CallHierarchyIncomingCallsSignature {
  type CallHierarchyOutgoingCallsSignature (line 19) | interface CallHierarchyOutgoingCallsSignature {
  type CallHierarchyMiddleware (line 27) | interface CallHierarchyMiddleware {
  class CallHierarchyFeature (line 33) | class CallHierarchyFeature extends TextDocumentLanguageFeature<boolean |...
    method constructor (line 34) | constructor(client: FeatureClient<CallHierarchyMiddleware>) {
    method fillClientCapabilities (line 38) | public fillClientCapabilities(cap: ClientCapabilities): void {
    method initialize (line 44) | public initialize(capabilities: ServerCapabilities, documentSelector: ...
    method registerLanguageProvider (line 52) | protected registerLanguageProvider(options: CallHierarchyRegistrationO...

FILE: src/language-client/client.ts
  type ConnectionErrorHandler (line 75) | interface ConnectionErrorHandler {
  type ConnectionCloseHandler (line 79) | interface ConnectionCloseHandler {
  type ConnectionOptions (line 83) | interface ConnectionOptions {
  function createConnection (line 92) | function createConnection(input: MessageReader, output: MessageWriter, e...
  type RevealOutputChannelOn (line 132) | enum RevealOutputChannelOn {
  type HandleWorkDoneProgressSignature (line 140) | interface HandleWorkDoneProgressSignature {
  type HandleDiagnosticsSignature (line 144) | interface HandleDiagnosticsSignature {
  type _WorkspaceMiddleware (line 148) | interface _WorkspaceMiddleware {
  type WorkspaceMiddleware (line 153) | type WorkspaceMiddleware = _WorkspaceMiddleware & ConfigurationMiddlewar...
  type _WindowMiddleware (line 155) | interface _WindowMiddleware {
  type WindowMiddleware (line 159) | type WindowMiddleware = _WindowMiddleware
  type _Middleware (line 165) | interface _Middleware {
  type GeneralMiddleware (line 175) | interface GeneralMiddleware {
  type Middleware (line 192) | type Middleware = _Middleware & TextDocumentSynchronizationMiddleware & ...
  type LanguageClientOptions (line 202) | type LanguageClientOptions = {
  type ResolvedClientOptions (line 245) | type ResolvedClientOptions = {
  type State (line 274) | enum State {
  type StateChangeEvent (line 281) | interface StateChangeEvent {
  type ClientState (line 286) | enum ClientState {
  type MessageTransports (line 295) | interface MessageTransports {
  function is (line 303) | function is(value: any): value is MessageTransports {
  type ShutdownMode (line 313) | enum ShutdownMode {
  method constructor (line 364) | public constructor(
  method switchConsole (line 415) | public switchConsole(): void {
  method resolveClientOptions (line 420) | private resolveClientOptions(clientOptions: LanguageClientOptions): Reso...
  method createTextSynchronizationOptions (line 478) | private createTextSynchronizationOptions(options: LanguageClientOptions[...
  method supportedMarkupKind (line 485) | public get supportedMarkupKind(): MarkupKind[] {
  method state (line 490) | public get state(): State {
  method $state (line 494) | private get $state(): ClientState {
  method $state (line 498) | private set $state(value: ClientState) {
  method id (line 507) | public get id(): string {
  method name (line 511) | public get name(): string {
  method middleware (line 515) | public get middleware(): Middleware {
  method code2ProtocolConverter (line 519) | public get code2ProtocolConverter(): c2p.Converter {
  method getPublicState (line 523) | public getPublicState(): State {
  method initializeResult (line 536) | public get initializeResult(): InitializeResult | undefined {
  method sendRequest (line 546) | public async sendRequest<R>(type: string | MessageSignature, ...params: ...
  method onRequest (line 601) | public onRequest<R, E>(type: string | MessageSignature, handler: Generic...
  method sendNotification (line 643) | public async sendNotification<P>(type: string | MessageSignature, params...
  method onNotification (line 680) | public onNotification(type: string | MessageSignature, handler: GenericN...
  method onProgress (line 717) | public onProgress<P>(type: ProgressType<any>, token: string | number, ha...
  method sendProgress (line 759) | public async sendProgress<P>(type: ProgressType<P>, token: string | numb...
  method configuredSection (line 775) | public get configuredSection(): string | undefined {
  method clientOptions (line 780) | public get clientOptions(): ResolvedClientOptions {
  method onDidChangeState (line 784) | public get onDidChangeState(): Event<StateChangeEvent> {
  method outputChannel (line 788) | public get outputChannel(): OutputChannel {
  method traceOutputChannel (line 796) | public get traceOutputChannel(): OutputChannel {
  method diagnostics (line 800) | public get diagnostics(): DiagnosticCollection | undefined {
  method createDefaultErrorHandler (line 804) | public createDefaultErrorHandler(maxRestartCount?: number): ErrorHandler {
  method trace (line 808) | public set trace(value: Trace) {
  method consoleMessage (line 812) | private consoleMessage(message: string, error = false): void {
  method debug (line 819) | public debug(message: string, data?: any, showNotification = true): void {
  method info (line 823) | public info(message: string, data?: any, showNotification = true): void {
  method warn (line 827) | public warn(message: string, data?: any, showNotification = true): void {
  method error (line 831) | public error(message: string, data?: any, showNotification: boolean | 'f...
  method logOutputMessage (line 835) | private logOutputMessage(type: MessageType, reveal: RevealOutputChannelO...
  method traceObject (line 844) | private traceObject(data: any): void {
  method traceMessage (line 848) | public traceMessage(message: string, data?: any): void {
  method getLogMessage (line 854) | private getLogMessage(message: string, data?: any): string {
  method showNotificationMessage (line 858) | private showNotificationMessage(type: MessageType, message?: string, dat...
  method needsStart (line 877) | public needsStart(): boolean {
  method needsStop (line 885) | public needsStop(): boolean {
  method activeConnection (line 891) | private activeConnection(): Connection | undefined {
  method hasPendingResponse (line 895) | public get hasPendingResponse(): boolean {
  method onReady (line 899) | public onReady(): Promise<void> {
  method started (line 911) | public get started(): boolean {
  method isRunning (line 915) | public isRunning(): boolean {
  method _start (line 919) | public async _start(): Promise<void> {
  method start (line 978) | public start(): Promise<void> & Disposable {
  method $start (line 988) | private async $start(): Promise<Connection> {
  method handleConnectionEvents (line 1000) | private handleConnectionEvents(connection: Connection) {
  method createOnStartPromise (line 1087) | private createOnStartPromise(): [Promise<void>, () => void, (error: any)...
  method resolveRootPath (line 1097) | private resolveRootPath(): string | null {
  method initialize (line 1114) | private initialize(connection: Connection): Promise<InitializeResult> {
  method doInitialize (line 1151) | private async doInitialize(connection: Connection, initParams: Initializ...
  method stop (line 1239) | public stop(timeout = 2000): Promise<void> {
  method shutdown (line 1244) | protected async shutdown(mode: ShutdownMode, timeout: number): Promise<v...
  method dispose (line 1300) | public dispose(timeout = 2000): Promise<void> {
  method cleanUp (line 1311) | private cleanUp(mode: ShutdownMode): void {
  method cleanUpChannel (line 1334) | private cleanUpChannel(): void {
  method notifyFileEvent (line 1341) | public notifyFileEvent(event: FileEvent | undefined): void {
  method forceDocumentSync (line 1366) | public async forceDocumentSync(): Promise<void> {
  method isSynced (line 1369) | public isSynced(uri: string): boolean {
  method createConnection (line 1375) | private async createConnection(): Promise<Connection> {
  method handleConnectionClosed (line 1390) | protected async handleConnectionClosed(): Promise<void> {
  method handleConnectionError (line 1437) | public async handleConnectionError(error: Error, message: Message | unde...
  method hookConfigurationChanged (line 1451) | private hookConfigurationChanged(): void {
  method refreshTrace (line 1459) | private refreshTrace(sendNotification: boolean): void {
  method changeTrace (line 1478) | private changeTrace(trace: Trace, traceFormat: TraceFormat, sendNotifica...
  method registerFeatures (line 1497) | public registerFeatures(
  method registerFeature (line 1505) | public registerFeature(feature: StaticFeature | DynamicFeature<any>, nam...
  method getStaticFeature (line 1517) | public getStaticFeature(method: string): StaticFeature | undefined {
  method getFeature (line 1567) | public getFeature(request: string): DynamicFeature<any> | undefined {
  method registerBuiltinFeatures (line 1571) | protected registerBuiltinFeatures() {
  method registerProposedFeatures (line 1627) | public registerProposedFeatures() {
  method fillInitializeParams (line 1631) | private fillInitializeParams(params: InitializeParams): void {
  method computeClientCapabilities (line 1639) | private computeClientCapabilities(): ClientCapabilities {
  method initializeFeatures (line 1687) | private initializeFeatures(_connection: Connection): void {
  method handleRegistrationRequest (line 1699) | private handleRegistrationRequest(params: RegistrationParams): Promise<v...
  method doRegisterCapability (line 1709) | private async doRegisterCapability(params: RegistrationParams): Promise<...
  method handleUnregistrationRequest (line 1735) | private handleUnregistrationRequest(params: UnregistrationParams): Promi...
  method doUnregisterCapability (line 1744) | private async doUnregisterCapability(params: UnregistrationParams): Prom...
  method handleDiagnostics (line 1754) | private handleDiagnostics(params: PublishDiagnosticsParams) {
  method setDiagnostics (line 1767) | private setDiagnostics(uri: string, diagnostics: Diagnostic[] | undefine...
  method doHandleApplyWorkspaceEdit (line 1772) | private doHandleApplyWorkspaceEdit(params: ApplyWorkspaceEditParams): Pr...
  method handleApplyWorkspaceEdit (line 1778) | private async handleApplyWorkspaceEdit(params: ApplyWorkspaceEditParams)...
  method handleFailedRequest (line 1802) | public handleFailedRequest<T, P extends { method: string }>(type: P, tok...
  method logFailedRequest (line 1830) | public logFailedRequest(type: any, error: any): void {
  method getExtensionName (line 1844) | public getExtensionName(): string {
  method attachExtensionName (line 1857) | public attachExtensionName<T extends object>(provider: T): void {

FILE: src/language-client/codeAction.ts
  type ProvideCodeActionsSignature (line 13) | interface ProvideCodeActionsSignature {
  type ResolveCodeActionSignature (line 23) | interface ResolveCodeActionSignature {
  type CodeActionMiddleware (line 27) | interface CodeActionMiddleware {
  class CodeActionFeature (line 44) | class CodeActionFeature extends TextDocumentLanguageFeature<boolean | Co...
    method constructor (line 46) | constructor(client: FeatureClient<CodeActionMiddleware>) {
    method fillClientCapabilities (line 50) | public fillClientCapabilities(capabilities: ClientCapabilities): void {
    method initialize (line 76) | public initialize(
    method registerLanguageProvider (line 91) | protected registerLanguageProvider(
    method dispose (line 149) | public dispose(): void {

FILE: src/language-client/codeLens.ts
  type ProvideCodeLensesSignature (line 10) | interface ProvideCodeLensesSignature {
  type ResolveCodeLensSignature (line 14) | interface ResolveCodeLensSignature {
  type CodeLensMiddleware (line 18) | interface CodeLensMiddleware {
  type CodeLensProviderShape (line 23) | interface CodeLensProviderShape {
  class CodeLensFeature (line 28) | class CodeLensFeature extends TextDocumentLanguageFeature<CodeLensOption...
    method constructor (line 30) | constructor(client: FeatureClient<CodeLensMiddleware>) {
    method fillClientCapabilities (line 34) | public fillClientCapabilities(capabilities: ClientCapabilities): void {
    method initialize (line 39) | public initialize(capabilities: ServerCapabilities, documentSelector: ...
    method registerLanguageProvider (line 51) | protected registerLanguageProvider(options: CodeLensRegistrationOption...

FILE: src/language-client/colorProvider.ts
  type ProvideDocumentColorsSignature (line 9) | type ProvideDocumentColorsSignature = (document: TextDocument, token: Ca...
  type ProvideColorPresentationSignature (line 11) | type ProvideColorPresentationSignature = (
  type ColorProviderMiddleware (line 17) | interface ColorProviderMiddleware {
  class ColorProviderFeature (line 33) | class ColorProviderFeature extends TextDocumentLanguageFeature<
    method constructor (line 36) | constructor(client: FeatureClient<ColorProviderMiddleware>) {
    method fillClientCapabilities (line 40) | public fillClientCapabilities(capabilities: ClientCapabilities): void {
    method initialize (line 44) | public initialize(
    method registerLanguageProvider (line 56) | protected registerLanguageProvider(

FILE: src/language-client/completion.ts
  type ProvideCompletionItemsSignature (line 39) | interface ProvideCompletionItemsSignature {
  type ResolveCompletionItemSignature (line 49) | interface ResolveCompletionItemSignature {
  type CompletionMiddleware (line 53) | interface CompletionMiddleware {
  type $CompletionOptions (line 70) | interface $CompletionOptions {
  class CompletionItemFeature (line 74) | class CompletionItemFeature extends TextDocumentLanguageFeature<Completi...
    method constructor (line 75) | constructor(client: FeatureClient<CompletionMiddleware, $CompletionOpt...
    method fillClientCapabilities (line 79) | public fillClientCapabilities(capabilities: ClientCapabilities): void {
    method initialize (line 105) | public initialize(
    method registerLanguageProvider (line 117) | protected registerLanguageProvider(options: CompletionRegistrationOpti...

FILE: src/language-client/configuration.ts
  type ConfigurationMiddleware (line 16) | interface ConfigurationMiddleware {
  type ConfigurationWorkspaceMiddleware (line 20) | interface ConfigurationWorkspaceMiddleware {
  type SynchronizeOptions (line 24) | interface SynchronizeOptions {
  type $ConfigurationOptions (line 43) | interface $ConfigurationOptions {
  class PullConfigurationFeature (line 48) | class PullConfigurationFeature implements StaticFeature {
    method constructor (line 49) | constructor(private _client: FeatureClient<ConfigurationWorkspaceMiddl...
    method method (line 52) | public get method(): string {
    method fillClientCapabilities (line 56) | public fillClientCapabilities(capabilities: ClientCapabilities): void {
    method getState (line 60) | public getState(): FeatureState {
    method initialize (line 64) | public initialize(): void {
    method getConfiguration (line 83) | private getConfiguration(resource: string | undefined, section: string...
    method dispose (line 105) | public dispose(): void {
  type DidChangeConfigurationSignature (line 109) | interface DidChangeConfigurationSignature {
  type DidChangeConfigurationMiddleware (line 113) | interface DidChangeConfigurationMiddleware {
  type DidChangeConfigurationWorkspaceMiddleware (line 117) | interface DidChangeConfigurationWorkspaceMiddleware {
  class SyncConfigurationFeature (line 121) | class SyncConfigurationFeature implements DynamicFeature<DidChangeConfig...
    method constructor (line 125) | constructor(private _client: FeatureClient<DidChangeConfigurationWorks...
    method getState (line 127) | public getState(): FeatureState {
    method registrationType (line 131) | public get registrationType(): RegistrationType<DidChangeConfiguration...
    method fillClientCapabilities (line 135) | public fillClientCapabilities(capabilities: ClientCapabilities): void {
    method initialize (line 139) | public initialize(): void {
    method register (line 152) | public register(
    method unregister (line 166) | public unregister(id: string): void {
    method dispose (line 174) | public dispose(): void {
    method onDidChangeConfiguration (line 181) | private onDidChangeConfiguration(configurationSection: string | string...
    method getConfiguredSettings (line 209) | public static getConfiguredSettings(key: string, workspaceFolder: Work...
    method extractSettingsInformation (line 215) | public static extractSettingsInformation(keys: string[], workspaceFold...

FILE: src/language-client/declaration.ts
  type ProvideDeclarationSignature (line 9) | interface ProvideDeclarationSignature {
  type DeclarationMiddleware (line 13) | interface DeclarationMiddleware {
  class DeclarationFeature (line 17) | class DeclarationFeature extends TextDocumentLanguageFeature<boolean | D...
    method constructor (line 19) | constructor(client: FeatureClient<DeclarationMiddleware>) {
    method fillClientCapabilities (line 23) | public fillClientCapabilities(capabilities: ClientCapabilities): void {
    method initialize (line 29) | public initialize(capabilities: ServerCapabilities, documentSelector: ...
    method registerLanguageProvider (line 37) | protected registerLanguageProvider(options: DeclarationRegistrationOpt...

FILE: src/language-client/definition.t

[
  {
    "path": ".all-contributorsrc",
    "chars": 59119,
    "preview": "{\n  \"projectName\": \"coc.nvim\",\n  \"projectOwner\": \"neoclide\",\n  \"repoType\": \"github\",\n  \"repoHost\": \"https://github.com\","
  },
  {
    "path": ".editorconfig",
    "chars": 702,
    "preview": "root = true\n\n[*]\nend_of_line = lf\ncharset = utf-8\n\n[*.{js,ts}]\nindent_style = space\nindent_size = 2\ntrim_trailing_whites"
  },
  {
    "path": ".github/.codecov.yml",
    "chars": 35,
    "preview": "coverage:\n  status:\n    patch: off\n"
  },
  {
    "path": ".github/FUNDING.yml",
    "chars": 89,
    "preview": "# These are supported funding model platforms\n\nopen_collective: cocnvim\npatreon: chemzqm\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 1018,
    "preview": "---\nname: Bug report\nabout: Create a report to help us improve\n---\n\n<!--\n**Warning: We will close the bug issue without "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 560,
    "preview": "---\nname: Feature request\nabout: Suggest an idea for this project\n\n---\n\n**Is your feature request related to a problem? "
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 2086,
    "preview": "name: Dev\n\non:\n  push:\n    branches:\n      - master\n  pull_request:\n    branches:\n      - master\n\njobs:\n  test:\n    if: "
  },
  {
    "path": ".github/workflows/lint.yml",
    "chars": 576,
    "preview": "name: Lint\n\non:\n  push:\n    branches:\n      - master\n  pull_request:\n    branches:\n      - master\n\njobs:\n  lint:\n    if:"
  },
  {
    "path": ".github/workflows/release.yml",
    "chars": 1427,
    "preview": "name: Publish Release Task\n\non:\n  schedule:\n    - cron: '0 16 * * *'  # UTC时间16:00（对应北京时间+8时区的0点）\n\njobs:\n  publish-relea"
  },
  {
    "path": ".gitignore",
    "chars": 161,
    "preview": "lib\n.cache\n*.map\ncoverage\n__pycache__\n.pyc\n.log\nbuild\ndoc/tags\ntypings/package.json\nnode_modules\npublish.sh\n!src/__tests"
  },
  {
    "path": ".ignore",
    "chars": 4,
    "preview": "lib\n"
  },
  {
    "path": ".npmignore",
    "chars": 139,
    "preview": "*.map\n.cache\nlib/extensions\nlib/__tests__\nplugin\nautoload\nrplugin\nsrc\n.github\nbuild\ncoverage\ndata\ntslint.json\ntsconfig.j"
  },
  {
    "path": ".prettierignore",
    "chars": 5,
    "preview": "src/\n"
  },
  {
    "path": ".prettierrc",
    "chars": 185,
    "preview": "{\n  \"bracketSpacing\": false,\n  \"arrowParens\": \"avoid\",\n  \"printWidth\": 120,\n  \"singleQuote\": true,\n  \"trailingComma\": \"n"
  },
  {
    "path": ".swcrc",
    "chars": 284,
    "preview": "{\n  \"sourceMaps\": false,\n  \"module\": {\n    \"type\": \"es6\"\n  },\n  \"env\": {\n    \"targets\": {\n      \"node\": \"14\"\n    }\n  },\n"
  },
  {
    "path": ".vim/coc-settings.json",
    "chars": 602,
    "preview": "{\n  \"eslint.validate\": [\"typescript\"],\n  \"eslint.lintTask.options\": [\".\"],\n  \"sumneko-lua.enableNvimLuaDev\": true,\n  \"ja"
  },
  {
    "path": "Backers.md",
    "chars": 12390,
    "preview": "# Backers\n\n❤️ coc.nvim? Help us keep it alive by [donating funds](https://www.bountysource.com/teams/coc-nvim)😘!\n\n<a hre"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 13609,
    "preview": "# Contributing\n\n## How do I... <a name=\"toc\"></a>\n\n- [Use This Guide](#introduction)?\n- Make Something? 🤓👩🏽‍💻📜🍳\n  - [Pro"
  },
  {
    "path": "LICENSE.md",
    "chars": 2663,
    "preview": "Copyright (c) <2022> <chemzqm@gmail.com>\n\n\"Anti 996\" License Version 1.0 (Draft)\n\nPermission is hereby granted to any in"
  },
  {
    "path": "README.md",
    "chars": 111585,
    "preview": "<p align=\"center\">\n  <a href=\"https://www.vim.org/scripts/script.php?script_id=5779\">\n    <img alt=\"Logo\" src=\"https://g"
  },
  {
    "path": "autoload/coc/api.vim",
    "chars": 38784,
    "preview": "if has('nvim')\n  finish\nendif\nvim9script\nscriptencoding utf-8\n\nvar namespace_id: number = 1\nfinal namespace_cache: dict<"
  },
  {
    "path": "autoload/coc/client.vim",
    "chars": 11067,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:clients = {}\n\nif get(g:, 'node_client_debug', 0)\n  echohl Warning"
  },
  {
    "path": "autoload/coc/color.vim",
    "chars": 18864,
    "preview": "scriptencoding utf-8\n\nlet s:activate = \"\"\nlet s:quit = \"\"\nif has(\"gui_macvim\") && has('gui_running')\n  let s:app = \"MacV"
  },
  {
    "path": "autoload/coc/compat.vim",
    "chars": 3278,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\n\n\" first window id for bufnr\n\" builtin bufwinid returns window of curre"
  },
  {
    "path": "autoload/coc/cursor.vim",
    "chars": 1854,
    "preview": "scriptencoding utf-8\n\n\" Position of cursor relative to screen cell\nfunction! coc#cursor#screen_pos() abort\n  let nr = wi"
  },
  {
    "path": "autoload/coc/dialog.vim",
    "chars": 26032,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:root = expand('<sfile>:h:h:h')\nlet s:prompt_win_bufnr = 0\nlet s:l"
  },
  {
    "path": "autoload/coc/dict.vim",
    "chars": 632,
    "preview": "scriptencoding utf-8\n\nfunction! coc#dict#equal(one, two) abort\n  for key in keys(a:one)\n    if a:one[key] != a:two[key]\n"
  },
  {
    "path": "autoload/coc/float.vim",
    "chars": 49106,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:borderchars = get(g:, 'coc_borderchars', ['─', '│', '─', '│', '┌'"
  },
  {
    "path": "autoload/coc/highlight.vim",
    "chars": 5818,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\n\nlet s:func_map = {\n    \\ 'del_markers': 'coc#vim9#Del_markers',\n    \\ "
  },
  {
    "path": "autoload/coc/hlgroup.vim",
    "chars": 4766,
    "preview": "scriptencoding utf-8\n\nfunction! coc#hlgroup#valid(hlGroup) abort\n  return hlexists(a:hlGroup) && execute('hi '.a:hlGroup"
  },
  {
    "path": "autoload/coc/inline.vim",
    "chars": 1982,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:inline_ns = coc#highlight#create_namespace('inlineSuggest')\nlet s"
  },
  {
    "path": "autoload/coc/list.vim",
    "chars": 14522,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:prefix = '[List Preview]'\nlet s:sign_group = 'CocList'\n\" filetype"
  },
  {
    "path": "autoload/coc/math.vim",
    "chars": 216,
    "preview": "\n\" support for float values\nfunction! coc#math#min(first, ...) abort\n  let val = a:first\n  for i in range(0, len(a:000) "
  },
  {
    "path": "autoload/coc/notify.vim",
    "chars": 18899,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:utf = has('nvim') || &encoding =~# '^utf'\nlet s:error_icon = get("
  },
  {
    "path": "autoload/coc/prompt.vim",
    "chars": 5858,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:activated = 0\nlet s:session_names = []\nlet s:saved_ve = &t_ve\nlet"
  },
  {
    "path": "autoload/coc/pum.vim",
    "chars": 18477,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:pum_bufnr = 0\nlet s:pum_winid = -1\nlet s:pum_index = -1\nlet s:pum"
  },
  {
    "path": "autoload/coc/rpc.vim",
    "chars": 6749,
    "preview": "scriptencoding utf-8\nlet s:is_win = has(\"win32\") || has(\"win64\")\nlet s:client = v:null\nlet s:name = 'coc'\nlet s:is_vim ="
  },
  {
    "path": "autoload/coc/snippet.vim",
    "chars": 4994,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:map_next = 1\nlet s:map_prev = 1\n\nfunction! coc#snippet#_select_ma"
  },
  {
    "path": "autoload/coc/string.vim",
    "chars": 3973,
    "preview": "scriptencoding utf-8\n\nfunction! coc#string#last_character(line) abort\n  return strcharpart(a:line, strchars(a:line) - 1,"
  },
  {
    "path": "autoload/coc/task.vim",
    "chars": 4555,
    "preview": "\" ============================================================================\n\" Description: Manage long running tasks."
  },
  {
    "path": "autoload/coc/terminal.vim",
    "chars": 3908,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:channel_map = {}\nlet s:is_win = has('win32') || has('win64')\n\n\" s"
  },
  {
    "path": "autoload/coc/text.vim",
    "chars": 6374,
    "preview": "vim9script\n\nexport def LinesEqual(one: list<string>, two: list<string>): bool\n  if len(one) != len(two)\n    return false"
  },
  {
    "path": "autoload/coc/ui.vim",
    "chars": 16466,
    "preview": "let s:is_vim = !has('nvim')\nlet s:is_win = has('win32') || has('win64')\nlet s:is_mac = has('mac')\nlet s:root = expand('<"
  },
  {
    "path": "autoload/coc/util.vim",
    "chars": 21966,
    "preview": "scriptencoding utf-8\nlet s:root = expand('<sfile>:h:h:h')\nlet s:is_win = has('win32') || has('win64')\nlet s:is_vim = !ha"
  },
  {
    "path": "autoload/coc/vim9.vim",
    "chars": 18655,
    "preview": "vim9script\nscriptencoding utf-8\n\nconst default_priority = 1024\nconst priorities = {\n  'CocListSearch': 2048,\n  'CocSearc"
  },
  {
    "path": "autoload/coc/vtext.vim",
    "chars": 2222,
    "preview": "let s:is_vim = !has('nvim')\n\n\" Add multiple virtual texts, use timer when needed.\n\" bufnr - The buffer number\n\" ns - Id "
  },
  {
    "path": "autoload/coc/window.vim",
    "chars": 5720,
    "preview": "let g:coc_max_treeview_width = get(g:, 'coc_max_treeview_width', 40)\nlet s:is_vim = !has('nvim')\n\n\" Get tabpagenr of win"
  },
  {
    "path": "autoload/coc.vim",
    "chars": 4848,
    "preview": "scriptencoding utf-8\nlet g:coc_user_config = get(g:, 'coc_user_config', {})\nlet g:coc_global_extensions = get(g:, 'coc_g"
  },
  {
    "path": "autoload/health/coc.vim",
    "chars": 3855,
    "preview": "scriptencoding utf-8\nlet s:root = expand('<sfile>:h:h:h')\n\nfunction! s:report_ok(report) abort\n  if has('nvim-0.10')\n   "
  },
  {
    "path": "bin/prompt.js",
    "chars": 2136,
    "preview": "/*\n * Used for prompt popup on vim\n */\nconst readline = require(\"readline\")\nconst rl = readline.createInterface({\n  inpu"
  },
  {
    "path": "bin/terminateProcess.sh",
    "chars": 184,
    "preview": "#!/bin/bash\nterminateTree() {\n    for cpid in $(pgrep -P $1); do\n        terminateTree $cpid\n    done\n    kill -9 $1 > /"
  },
  {
    "path": "data/schema.json",
    "chars": 85898,
    "preview": "{\n  \"description\": \"Configuration file for coc.nvim\",\n  \"additionalProperties\": false,\n  \"definitions\": {\n    \"floatConf"
  },
  {
    "path": "doc/coc-api.txt",
    "chars": 17058,
    "preview": "*coc-api.txt*                                  NodeJS client for Vim & Neovim.\n\nCONTENTS\n\nVim sources \t\t\t\t\t|coc-api-vim-"
  },
  {
    "path": "doc/coc-config.txt",
    "chars": 59380,
    "preview": "*coc-config.txt*\t\t\t\tNodeJS client for Vim & Neovim.\n\nCONTENTS\n\nCore features\n\tWorkspace \t\t\t\t|coc-config-workspace|\n\tFile"
  },
  {
    "path": "doc/coc-example-config.lua",
    "chars": 7693,
    "preview": "-- https://raw.githubusercontent.com/neoclide/coc.nvim/refs/heads/master/doc/coc-example-config.lua\n\n-- Some servers hav"
  },
  {
    "path": "doc/coc-example-config.vim",
    "chars": 6221,
    "preview": "\" https://raw.githubusercontent.com/neoclide/coc.nvim/refs/heads/master/doc/coc-example-config.vim\n\n\" May need for Vim ("
  },
  {
    "path": "doc/coc.txt",
    "chars": 147379,
    "preview": "*coc-nvim.txt*\t\t\t\t\tNodeJS client for Vim & Neovim.\n\nVersion: 0.0.82\nAuthor: Qiming Zhao <chemzqm at gmail.com>\n\nCONTENTS"
  },
  {
    "path": "esbuild.js",
    "chars": 2770,
    "preview": "const cp = require('child_process')\nlet revision = 'master'\nif (process.env.NODE_ENV !== 'development') {\n  try {\n    le"
  },
  {
    "path": "eslint.config.mjs",
    "chars": 8502,
    "preview": "import {defineConfig, globalIgnores} from \"eslint/config\"\nimport jsdoc from \"eslint-plugin-jsdoc\"\nimport jest from \"esli"
  },
  {
    "path": "history.md",
    "chars": 73945,
    "preview": "# Changelog\n\nNotable changes of coc.nvim:\n\n## 2025-11-22\n\n- Add configurable front end for reporting regular messages to"
  },
  {
    "path": "jest.js",
    "chars": 696,
    "preview": "const path = require('path')\nconst os = require('os')\nconst fs = require('fs')\n\nconst tmpdir = process.env.TMPDIR = path"
  },
  {
    "path": "lua/coc/diagnostic.lua",
    "chars": 995,
    "preview": "local M = {}\n\nlocal ns = vim.api.nvim_create_namespace('coc-diagnostic')\n\nfunction M.refresh()\n  vim.diagnostic.reset(ns"
  },
  {
    "path": "lua/coc/highlight.lua",
    "chars": 14454,
    "preview": "local util = require('coc.util')\nlocal api = vim.api\n\nlocal M = {}\n\nlocal default_priority = 1024\nlocal priorities = {\n "
  },
  {
    "path": "lua/coc/text.lua",
    "chars": 12146,
    "preview": "local api = vim.api\n\nlocal M = {}\n\nlocal function splitText(text, col)\n  return text:sub(1, col - 1), text:sub(col)\nend\n"
  },
  {
    "path": "lua/coc/util.lua",
    "chars": 1050,
    "preview": "\nlocal M = {}\n\nlocal unpackFn = unpack\nif unpackFn == nil then\n  unpackFn = table.unpack\nend\n\nM.unpack = unpackFn\n\nfunct"
  },
  {
    "path": "lua/coc/vtext.lua",
    "chars": 3787,
    "preview": "local api = vim.api\nlocal M = {}\nlocal n10 = vim.fn.has('nvim-0.10')\nlocal maxCount = vim.g.coc_highlight_maximum_count "
  },
  {
    "path": "package.json",
    "chars": 3233,
    "preview": "{\n  \"name\": \"coc.nvim-master\",\n  \"version\": \"0.0.82\",\n  \"description\": \"LSP based intellisense engine for neovim & vim8."
  },
  {
    "path": "plugin/coc.lua",
    "chars": 326,
    "preview": "if vim.fn.has('nvim-0.10') then\n  vim.api.nvim_create_autocmd({ 'BufEnter' }, {\n    callback = function()\n      require("
  },
  {
    "path": "plugin/coc.vim",
    "chars": 35672,
    "preview": "scriptencoding utf-8\nlet s:is_vim = !has('nvim')\nlet s:is_gvim = s:is_vim && has(\"gui_running\")\nif exists('g:did_coc_loa"
  },
  {
    "path": "release.sh",
    "chars": 780,
    "preview": "#!/bin/sh\n\nset -e\n[ \"$TRACE\" ] && set -x\n\ngit checkout master\nnpm run lint:typecheck\nif [ $? -ne 0 ]; then\n  echo \"tsc 类"
  },
  {
    "path": "src/__tests__/autoload/coc/source/email.vim",
    "chars": 401,
    "preview": "\" vim source for emails\nfunction! coc#source#email#init() abort\n  return {\n        \\ 'priority': 9,\n        \\ 'shortcut'"
  },
  {
    "path": "src/__tests__/autoload/coc/source/vim9.vim",
    "chars": 274,
    "preview": "vim9script\nexport def Init(): dict<any>\n  return {\n    priority: 9,\n    shortcut: 'Email',\n    triggerCharacters: ['@']\n"
  },
  {
    "path": "src/__tests__/autoload/legacy.vim",
    "chars": 173,
    "preview": "\nfunction legacy#dict_add() dict\n  return self.key + 1\nendfunction\n\nfunction legacy#win_execute() abort\n  call win_execu"
  },
  {
    "path": "src/__tests__/autoload/vim9.vim",
    "chars": 201,
    "preview": "vim9script\nscriptencoding utf-8\n\nexport def WinExecute(): any\n  win_execute(win_getid(), 'cursor(1, 1)')\n  return v:true"
  },
  {
    "path": "src/__tests__/client/configuration.test.ts",
    "chars": 6231,
    "preview": "import path from 'path'\nimport { DidChangeConfigurationNotification, DocumentSelector } from 'vscode-languageserver-prot"
  },
  {
    "path": "src/__tests__/client/connection.test.ts",
    "chars": 4903,
    "preview": "import { Duplex } from 'stream'\nimport { createProtocolConnection, ProgressType, DocumentSymbolParams, DocumentSymbolReq"
  },
  {
    "path": "src/__tests__/client/converter.test.ts",
    "chars": 3595,
    "preview": "import { CompletionTriggerKind, Position, TextDocumentItem, TextDocumentSaveReason } from 'vscode-languageserver-protoco"
  },
  {
    "path": "src/__tests__/client/diagnostics.test.ts",
    "chars": 13140,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as uuid } from 'uuid'\ni"
  },
  {
    "path": "src/__tests__/client/dynamic.test.ts",
    "chars": 20523,
    "preview": "import os from 'os'\nimport path from 'path'\nimport { CancellationToken, CodeActionRequest, CodeLensRequest, CompletionRe"
  },
  {
    "path": "src/__tests__/client/features.test.ts",
    "chars": 72177,
    "preview": "import * as assert from 'assert'\nimport path from 'path'\nimport { v4 as uuidv4 } from 'uuid'\nimport { ApplyWorkspaceEdit"
  },
  {
    "path": "src/__tests__/client/fileSystemWatcher.test.ts",
    "chars": 5121,
    "preview": "import path from 'path'\nimport { DidChangeWatchedFilesNotification, DocumentSelector, Emitter, Event, FileChangeType } f"
  },
  {
    "path": "src/__tests__/client/integration.test.ts",
    "chars": 34599,
    "preview": "import * as assert from 'assert'\nimport cp, { ChildProcess } from 'child_process'\nimport fs from 'fs'\nimport os from 'os"
  },
  {
    "path": "src/__tests__/client/progressPart.test.ts",
    "chars": 3426,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Emitter, Event, NotificationHandler, WorkDoneProgressBegin, WorkDonePr"
  },
  {
    "path": "src/__tests__/client/server/configServer.js",
    "chars": 991,
    "preview": "'use strict'\nconst {createConnection, ConfigurationRequest, DidChangeConfigurationNotification} = require('vscode-langua"
  },
  {
    "path": "src/__tests__/client/server/crashOnShutdownServer.js",
    "chars": 319,
    "preview": "'use strict'\nObject.defineProperty(exports, \"__esModule\", {value: true})\nconst node_1 = require(\"vscode-languageserver/n"
  },
  {
    "path": "src/__tests__/client/server/crashServer.js",
    "chars": 530,
    "preview": "\"use strict\"\nObject.defineProperty(exports, \"__esModule\", {value: true})\nconst node_1 = require('vscode-languageserver/n"
  },
  {
    "path": "src/__tests__/client/server/customServer.js",
    "chars": 611,
    "preview": "\"use strict\"\nObject.defineProperty(exports, \"__esModule\", {value: true})\nconst node_1 = require(\"vscode-languageserver/n"
  },
  {
    "path": "src/__tests__/client/server/diagnosticServer.js",
    "chars": 4051,
    "preview": "'use strict'\nconst {createConnection, ResponseError, LSPErrorCodes, DiagnosticRefreshRequest, DocumentDiagnosticReportKi"
  },
  {
    "path": "src/__tests__/client/server/dynamicServer.js",
    "chars": 7093,
    "preview": "'use strict'\nconst {createConnection, TextDocumentContentRefreshRequest, ProtocolRequestType, Range, TextDocumentSyncKin"
  },
  {
    "path": "src/__tests__/client/server/errorServer.js",
    "chars": 319,
    "preview": "\"use strict\"\nconst {createConnection, ResponseError} = require(\"vscode-languageserver/node\")\nconst connection = createCo"
  },
  {
    "path": "src/__tests__/client/server/eventServer.js",
    "chars": 5149,
    "preview": "'use strict'\nconst {createConnection, TextEdit, RenameRequest, ProtocolRequestType, TextDocuments, Range, DiagnosticSeve"
  },
  {
    "path": "src/__tests__/client/server/fileWatchServer.js",
    "chars": 1301,
    "preview": "'use strict'\nconst {createConnection, DidChangeWatchedFilesNotification} = require('vscode-languageserver/node')\nconst {"
  },
  {
    "path": "src/__tests__/client/server/nullServer.js",
    "chars": 307,
    "preview": "\"use strict\"\nObject.defineProperty(exports, \"__esModule\", {value: true})\nconst node_1 = require(\"vscode-languageserver/n"
  },
  {
    "path": "src/__tests__/client/server/testDocuments.js",
    "chars": 2941,
    "preview": "const {ResponseError, LSPErrorCodes} = require('vscode-languageserver/node')\nconst ls = require('vscode-languageserver/n"
  },
  {
    "path": "src/__tests__/client/server/testFileWatcher.js",
    "chars": 811,
    "preview": "const languageserver = require('vscode-languageserver')\nlet connection = languageserver.createConnection()\nlet documents"
  },
  {
    "path": "src/__tests__/client/server/testInitializeResult.js",
    "chars": 2000,
    "preview": "'use strict'\nObject.defineProperty(exports, \"__esModule\", {value: true})\nconst tslib_1 = require(\"tslib\")\nconst assert ="
  },
  {
    "path": "src/__tests__/client/server/testServer.js",
    "chars": 21450,
    "preview": "const assert = require('assert')\nconst {URI} = require('vscode-uri')\nconst {\n  createConnection, CompletionItemKind, Res"
  },
  {
    "path": "src/__tests__/client/server/timeoutOnShutdownServer.js",
    "chars": 378,
    "preview": "\"use strict\"\nObject.defineProperty(exports, \"__esModule\", {value: true})\nconst node_1 = require(\"vscode-languageserver/n"
  },
  {
    "path": "src/__tests__/client/textSynchronization.test.ts",
    "chars": 16208,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as "
  },
  {
    "path": "src/__tests__/client/utils.test.ts",
    "chars": 6693,
    "preview": "/* eslint-disable */\nimport assert from 'assert'\nimport { spawn } from 'child_process'\nimport { NotificationType, Notifi"
  },
  {
    "path": "src/__tests__/client/workspaceFolder.test.ts",
    "chars": 3361,
    "preview": "'use strict'\nimport * as assert from 'assert'\nimport * as proto from 'vscode-languageserver-protocol'\nimport { DidChange"
  },
  {
    "path": "src/__tests__/coc-settings.json",
    "chars": 56,
    "preview": "{\n  \"suggest.timeout\": 5000,\n  \"tslint.enable\": false\n}\n"
  },
  {
    "path": "src/__tests__/completion/basic.test.ts",
    "chars": 54142,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { v4 as uuidv4 } from 'uuid'\nimport { CancellationToken, Disposable, Pos"
  },
  {
    "path": "src/__tests__/completion/float.test.ts",
    "chars": 5897,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport Floating from '../../completion/floating'\nimport { getInsertWord, prefix"
  },
  {
    "path": "src/__tests__/completion/language.test.ts",
    "chars": 33464,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Disposable } from 'vscode-languageserver-protocol'\n"
  },
  {
    "path": "src/__tests__/completion/sources.test.ts",
    "chars": 19229,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { Cancel"
  },
  {
    "path": "src/__tests__/completion/util.test.ts",
    "chars": 22787,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, CompletionItem, CompletionItemKind, CompletionItemT"
  },
  {
    "path": "src/__tests__/configuration/configurationModel.test.ts",
    "chars": 62234,
    "preview": "import * as assert from 'assert'\nimport { join } from 'path'\nimport { URI } from 'vscode-uri'\nimport { Configuration } f"
  },
  {
    "path": "src/__tests__/configuration/configurations.test.ts",
    "chars": 16356,
    "preview": "import fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { v1 as uuid } from 'uuid'\nimport { Disposable } "
  },
  {
    "path": "src/__tests__/configuration/settings.json",
    "chars": 158,
    "preview": "{\n  \"foo.bar\": 1,\n  \"bar.foo\": 2,\n  \"schema\": {\n    \"https://example.com\": \"*.yaml\"\n  },\n  \"servers\": {\n    \"c\": {\n     "
  },
  {
    "path": "src/__tests__/configuration/util.test.ts",
    "chars": 8829,
    "preview": "import * as assert from 'assert'\nimport os from 'os'\nimport { ParseError } from 'jsonc-parser'\nimport { addToValueTree, "
  },
  {
    "path": "src/__tests__/core/autocmds.test.ts",
    "chars": 6921,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Disposable, Emitter } from 'vscode-languageserver-p"
  },
  {
    "path": "src/__tests__/core/documents.test.ts",
    "chars": 11567,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as "
  },
  {
    "path": "src/__tests__/core/editors.test.ts",
    "chars": 8791,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable } from 'vscode-languageserver-protocol'\nimport { URI } from"
  },
  {
    "path": "src/__tests__/core/fileSystemWatcher.test.ts",
    "chars": 13225,
    "preview": "import bser from 'bser'\nimport net from 'net'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as uuid } from 'uu"
  },
  {
    "path": "src/__tests__/core/files.test.ts",
    "chars": 33053,
    "preview": "import { Buffer, Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport "
  },
  {
    "path": "src/__tests__/core/funcs.test.ts",
    "chars": 4326,
    "preview": "import fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as uuid } from 'uuid'\nimport which from 'whi"
  },
  {
    "path": "src/__tests__/core/keymaps.test.ts",
    "chars": 6016,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable } from 'vscode-languageserver-protocol'\nimport Keymaps, { g"
  },
  {
    "path": "src/__tests__/core/locations.test.ts",
    "chars": 5484,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport os from 'os'\nimport path from 'path'\nimport { Location, Position, Range "
  },
  {
    "path": "src/__tests__/core/terminals.test.ts",
    "chars": 4067,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as uuid } from 'uuid'\ni"
  },
  {
    "path": "src/__tests__/core/ui.test.ts",
    "chars": 4219,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Position, Range } from 'vscode-languageserver-types'\nimport * as ui fr"
  },
  {
    "path": "src/__tests__/core/workspaceFolder.test.ts",
    "chars": 14166,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { Dispos"
  },
  {
    "path": "src/__tests__/handler/callHierarchy.test.ts",
    "chars": 14042,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable, CallHierarchyItem, SymbolKind, Range, SymbolTag, Cancellat"
  },
  {
    "path": "src/__tests__/handler/codeActions.test.ts",
    "chars": 21806,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, CodeAction, CodeActionContext, CodeActionKind, Comm"
  },
  {
    "path": "src/__tests__/handler/codelens.test.ts",
    "chars": 11794,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, CodeLens, Command, Disposable, Position, Range, Tex"
  },
  {
    "path": "src/__tests__/handler/commands.test.ts",
    "chars": 3301,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable } from 'vscode-languageserver-protocol'\nimport commandManag"
  },
  {
    "path": "src/__tests__/handler/documentColors.test.ts",
    "chars": 11927,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Color, ColorInformation, ColorPresentation, Disposa"
  },
  {
    "path": "src/__tests__/handler/documentLinks.test.ts",
    "chars": 9156,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Disposable, DocumentLink, Range } from 'vscode-lang"
  },
  {
    "path": "src/__tests__/handler/fold.test.ts",
    "chars": 4158,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, CancellationTokenSource, Disposable, FoldingRange }"
  },
  {
    "path": "src/__tests__/handler/format.test.ts",
    "chars": 14641,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, CancellationTokenSource, Disposable, Position, Rang"
  },
  {
    "path": "src/__tests__/handler/highlights.test.ts",
    "chars": 7672,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable, DocumentHighlightKind, Position, Range, TextEdit } from 'v"
  },
  {
    "path": "src/__tests__/handler/hover.test.ts",
    "chars": 9011,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Disposable, Hover, MarkedString, MarkupKind, Positi"
  },
  {
    "path": "src/__tests__/handler/index.test.ts",
    "chars": 3981,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable, SymbolKind } from 'vscode-languageserver-protocol'\nimport "
  },
  {
    "path": "src/__tests__/handler/inlayHint.test.ts",
    "chars": 18737,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, CancellationTokenSource, Disposable, InlayHint, Inl"
  },
  {
    "path": "src/__tests__/handler/inline.test.ts",
    "chars": 48708,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { FormattingOptions, InlineCompletionItem, Position, Range, TextEdit } f"
  },
  {
    "path": "src/__tests__/handler/inlineCompletion.test.ts",
    "chars": 3378,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, CancellationTokenSource, Disposable, InlineCompleti"
  },
  {
    "path": "src/__tests__/handler/inlineValue.test.ts",
    "chars": 2016,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Disposable, InlineValueText, Range } from 'vscode-l"
  },
  {
    "path": "src/__tests__/handler/linkedEditing.test.ts",
    "chars": 6003,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable, Position, Range, TextEdit } from 'vscode-languageserver-pr"
  },
  {
    "path": "src/__tests__/handler/locations.test.ts",
    "chars": 12953,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, CancellationTokenSource, Disposable, Location, Loca"
  },
  {
    "path": "src/__tests__/handler/outline.test.ts",
    "chars": 18461,
    "preview": "import { Buffer, Neovim } from '@chemzqm/neovim'\nimport { CodeAction, CodeActionKind, Disposable, DocumentSymbol, Range,"
  },
  {
    "path": "src/__tests__/handler/parser.ts",
    "chars": 3608,
    "preview": "import { DocumentSymbol, Range, SymbolKind } from 'vscode-languageserver-protocol'\nimport { TextDocument } from 'vscode-"
  },
  {
    "path": "src/__tests__/handler/refactor.test.ts",
    "chars": 22258,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport { Position, Range, TextDocumentEdit, TextEdit, Works"
  },
  {
    "path": "src/__tests__/handler/rename.test.ts",
    "chars": 9197,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Disposable, Position, Range, TextEdit } from 'vscod"
  },
  {
    "path": "src/__tests__/handler/search.test.ts",
    "chars": 2950,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport Refactor from '../../handler/refactor'\nimport Search, { getPathFromArgs "
  },
  {
    "path": "src/__tests__/handler/selectionRange.test.ts",
    "chars": 7347,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Disposable, Position, Range, TextEdit } from 'vscod"
  },
  {
    "path": "src/__tests__/handler/semanticTokens.test.ts",
    "chars": 30035,
    "preview": "import { Buffer, Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport { tmpdir } from 'os'\nimport path from 'path'"
  },
  {
    "path": "src/__tests__/handler/signature.test.ts",
    "chars": 16801,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable, ParameterInformation, Range, SignatureInformation } from '"
  },
  {
    "path": "src/__tests__/handler/symbols.test.ts",
    "chars": 10722,
    "preview": "import { Buffer, Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, Disposable, Range, SymbolInformation, Symbo"
  },
  {
    "path": "src/__tests__/handler/typeHierarchy.test.ts",
    "chars": 9268,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken, TypeHierarchyItem, Disposable, Range, SymbolKind, P"
  },
  {
    "path": "src/__tests__/handler/workspace.test.ts",
    "chars": 13883,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as "
  },
  {
    "path": "src/__tests__/helper.ts",
    "chars": 12652,
    "preview": "import type { Buffer, Neovim, Window } from '@chemzqm/neovim'\nimport * as cp from 'child_process'\nimport crypto from 'cr"
  },
  {
    "path": "src/__tests__/list/commandTask.test.ts",
    "chars": 3302,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport path from 'path'\nimport { ListContext, ListTask } from '../../list/types"
  },
  {
    "path": "src/__tests__/list/history.test.ts",
    "chars": 3484,
    "preview": "import History from '../../list/history'\nimport { DataBase } from '../../list/db'\nimport os from 'os'\nimport fs from 'fs"
  },
  {
    "path": "src/__tests__/list/manager.test.ts",
    "chars": 21471,
    "preview": "import { Neovim, Window } from '@chemzqm/neovim'\nimport EventEmitter from 'events'\nimport path from 'path'\nimport { Rang"
  },
  {
    "path": "src/__tests__/list/mappings.test.ts",
    "chars": 25969,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport path from 'path'\nimport { CancellationToken, Disposable } from 'vscode-l"
  },
  {
    "path": "src/__tests__/list/session.test.ts",
    "chars": 9960,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable } from 'vscode-languageserver-protocol'\nimport BasicList fr"
  },
  {
    "path": "src/__tests__/list/source-funcs.test.ts",
    "chars": 6989,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationToken } from 'vscode-languageserver-protocol'\nimport { Doc"
  },
  {
    "path": "src/__tests__/list/sources.test.ts",
    "chars": 33945,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport { v4 as uuid } from 'uuid'\nimpor"
  },
  {
    "path": "src/__tests__/list/ui.test.ts",
    "chars": 8309,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { EventEmitter } from 'events'\nimport { Disposable } from 'vscode-langua"
  },
  {
    "path": "src/__tests__/list/worker.test.ts",
    "chars": 7095,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport styles from 'ansi-styles'\nimport { EventEmitter } from 'events'\nimport {"
  },
  {
    "path": "src/__tests__/markdown/index.test.ts",
    "chars": 8398,
    "preview": "import { getHighlightItems, toFiletype, parseMarkdown, parseDocuments } from '../../markdown/index'\nimport { Documentati"
  },
  {
    "path": "src/__tests__/markdown/renderer.test.ts",
    "chars": 4078,
    "preview": "import { marked } from 'marked'\nimport Renderer, { bulletPointLine, fixHardReturn, generateTableRow, identify, numberedL"
  },
  {
    "path": "src/__tests__/memos.json",
    "chars": 2,
    "preview": "{}"
  },
  {
    "path": "src/__tests__/modules/attach.test.ts",
    "chars": 3474,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable } from 'vscode-languageserver-protocol'\nimport events from "
  },
  {
    "path": "src/__tests__/modules/chars.test.ts",
    "chars": 8423,
    "preview": "import { CancellationTokenSource, Range } from 'vscode-languageserver-protocol'\nimport { Chars, IntegerRanges, detectLan"
  },
  {
    "path": "src/__tests__/modules/cursors.test.ts",
    "chars": 26394,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Position, Range, TextEdit } from 'vscode-languageserver-types'\nimport "
  },
  {
    "path": "src/__tests__/modules/db.test.ts",
    "chars": 3523,
    "preview": "import fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport DB from '../../model/db'\nimport Mru from '../../m"
  },
  {
    "path": "src/__tests__/modules/diagnosticBuffer.test.ts",
    "chars": 17911,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Diagnostic, DiagnosticSeverity, DiagnosticTag, Location, Position, Ran"
  },
  {
    "path": "src/__tests__/modules/diagnosticCollection.test.ts",
    "chars": 3929,
    "preview": "import DiagnosticCollection from '../../diagnostic/collection'\nimport { Diagnostic, DiagnosticSeverity, DiagnosticTag, R"
  },
  {
    "path": "src/__tests__/modules/diagnosticManager.test.ts",
    "chars": 30783,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport os from 'os'\nimport path from 'path'\nimport { Diagnostic, DiagnosticSeve"
  },
  {
    "path": "src/__tests__/modules/dialog.test.ts",
    "chars": 3712,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport events from '../../events'\nimport { Dialog, DialogButton } from '../../m"
  },
  {
    "path": "src/__tests__/modules/document.test.ts",
    "chars": 30333,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport path from 'path'\nimport { Position, Range, TextEdit "
  },
  {
    "path": "src/__tests__/modules/events.test.ts",
    "chars": 5263,
    "preview": "import { CancellationTokenSource, Disposable } from 'vscode-languageserver-protocol'\nimport events from '../../events'\ni"
  },
  {
    "path": "src/__tests__/modules/extensionInstaller.test.ts",
    "chars": 18670,
    "preview": "import fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as uuid } from 'uuid'\nimport { getDependenci"
  },
  {
    "path": "src/__tests__/modules/extensionManager.test.ts",
    "chars": 33752,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as "
  },
  {
    "path": "src/__tests__/modules/extensionModules.test.ts",
    "chars": 16435,
    "preview": "process.env.COC_NO_PLUGINS = '1'\nimport { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport os from 'os'\nimport"
  },
  {
    "path": "src/__tests__/modules/extensions.test.ts",
    "chars": 13511,
    "preview": "import fs from 'fs'\nimport os from 'os'\nimport path from 'path'\nimport { v4 as uuid } from 'uuid'\nimport { URI } from 'v"
  },
  {
    "path": "src/__tests__/modules/fetch.test.ts",
    "chars": 17912,
    "preview": "import fs from 'fs'\nimport http, { Server } from 'http'\nimport os from 'os'\nimport path from 'path'\nimport semver from '"
  },
  {
    "path": "src/__tests__/modules/filter.test.ts",
    "chars": 19876,
    "preview": "import { isWhitespaceAtPos, fuzzyScore, isSeparatorAtPos, isPatternInWord, createMatches, FuzzyScorer, fuzzyScoreGracefu"
  },
  {
    "path": "src/__tests__/modules/floatFactory.test.ts",
    "chars": 9588,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport events from '../../events'\nimport FloatFactoryImpl from '../../model/flo"
  },
  {
    "path": "src/__tests__/modules/fs.test.ts",
    "chars": 12713,
    "preview": "import { findUp, isDirectory, findMatch, watchFile, writeJson, loadJson, normalizeFilePath, checkFolder, getFileType, is"
  },
  {
    "path": "src/__tests__/modules/fuzzyMatch.test.ts",
    "chars": 5987,
    "preview": "import { matchScoreWithPositions } from '../../completion/match'\nimport { FuzzyMatch, matchSpansReverse, FuzzyWasi, init"
  },
  {
    "path": "src/__tests__/modules/highlighter.test.ts",
    "chars": 1760,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport Highlighter from '../../model/highlighter'\nimport helper from '../helper"
  },
  {
    "path": "src/__tests__/modules/line.test.ts",
    "chars": 1178,
    "preview": "import LineBuilder from '../../model/line'\n\ndescribe('LineBuilder', () => {\n  it('should append', async () => {\n    let "
  },
  {
    "path": "src/__tests__/modules/logger.test.ts",
    "chars": 6846,
    "preview": "import { FileLogger, toTwoDigits, toThreeDigits, textToLogLevel, format, DEFAULT_LOG_LEVEL, LogLevel, stringifyLogLevel "
  },
  {
    "path": "src/__tests__/modules/map.test.ts",
    "chars": 10335,
    "preview": "import * as assert from 'assert'\nimport { LinkedMap, LRUCache, Touch } from '../../util/map'\n\ndescribe('Map', () => {\n\n "
  },
  {
    "path": "src/__tests__/modules/memos.test.ts",
    "chars": 1711,
    "preview": "import Memos from '../../model/memos'\nimport os from 'os'\nimport path from 'path'\nimport fs from 'fs'\nimport { loadJson,"
  },
  {
    "path": "src/__tests__/modules/menu.test.ts",
    "chars": 6000,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationTokenSource } from 'vscode-languageserver-protocol'\nimport"
  },
  {
    "path": "src/__tests__/modules/outputChannel.test.ts",
    "chars": 2817,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport OutputChannel from '../../model/outputChannel'\nimport { wait } from '../"
  },
  {
    "path": "src/__tests__/modules/picker.test.ts",
    "chars": 7241,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationTokenSource } from 'vscode-languageserver-protocol'\nimport"
  },
  {
    "path": "src/__tests__/modules/plugin.test.ts",
    "chars": 2613,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport path from 'path'\nimport * as vsTypes from 'vscode-languageserver-types'\n"
  },
  {
    "path": "src/__tests__/modules/quickpick.test.ts",
    "chars": 15816,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { CancellationTokenSource, Disposable } from 'vscode-languageserver-prot"
  },
  {
    "path": "src/__tests__/modules/regions.test.ts",
    "chars": 2473,
    "preview": "import Regions from '../../model/regions'\n\ndescribe('Regions', () => {\n  it('should add #1', async () => {\n    let r = n"
  },
  {
    "path": "src/__tests__/modules/sandbox/log.js",
    "chars": 197,
    "preview": "const {wait, nvim} = require('coc.nvim')\nconsole.log('log')\nconsole.debug('debug')\nconsole.info('info')\nconsole.error('e"
  },
  {
    "path": "src/__tests__/modules/semanticTokensBuilder.test.ts",
    "chars": 3055,
    "preview": "import { SemanticTokensBuilder } from '../../model/semanticTokensBuilder'\nimport { Range, SemanticTokensLegend } from 'v"
  },
  {
    "path": "src/__tests__/modules/server.js",
    "chars": 733,
    "preview": "\"use strict\"\nObject.defineProperty(exports, \"__esModule\", {value: true})\nconst node_1 = require(\"vscode-languageserver/n"
  },
  {
    "path": "src/__tests__/modules/services.test.ts",
    "chars": 17114,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport fs from 'fs'\nimport net from 'net'\nimport os from 'os'\nimport path from "
  },
  {
    "path": "src/__tests__/modules/sources.test.ts",
    "chars": 7146,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport path from 'path'\nimport { Disposable } from 'vscode-languageserver-proto"
  },
  {
    "path": "src/__tests__/modules/strWidth.test.ts",
    "chars": 765,
    "preview": "import { initStrWidthWasm, StrWidth, StrWidthWasi } from '../../model/strwidth'\n\nlet api: StrWidthWasi\nbeforeAll(async ("
  },
  {
    "path": "src/__tests__/modules/task.test.ts",
    "chars": 4110,
    "preview": "import { Neovim } from '@chemzqm/neovim'\nimport { Disposable } from 'vscode-languageserver-protocol'\nimport { disposeAll"
  }
]

// ... and 308 more files (download for full content)