.config/coc/extensions/node_modules/coc-snippets/lib/index.js

   1 (function(e, a) { for(var i in a) e[i] = a[i]; }(exports, /******/ (function(modules) { // webpackBootstrap
   2 /******/        // The module cache
   3 /******/        var installedModules = {};
   4 /******/
   5 /******/        // The require function
   6 /******/        function __webpack_require__(moduleId) {
   7 /******/
   8 /******/                // Check if module is in cache
   9 /******/                if(installedModules[moduleId]) {
  10 /******/                        return installedModules[moduleId].exports;
  11 /******/                }
  12 /******/                // Create a new module (and put it into the cache)
  13 /******/                var module = installedModules[moduleId] = {
  14 /******/                        i: moduleId,
  15 /******/                        l: false,
  16 /******/                        exports: {}
  17 /******/                };
  18 /******/
  19 /******/                // Execute the module function
  20 /******/                modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  21 /******/
  22 /******/                // Flag the module as loaded
  23 /******/                module.l = true;
  24 /******/
  25 /******/                // Return the exports of the module
  26 /******/                return module.exports;
  27 /******/        }
  28 /******/
  29 /******/
  30 /******/        // expose the modules object (__webpack_modules__)
  31 /******/        __webpack_require__.m = modules;
  32 /******/
  33 /******/        // expose the module cache
  34 /******/        __webpack_require__.c = installedModules;
  35 /******/
  36 /******/        // define getter function for harmony exports
  37 /******/        __webpack_require__.d = function(exports, name, getter) {
  38 /******/                if(!__webpack_require__.o(exports, name)) {
  39 /******/                        Object.defineProperty(exports, name, { enumerable: true, get: getter });
  40 /******/                }
  41 /******/        };
  42 /******/
  43 /******/        // define __esModule on exports
  44 /******/        __webpack_require__.r = function(exports) {
  45 /******/                if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  46 /******/                        Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  47 /******/                }
  48 /******/                Object.defineProperty(exports, '__esModule', { value: true });
  49 /******/        };
  50 /******/
  51 /******/        // create a fake namespace object
  52 /******/        // mode & 1: value is a module id, require it
  53 /******/        // mode & 2: merge all properties of value into the ns
  54 /******/        // mode & 4: return value when already ns object
  55 /******/        // mode & 8|1: behave like require
  56 /******/        __webpack_require__.t = function(value, mode) {
  57 /******/                if(mode & 1) value = __webpack_require__(value);
  58 /******/                if(mode & 8) return value;
  59 /******/                if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  60 /******/                var ns = Object.create(null);
  61 /******/                __webpack_require__.r(ns);
  62 /******/                Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  63 /******/                if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  64 /******/                return ns;
  65 /******/        };
  66 /******/
  67 /******/        // getDefaultExport function for compatibility with non-harmony modules
  68 /******/        __webpack_require__.n = function(module) {
  69 /******/                var getter = module && module.__esModule ?
  70 /******/                        function getDefault() { return module['default']; } :
  71 /******/                        function getModuleExports() { return module; };
  72 /******/                __webpack_require__.d(getter, 'a', getter);
  73 /******/                return getter;
  74 /******/        };
  75 /******/
  76 /******/        // Object.prototype.hasOwnProperty.call
  77 /******/        __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  78 /******/
  79 /******/        // __webpack_public_path__
  80 /******/        __webpack_require__.p = "";
  81 /******/
  82 /******/
  83 /******/        // Load entry module and return exports
  84 /******/        return __webpack_require__(__webpack_require__.s = 0);
  85 /******/ })
  86 /************************************************************************/
  87 /******/ ([
  88 /* 0 */
  89 /***/ (function(module, exports, __webpack_require__) {
  90
  91 "use strict";
  92
  93 var __importDefault = (this && this.__importDefault) || function (mod) {
  94     return (mod && mod.__esModule) ? mod : { "default": mod };
  95 };
  96 Object.defineProperty(exports, "__esModule", { value: true });
  97 /******************************************************************
  98 MIT License http://www.opensource.org/licenses/mit-license.php
  99 Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
 100 *******************************************************************/
 101 const coc_nvim_1 = __webpack_require__(1);
 102 const os_1 = __importDefault(__webpack_require__(2));
 103 const fs_1 = __importDefault(__webpack_require__(3));
 104 const path_1 = __importDefault(__webpack_require__(4));
 105 const util_1 = __importDefault(__webpack_require__(5));
 106 const vscode_languageserver_types_1 = __webpack_require__(6);
 107 const snippet_1 = __importDefault(__webpack_require__(7));
 108 const provider_1 = __webpack_require__(35);
 109 const snipmateProvider_1 = __webpack_require__(39);
 110 const textmateProvider_1 = __webpack_require__(43);
 111 const ultisnipsProvider_1 = __webpack_require__(49);
 112 const debounce_1 = __importDefault(__webpack_require__(52));
 113 const languages_1 = __importDefault(__webpack_require__(53));
 114 const documentation = `# A valid snippet should starts with:
 115 #
 116 #               snippet trigger_word [ "description" [ options ] ]
 117 #
 118 # and end with:
 119 #
 120 #               endsnippet
 121 #
 122 # Snippet options:
 123 #
 124 #               b - Beginning of line.
 125 #               i - In-word expansion.
 126 #               w - Word boundary.
 127 #               r - Regular expression
 128 #               e - Custom context snippet
 129 #               A - Snippet will be triggered automatically, when condition matches.
 130 #
 131 # Basic example:
 132 #
 133 #               snippet emitter "emitter properties" b
 134 #               private readonly $\{1} = new Emitter<$2>()
 135 #               public readonly $\{1/^_(.*)/$1/}: Event<$2> = this.$1.event
 136 #               endsnippet
 137 #
 138 # Online reference: https://github.com/SirVer/ultisnips/blob/master/doc/UltiSnips.txt
 139 `;
 140 async function activate(context) {
 141     let { subscriptions } = context;
 142     const { nvim } = coc_nvim_1.workspace;
 143     const configuration = coc_nvim_1.workspace.getConfiguration('snippets');
 144     const filetypeExtends = configuration.get('extends', {});
 145     const manager = new provider_1.ProviderManager();
 146     const trace = configuration.get('trace', 'error');
 147     let mru = coc_nvim_1.workspace.createMru('snippets-mru');
 148     const channel = coc_nvim_1.workspace.createOutputChannel('snippets');
 149     let snippetsDir = configuration.get('userSnippetsDirectory');
 150     if (snippetsDir) {
 151         snippetsDir = snippetsDir.replace(/^~/, os_1.default.homedir());
 152         if (snippetsDir.indexOf('$') !== -1) {
 153             snippetsDir = snippetsDir.replace(/\$(\w+)/g, (match, p1) => {
 154                 var _a;
 155                 return (_a = process.env[p1]) !== null && _a !== void 0 ? _a : match;
 156             });
 157         }
 158         if (!path_1.default.isAbsolute(snippetsDir)) {
 159             coc_nvim_1.workspace.showMessage(`snippets.userSnippetsDirectory => ${snippetsDir} should be absolute path`, 'warning');
 160             snippetsDir = null;
 161         }
 162     }
 163     if (!snippetsDir)
 164         snippetsDir = path_1.default.join(path_1.default.dirname(coc_nvim_1.workspace.env.extensionRoot), 'ultisnips');
 165     if (!fs_1.default.existsSync(snippetsDir)) {
 166         await util_1.default.promisify(fs_1.default.mkdir)(snippetsDir);
 167     }
 168     coc_nvim_1.events.on('CompleteDone', async (item) => {
 169         if (item.user_data && item.user_data.indexOf('snippets') !== -1) {
 170             await mru.add(item.word);
 171         }
 172     }, null, subscriptions);
 173     coc_nvim_1.workspace.onDidOpenTextDocument(async (document) => {
 174         if (document.uri.endsWith('.snippets')) {
 175             let doc = coc_nvim_1.workspace.getDocument(document.uri);
 176             if (!doc)
 177                 return;
 178             let { buffer } = doc;
 179             await buffer.setOption('filetype', 'snippets');
 180         }
 181     }, null, subscriptions);
 182     if (configuration.get('ultisnips.enable', true)) {
 183         let config = configuration.get('ultisnips', {});
 184         let c = Object.assign({}, config, {
 185             extends: Object.assign({}, filetypeExtends)
 186         });
 187         c.directories = c.directories ? c.directories.slice() : [];
 188         if (c.directories.indexOf(snippetsDir) == -1) {
 189             c.directories.push(snippetsDir);
 190         }
 191         let provider = new ultisnipsProvider_1.UltiSnippetsProvider(channel, trace, c, context);
 192         manager.regist(provider, 'ultisnips');
 193         subscriptions.push(provider);
 194         // add rtp if ultisnips not found
 195         nvim.getOption('runtimepath').then(async (rtp) => {
 196             let paths = rtp.split(',');
 197             let idx = paths.findIndex(s => /^ultisnips$/i.test(path_1.default.basename(s)));
 198             if (idx !== -1)
 199                 return;
 200             let directory = path_1.default.resolve(__dirname, '..');
 201             nvim.command('autocmd BufNewFile,BufRead *.snippets setf snippets', true);
 202             nvim.command(`execute 'noa set rtp+='.fnameescape('${directory.replace(/'/g, "''")}')`, true);
 203             coc_nvim_1.workspace.documents.forEach(doc => {
 204                 if (doc.uri.endsWith('.snippets')) {
 205                     doc.buffer.setOption('filetype', 'snippets', true);
 206                 }
 207             });
 208         }, _e => {
 209             // noop
 210         });
 211     }
 212     let config = {
 213         loadFromExtensions: configuration.get('loadFromExtensions', true),
 214         snippetsRoots: configuration.get('textmateSnippetsRoots', []),
 215         extends: Object.assign({}, filetypeExtends)
 216     };
 217     let provider = new textmateProvider_1.TextmateProvider(channel, trace, config);
 218     manager.regist(provider, 'snippets');
 219     if (configuration.get('snipmate.enable', true)) {
 220         let config = {
 221             author: configuration.get('snipmate.author', ''),
 222             extends: Object.assign({}, filetypeExtends)
 223         };
 224         let provider = new snipmateProvider_1.SnipmateProvider(channel, trace, config);
 225         manager.regist(provider, 'snipmate');
 226     }
 227     if (configuration.get('autoTrigger', true)) {
 228         let insertTs;
 229         coc_nvim_1.events.on('InsertCharPre', () => {
 230             insertTs = Date.now();
 231         }, null, subscriptions);
 232         coc_nvim_1.events.on(['TextChanged', 'TextChangedP', 'TextChangedI'], debounce_1.default(async () => {
 233             if (!coc_nvim_1.workspace.insertMode)
 234                 return;
 235             if (!insertTs || Date.now() - insertTs > 200)
 236                 return;
 237             let curr = insertTs;
 238             let edits = await manager.getTriggerSnippets(true);
 239             if (insertTs != curr || edits.length == 0)
 240                 return;
 241             if (edits.length > 1) {
 242                 channel.appendLine(`Multiple snippet found for auto trigger: ${edits.map(s => s.prefix).join(', ')}`);
 243                 coc_nvim_1.workspace.showMessage('Multiple snippet found for auto trigger, check output by :CocCommand workspace.showOutput', 'warning');
 244             }
 245             await coc_nvim_1.commands.executeCommand('editor.action.insertSnippet', edits[0]);
 246             await mru.add(edits[0].prefix);
 247         }, 100), null, subscriptions);
 248     }
 249     let statusItem;
 250     if (configuration.get('enableStatusItem', true)) {
 251         statusItem = coc_nvim_1.workspace.createStatusBarItem(90, { progress: true });
 252         statusItem.text = 'loading snippets';
 253         statusItem.show();
 254     }
 255     manager.init().then(() => {
 256         statusItem === null || statusItem === void 0 ? void 0 : statusItem.hide();
 257     }, e => {
 258         statusItem === null || statusItem === void 0 ? void 0 : statusItem.hide();
 259         coc_nvim_1.workspace.showMessage(`Error on load snippets: ${e.message}`, 'error');
 260     });
 261     if (manager.hasProvider) {
 262         let disposable = coc_nvim_1.languages.registerCompletionItemProvider('snippets', 'S', null, manager, configuration.get('triggerCharacters', []), configuration.get('priority', 90));
 263         subscriptions.push(disposable);
 264     }
 265     async function fallback() {
 266         await nvim.call('coc#start', [{ source: 'snippets' }]);
 267     }
 268     async function doExpand() {
 269         let edits = await manager.getTriggerSnippets();
 270         if (edits.length == 0)
 271             return false;
 272         if (edits.length == 1) {
 273             await coc_nvim_1.commands.executeCommand('editor.action.insertSnippet', edits[0]);
 274             await mru.add(edits[0].prefix);
 275         }
 276         else {
 277             let idx = await coc_nvim_1.workspace.showQuickpick(edits.map(e => e.description || e.prefix), 'choose snippet:');
 278             if (idx == -1)
 279                 return;
 280             await coc_nvim_1.commands.executeCommand('editor.action.insertSnippet', edits[idx]);
 281             await mru.add(edits[idx].prefix);
 282         }
 283         return true;
 284     }
 285     if (configuration.get("convertToSnippetsAction")) {
 286         subscriptions.push(coc_nvim_1.languages.registerCodeActionProvider([{ scheme: 'file' }, { scheme: 'untitled' }], {
 287             provideCodeActions: async (document, range, context) => {
 288                 if (context.only && !context.only.includes(vscode_languageserver_types_1.CodeActionKind.Source))
 289                     return;
 290                 let text = document.getText(range);
 291                 if (text.endsWith('\n'))
 292                     text = text.replace(/\n$/, '');
 293                 let action = vscode_languageserver_types_1.CodeAction.create('Convert to snippet', {
 294                     command: 'snippets.editSnippets',
 295                     title: 'Convert to snippet',
 296                     arguments: [text]
 297                 });
 298                 return [action];
 299             }
 300         }, 'snippets', [vscode_languageserver_types_1.CodeActionKind.Source]));
 301     }
 302     subscriptions.push(coc_nvim_1.commands.registerCommand('snippets.editSnippets', async (text) => {
 303         let buf = await nvim.buffer;
 304         let doc = coc_nvim_1.workspace.getDocument(buf.id);
 305         if (!doc) {
 306             coc_nvim_1.workspace.showMessage('Document not found', 'error');
 307             return;
 308         }
 309         let file = path_1.default.join(snippetsDir, `${doc.filetype}.snippets`);
 310         if (!fs_1.default.existsSync(file)) {
 311             await util_1.default.promisify(fs_1.default.writeFile)(file, documentation, 'utf8');
 312         }
 313         let uri = coc_nvim_1.Uri.file(file).toString();
 314         await coc_nvim_1.workspace.jumpTo(uri, null, configuration.get('editSnippetsCommand'));
 315         if (text) {
 316             await nvim.command('normal! G');
 317             await nvim.command('normal! 2o');
 318             let position = await coc_nvim_1.workspace.getCursorPosition();
 319             let indent = text.match(/^\s*/)[0];
 320             text = text.split(/\r?\n/).map(s => s.startsWith(indent) ? s.slice(indent.length) : s).join('\n');
 321             let escaped = text.replace(/([$}\]])/g, '\\$1');
 322             // tslint:disable-next-line: no-invalid-template-strings
 323             let snippet = 'snippet ${1:Tab_trigger} "${2:Description}" ${3:b}\n' + escaped + '\nendsnippet';
 324             let edit = vscode_languageserver_types_1.TextEdit.insert(position, snippet);
 325             await coc_nvim_1.commands.executeCommand('editor.action.insertSnippet', edit);
 326         }
 327     }));
 328     subscriptions.push(coc_nvim_1.commands.registerCommand('snippets.openSnippetFiles', async () => {
 329         let buf = await nvim.buffer;
 330         let doc = coc_nvim_1.workspace.getDocument(buf.id);
 331         if (!doc) {
 332             coc_nvim_1.workspace.showMessage('Document not found', 'error');
 333             return;
 334         }
 335         let files = await manager.getSnippetFiles(doc.filetype);
 336         if (!files.length) {
 337             coc_nvim_1.workspace.showMessage('No related snippet file found', 'warning');
 338             return;
 339         }
 340         let idx = await coc_nvim_1.workspace.showQuickpick(files, 'choose snippet file:');
 341         if (idx == -1)
 342             return;
 343         let uri = coc_nvim_1.Uri.file(files[idx]).toString();
 344         await coc_nvim_1.workspace.jumpTo(uri, null, configuration.get('editSnippetsCommand'));
 345     }));
 346     subscriptions.push(coc_nvim_1.workspace.registerKeymap(['i'], 'snippets-expand', async () => {
 347         let expanded = await doExpand();
 348         if (!expanded)
 349             await fallback();
 350     }, { silent: true, sync: true, cancel: true }));
 351     subscriptions.push(coc_nvim_1.workspace.registerKeymap(['i'], 'snippets-expand-jump', async () => {
 352         let expanded = await doExpand();
 353         if (!expanded) {
 354             let bufnr = await nvim.call('bufnr', '%');
 355             let session = coc_nvim_1.snippetManager.getSession(bufnr);
 356             if (session && session.isActive) {
 357                 await nvim.call('coc#_cancel', []);
 358                 await coc_nvim_1.snippetManager.nextPlaceholder();
 359                 return;
 360             }
 361             await fallback();
 362         }
 363     }, { silent: true, sync: true, cancel: true }));
 364     subscriptions.push(coc_nvim_1.workspace.registerKeymap(['v'], 'snippets-select', async () => {
 365         let doc = await coc_nvim_1.workspace.document;
 366         if (!doc)
 367             return;
 368         let mode = await nvim.call('visualmode');
 369         if (['v', 'V'].indexOf(mode) == -1) {
 370             coc_nvim_1.workspace.showMessage(`visual mode ${mode} not supported`, 'warning');
 371             return;
 372         }
 373         await nvim.command('normal! `<');
 374         let start = await coc_nvim_1.workspace.getCursorPosition();
 375         await nvim.command('normal! `>');
 376         let end = await coc_nvim_1.workspace.getCursorPosition();
 377         end = vscode_languageserver_types_1.Position.create(end.line, end.character + 1);
 378         let range = vscode_languageserver_types_1.Range.create(start, end);
 379         let text = doc.textDocument.getText(range);
 380         await nvim.call('feedkeys', ['i', 'in']);
 381         if (mode == 'v') {
 382             await doc.applyEdits(coc_nvim_1.workspace.nvim, [{ range, newText: '' }]);
 383         }
 384         else {
 385             // keep indent
 386             let currline = doc.getline(start.line);
 387             let indent = currline.match(/^\s*/)[0];
 388             let lines = text.split(/\r?\n/);
 389             lines = lines.map(s => s.startsWith(indent) ? s.slice(indent.length) : s);
 390             text = lines.join('\n');
 391             range = vscode_languageserver_types_1.Range.create(vscode_languageserver_types_1.Position.create(start.line, indent.length), end);
 392             await doc.applyEdits(coc_nvim_1.workspace.nvim, [{ range, newText: '' }]);
 393         }
 394         await nvim.setVar('coc_selected_text', text);
 395         await coc_nvim_1.workspace.moveTo(range.start);
 396     }, { silent: true, sync: false, cancel: true }));
 397     let languageProvider = new languages_1.default(channel, trace);
 398     subscriptions.push(coc_nvim_1.languages.registerCompletionItemProvider('snippets-source', 'S', ['snippets'], languageProvider, ['$'], configuration.get('priority', 90)));
 399     subscriptions.push(statusItem);
 400     subscriptions.push(channel);
 401     subscriptions.push(coc_nvim_1.listManager.registerList(new snippet_1.default(coc_nvim_1.workspace.nvim, manager, mru)));
 402     return {
 403         expandable: async () => {
 404             let edits;
 405             try {
 406                 edits = await manager.getTriggerSnippets();
 407             }
 408             catch (e) {
 409                 channel.appendLine(`[Error ${(new Date()).toLocaleTimeString()}] Error on getTriggerSnippets: ${e}`);
 410             }
 411             return edits && edits.length > 0;
 412         }
 413     };
 414 }
 415 exports.activate = activate;
 416
 417
 418 /***/ }),
 419 /* 1 */
 420 /***/ (function(module, exports) {
 421
 422 module.exports = require("coc.nvim");
 423
 424 /***/ }),
 425 /* 2 */
 426 /***/ (function(module, exports) {
 427
 428 module.exports = require("os");
 429
 430 /***/ }),
 431 /* 3 */
 432 /***/ (function(module, exports) {
 433
 434 module.exports = require("fs");
 435
 436 /***/ }),
 437 /* 4 */
 438 /***/ (function(module, exports) {
 439
 440 module.exports = require("path");
 441
 442 /***/ }),
 443 /* 5 */
 444 /***/ (function(module, exports) {
 445
 446 module.exports = require("util");
 447
 448 /***/ }),
 449 /* 6 */
 450 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 451
 452 "use strict";
 453 __webpack_require__.r(__webpack_exports__);
 454 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Position", function() { return Position; });
 455 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Range", function() { return Range; });
 456 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Location", function() { return Location; });
 457 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LocationLink", function() { return LocationLink; });
 458 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Color", function() { return Color; });
 459 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ColorInformation", function() { return ColorInformation; });
 460 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ColorPresentation", function() { return ColorPresentation; });
 461 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FoldingRangeKind", function() { return FoldingRangeKind; });
 462 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FoldingRange", function() { return FoldingRange; });
 463 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DiagnosticRelatedInformation", function() { return DiagnosticRelatedInformation; });
 464 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DiagnosticSeverity", function() { return DiagnosticSeverity; });
 465 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DiagnosticTag", function() { return DiagnosticTag; });
 466 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Diagnostic", function() { return Diagnostic; });
 467 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Command", function() { return Command; });
 468 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextEdit", function() { return TextEdit; });
 469 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocumentEdit", function() { return TextDocumentEdit; });
 470 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CreateFile", function() { return CreateFile; });
 471 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RenameFile", function() { return RenameFile; });
 472 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DeleteFile", function() { return DeleteFile; });
 473 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "WorkspaceEdit", function() { return WorkspaceEdit; });
 474 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "WorkspaceChange", function() { return WorkspaceChange; });
 475 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocumentIdentifier", function() { return TextDocumentIdentifier; });
 476 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "VersionedTextDocumentIdentifier", function() { return VersionedTextDocumentIdentifier; });
 477 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocumentItem", function() { return TextDocumentItem; });
 478 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MarkupKind", function() { return MarkupKind; });
 479 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MarkupContent", function() { return MarkupContent; });
 480 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionItemKind", function() { return CompletionItemKind; });
 481 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "InsertTextFormat", function() { return InsertTextFormat; });
 482 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionItemTag", function() { return CompletionItemTag; });
 483 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionItem", function() { return CompletionItem; });
 484 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionList", function() { return CompletionList; });
 485 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MarkedString", function() { return MarkedString; });
 486 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Hover", function() { return Hover; });
 487 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ParameterInformation", function() { return ParameterInformation; });
 488 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SignatureInformation", function() { return SignatureInformation; });
 489 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentHighlightKind", function() { return DocumentHighlightKind; });
 490 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentHighlight", function() { return DocumentHighlight; });
 491 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SymbolKind", function() { return SymbolKind; });
 492 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SymbolTag", function() { return SymbolTag; });
 493 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SymbolInformation", function() { return SymbolInformation; });
 494 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentSymbol", function() { return DocumentSymbol; });
 495 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodeActionKind", function() { return CodeActionKind; });
 496 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodeActionContext", function() { return CodeActionContext; });
 497 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodeAction", function() { return CodeAction; });
 498 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodeLens", function() { return CodeLens; });
 499 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FormattingOptions", function() { return FormattingOptions; });
 500 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentLink", function() { return DocumentLink; });
 501 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SelectionRange", function() { return SelectionRange; });
 502 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EOL", function() { return EOL; });
 503 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocument", function() { return TextDocument; });
 504 /* --------------------------------------------------------------------------------------------\r
 505  * Copyright (c) Microsoft Corporation. All rights reserved.\r
 506  * Licensed under the MIT License. See License.txt in the project root for license information.\r
 507  * ------------------------------------------------------------------------------------------ */\r
 508 \r
 509 /**\r
 510  * The Position namespace provides helper functions to work with\r
 511  * [Position](#Position) literals.\r
 512  */\r
 513 var Position;\r
 514 (function (Position) {\r
 515     /**\r
 516      * Creates a new Position literal from the given line and character.\r
 517      * @param line The position's line.\r
 518      * @param character The position's character.\r
 519      */\r
 520     function create(line, character) {\r
 521         return { line: line, character: character };\r
 522     }\r
 523     Position.create = create;\r
 524     /**\r
 525      * Checks whether the given liternal conforms to the [Position](#Position) interface.\r
 526      */\r
 527     function is(value) {\r
 528         var candidate = value;\r
 529         return Is.objectLiteral(candidate) && Is.number(candidate.line) && Is.number(candidate.character);\r
 530     }\r
 531     Position.is = is;\r
 532 })(Position || (Position = {}));\r
 533 /**\r
 534  * The Range namespace provides helper functions to work with\r
 535  * [Range](#Range) literals.\r
 536  */\r
 537 var Range;\r
 538 (function (Range) {\r
 539     function create(one, two, three, four) {\r
 540         if (Is.number(one) && Is.number(two) && Is.number(three) && Is.number(four)) {\r
 541             return { start: Position.create(one, two), end: Position.create(three, four) };\r
 542         }\r
 543         else if (Position.is(one) && Position.is(two)) {\r
 544             return { start: one, end: two };\r
 545         }\r
 546         else {\r
 547             throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");\r
 548         }\r
 549     }\r
 550     Range.create = create;\r
 551     /**\r
 552      * Checks whether the given literal conforms to the [Range](#Range) interface.\r
 553      */\r
 554     function is(value) {\r
 555         var candidate = value;\r
 556         return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);\r
 557     }\r
 558     Range.is = is;\r
 559 })(Range || (Range = {}));\r
 560 /**\r
 561  * The Location namespace provides helper functions to work with\r
 562  * [Location](#Location) literals.\r
 563  */\r
 564 var Location;\r
 565 (function (Location) {\r
 566     /**\r
 567      * Creates a Location literal.\r
 568      * @param uri The location's uri.\r
 569      * @param range The location's range.\r
 570      */\r
 571     function create(uri, range) {\r
 572         return { uri: uri, range: range };\r
 573     }\r
 574     Location.create = create;\r
 575     /**\r
 576      * Checks whether the given literal conforms to the [Location](#Location) interface.\r
 577      */\r
 578     function is(value) {\r
 579         var candidate = value;\r
 580         return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));\r
 581     }\r
 582     Location.is = is;\r
 583 })(Location || (Location = {}));\r
 584 /**\r
 585  * The LocationLink namespace provides helper functions to work with\r
 586  * [LocationLink](#LocationLink) literals.\r
 587  */\r
 588 var LocationLink;\r
 589 (function (LocationLink) {\r
 590     /**\r
 591      * Creates a LocationLink literal.\r
 592      * @param targetUri The definition's uri.\r
 593      * @param targetRange The full range of the definition.\r
 594      * @param targetSelectionRange The span of the symbol definition at the target.\r
 595      * @param originSelectionRange The span of the symbol being defined in the originating source file.\r
 596      */\r
 597     function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {\r
 598         return { targetUri: targetUri, targetRange: targetRange, targetSelectionRange: targetSelectionRange, originSelectionRange: originSelectionRange };\r
 599     }\r
 600     LocationLink.create = create;\r
 601     /**\r
 602      * Checks whether the given literal conforms to the [LocationLink](#LocationLink) interface.\r
 603      */\r
 604     function is(value) {\r
 605         var candidate = value;\r
 606         return Is.defined(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri)\r
 607             && (Range.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange))\r
 608             && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));\r
 609     }\r
 610     LocationLink.is = is;\r
 611 })(LocationLink || (LocationLink = {}));\r
 612 /**\r
 613  * The Color namespace provides helper functions to work with\r
 614  * [Color](#Color) literals.\r
 615  */\r
 616 var Color;\r
 617 (function (Color) {\r
 618     /**\r
 619      * Creates a new Color literal.\r
 620      */\r
 621     function create(red, green, blue, alpha) {\r
 622         return {\r
 623             red: red,\r
 624             green: green,\r
 625             blue: blue,\r
 626             alpha: alpha,\r
 627         };\r
 628     }\r
 629     Color.create = create;\r
 630     /**\r
 631      * Checks whether the given literal conforms to the [Color](#Color) interface.\r
 632      */\r
 633     function is(value) {\r
 634         var candidate = value;\r
 635         return Is.number(candidate.red)\r
 636             && Is.number(candidate.green)\r
 637             && Is.number(candidate.blue)\r
 638             && Is.number(candidate.alpha);\r
 639     }\r
 640     Color.is = is;\r
 641 })(Color || (Color = {}));\r
 642 /**\r
 643  * The ColorInformation namespace provides helper functions to work with\r
 644  * [ColorInformation](#ColorInformation) literals.\r
 645  */\r
 646 var ColorInformation;\r
 647 (function (ColorInformation) {\r
 648     /**\r
 649      * Creates a new ColorInformation literal.\r
 650      */\r
 651     function create(range, color) {\r
 652         return {\r
 653             range: range,\r
 654             color: color,\r
 655         };\r
 656     }\r
 657     ColorInformation.create = create;\r
 658     /**\r
 659      * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.\r
 660      */\r
 661     function is(value) {\r
 662         var candidate = value;\r
 663         return Range.is(candidate.range) && Color.is(candidate.color);\r
 664     }\r
 665     ColorInformation.is = is;\r
 666 })(ColorInformation || (ColorInformation = {}));\r
 667 /**\r
 668  * The Color namespace provides helper functions to work with\r
 669  * [ColorPresentation](#ColorPresentation) literals.\r
 670  */\r
 671 var ColorPresentation;\r
 672 (function (ColorPresentation) {\r
 673     /**\r
 674      * Creates a new ColorInformation literal.\r
 675      */\r
 676     function create(label, textEdit, additionalTextEdits) {\r
 677         return {\r
 678             label: label,\r
 679             textEdit: textEdit,\r
 680             additionalTextEdits: additionalTextEdits,\r
 681         };\r
 682     }\r
 683     ColorPresentation.create = create;\r
 684     /**\r
 685      * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.\r
 686      */\r
 687     function is(value) {\r
 688         var candidate = value;\r
 689         return Is.string(candidate.label)\r
 690             && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))\r
 691             && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));\r
 692     }\r
 693     ColorPresentation.is = is;\r
 694 })(ColorPresentation || (ColorPresentation = {}));\r
 695 /**\r
 696  * Enum of known range kinds\r
 697  */\r
 698 var FoldingRangeKind;\r
 699 (function (FoldingRangeKind) {\r
 700     /**\r
 701      * Folding range for a comment\r
 702      */\r
 703     FoldingRangeKind["Comment"] = "comment";\r
 704     /**\r
 705      * Folding range for a imports or includes\r
 706      */\r
 707     FoldingRangeKind["Imports"] = "imports";\r
 708     /**\r
 709      * Folding range for a region (e.g. `#region`)\r
 710      */\r
 711     FoldingRangeKind["Region"] = "region";\r
 712 })(FoldingRangeKind || (FoldingRangeKind = {}));\r
 713 /**\r
 714  * The folding range namespace provides helper functions to work with\r
 715  * [FoldingRange](#FoldingRange) literals.\r
 716  */\r
 717 var FoldingRange;\r
 718 (function (FoldingRange) {\r
 719     /**\r
 720      * Creates a new FoldingRange literal.\r
 721      */\r
 722     function create(startLine, endLine, startCharacter, endCharacter, kind) {\r
 723         var result = {\r
 724             startLine: startLine,\r
 725             endLine: endLine\r
 726         };\r
 727         if (Is.defined(startCharacter)) {\r
 728             result.startCharacter = startCharacter;\r
 729         }\r
 730         if (Is.defined(endCharacter)) {\r
 731             result.endCharacter = endCharacter;\r
 732         }\r
 733         if (Is.defined(kind)) {\r
 734             result.kind = kind;\r
 735         }\r
 736         return result;\r
 737     }\r
 738     FoldingRange.create = create;\r
 739     /**\r
 740      * Checks whether the given literal conforms to the [FoldingRange](#FoldingRange) interface.\r
 741      */\r
 742     function is(value) {\r
 743         var candidate = value;\r
 744         return Is.number(candidate.startLine) && Is.number(candidate.startLine)\r
 745             && (Is.undefined(candidate.startCharacter) || Is.number(candidate.startCharacter))\r
 746             && (Is.undefined(candidate.endCharacter) || Is.number(candidate.endCharacter))\r
 747             && (Is.undefined(candidate.kind) || Is.string(candidate.kind));\r
 748     }\r
 749     FoldingRange.is = is;\r
 750 })(FoldingRange || (FoldingRange = {}));\r
 751 /**\r
 752  * The DiagnosticRelatedInformation namespace provides helper functions to work with\r
 753  * [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) literals.\r
 754  */\r
 755 var DiagnosticRelatedInformation;\r
 756 (function (DiagnosticRelatedInformation) {\r
 757     /**\r
 758      * Creates a new DiagnosticRelatedInformation literal.\r
 759      */\r
 760     function create(location, message) {\r
 761         return {\r
 762             location: location,\r
 763             message: message\r
 764         };\r
 765     }\r
 766     DiagnosticRelatedInformation.create = create;\r
 767     /**\r
 768      * Checks whether the given literal conforms to the [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) interface.\r
 769      */\r
 770     function is(value) {\r
 771         var candidate = value;\r
 772         return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);\r
 773     }\r
 774     DiagnosticRelatedInformation.is = is;\r
 775 })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));\r
 776 /**\r
 777  * The diagnostic's severity.\r
 778  */\r
 779 var DiagnosticSeverity;\r
 780 (function (DiagnosticSeverity) {\r
 781     /**\r
 782      * Reports an error.\r
 783      */\r
 784     DiagnosticSeverity.Error = 1;\r
 785     /**\r
 786      * Reports a warning.\r
 787      */\r
 788     DiagnosticSeverity.Warning = 2;\r
 789     /**\r
 790      * Reports an information.\r
 791      */\r
 792     DiagnosticSeverity.Information = 3;\r
 793     /**\r
 794      * Reports a hint.\r
 795      */\r
 796     DiagnosticSeverity.Hint = 4;\r
 797 })(DiagnosticSeverity || (DiagnosticSeverity = {}));\r
 798 /**\r
 799  * The diagnostic tags.\r
 800  *\r
 801  * @since 3.15.0\r
 802  */\r
 803 var DiagnosticTag;\r
 804 (function (DiagnosticTag) {\r
 805     /**\r
 806      * Unused or unnecessary code.\r
 807      *\r
 808      * Clients are allowed to render diagnostics with this tag faded out instead of having\r
 809      * an error squiggle.\r
 810      */\r
 811     DiagnosticTag.Unnecessary = 1;\r
 812     /**\r
 813      * Deprecated or obsolete code.\r
 814      *\r
 815      * Clients are allowed to rendered diagnostics with this tag strike through.\r
 816      */\r
 817     DiagnosticTag.Deprecated = 2;\r
 818 })(DiagnosticTag || (DiagnosticTag = {}));\r
 819 /**\r
 820  * The Diagnostic namespace provides helper functions to work with\r
 821  * [Diagnostic](#Diagnostic) literals.\r
 822  */\r
 823 var Diagnostic;\r
 824 (function (Diagnostic) {\r
 825     /**\r
 826      * Creates a new Diagnostic literal.\r
 827      */\r
 828     function create(range, message, severity, code, source, relatedInformation) {\r
 829         var result = { range: range, message: message };\r
 830         if (Is.defined(severity)) {\r
 831             result.severity = severity;\r
 832         }\r
 833         if (Is.defined(code)) {\r
 834             result.code = code;\r
 835         }\r
 836         if (Is.defined(source)) {\r
 837             result.source = source;\r
 838         }\r
 839         if (Is.defined(relatedInformation)) {\r
 840             result.relatedInformation = relatedInformation;\r
 841         }\r
 842         return result;\r
 843     }\r
 844     Diagnostic.create = create;\r
 845     /**\r
 846      * Checks whether the given literal conforms to the [Diagnostic](#Diagnostic) interface.\r
 847      */\r
 848     function is(value) {\r
 849         var candidate = value;\r
 850         return Is.defined(candidate)\r
 851             && Range.is(candidate.range)\r
 852             && Is.string(candidate.message)\r
 853             && (Is.number(candidate.severity) || Is.undefined(candidate.severity))\r
 854             && (Is.number(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code))\r
 855             && (Is.string(candidate.source) || Is.undefined(candidate.source))\r
 856             && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));\r
 857     }\r
 858     Diagnostic.is = is;\r
 859 })(Diagnostic || (Diagnostic = {}));\r
 860 /**\r
 861  * The Command namespace provides helper functions to work with\r
 862  * [Command](#Command) literals.\r
 863  */\r
 864 var Command;\r
 865 (function (Command) {\r
 866     /**\r
 867      * Creates a new Command literal.\r
 868      */\r
 869     function create(title, command) {\r
 870         var args = [];\r
 871         for (var _i = 2; _i < arguments.length; _i++) {\r
 872             args[_i - 2] = arguments[_i];\r
 873         }\r
 874         var result = { title: title, command: command };\r
 875         if (Is.defined(args) && args.length > 0) {\r
 876             result.arguments = args;\r
 877         }\r
 878         return result;\r
 879     }\r
 880     Command.create = create;\r
 881     /**\r
 882      * Checks whether the given literal conforms to the [Command](#Command) interface.\r
 883      */\r
 884     function is(value) {\r
 885         var candidate = value;\r
 886         return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);\r
 887     }\r
 888     Command.is = is;\r
 889 })(Command || (Command = {}));\r
 890 /**\r
 891  * The TextEdit namespace provides helper function to create replace,\r
 892  * insert and delete edits more easily.\r
 893  */\r
 894 var TextEdit;\r
 895 (function (TextEdit) {\r
 896     /**\r
 897      * Creates a replace text edit.\r
 898      * @param range The range of text to be replaced.\r
 899      * @param newText The new text.\r
 900      */\r
 901     function replace(range, newText) {\r
 902         return { range: range, newText: newText };\r
 903     }\r
 904     TextEdit.replace = replace;\r
 905     /**\r
 906      * Creates a insert text edit.\r
 907      * @param position The position to insert the text at.\r
 908      * @param newText The text to be inserted.\r
 909      */\r
 910     function insert(position, newText) {\r
 911         return { range: { start: position, end: position }, newText: newText };\r
 912     }\r
 913     TextEdit.insert = insert;\r
 914     /**\r
 915      * Creates a delete text edit.\r
 916      * @param range The range of text to be deleted.\r
 917      */\r
 918     function del(range) {\r
 919         return { range: range, newText: '' };\r
 920     }\r
 921     TextEdit.del = del;\r
 922     function is(value) {\r
 923         var candidate = value;\r
 924         return Is.objectLiteral(candidate)\r
 925             && Is.string(candidate.newText)\r
 926             && Range.is(candidate.range);\r
 927     }\r
 928     TextEdit.is = is;\r
 929 })(TextEdit || (TextEdit = {}));\r
 930 /**\r
 931  * The TextDocumentEdit namespace provides helper function to create\r
 932  * an edit that manipulates a text document.\r
 933  */\r
 934 var TextDocumentEdit;\r
 935 (function (TextDocumentEdit) {\r
 936     /**\r
 937      * Creates a new `TextDocumentEdit`\r
 938      */\r
 939     function create(textDocument, edits) {\r
 940         return { textDocument: textDocument, edits: edits };\r
 941     }\r
 942     TextDocumentEdit.create = create;\r
 943     function is(value) {\r
 944         var candidate = value;\r
 945         return Is.defined(candidate)\r
 946             && VersionedTextDocumentIdentifier.is(candidate.textDocument)\r
 947             && Array.isArray(candidate.edits);\r
 948     }\r
 949     TextDocumentEdit.is = is;\r
 950 })(TextDocumentEdit || (TextDocumentEdit = {}));\r
 951 var CreateFile;\r
 952 (function (CreateFile) {\r
 953     function create(uri, options) {\r
 954         var result = {\r
 955             kind: 'create',\r
 956             uri: uri\r
 957         };\r
 958         if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {\r
 959             result.options = options;\r
 960         }\r
 961         return result;\r
 962     }\r
 963     CreateFile.create = create;\r
 964     function is(value) {\r
 965         var candidate = value;\r
 966         return candidate && candidate.kind === 'create' && Is.string(candidate.uri) &&\r
 967             (candidate.options === void 0 ||\r
 968                 ((candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))));\r
 969     }\r
 970     CreateFile.is = is;\r
 971 })(CreateFile || (CreateFile = {}));\r
 972 var RenameFile;\r
 973 (function (RenameFile) {\r
 974     function create(oldUri, newUri, options) {\r
 975         var result = {\r
 976             kind: 'rename',\r
 977             oldUri: oldUri,\r
 978             newUri: newUri\r
 979         };\r
 980         if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {\r
 981             result.options = options;\r
 982         }\r
 983         return result;\r
 984     }\r
 985     RenameFile.create = create;\r
 986     function is(value) {\r
 987         var candidate = value;\r
 988         return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) &&\r
 989             (candidate.options === void 0 ||\r
 990                 ((candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))));\r
 991     }\r
 992     RenameFile.is = is;\r
 993 })(RenameFile || (RenameFile = {}));\r
 994 var DeleteFile;\r
 995 (function (DeleteFile) {\r
 996     function create(uri, options) {\r
 997         var result = {\r
 998             kind: 'delete',\r
 999             uri: uri\r
1000         };\r
1001         if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {\r
1002             result.options = options;\r
1003         }\r
1004         return result;\r
1005     }\r
1006     DeleteFile.create = create;\r
1007     function is(value) {\r
1008         var candidate = value;\r
1009         return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) &&\r
1010             (candidate.options === void 0 ||\r
1011                 ((candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))));\r
1012     }\r
1013     DeleteFile.is = is;\r
1014 })(DeleteFile || (DeleteFile = {}));\r
1015 var WorkspaceEdit;\r
1016 (function (WorkspaceEdit) {\r
1017     function is(value) {\r
1018         var candidate = value;\r
1019         return candidate &&\r
1020             (candidate.changes !== void 0 || candidate.documentChanges !== void 0) &&\r
1021             (candidate.documentChanges === void 0 || candidate.documentChanges.every(function (change) {\r
1022                 if (Is.string(change.kind)) {\r
1023                     return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);\r
1024                 }\r
1025                 else {\r
1026                     return TextDocumentEdit.is(change);\r
1027                 }\r
1028             }));\r
1029     }\r
1030     WorkspaceEdit.is = is;\r
1031 })(WorkspaceEdit || (WorkspaceEdit = {}));\r
1032 var TextEditChangeImpl = /** @class */ (function () {\r
1033     function TextEditChangeImpl(edits) {\r
1034         this.edits = edits;\r
1035     }\r
1036     TextEditChangeImpl.prototype.insert = function (position, newText) {\r
1037         this.edits.push(TextEdit.insert(position, newText));\r
1038     };\r
1039     TextEditChangeImpl.prototype.replace = function (range, newText) {\r
1040         this.edits.push(TextEdit.replace(range, newText));\r
1041     };\r
1042     TextEditChangeImpl.prototype.delete = function (range) {\r
1043         this.edits.push(TextEdit.del(range));\r
1044     };\r
1045     TextEditChangeImpl.prototype.add = function (edit) {\r
1046         this.edits.push(edit);\r
1047     };\r
1048     TextEditChangeImpl.prototype.all = function () {\r
1049         return this.edits;\r
1050     };\r
1051     TextEditChangeImpl.prototype.clear = function () {\r
1052         this.edits.splice(0, this.edits.length);\r
1053     };\r
1054     return TextEditChangeImpl;\r
1055 }());\r
1056 /**\r
1057  * A workspace change helps constructing changes to a workspace.\r
1058  */\r
1059 var WorkspaceChange = /** @class */ (function () {\r
1060     function WorkspaceChange(workspaceEdit) {\r
1061         var _this = this;\r
1062         this._textEditChanges = Object.create(null);\r
1063         if (workspaceEdit) {\r
1064             this._workspaceEdit = workspaceEdit;\r
1065             if (workspaceEdit.documentChanges) {\r
1066                 workspaceEdit.documentChanges.forEach(function (change) {\r
1067                     if (TextDocumentEdit.is(change)) {\r
1068                         var textEditChange = new TextEditChangeImpl(change.edits);\r
1069                         _this._textEditChanges[change.textDocument.uri] = textEditChange;\r
1070                     }\r
1071                 });\r
1072             }\r
1073             else if (workspaceEdit.changes) {\r
1074                 Object.keys(workspaceEdit.changes).forEach(function (key) {\r
1075                     var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);\r
1076                     _this._textEditChanges[key] = textEditChange;\r
1077                 });\r
1078             }\r
1079         }\r
1080     }\r
1081     Object.defineProperty(WorkspaceChange.prototype, "edit", {\r
1082         /**\r
1083          * Returns the underlying [WorkspaceEdit](#WorkspaceEdit) literal\r
1084          * use to be returned from a workspace edit operation like rename.\r
1085          */\r
1086         get: function () {\r
1087             return this._workspaceEdit;\r
1088         },\r
1089         enumerable: true,\r
1090         configurable: true\r
1091     });\r
1092     WorkspaceChange.prototype.getTextEditChange = function (key) {\r
1093         if (VersionedTextDocumentIdentifier.is(key)) {\r
1094             if (!this._workspaceEdit) {\r
1095                 this._workspaceEdit = {\r
1096                     documentChanges: []\r
1097                 };\r
1098             }\r
1099             if (!this._workspaceEdit.documentChanges) {\r
1100                 throw new Error('Workspace edit is not configured for document changes.');\r
1101             }\r
1102             var textDocument = key;\r
1103             var result = this._textEditChanges[textDocument.uri];\r
1104             if (!result) {\r
1105                 var edits = [];\r
1106                 var textDocumentEdit = {\r
1107                     textDocument: textDocument,\r
1108                     edits: edits\r
1109                 };\r
1110                 this._workspaceEdit.documentChanges.push(textDocumentEdit);\r
1111                 result = new TextEditChangeImpl(edits);\r
1112                 this._textEditChanges[textDocument.uri] = result;\r
1113             }\r
1114             return result;\r
1115         }\r
1116         else {\r
1117             if (!this._workspaceEdit) {\r
1118                 this._workspaceEdit = {\r
1119                     changes: Object.create(null)\r
1120                 };\r
1121             }\r
1122             if (!this._workspaceEdit.changes) {\r
1123                 throw new Error('Workspace edit is not configured for normal text edit changes.');\r
1124             }\r
1125             var result = this._textEditChanges[key];\r
1126             if (!result) {\r
1127                 var edits = [];\r
1128                 this._workspaceEdit.changes[key] = edits;\r
1129                 result = new TextEditChangeImpl(edits);\r
1130                 this._textEditChanges[key] = result;\r
1131             }\r
1132             return result;\r
1133         }\r
1134     };\r
1135     WorkspaceChange.prototype.createFile = function (uri, options) {\r
1136         this.checkDocumentChanges();\r
1137         this._workspaceEdit.documentChanges.push(CreateFile.create(uri, options));\r
1138     };\r
1139     WorkspaceChange.prototype.renameFile = function (oldUri, newUri, options) {\r
1140         this.checkDocumentChanges();\r
1141         this._workspaceEdit.documentChanges.push(RenameFile.create(oldUri, newUri, options));\r
1142     };\r
1143     WorkspaceChange.prototype.deleteFile = function (uri, options) {\r
1144         this.checkDocumentChanges();\r
1145         this._workspaceEdit.documentChanges.push(DeleteFile.create(uri, options));\r
1146     };\r
1147     WorkspaceChange.prototype.checkDocumentChanges = function () {\r
1148         if (!this._workspaceEdit || !this._workspaceEdit.documentChanges) {\r
1149             throw new Error('Workspace edit is not configured for document changes.');\r
1150         }\r
1151     };\r
1152     return WorkspaceChange;\r
1153 }());\r
1154 \r
1155 /**\r
1156  * The TextDocumentIdentifier namespace provides helper functions to work with\r
1157  * [TextDocumentIdentifier](#TextDocumentIdentifier) literals.\r
1158  */\r
1159 var TextDocumentIdentifier;\r
1160 (function (TextDocumentIdentifier) {\r
1161     /**\r
1162      * Creates a new TextDocumentIdentifier literal.\r
1163      * @param uri The document's uri.\r
1164      */\r
1165     function create(uri) {\r
1166         return { uri: uri };\r
1167     }\r
1168     TextDocumentIdentifier.create = create;\r
1169     /**\r
1170      * Checks whether the given literal conforms to the [TextDocumentIdentifier](#TextDocumentIdentifier) interface.\r
1171      */\r
1172     function is(value) {\r
1173         var candidate = value;\r
1174         return Is.defined(candidate) && Is.string(candidate.uri);\r
1175     }\r
1176     TextDocumentIdentifier.is = is;\r
1177 })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));\r
1178 /**\r
1179  * The VersionedTextDocumentIdentifier namespace provides helper functions to work with\r
1180  * [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) literals.\r
1181  */\r
1182 var VersionedTextDocumentIdentifier;\r
1183 (function (VersionedTextDocumentIdentifier) {\r
1184     /**\r
1185      * Creates a new VersionedTextDocumentIdentifier literal.\r
1186      * @param uri The document's uri.\r
1187      * @param uri The document's text.\r
1188      */\r
1189     function create(uri, version) {\r
1190         return { uri: uri, version: version };\r
1191     }\r
1192     VersionedTextDocumentIdentifier.create = create;\r
1193     /**\r
1194      * Checks whether the given literal conforms to the [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) interface.\r
1195      */\r
1196     function is(value) {\r
1197         var candidate = value;\r
1198         return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.number(candidate.version));\r
1199     }\r
1200     VersionedTextDocumentIdentifier.is = is;\r
1201 })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));\r
1202 /**\r
1203  * The TextDocumentItem namespace provides helper functions to work with\r
1204  * [TextDocumentItem](#TextDocumentItem) literals.\r
1205  */\r
1206 var TextDocumentItem;\r
1207 (function (TextDocumentItem) {\r
1208     /**\r
1209      * Creates a new TextDocumentItem literal.\r
1210      * @param uri The document's uri.\r
1211      * @param languageId The document's language identifier.\r
1212      * @param version The document's version number.\r
1213      * @param text The document's text.\r
1214      */\r
1215     function create(uri, languageId, version, text) {\r
1216         return { uri: uri, languageId: languageId, version: version, text: text };\r
1217     }\r
1218     TextDocumentItem.create = create;\r
1219     /**\r
1220      * Checks whether the given literal conforms to the [TextDocumentItem](#TextDocumentItem) interface.\r
1221      */\r
1222     function is(value) {\r
1223         var candidate = value;\r
1224         return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.number(candidate.version) && Is.string(candidate.text);\r
1225     }\r
1226     TextDocumentItem.is = is;\r
1227 })(TextDocumentItem || (TextDocumentItem = {}));\r
1228 /**\r
1229  * Describes the content type that a client supports in various\r
1230  * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.\r
1231  *\r
1232  * Please note that `MarkupKinds` must not start with a `$`. This kinds\r
1233  * are reserved for internal usage.\r
1234  */\r
1235 var MarkupKind;\r
1236 (function (MarkupKind) {\r
1237     /**\r
1238      * Plain text is supported as a content format\r
1239      */\r
1240     MarkupKind.PlainText = 'plaintext';\r
1241     /**\r
1242      * Markdown is supported as a content format\r
1243      */\r
1244     MarkupKind.Markdown = 'markdown';\r
1245 })(MarkupKind || (MarkupKind = {}));\r
1246 (function (MarkupKind) {\r
1247     /**\r
1248      * Checks whether the given value is a value of the [MarkupKind](#MarkupKind) type.\r
1249      */\r
1250     function is(value) {\r
1251         var candidate = value;\r
1252         return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;\r
1253     }\r
1254     MarkupKind.is = is;\r
1255 })(MarkupKind || (MarkupKind = {}));\r
1256 var MarkupContent;\r
1257 (function (MarkupContent) {\r
1258     /**\r
1259      * Checks whether the given value conforms to the [MarkupContent](#MarkupContent) interface.\r
1260      */\r
1261     function is(value) {\r
1262         var candidate = value;\r
1263         return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);\r
1264     }\r
1265     MarkupContent.is = is;\r
1266 })(MarkupContent || (MarkupContent = {}));\r
1267 /**\r
1268  * The kind of a completion entry.\r
1269  */\r
1270 var CompletionItemKind;\r
1271 (function (CompletionItemKind) {\r
1272     CompletionItemKind.Text = 1;\r
1273     CompletionItemKind.Method = 2;\r
1274     CompletionItemKind.Function = 3;\r
1275     CompletionItemKind.Constructor = 4;\r
1276     CompletionItemKind.Field = 5;\r
1277     CompletionItemKind.Variable = 6;\r
1278     CompletionItemKind.Class = 7;\r
1279     CompletionItemKind.Interface = 8;\r
1280     CompletionItemKind.Module = 9;\r
1281     CompletionItemKind.Property = 10;\r
1282     CompletionItemKind.Unit = 11;\r
1283     CompletionItemKind.Value = 12;\r
1284     CompletionItemKind.Enum = 13;\r
1285     CompletionItemKind.Keyword = 14;\r
1286     CompletionItemKind.Snippet = 15;\r
1287     CompletionItemKind.Color = 16;\r
1288     CompletionItemKind.File = 17;\r
1289     CompletionItemKind.Reference = 18;\r
1290     CompletionItemKind.Folder = 19;\r
1291     CompletionItemKind.EnumMember = 20;\r
1292     CompletionItemKind.Constant = 21;\r
1293     CompletionItemKind.Struct = 22;\r
1294     CompletionItemKind.Event = 23;\r
1295     CompletionItemKind.Operator = 24;\r
1296     CompletionItemKind.TypeParameter = 25;\r
1297 })(CompletionItemKind || (CompletionItemKind = {}));\r
1298 /**\r
1299  * Defines whether the insert text in a completion item should be interpreted as\r
1300  * plain text or a snippet.\r
1301  */\r
1302 var InsertTextFormat;\r
1303 (function (InsertTextFormat) {\r
1304     /**\r
1305      * The primary text to be inserted is treated as a plain string.\r
1306      */\r
1307     InsertTextFormat.PlainText = 1;\r
1308     /**\r
1309      * The primary text to be inserted is treated as a snippet.\r
1310      *\r
1311      * A snippet can define tab stops and placeholders with `$1`, `$2`\r
1312      * and `${3:foo}`. `$0` defines the final tab stop, it defaults to\r
1313      * the end of the snippet. Placeholders with equal identifiers are linked,\r
1314      * that is typing in one will update others too.\r
1315      *\r
1316      * See also: https://github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md\r
1317      */\r
1318     InsertTextFormat.Snippet = 2;\r
1319 })(InsertTextFormat || (InsertTextFormat = {}));\r
1320 /**\r
1321  * Completion item tags are extra annotations that tweak the rendering of a completion\r
1322  * item.\r
1323  *\r
1324  * @since 3.15.0\r
1325  */\r
1326 var CompletionItemTag;\r
1327 (function (CompletionItemTag) {\r
1328     /**\r
1329      * Render a completion as obsolete, usually using a strike-out.\r
1330      */\r
1331     CompletionItemTag.Deprecated = 1;\r
1332 })(CompletionItemTag || (CompletionItemTag = {}));\r
1333 /**\r
1334  * The CompletionItem namespace provides functions to deal with\r
1335  * completion items.\r
1336  */\r
1337 var CompletionItem;\r
1338 (function (CompletionItem) {\r
1339     /**\r
1340      * Create a completion item and seed it with a label.\r
1341      * @param label The completion item's label\r
1342      */\r
1343     function create(label) {\r
1344         return { label: label };\r
1345     }\r
1346     CompletionItem.create = create;\r
1347 })(CompletionItem || (CompletionItem = {}));\r
1348 /**\r
1349  * The CompletionList namespace provides functions to deal with\r
1350  * completion lists.\r
1351  */\r
1352 var CompletionList;\r
1353 (function (CompletionList) {\r
1354     /**\r
1355      * Creates a new completion list.\r
1356      *\r
1357      * @param items The completion items.\r
1358      * @param isIncomplete The list is not complete.\r
1359      */\r
1360     function create(items, isIncomplete) {\r
1361         return { items: items ? items : [], isIncomplete: !!isIncomplete };\r
1362     }\r
1363     CompletionList.create = create;\r
1364 })(CompletionList || (CompletionList = {}));\r
1365 var MarkedString;\r
1366 (function (MarkedString) {\r
1367     /**\r
1368      * Creates a marked string from plain text.\r
1369      *\r
1370      * @param plainText The plain text.\r
1371      */\r
1372     function fromPlainText(plainText) {\r
1373         return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash\r
1374     }\r
1375     MarkedString.fromPlainText = fromPlainText;\r
1376     /**\r
1377      * Checks whether the given value conforms to the [MarkedString](#MarkedString) type.\r
1378      */\r
1379     function is(value) {\r
1380         var candidate = value;\r
1381         return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value));\r
1382     }\r
1383     MarkedString.is = is;\r
1384 })(MarkedString || (MarkedString = {}));\r
1385 var Hover;\r
1386 (function (Hover) {\r
1387     /**\r
1388      * Checks whether the given value conforms to the [Hover](#Hover) interface.\r
1389      */\r
1390     function is(value) {\r
1391         var candidate = value;\r
1392         return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) ||\r
1393             MarkedString.is(candidate.contents) ||\r
1394             Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range));\r
1395     }\r
1396     Hover.is = is;\r
1397 })(Hover || (Hover = {}));\r
1398 /**\r
1399  * The ParameterInformation namespace provides helper functions to work with\r
1400  * [ParameterInformation](#ParameterInformation) literals.\r
1401  */\r
1402 var ParameterInformation;\r
1403 (function (ParameterInformation) {\r
1404     /**\r
1405      * Creates a new parameter information literal.\r
1406      *\r
1407      * @param label A label string.\r
1408      * @param documentation A doc string.\r
1409      */\r
1410     function create(label, documentation) {\r
1411         return documentation ? { label: label, documentation: documentation } : { label: label };\r
1412     }\r
1413     ParameterInformation.create = create;\r
1414 })(ParameterInformation || (ParameterInformation = {}));\r
1415 /**\r
1416  * The SignatureInformation namespace provides helper functions to work with\r
1417  * [SignatureInformation](#SignatureInformation) literals.\r
1418  */\r
1419 var SignatureInformation;\r
1420 (function (SignatureInformation) {\r
1421     function create(label, documentation) {\r
1422         var parameters = [];\r
1423         for (var _i = 2; _i < arguments.length; _i++) {\r
1424             parameters[_i - 2] = arguments[_i];\r
1425         }\r
1426         var result = { label: label };\r
1427         if (Is.defined(documentation)) {\r
1428             result.documentation = documentation;\r
1429         }\r
1430         if (Is.defined(parameters)) {\r
1431             result.parameters = parameters;\r
1432         }\r
1433         else {\r
1434             result.parameters = [];\r
1435         }\r
1436         return result;\r
1437     }\r
1438     SignatureInformation.create = create;\r
1439 })(SignatureInformation || (SignatureInformation = {}));\r
1440 /**\r
1441  * A document highlight kind.\r
1442  */\r
1443 var DocumentHighlightKind;\r
1444 (function (DocumentHighlightKind) {\r
1445     /**\r
1446      * A textual occurrence.\r
1447      */\r
1448     DocumentHighlightKind.Text = 1;\r
1449     /**\r
1450      * Read-access of a symbol, like reading a variable.\r
1451      */\r
1452     DocumentHighlightKind.Read = 2;\r
1453     /**\r
1454      * Write-access of a symbol, like writing to a variable.\r
1455      */\r
1456     DocumentHighlightKind.Write = 3;\r
1457 })(DocumentHighlightKind || (DocumentHighlightKind = {}));\r
1458 /**\r
1459  * DocumentHighlight namespace to provide helper functions to work with\r
1460  * [DocumentHighlight](#DocumentHighlight) literals.\r
1461  */\r
1462 var DocumentHighlight;\r
1463 (function (DocumentHighlight) {\r
1464     /**\r
1465      * Create a DocumentHighlight object.\r
1466      * @param range The range the highlight applies to.\r
1467      */\r
1468     function create(range, kind) {\r
1469         var result = { range: range };\r
1470         if (Is.number(kind)) {\r
1471             result.kind = kind;\r
1472         }\r
1473         return result;\r
1474     }\r
1475     DocumentHighlight.create = create;\r
1476 })(DocumentHighlight || (DocumentHighlight = {}));\r
1477 /**\r
1478  * A symbol kind.\r
1479  */\r
1480 var SymbolKind;\r
1481 (function (SymbolKind) {\r
1482     SymbolKind.File = 1;\r
1483     SymbolKind.Module = 2;\r
1484     SymbolKind.Namespace = 3;\r
1485     SymbolKind.Package = 4;\r
1486     SymbolKind.Class = 5;\r
1487     SymbolKind.Method = 6;\r
1488     SymbolKind.Property = 7;\r
1489     SymbolKind.Field = 8;\r
1490     SymbolKind.Constructor = 9;\r
1491     SymbolKind.Enum = 10;\r
1492     SymbolKind.Interface = 11;\r
1493     SymbolKind.Function = 12;\r
1494     SymbolKind.Variable = 13;\r
1495     SymbolKind.Constant = 14;\r
1496     SymbolKind.String = 15;\r
1497     SymbolKind.Number = 16;\r
1498     SymbolKind.Boolean = 17;\r
1499     SymbolKind.Array = 18;\r
1500     SymbolKind.Object = 19;\r
1501     SymbolKind.Key = 20;\r
1502     SymbolKind.Null = 21;\r
1503     SymbolKind.EnumMember = 22;\r
1504     SymbolKind.Struct = 23;\r
1505     SymbolKind.Event = 24;\r
1506     SymbolKind.Operator = 25;\r
1507     SymbolKind.TypeParameter = 26;\r
1508 })(SymbolKind || (SymbolKind = {}));\r
1509 /**\r
1510  * Symbol tags are extra annotations that tweak the rendering of a symbol.\r
1511  * @since 3.15\r
1512  */\r
1513 var SymbolTag;\r
1514 (function (SymbolTag) {\r
1515     /**\r
1516      * Render a symbol as obsolete, usually using a strike-out.\r
1517      */\r
1518     SymbolTag.Deprecated = 1;\r
1519 })(SymbolTag || (SymbolTag = {}));\r
1520 var SymbolInformation;\r
1521 (function (SymbolInformation) {\r
1522     /**\r
1523      * Creates a new symbol information literal.\r
1524      *\r
1525      * @param name The name of the symbol.\r
1526      * @param kind The kind of the symbol.\r
1527      * @param range The range of the location of the symbol.\r
1528      * @param uri The resource of the location of symbol, defaults to the current document.\r
1529      * @param containerName The name of the symbol containing the symbol.\r
1530      */\r
1531     function create(name, kind, range, uri, containerName) {\r
1532         var result = {\r
1533             name: name,\r
1534             kind: kind,\r
1535             location: { uri: uri, range: range }\r
1536         };\r
1537         if (containerName) {\r
1538             result.containerName = containerName;\r
1539         }\r
1540         return result;\r
1541     }\r
1542     SymbolInformation.create = create;\r
1543 })(SymbolInformation || (SymbolInformation = {}));\r
1544 var DocumentSymbol;\r
1545 (function (DocumentSymbol) {\r
1546     /**\r
1547      * Creates a new symbol information literal.\r
1548      *\r
1549      * @param name The name of the symbol.\r
1550      * @param detail The detail of the symbol.\r
1551      * @param kind The kind of the symbol.\r
1552      * @param range The range of the symbol.\r
1553      * @param selectionRange The selectionRange of the symbol.\r
1554      * @param children Children of the symbol.\r
1555      */\r
1556     function create(name, detail, kind, range, selectionRange, children) {\r
1557         var result = {\r
1558             name: name,\r
1559             detail: detail,\r
1560             kind: kind,\r
1561             range: range,\r
1562             selectionRange: selectionRange\r
1563         };\r
1564         if (children !== void 0) {\r
1565             result.children = children;\r
1566         }\r
1567         return result;\r
1568     }\r
1569     DocumentSymbol.create = create;\r
1570     /**\r
1571      * Checks whether the given literal conforms to the [DocumentSymbol](#DocumentSymbol) interface.\r
1572      */\r
1573     function is(value) {\r
1574         var candidate = value;\r
1575         return candidate &&\r
1576             Is.string(candidate.name) && Is.number(candidate.kind) &&\r
1577             Range.is(candidate.range) && Range.is(candidate.selectionRange) &&\r
1578             (candidate.detail === void 0 || Is.string(candidate.detail)) &&\r
1579             (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) &&\r
1580             (candidate.children === void 0 || Array.isArray(candidate.children));\r
1581     }\r
1582     DocumentSymbol.is = is;\r
1583 })(DocumentSymbol || (DocumentSymbol = {}));\r
1584 /**\r
1585  * A set of predefined code action kinds\r
1586  */\r
1587 var CodeActionKind;\r
1588 (function (CodeActionKind) {\r
1589     /**\r
1590      * Empty kind.\r
1591      */\r
1592     CodeActionKind.Empty = '';\r
1593     /**\r
1594      * Base kind for quickfix actions: 'quickfix'\r
1595      */\r
1596     CodeActionKind.QuickFix = 'quickfix';\r
1597     /**\r
1598      * Base kind for refactoring actions: 'refactor'\r
1599      */\r
1600     CodeActionKind.Refactor = 'refactor';\r
1601     /**\r
1602      * Base kind for refactoring extraction actions: 'refactor.extract'\r
1603      *\r
1604      * Example extract actions:\r
1605      *\r
1606      * - Extract method\r
1607      * - Extract function\r
1608      * - Extract variable\r
1609      * - Extract interface from class\r
1610      * - ...\r
1611      */\r
1612     CodeActionKind.RefactorExtract = 'refactor.extract';\r
1613     /**\r
1614      * Base kind for refactoring inline actions: 'refactor.inline'\r
1615      *\r
1616      * Example inline actions:\r
1617      *\r
1618      * - Inline function\r
1619      * - Inline variable\r
1620      * - Inline constant\r
1621      * - ...\r
1622      */\r
1623     CodeActionKind.RefactorInline = 'refactor.inline';\r
1624     /**\r
1625      * Base kind for refactoring rewrite actions: 'refactor.rewrite'\r
1626      *\r
1627      * Example rewrite actions:\r
1628      *\r
1629      * - Convert JavaScript function to class\r
1630      * - Add or remove parameter\r
1631      * - Encapsulate field\r
1632      * - Make method static\r
1633      * - Move method to base class\r
1634      * - ...\r
1635      */\r
1636     CodeActionKind.RefactorRewrite = 'refactor.rewrite';\r
1637     /**\r
1638      * Base kind for source actions: `source`\r
1639      *\r
1640      * Source code actions apply to the entire file.\r
1641      */\r
1642     CodeActionKind.Source = 'source';\r
1643     /**\r
1644      * Base kind for an organize imports source action: `source.organizeImports`\r
1645      */\r
1646     CodeActionKind.SourceOrganizeImports = 'source.organizeImports';\r
1647     /**\r
1648      * Base kind for auto-fix source actions: `source.fixAll`.\r
1649      *\r
1650      * Fix all actions automatically fix errors that have a clear fix that do not require user input.\r
1651      * They should not suppress errors or perform unsafe fixes such as generating new types or classes.\r
1652      *\r
1653      * @since 3.15.0\r
1654      */\r
1655     CodeActionKind.SourceFixAll = 'source.fixAll';\r
1656 })(CodeActionKind || (CodeActionKind = {}));\r
1657 /**\r
1658  * The CodeActionContext namespace provides helper functions to work with\r
1659  * [CodeActionContext](#CodeActionContext) literals.\r
1660  */\r
1661 var CodeActionContext;\r
1662 (function (CodeActionContext) {\r
1663     /**\r
1664      * Creates a new CodeActionContext literal.\r
1665      */\r
1666     function create(diagnostics, only) {\r
1667         var result = { diagnostics: diagnostics };\r
1668         if (only !== void 0 && only !== null) {\r
1669             result.only = only;\r
1670         }\r
1671         return result;\r
1672     }\r
1673     CodeActionContext.create = create;\r
1674     /**\r
1675      * Checks whether the given literal conforms to the [CodeActionContext](#CodeActionContext) interface.\r
1676      */\r
1677     function is(value) {\r
1678         var candidate = value;\r
1679         return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));\r
1680     }\r
1681     CodeActionContext.is = is;\r
1682 })(CodeActionContext || (CodeActionContext = {}));\r
1683 var CodeAction;\r
1684 (function (CodeAction) {\r
1685     function create(title, commandOrEdit, kind) {\r
1686         var result = { title: title };\r
1687         if (Command.is(commandOrEdit)) {\r
1688             result.command = commandOrEdit;\r
1689         }\r
1690         else {\r
1691             result.edit = commandOrEdit;\r
1692         }\r
1693         if (kind !== void 0) {\r
1694             result.kind = kind;\r
1695         }\r
1696         return result;\r
1697     }\r
1698     CodeAction.create = create;\r
1699     function is(value) {\r
1700         var candidate = value;\r
1701         return candidate && Is.string(candidate.title) &&\r
1702             (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&\r
1703             (candidate.kind === void 0 || Is.string(candidate.kind)) &&\r
1704             (candidate.edit !== void 0 || candidate.command !== void 0) &&\r
1705             (candidate.command === void 0 || Command.is(candidate.command)) &&\r
1706             (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) &&\r
1707             (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit));\r
1708     }\r
1709     CodeAction.is = is;\r
1710 })(CodeAction || (CodeAction = {}));\r
1711 /**\r
1712  * The CodeLens namespace provides helper functions to work with\r
1713  * [CodeLens](#CodeLens) literals.\r
1714  */\r
1715 var CodeLens;\r
1716 (function (CodeLens) {\r
1717     /**\r
1718      * Creates a new CodeLens literal.\r
1719      */\r
1720     function create(range, data) {\r
1721         var result = { range: range };\r
1722         if (Is.defined(data)) {\r
1723             result.data = data;\r
1724         }\r
1725         return result;\r
1726     }\r
1727     CodeLens.create = create;\r
1728     /**\r
1729      * Checks whether the given literal conforms to the [CodeLens](#CodeLens) interface.\r
1730      */\r
1731     function is(value) {\r
1732         var candidate = value;\r
1733         return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));\r
1734     }\r
1735     CodeLens.is = is;\r
1736 })(CodeLens || (CodeLens = {}));\r
1737 /**\r
1738  * The FormattingOptions namespace provides helper functions to work with\r
1739  * [FormattingOptions](#FormattingOptions) literals.\r
1740  */\r
1741 var FormattingOptions;\r
1742 (function (FormattingOptions) {\r
1743     /**\r
1744      * Creates a new FormattingOptions literal.\r
1745      */\r
1746     function create(tabSize, insertSpaces) {\r
1747         return { tabSize: tabSize, insertSpaces: insertSpaces };\r
1748     }\r
1749     FormattingOptions.create = create;\r
1750     /**\r
1751      * Checks whether the given literal conforms to the [FormattingOptions](#FormattingOptions) interface.\r
1752      */\r
1753     function is(value) {\r
1754         var candidate = value;\r
1755         return Is.defined(candidate) && Is.number(candidate.tabSize) && Is.boolean(candidate.insertSpaces);\r
1756     }\r
1757     FormattingOptions.is = is;\r
1758 })(FormattingOptions || (FormattingOptions = {}));\r
1759 /**\r
1760  * The DocumentLink namespace provides helper functions to work with\r
1761  * [DocumentLink](#DocumentLink) literals.\r
1762  */\r
1763 var DocumentLink;\r
1764 (function (DocumentLink) {\r
1765     /**\r
1766      * Creates a new DocumentLink literal.\r
1767      */\r
1768     function create(range, target, data) {\r
1769         return { range: range, target: target, data: data };\r
1770     }\r
1771     DocumentLink.create = create;\r
1772     /**\r
1773      * Checks whether the given literal conforms to the [DocumentLink](#DocumentLink) interface.\r
1774      */\r
1775     function is(value) {\r
1776         var candidate = value;\r
1777         return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));\r
1778     }\r
1779     DocumentLink.is = is;\r
1780 })(DocumentLink || (DocumentLink = {}));\r
1781 /**\r
1782  * The SelectionRange namespace provides helper function to work with\r
1783  * SelectionRange literals.\r
1784  */\r
1785 var SelectionRange;\r
1786 (function (SelectionRange) {\r
1787     /**\r
1788      * Creates a new SelectionRange\r
1789      * @param range the range.\r
1790      * @param parent an optional parent.\r
1791      */\r
1792     function create(range, parent) {\r
1793         return { range: range, parent: parent };\r
1794     }\r
1795     SelectionRange.create = create;\r
1796     function is(value) {\r
1797         var candidate = value;\r
1798         return candidate !== undefined && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));\r
1799     }\r
1800     SelectionRange.is = is;\r
1801 })(SelectionRange || (SelectionRange = {}));\r
1802 var EOL = ['\n', '\r\n', '\r'];\r
1803 /**\r
1804  * @deprecated Use the text document from the new vscode-languageserver-textdocument package.\r
1805  */\r
1806 var TextDocument;\r
1807 (function (TextDocument) {\r
1808     /**\r
1809      * Creates a new ITextDocument literal from the given uri and content.\r
1810      * @param uri The document's uri.\r
1811      * @param languageId  The document's language Id.\r
1812      * @param content The document's content.\r
1813      */\r
1814     function create(uri, languageId, version, content) {\r
1815         return new FullTextDocument(uri, languageId, version, content);\r
1816     }\r
1817     TextDocument.create = create;\r
1818     /**\r
1819      * Checks whether the given literal conforms to the [ITextDocument](#ITextDocument) interface.\r
1820      */\r
1821     function is(value) {\r
1822         var candidate = value;\r
1823         return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.number(candidate.lineCount)\r
1824             && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;\r
1825     }\r
1826     TextDocument.is = is;\r
1827     function applyEdits(document, edits) {\r
1828         var text = document.getText();\r
1829         var sortedEdits = mergeSort(edits, function (a, b) {\r
1830             var diff = a.range.start.line - b.range.start.line;\r
1831             if (diff === 0) {\r
1832                 return a.range.start.character - b.range.start.character;\r
1833             }\r
1834             return diff;\r
1835         });\r
1836         var lastModifiedOffset = text.length;\r
1837         for (var i = sortedEdits.length - 1; i >= 0; i--) {\r
1838             var e = sortedEdits[i];\r
1839             var startOffset = document.offsetAt(e.range.start);\r
1840             var endOffset = document.offsetAt(e.range.end);\r
1841             if (endOffset <= lastModifiedOffset) {\r
1842                 text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);\r
1843             }\r
1844             else {\r
1845                 throw new Error('Overlapping edit');\r
1846             }\r
1847             lastModifiedOffset = startOffset;\r
1848         }\r
1849         return text;\r
1850     }\r
1851     TextDocument.applyEdits = applyEdits;\r
1852     function mergeSort(data, compare) {\r
1853         if (data.length <= 1) {\r
1854             // sorted\r
1855             return data;\r
1856         }\r
1857         var p = (data.length / 2) | 0;\r
1858         var left = data.slice(0, p);\r
1859         var right = data.slice(p);\r
1860         mergeSort(left, compare);\r
1861         mergeSort(right, compare);\r
1862         var leftIdx = 0;\r
1863         var rightIdx = 0;\r
1864         var i = 0;\r
1865         while (leftIdx < left.length && rightIdx < right.length) {\r
1866             var ret = compare(left[leftIdx], right[rightIdx]);\r
1867             if (ret <= 0) {\r
1868                 // smaller_equal -> take left to preserve order\r
1869                 data[i++] = left[leftIdx++];\r
1870             }\r
1871             else {\r
1872                 // greater -> take right\r
1873                 data[i++] = right[rightIdx++];\r
1874             }\r
1875         }\r
1876         while (leftIdx < left.length) {\r
1877             data[i++] = left[leftIdx++];\r
1878         }\r
1879         while (rightIdx < right.length) {\r
1880             data[i++] = right[rightIdx++];\r
1881         }\r
1882         return data;\r
1883     }\r
1884 })(TextDocument || (TextDocument = {}));\r
1885 var FullTextDocument = /** @class */ (function () {\r
1886     function FullTextDocument(uri, languageId, version, content) {\r
1887         this._uri = uri;\r
1888         this._languageId = languageId;\r
1889         this._version = version;\r
1890         this._content = content;\r
1891         this._lineOffsets = undefined;\r
1892     }\r
1893     Object.defineProperty(FullTextDocument.prototype, "uri", {\r
1894         get: function () {\r
1895             return this._uri;\r
1896         },\r
1897         enumerable: true,\r
1898         configurable: true\r
1899     });\r
1900     Object.defineProperty(FullTextDocument.prototype, "languageId", {\r
1901         get: function () {\r
1902             return this._languageId;\r
1903         },\r
1904         enumerable: true,\r
1905         configurable: true\r
1906     });\r
1907     Object.defineProperty(FullTextDocument.prototype, "version", {\r
1908         get: function () {\r
1909             return this._version;\r
1910         },\r
1911         enumerable: true,\r
1912         configurable: true\r
1913     });\r
1914     FullTextDocument.prototype.getText = function (range) {\r
1915         if (range) {\r
1916             var start = this.offsetAt(range.start);\r
1917             var end = this.offsetAt(range.end);\r
1918             return this._content.substring(start, end);\r
1919         }\r
1920         return this._content;\r
1921     };\r
1922     FullTextDocument.prototype.update = function (event, version) {\r
1923         this._content = event.text;\r
1924         this._version = version;\r
1925         this._lineOffsets = undefined;\r
1926     };\r
1927     FullTextDocument.prototype.getLineOffsets = function () {\r
1928         if (this._lineOffsets === undefined) {\r
1929             var lineOffsets = [];\r
1930             var text = this._content;\r
1931             var isLineStart = true;\r
1932             for (var i = 0; i < text.length; i++) {\r
1933                 if (isLineStart) {\r
1934                     lineOffsets.push(i);\r
1935                     isLineStart = false;\r
1936                 }\r
1937                 var ch = text.charAt(i);\r
1938                 isLineStart = (ch === '\r' || ch === '\n');\r
1939                 if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {\r
1940                     i++;\r
1941                 }\r
1942             }\r
1943             if (isLineStart && text.length > 0) {\r
1944                 lineOffsets.push(text.length);\r
1945             }\r
1946             this._lineOffsets = lineOffsets;\r
1947         }\r
1948         return this._lineOffsets;\r
1949     };\r
1950     FullTextDocument.prototype.positionAt = function (offset) {\r
1951         offset = Math.max(Math.min(offset, this._content.length), 0);\r
1952         var lineOffsets = this.getLineOffsets();\r
1953         var low = 0, high = lineOffsets.length;\r
1954         if (high === 0) {\r
1955             return Position.create(0, offset);\r
1956         }\r
1957         while (low < high) {\r
1958             var mid = Math.floor((low + high) / 2);\r
1959             if (lineOffsets[mid] > offset) {\r
1960                 high = mid;\r
1961             }\r
1962             else {\r
1963                 low = mid + 1;\r
1964             }\r
1965         }\r
1966         // low is the least x for which the line offset is larger than the current offset\r
1967         // or array.length if no line offset is larger than the current offset\r
1968         var line = low - 1;\r
1969         return Position.create(line, offset - lineOffsets[line]);\r
1970     };\r
1971     FullTextDocument.prototype.offsetAt = function (position) {\r
1972         var lineOffsets = this.getLineOffsets();\r
1973         if (position.line >= lineOffsets.length) {\r
1974             return this._content.length;\r
1975         }\r
1976         else if (position.line < 0) {\r
1977             return 0;\r
1978         }\r
1979         var lineOffset = lineOffsets[position.line];\r
1980         var nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;\r
1981         return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);\r
1982     };\r
1983     Object.defineProperty(FullTextDocument.prototype, "lineCount", {\r
1984         get: function () {\r
1985             return this.getLineOffsets().length;\r
1986         },\r
1987         enumerable: true,\r
1988         configurable: true\r
1989     });\r
1990     return FullTextDocument;\r
1991 }());\r
1992 var Is;\r
1993 (function (Is) {\r
1994     var toString = Object.prototype.toString;\r
1995     function defined(value) {\r
1996         return typeof value !== 'undefined';\r
1997     }\r
1998     Is.defined = defined;\r
1999     function undefined(value) {\r
2000         return typeof value === 'undefined';\r
2001     }\r
2002     Is.undefined = undefined;\r
2003     function boolean(value) {\r
2004         return value === true || value === false;\r
2005     }\r
2006     Is.boolean = boolean;\r
2007     function string(value) {\r
2008         return toString.call(value) === '[object String]';\r
2009     }\r
2010     Is.string = string;\r
2011     function number(value) {\r
2012         return toString.call(value) === '[object Number]';\r
2013     }\r
2014     Is.number = number;\r
2015     function func(value) {\r
2016         return toString.call(value) === '[object Function]';\r
2017     }\r
2018     Is.func = func;\r
2019     function objectLiteral(value) {\r
2020         // Strictly speaking class instances pass this check as well. Since the LSP\r
2021         // doesn't use classes we ignore this for now. If we do we need to add something\r
2022         // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`\r
2023         return value !== null && typeof value === 'object';\r
2024     }\r
2025     Is.objectLiteral = objectLiteral;\r
2026     function typedArray(value, check) {\r
2027         return Array.isArray(value) && value.every(check);\r
2028     }\r
2029     Is.typedArray = typedArray;\r
2030 })(Is || (Is = {}));\r
2031
2032
2033 /***/ }),
2034 /* 7 */
2035 /***/ (function(module, exports, __webpack_require__) {
2036
2037 "use strict";
2038
2039 var __importDefault = (this && this.__importDefault) || function (mod) {
2040     return (mod && mod.__esModule) ? mod : { "default": mod };
2041 };
2042 Object.defineProperty(exports, "__esModule", { value: true });
2043 /******************************************************************
2044 MIT License http://www.opensource.org/licenses/mit-license.php
2045 Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
2046 *******************************************************************/
2047 const coc_nvim_1 = __webpack_require__(1);
2048 const vscode_languageserver_protocol_1 = __webpack_require__(8);
2049 const os_1 = __importDefault(__webpack_require__(2));
2050 class SnippetsList extends coc_nvim_1.BasicList {
2051     constructor(nvim, manager, mru) {
2052         super(nvim);
2053         this.manager = manager;
2054         this.mru = mru;
2055         this.name = 'snippets';
2056         this.description = 'snippets list';
2057         this.addLocationActions();
2058     }
2059     async loadItems(context) {
2060         let { window } = context;
2061         let valid = await window.valid;
2062         if (!valid)
2063             return;
2064         let buf = await window.buffer;
2065         let doc = coc_nvim_1.workspace.getDocument(buf.id);
2066         if (!doc)
2067             return [];
2068         let snippets = await this.manager.getSnippets(doc.filetype);
2069         let res = [];
2070         let recents = await this.mru.load();
2071         for (let snip of snippets) {
2072             let pos = vscode_languageserver_protocol_1.Position.create(snip.lnum, 0);
2073             let location = vscode_languageserver_protocol_1.Location.create(coc_nvim_1.Uri.file(snip.filepath).toString(), vscode_languageserver_protocol_1.Range.create(pos, pos));
2074             let prefix = snip.prefix;
2075             if (prefix.length < 20) {
2076                 prefix = `${prefix}${' '.repeat(20 - prefix.length)}`;
2077             }
2078             let idx = recents.indexOf(snip.prefix);
2079             res.push({
2080                 label: `${prefix}\t${snip.description}\t${snip.filepath.replace(os_1.default.homedir(), '~')}`,
2081                 filterText: `${snip.prefix} ${snip.description}`,
2082                 location,
2083                 recentScore: idx == -1 ? -1 : recents.length - idx
2084             });
2085         }
2086         return res;
2087     }
2088     async doHighlight() {
2089         let { nvim } = coc_nvim_1.workspace;
2090         nvim.pauseNotification();
2091         nvim.command('syntax match CocSnippetsPrefix /\\v^\\S+/ contained containedin=CocSnippetsLine', true);
2092         nvim.command('syntax match CocSnippetsFile /\\v\\t\\S+$/ contained containedin=CocSnippetsLine', true);
2093         nvim.command('highlight default link CocSnippetsPrefix Identifier', true);
2094         nvim.command('highlight default link CocSnippetsFile Comment', true);
2095         await nvim.resumeNotification();
2096     }
2097 }
2098 exports.default = SnippetsList;
2099
2100
2101 /***/ }),
2102 /* 8 */
2103 /***/ (function(module, exports, __webpack_require__) {
2104
2105 "use strict";
2106 /* --------------------------------------------------------------------------------------------\r
2107  * Copyright (c) Microsoft Corporation. All rights reserved.\r
2108  * Licensed under the MIT License. See License.txt in the project root for license information.\r
2109  * ------------------------------------------------------------------------------------------ */\r
2110 \r
2111 function __export(m) {\r
2112     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r
2113 }\r
2114 Object.defineProperty(exports, "__esModule", { value: true });\r
2115 const vscode_jsonrpc_1 = __webpack_require__(9);\r
2116 exports.ErrorCodes = vscode_jsonrpc_1.ErrorCodes;\r
2117 exports.ResponseError = vscode_jsonrpc_1.ResponseError;\r
2118 exports.CancellationToken = vscode_jsonrpc_1.CancellationToken;\r
2119 exports.CancellationTokenSource = vscode_jsonrpc_1.CancellationTokenSource;\r
2120 exports.Disposable = vscode_jsonrpc_1.Disposable;\r
2121 exports.Event = vscode_jsonrpc_1.Event;\r
2122 exports.Emitter = vscode_jsonrpc_1.Emitter;\r
2123 exports.Trace = vscode_jsonrpc_1.Trace;\r
2124 exports.TraceFormat = vscode_jsonrpc_1.TraceFormat;\r
2125 exports.SetTraceNotification = vscode_jsonrpc_1.SetTraceNotification;\r
2126 exports.LogTraceNotification = vscode_jsonrpc_1.LogTraceNotification;\r
2127 exports.RequestType = vscode_jsonrpc_1.RequestType;\r
2128 exports.RequestType0 = vscode_jsonrpc_1.RequestType0;\r
2129 exports.NotificationType = vscode_jsonrpc_1.NotificationType;\r
2130 exports.NotificationType0 = vscode_jsonrpc_1.NotificationType0;\r
2131 exports.MessageReader = vscode_jsonrpc_1.MessageReader;\r
2132 exports.MessageWriter = vscode_jsonrpc_1.MessageWriter;\r
2133 exports.ConnectionStrategy = vscode_jsonrpc_1.ConnectionStrategy;\r
2134 exports.StreamMessageReader = vscode_jsonrpc_1.StreamMessageReader;\r
2135 exports.StreamMessageWriter = vscode_jsonrpc_1.StreamMessageWriter;\r
2136 exports.IPCMessageReader = vscode_jsonrpc_1.IPCMessageReader;\r
2137 exports.IPCMessageWriter = vscode_jsonrpc_1.IPCMessageWriter;\r
2138 exports.createClientPipeTransport = vscode_jsonrpc_1.createClientPipeTransport;\r
2139 exports.createServerPipeTransport = vscode_jsonrpc_1.createServerPipeTransport;\r
2140 exports.generateRandomPipeName = vscode_jsonrpc_1.generateRandomPipeName;\r
2141 exports.createClientSocketTransport = vscode_jsonrpc_1.createClientSocketTransport;\r
2142 exports.createServerSocketTransport = vscode_jsonrpc_1.createServerSocketTransport;\r
2143 exports.ProgressType = vscode_jsonrpc_1.ProgressType;\r
2144 __export(__webpack_require__(6));\r
2145 __export(__webpack_require__(21));\r
2146 const callHierarchy = __webpack_require__(33);\r
2147 const st = __webpack_require__(34);\r
2148 var Proposed;\r
2149 (function (Proposed) {\r
2150     let CallHierarchyPrepareRequest;\r
2151     (function (CallHierarchyPrepareRequest) {\r
2152         CallHierarchyPrepareRequest.method = callHierarchy.CallHierarchyPrepareRequest.method;\r
2153         CallHierarchyPrepareRequest.type = callHierarchy.CallHierarchyPrepareRequest.type;\r
2154     })(CallHierarchyPrepareRequest = Proposed.CallHierarchyPrepareRequest || (Proposed.CallHierarchyPrepareRequest = {}));\r
2155     let CallHierarchyIncomingCallsRequest;\r
2156     (function (CallHierarchyIncomingCallsRequest) {\r
2157         CallHierarchyIncomingCallsRequest.method = callHierarchy.CallHierarchyIncomingCallsRequest.method;\r
2158         CallHierarchyIncomingCallsRequest.type = callHierarchy.CallHierarchyIncomingCallsRequest.type;\r
2159     })(CallHierarchyIncomingCallsRequest = Proposed.CallHierarchyIncomingCallsRequest || (Proposed.CallHierarchyIncomingCallsRequest = {}));\r
2160     let CallHierarchyOutgoingCallsRequest;\r
2161     (function (CallHierarchyOutgoingCallsRequest) {\r
2162         CallHierarchyOutgoingCallsRequest.method = callHierarchy.CallHierarchyOutgoingCallsRequest.method;\r
2163         CallHierarchyOutgoingCallsRequest.type = callHierarchy.CallHierarchyOutgoingCallsRequest.type;\r
2164     })(CallHierarchyOutgoingCallsRequest = Proposed.CallHierarchyOutgoingCallsRequest || (Proposed.CallHierarchyOutgoingCallsRequest = {}));\r
2165     Proposed.SemanticTokenTypes = st.SemanticTokenTypes;\r
2166     Proposed.SemanticTokenModifiers = st.SemanticTokenModifiers;\r
2167     Proposed.SemanticTokens = st.SemanticTokens;\r
2168     let SemanticTokensRequest;\r
2169     (function (SemanticTokensRequest) {\r
2170         SemanticTokensRequest.method = st.SemanticTokensRequest.method;\r
2171         SemanticTokensRequest.type = st.SemanticTokensRequest.type;\r
2172     })(SemanticTokensRequest = Proposed.SemanticTokensRequest || (Proposed.SemanticTokensRequest = {}));\r
2173     let SemanticTokensEditsRequest;\r
2174     (function (SemanticTokensEditsRequest) {\r
2175         SemanticTokensEditsRequest.method = st.SemanticTokensEditsRequest.method;\r
2176         SemanticTokensEditsRequest.type = st.SemanticTokensEditsRequest.type;\r
2177     })(SemanticTokensEditsRequest = Proposed.SemanticTokensEditsRequest || (Proposed.SemanticTokensEditsRequest = {}));\r
2178     let SemanticTokensRangeRequest;\r
2179     (function (SemanticTokensRangeRequest) {\r
2180         SemanticTokensRangeRequest.method = st.SemanticTokensRangeRequest.method;\r
2181         SemanticTokensRangeRequest.type = st.SemanticTokensRangeRequest.type;\r
2182     })(SemanticTokensRangeRequest = Proposed.SemanticTokensRangeRequest || (Proposed.SemanticTokensRangeRequest = {}));\r
2183 })(Proposed = exports.Proposed || (exports.Proposed = {}));\r
2184 function createProtocolConnection(reader, writer, logger, strategy) {\r
2185     return vscode_jsonrpc_1.createMessageConnection(reader, writer, logger, strategy);\r
2186 }\r
2187 exports.createProtocolConnection = createProtocolConnection;\r
2188
2189
2190 /***/ }),
2191 /* 9 */
2192 /***/ (function(module, exports, __webpack_require__) {
2193
2194 "use strict";
2195 /* --------------------------------------------------------------------------------------------\r
2196  * Copyright (c) Microsoft Corporation. All rights reserved.\r
2197  * Licensed under the MIT License. See License.txt in the project root for license information.\r
2198  * ------------------------------------------------------------------------------------------ */\r
2199 /// <reference path="../typings/thenable.d.ts" />\r
2200 \r
2201 function __export(m) {\r
2202     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r
2203 }\r
2204 Object.defineProperty(exports, "__esModule", { value: true });\r
2205 const Is = __webpack_require__(10);\r
2206 const messages_1 = __webpack_require__(11);\r
2207 exports.RequestType = messages_1.RequestType;\r
2208 exports.RequestType0 = messages_1.RequestType0;\r
2209 exports.RequestType1 = messages_1.RequestType1;\r
2210 exports.RequestType2 = messages_1.RequestType2;\r
2211 exports.RequestType3 = messages_1.RequestType3;\r
2212 exports.RequestType4 = messages_1.RequestType4;\r
2213 exports.RequestType5 = messages_1.RequestType5;\r
2214 exports.RequestType6 = messages_1.RequestType6;\r
2215 exports.RequestType7 = messages_1.RequestType7;\r
2216 exports.RequestType8 = messages_1.RequestType8;\r
2217 exports.RequestType9 = messages_1.RequestType9;\r
2218 exports.ResponseError = messages_1.ResponseError;\r
2219 exports.ErrorCodes = messages_1.ErrorCodes;\r
2220 exports.NotificationType = messages_1.NotificationType;\r
2221 exports.NotificationType0 = messages_1.NotificationType0;\r
2222 exports.NotificationType1 = messages_1.NotificationType1;\r
2223 exports.NotificationType2 = messages_1.NotificationType2;\r
2224 exports.NotificationType3 = messages_1.NotificationType3;\r
2225 exports.NotificationType4 = messages_1.NotificationType4;\r
2226 exports.NotificationType5 = messages_1.NotificationType5;\r
2227 exports.NotificationType6 = messages_1.NotificationType6;\r
2228 exports.NotificationType7 = messages_1.NotificationType7;\r
2229 exports.NotificationType8 = messages_1.NotificationType8;\r
2230 exports.NotificationType9 = messages_1.NotificationType9;\r
2231 const messageReader_1 = __webpack_require__(12);\r
2232 exports.MessageReader = messageReader_1.MessageReader;\r
2233 exports.StreamMessageReader = messageReader_1.StreamMessageReader;\r
2234 exports.IPCMessageReader = messageReader_1.IPCMessageReader;\r
2235 exports.SocketMessageReader = messageReader_1.SocketMessageReader;\r
2236 const messageWriter_1 = __webpack_require__(14);\r
2237 exports.MessageWriter = messageWriter_1.MessageWriter;\r
2238 exports.StreamMessageWriter = messageWriter_1.StreamMessageWriter;\r
2239 exports.IPCMessageWriter = messageWriter_1.IPCMessageWriter;\r
2240 exports.SocketMessageWriter = messageWriter_1.SocketMessageWriter;\r
2241 const events_1 = __webpack_require__(13);\r
2242 exports.Disposable = events_1.Disposable;\r
2243 exports.Event = events_1.Event;\r
2244 exports.Emitter = events_1.Emitter;\r
2245 const cancellation_1 = __webpack_require__(15);\r
2246 exports.CancellationTokenSource = cancellation_1.CancellationTokenSource;\r
2247 exports.CancellationToken = cancellation_1.CancellationToken;\r
2248 const linkedMap_1 = __webpack_require__(16);\r
2249 __export(__webpack_require__(17));\r
2250 __export(__webpack_require__(20));\r
2251 var CancelNotification;\r
2252 (function (CancelNotification) {\r
2253     CancelNotification.type = new messages_1.NotificationType('$/cancelRequest');\r
2254 })(CancelNotification || (CancelNotification = {}));\r
2255 var ProgressNotification;\r
2256 (function (ProgressNotification) {\r
2257     ProgressNotification.type = new messages_1.NotificationType('$/progress');\r
2258 })(ProgressNotification || (ProgressNotification = {}));\r
2259 class ProgressType {\r
2260     constructor() {\r
2261     }\r
2262 }\r
2263 exports.ProgressType = ProgressType;\r
2264 exports.NullLogger = Object.freeze({\r
2265     error: () => { },\r
2266     warn: () => { },\r
2267     info: () => { },\r
2268     log: () => { }\r
2269 });\r
2270 var Trace;\r
2271 (function (Trace) {\r
2272     Trace[Trace["Off"] = 0] = "Off";\r
2273     Trace[Trace["Messages"] = 1] = "Messages";\r
2274     Trace[Trace["Verbose"] = 2] = "Verbose";\r
2275 })(Trace = exports.Trace || (exports.Trace = {}));\r
2276 (function (Trace) {\r
2277     function fromString(value) {\r
2278         if (!Is.string(value)) {\r
2279             return Trace.Off;\r
2280         }\r
2281         value = value.toLowerCase();\r
2282         switch (value) {\r
2283             case 'off':\r
2284                 return Trace.Off;\r
2285             case 'messages':\r
2286                 return Trace.Messages;\r
2287             case 'verbose':\r
2288                 return Trace.Verbose;\r
2289             default:\r
2290                 return Trace.Off;\r
2291         }\r
2292     }\r
2293     Trace.fromString = fromString;\r
2294     function toString(value) {\r
2295         switch (value) {\r
2296             case Trace.Off:\r
2297                 return 'off';\r
2298             case Trace.Messages:\r
2299                 return 'messages';\r
2300             case Trace.Verbose:\r
2301                 return 'verbose';\r
2302             default:\r
2303                 return 'off';\r
2304         }\r
2305     }\r
2306     Trace.toString = toString;\r
2307 })(Trace = exports.Trace || (exports.Trace = {}));\r
2308 var TraceFormat;\r
2309 (function (TraceFormat) {\r
2310     TraceFormat["Text"] = "text";\r
2311     TraceFormat["JSON"] = "json";\r
2312 })(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));\r
2313 (function (TraceFormat) {\r
2314     function fromString(value) {\r
2315         value = value.toLowerCase();\r
2316         if (value === 'json') {\r
2317             return TraceFormat.JSON;\r
2318         }\r
2319         else {\r
2320             return TraceFormat.Text;\r
2321         }\r
2322     }\r
2323     TraceFormat.fromString = fromString;\r
2324 })(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));\r
2325 var SetTraceNotification;\r
2326 (function (SetTraceNotification) {\r
2327     SetTraceNotification.type = new messages_1.NotificationType('$/setTraceNotification');\r
2328 })(SetTraceNotification = exports.SetTraceNotification || (exports.SetTraceNotification = {}));\r
2329 var LogTraceNotification;\r
2330 (function (LogTraceNotification) {\r
2331     LogTraceNotification.type = new messages_1.NotificationType('$/logTraceNotification');\r
2332 })(LogTraceNotification = exports.LogTraceNotification || (exports.LogTraceNotification = {}));\r
2333 var ConnectionErrors;\r
2334 (function (ConnectionErrors) {\r
2335     /**\r
2336      * The connection is closed.\r
2337      */\r
2338     ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";\r
2339     /**\r
2340      * The connection got disposed.\r
2341      */\r
2342     ConnectionErrors[ConnectionErrors["Disposed"] = 2] = "Disposed";\r
2343     /**\r
2344      * The connection is already in listening mode.\r
2345      */\r
2346     ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";\r
2347 })(ConnectionErrors = exports.ConnectionErrors || (exports.ConnectionErrors = {}));\r
2348 class ConnectionError extends Error {\r
2349     constructor(code, message) {\r
2350         super(message);\r
2351         this.code = code;\r
2352         Object.setPrototypeOf(this, ConnectionError.prototype);\r
2353     }\r
2354 }\r
2355 exports.ConnectionError = ConnectionError;\r
2356 var ConnectionStrategy;\r
2357 (function (ConnectionStrategy) {\r
2358     function is(value) {\r
2359         let candidate = value;\r
2360         return candidate && Is.func(candidate.cancelUndispatched);\r
2361     }\r
2362     ConnectionStrategy.is = is;\r
2363 })(ConnectionStrategy = exports.ConnectionStrategy || (exports.ConnectionStrategy = {}));\r
2364 var ConnectionState;\r
2365 (function (ConnectionState) {\r
2366     ConnectionState[ConnectionState["New"] = 1] = "New";\r
2367     ConnectionState[ConnectionState["Listening"] = 2] = "Listening";\r
2368     ConnectionState[ConnectionState["Closed"] = 3] = "Closed";\r
2369     ConnectionState[ConnectionState["Disposed"] = 4] = "Disposed";\r
2370 })(ConnectionState || (ConnectionState = {}));\r
2371 function _createMessageConnection(messageReader, messageWriter, logger, strategy) {\r
2372     let sequenceNumber = 0;\r
2373     let notificationSquenceNumber = 0;\r
2374     let unknownResponseSquenceNumber = 0;\r
2375     const version = '2.0';\r
2376     let starRequestHandler = undefined;\r
2377     let requestHandlers = Object.create(null);\r
2378     let starNotificationHandler = undefined;\r
2379     let notificationHandlers = Object.create(null);\r
2380     let progressHandlers = new Map();\r
2381     let timer;\r
2382     let messageQueue = new linkedMap_1.LinkedMap();\r
2383     let responsePromises = Object.create(null);\r
2384     let requestTokens = Object.create(null);\r
2385     let trace = Trace.Off;\r
2386     let traceFormat = TraceFormat.Text;\r
2387     let tracer;\r
2388     let state = ConnectionState.New;\r
2389     let errorEmitter = new events_1.Emitter();\r
2390     let closeEmitter = new events_1.Emitter();\r
2391     let unhandledNotificationEmitter = new events_1.Emitter();\r
2392     let unhandledProgressEmitter = new events_1.Emitter();\r
2393     let disposeEmitter = new events_1.Emitter();\r
2394     function createRequestQueueKey(id) {\r
2395         return 'req-' + id.toString();\r
2396     }\r
2397     function createResponseQueueKey(id) {\r
2398         if (id === null) {\r
2399             return 'res-unknown-' + (++unknownResponseSquenceNumber).toString();\r
2400         }\r
2401         else {\r
2402             return 'res-' + id.toString();\r
2403         }\r
2404     }\r
2405     function createNotificationQueueKey() {\r
2406         return 'not-' + (++notificationSquenceNumber).toString();\r
2407     }\r
2408     function addMessageToQueue(queue, message) {\r
2409         if (messages_1.isRequestMessage(message)) {\r
2410             queue.set(createRequestQueueKey(message.id), message);\r
2411         }\r
2412         else if (messages_1.isResponseMessage(message)) {\r
2413             queue.set(createResponseQueueKey(message.id), message);\r
2414         }\r
2415         else {\r
2416             queue.set(createNotificationQueueKey(), message);\r
2417         }\r
2418     }\r
2419     function cancelUndispatched(_message) {\r
2420         return undefined;\r
2421     }\r
2422     function isListening() {\r
2423         return state === ConnectionState.Listening;\r
2424     }\r
2425     function isClosed() {\r
2426         return state === ConnectionState.Closed;\r
2427     }\r
2428     function isDisposed() {\r
2429         return state === ConnectionState.Disposed;\r
2430     }\r
2431     function closeHandler() {\r
2432         if (state === ConnectionState.New || state === ConnectionState.Listening) {\r
2433             state = ConnectionState.Closed;\r
2434             closeEmitter.fire(undefined);\r
2435         }\r
2436         // If the connection is disposed don't sent close events.\r
2437     }\r
2438     function readErrorHandler(error) {\r
2439         errorEmitter.fire([error, undefined, undefined]);\r
2440     }\r
2441     function writeErrorHandler(data) {\r
2442         errorEmitter.fire(data);\r
2443     }\r
2444     messageReader.onClose(closeHandler);\r
2445     messageReader.onError(readErrorHandler);\r
2446     messageWriter.onClose(closeHandler);\r
2447     messageWriter.onError(writeErrorHandler);\r
2448     function triggerMessageQueue() {\r
2449         if (timer || messageQueue.size === 0) {\r
2450             return;\r
2451         }\r
2452         timer = setImmediate(() => {\r
2453             timer = undefined;\r
2454             processMessageQueue();\r
2455         });\r
2456     }\r
2457     function processMessageQueue() {\r
2458         if (messageQueue.size === 0) {\r
2459             return;\r
2460         }\r
2461         let message = messageQueue.shift();\r
2462         try {\r
2463             if (messages_1.isRequestMessage(message)) {\r
2464                 handleRequest(message);\r
2465             }\r
2466             else if (messages_1.isNotificationMessage(message)) {\r
2467                 handleNotification(message);\r
2468             }\r
2469             else if (messages_1.isResponseMessage(message)) {\r
2470                 handleResponse(message);\r
2471             }\r
2472             else {\r
2473                 handleInvalidMessage(message);\r
2474             }\r
2475         }\r
2476         finally {\r
2477             triggerMessageQueue();\r
2478         }\r
2479     }\r
2480     let callback = (message) => {\r
2481         try {\r
2482             // We have received a cancellation message. Check if the message is still in the queue\r
2483             // and cancel it if allowed to do so.\r
2484             if (messages_1.isNotificationMessage(message) && message.method === CancelNotification.type.method) {\r
2485                 let key = createRequestQueueKey(message.params.id);\r
2486                 let toCancel = messageQueue.get(key);\r
2487                 if (messages_1.isRequestMessage(toCancel)) {\r
2488                     let response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);\r
2489                     if (response && (response.error !== void 0 || response.result !== void 0)) {\r
2490                         messageQueue.delete(key);\r
2491                         response.id = toCancel.id;\r
2492                         traceSendingResponse(response, message.method, Date.now());\r
2493                         messageWriter.write(response);\r
2494                         return;\r
2495                     }\r
2496                 }\r
2497             }\r
2498             addMessageToQueue(messageQueue, message);\r
2499         }\r
2500         finally {\r
2501             triggerMessageQueue();\r
2502         }\r
2503     };\r
2504     function handleRequest(requestMessage) {\r
2505         if (isDisposed()) {\r
2506             // we return here silently since we fired an event when the\r
2507             // connection got disposed.\r
2508             return;\r
2509         }\r
2510         function reply(resultOrError, method, startTime) {\r
2511             let message = {\r
2512                 jsonrpc: version,\r
2513                 id: requestMessage.id\r
2514             };\r
2515             if (resultOrError instanceof messages_1.ResponseError) {\r
2516                 message.error = resultOrError.toJson();\r
2517             }\r
2518             else {\r
2519                 message.result = resultOrError === void 0 ? null : resultOrError;\r
2520             }\r
2521             traceSendingResponse(message, method, startTime);\r
2522             messageWriter.write(message);\r
2523         }\r
2524         function replyError(error, method, startTime) {\r
2525             let message = {\r
2526                 jsonrpc: version,\r
2527                 id: requestMessage.id,\r
2528                 error: error.toJson()\r
2529             };\r
2530             traceSendingResponse(message, method, startTime);\r
2531             messageWriter.write(message);\r
2532         }\r
2533         function replySuccess(result, method, startTime) {\r
2534             // The JSON RPC defines that a response must either have a result or an error\r
2535             // So we can't treat undefined as a valid response result.\r
2536             if (result === void 0) {\r
2537                 result = null;\r
2538             }\r
2539             let message = {\r
2540                 jsonrpc: version,\r
2541                 id: requestMessage.id,\r
2542                 result: result\r
2543             };\r
2544             traceSendingResponse(message, method, startTime);\r
2545             messageWriter.write(message);\r
2546         }\r
2547         traceReceivedRequest(requestMessage);\r
2548         let element = requestHandlers[requestMessage.method];\r
2549         let type;\r
2550         let requestHandler;\r
2551         if (element) {\r
2552             type = element.type;\r
2553             requestHandler = element.handler;\r
2554         }\r
2555         let startTime = Date.now();\r
2556         if (requestHandler || starRequestHandler) {\r
2557             let cancellationSource = new cancellation_1.CancellationTokenSource();\r
2558             let tokenKey = String(requestMessage.id);\r
2559             requestTokens[tokenKey] = cancellationSource;\r
2560             try {\r
2561                 let handlerResult;\r
2562                 if (requestMessage.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) {\r
2563                     handlerResult = requestHandler\r
2564                         ? requestHandler(cancellationSource.token)\r
2565                         : starRequestHandler(requestMessage.method, cancellationSource.token);\r
2566                 }\r
2567                 else if (Is.array(requestMessage.params) && (type === void 0 || type.numberOfParams > 1)) {\r
2568                     handlerResult = requestHandler\r
2569                         ? requestHandler(...requestMessage.params, cancellationSource.token)\r
2570                         : starRequestHandler(requestMessage.method, ...requestMessage.params, cancellationSource.token);\r
2571                 }\r
2572                 else {\r
2573                     handlerResult = requestHandler\r
2574                         ? requestHandler(requestMessage.params, cancellationSource.token)\r
2575                         : starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);\r
2576                 }\r
2577                 let promise = handlerResult;\r
2578                 if (!handlerResult) {\r
2579                     delete requestTokens[tokenKey];\r
2580                     replySuccess(handlerResult, requestMessage.method, startTime);\r
2581                 }\r
2582                 else if (promise.then) {\r
2583                     promise.then((resultOrError) => {\r
2584                         delete requestTokens[tokenKey];\r
2585                         reply(resultOrError, requestMessage.method, startTime);\r
2586                     }, error => {\r
2587                         delete requestTokens[tokenKey];\r
2588                         if (error instanceof messages_1.ResponseError) {\r
2589                             replyError(error, requestMessage.method, startTime);\r
2590                         }\r
2591                         else if (error && Is.string(error.message)) {\r
2592                             replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);\r
2593                         }\r
2594                         else {\r
2595                             replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);\r
2596                         }\r
2597                     });\r
2598                 }\r
2599                 else {\r
2600                     delete requestTokens[tokenKey];\r
2601                     reply(handlerResult, requestMessage.method, startTime);\r
2602                 }\r
2603             }\r
2604             catch (error) {\r
2605                 delete requestTokens[tokenKey];\r
2606                 if (error instanceof messages_1.ResponseError) {\r
2607                     reply(error, requestMessage.method, startTime);\r
2608                 }\r
2609                 else if (error && Is.string(error.message)) {\r
2610                     replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);\r
2611                 }\r
2612                 else {\r
2613                     replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);\r
2614                 }\r
2615             }\r
2616         }\r
2617         else {\r
2618             replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);\r
2619         }\r
2620     }\r
2621     function handleResponse(responseMessage) {\r
2622         if (isDisposed()) {\r
2623             // See handle request.\r
2624             return;\r
2625         }\r
2626         if (responseMessage.id === null) {\r
2627             if (responseMessage.error) {\r
2628                 logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);\r
2629             }\r
2630             else {\r
2631                 logger.error(`Received response message without id. No further error information provided.`);\r
2632             }\r
2633         }\r
2634         else {\r
2635             let key = String(responseMessage.id);\r
2636             let responsePromise = responsePromises[key];\r
2637             traceReceivedResponse(responseMessage, responsePromise);\r
2638             if (responsePromise) {\r
2639                 delete responsePromises[key];\r
2640                 try {\r
2641                     if (responseMessage.error) {\r
2642                         let error = responseMessage.error;\r
2643                         responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));\r
2644                     }\r
2645                     else if (responseMessage.result !== void 0) {\r
2646                         responsePromise.resolve(responseMessage.result);\r
2647                     }\r
2648                     else {\r
2649                         throw new Error('Should never happen.');\r
2650                     }\r
2651                 }\r
2652                 catch (error) {\r
2653                     if (error.message) {\r
2654                         logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);\r
2655                     }\r
2656                     else {\r
2657                         logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);\r
2658                     }\r
2659                 }\r
2660             }\r
2661         }\r
2662     }\r
2663     function handleNotification(message) {\r
2664         if (isDisposed()) {\r
2665             // See handle request.\r
2666             return;\r
2667         }\r
2668         let type = undefined;\r
2669         let notificationHandler;\r
2670         if (message.method === CancelNotification.type.method) {\r
2671             notificationHandler = (params) => {\r
2672                 let id = params.id;\r
2673                 let source = requestTokens[String(id)];\r
2674                 if (source) {\r
2675                     source.cancel();\r
2676                 }\r
2677             };\r
2678         }\r
2679         else {\r
2680             let element = notificationHandlers[message.method];\r
2681             if (element) {\r
2682                 notificationHandler = element.handler;\r
2683                 type = element.type;\r
2684             }\r
2685         }\r
2686         if (notificationHandler || starNotificationHandler) {\r
2687             try {\r
2688                 traceReceivedNotification(message);\r
2689                 if (message.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) {\r
2690                     notificationHandler ? notificationHandler() : starNotificationHandler(message.method);\r
2691                 }\r
2692                 else if (Is.array(message.params) && (type === void 0 || type.numberOfParams > 1)) {\r
2693                     notificationHandler ? notificationHandler(...message.params) : starNotificationHandler(message.method, ...message.params);\r
2694                 }\r
2695                 else {\r
2696                     notificationHandler ? notificationHandler(message.params) : starNotificationHandler(message.method, message.params);\r
2697                 }\r
2698             }\r
2699             catch (error) {\r
2700                 if (error.message) {\r
2701                     logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);\r
2702                 }\r
2703                 else {\r
2704                     logger.error(`Notification handler '${message.method}' failed unexpectedly.`);\r
2705                 }\r
2706             }\r
2707         }\r
2708         else {\r
2709             unhandledNotificationEmitter.fire(message);\r
2710         }\r
2711     }\r
2712     function handleInvalidMessage(message) {\r
2713         if (!message) {\r
2714             logger.error('Received empty message.');\r
2715             return;\r
2716         }\r
2717         logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);\r
2718         // Test whether we find an id to reject the promise\r
2719         let responseMessage = message;\r
2720         if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {\r
2721             let key = String(responseMessage.id);\r
2722             let responseHandler = responsePromises[key];\r
2723             if (responseHandler) {\r
2724                 responseHandler.reject(new Error('The received response has neither a result nor an error property.'));\r
2725             }\r
2726         }\r
2727     }\r
2728     function traceSendingRequest(message) {\r
2729         if (trace === Trace.Off || !tracer) {\r
2730             return;\r
2731         }\r
2732         if (traceFormat === TraceFormat.Text) {\r
2733             let data = undefined;\r
2734             if (trace === Trace.Verbose && message.params) {\r
2735                 data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;\r
2736             }\r
2737             tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);\r
2738         }\r
2739         else {\r
2740             logLSPMessage('send-request', message);\r
2741         }\r
2742     }\r
2743     function traceSendingNotification(message) {\r
2744         if (trace === Trace.Off || !tracer) {\r
2745             return;\r
2746         }\r
2747         if (traceFormat === TraceFormat.Text) {\r
2748             let data = undefined;\r
2749             if (trace === Trace.Verbose) {\r
2750                 if (message.params) {\r
2751                     data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;\r
2752                 }\r
2753                 else {\r
2754                     data = 'No parameters provided.\n\n';\r
2755                 }\r
2756             }\r
2757             tracer.log(`Sending notification '${message.method}'.`, data);\r
2758         }\r
2759         else {\r
2760             logLSPMessage('send-notification', message);\r
2761         }\r
2762     }\r
2763     function traceSendingResponse(message, method, startTime) {\r
2764         if (trace === Trace.Off || !tracer) {\r
2765             return;\r
2766         }\r
2767         if (traceFormat === TraceFormat.Text) {\r
2768             let data = undefined;\r
2769             if (trace === Trace.Verbose) {\r
2770                 if (message.error && message.error.data) {\r
2771                     data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`;\r
2772                 }\r
2773                 else {\r
2774                     if (message.result) {\r
2775                         data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`;\r
2776                     }\r
2777                     else if (message.error === void 0) {\r
2778                         data = 'No result returned.\n\n';\r
2779                     }\r
2780                 }\r
2781             }\r
2782             tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);\r
2783         }\r
2784         else {\r
2785             logLSPMessage('send-response', message);\r
2786         }\r
2787     }\r
2788     function traceReceivedRequest(message) {\r
2789         if (trace === Trace.Off || !tracer) {\r
2790             return;\r
2791         }\r
2792         if (traceFormat === TraceFormat.Text) {\r
2793             let data = undefined;\r
2794             if (trace === Trace.Verbose && message.params) {\r
2795                 data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;\r
2796             }\r
2797             tracer.log(`Received request '${message.method} - (${message.id})'.`, data);\r
2798         }\r
2799         else {\r
2800             logLSPMessage('receive-request', message);\r
2801         }\r
2802     }\r
2803     function traceReceivedNotification(message) {\r
2804         if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {\r
2805             return;\r
2806         }\r
2807         if (traceFormat === TraceFormat.Text) {\r
2808             let data = undefined;\r
2809             if (trace === Trace.Verbose) {\r
2810                 if (message.params) {\r
2811                     data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;\r
2812                 }\r
2813                 else {\r
2814                     data = 'No parameters provided.\n\n';\r
2815                 }\r
2816             }\r
2817             tracer.log(`Received notification '${message.method}'.`, data);\r
2818         }\r
2819         else {\r
2820             logLSPMessage('receive-notification', message);\r
2821         }\r
2822     }\r
2823     function traceReceivedResponse(message, responsePromise) {\r
2824         if (trace === Trace.Off || !tracer) {\r
2825             return;\r
2826         }\r
2827         if (traceFormat === TraceFormat.Text) {\r
2828             let data = undefined;\r
2829             if (trace === Trace.Verbose) {\r
2830                 if (message.error && message.error.data) {\r
2831                     data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`;\r
2832                 }\r
2833                 else {\r
2834                     if (message.result) {\r
2835                         data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`;\r
2836                     }\r
2837                     else if (message.error === void 0) {\r
2838                         data = 'No result returned.\n\n';\r
2839                     }\r
2840                 }\r
2841             }\r
2842             if (responsePromise) {\r
2843                 let error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : '';\r
2844                 tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);\r
2845             }\r
2846             else {\r
2847                 tracer.log(`Received response ${message.id} without active response promise.`, data);\r
2848             }\r
2849         }\r
2850         else {\r
2851             logLSPMessage('receive-response', message);\r
2852         }\r
2853     }\r
2854     function logLSPMessage(type, message) {\r
2855         if (!tracer || trace === Trace.Off) {\r
2856             return;\r
2857         }\r
2858         const lspMessage = {\r
2859             isLSPMessage: true,\r
2860             type,\r
2861             message,\r
2862             timestamp: Date.now()\r
2863         };\r
2864         tracer.log(lspMessage);\r
2865     }\r
2866     function throwIfClosedOrDisposed() {\r
2867         if (isClosed()) {\r
2868             throw new ConnectionError(ConnectionErrors.Closed, 'Connection is closed.');\r
2869         }\r
2870         if (isDisposed()) {\r
2871             throw new ConnectionError(ConnectionErrors.Disposed, 'Connection is disposed.');\r
2872         }\r
2873     }\r
2874     function throwIfListening() {\r
2875         if (isListening()) {\r
2876             throw new ConnectionError(ConnectionErrors.AlreadyListening, 'Connection is already listening');\r
2877         }\r
2878     }\r
2879     function throwIfNotListening() {\r
2880         if (!isListening()) {\r
2881             throw new Error('Call listen() first.');\r
2882         }\r
2883     }\r
2884     function undefinedToNull(param) {\r
2885         if (param === void 0) {\r
2886             return null;\r
2887         }\r
2888         else {\r
2889             return param;\r
2890         }\r
2891     }\r
2892     function computeMessageParams(type, params) {\r
2893         let result;\r
2894         let numberOfParams = type.numberOfParams;\r
2895         switch (numberOfParams) {\r
2896             case 0:\r
2897                 result = null;\r
2898                 break;\r
2899             case 1:\r
2900                 result = undefinedToNull(params[0]);\r
2901                 break;\r
2902             default:\r
2903                 result = [];\r
2904                 for (let i = 0; i < params.length && i < numberOfParams; i++) {\r
2905                     result.push(undefinedToNull(params[i]));\r
2906                 }\r
2907                 if (params.length < numberOfParams) {\r
2908                     for (let i = params.length; i < numberOfParams; i++) {\r
2909                         result.push(null);\r
2910                     }\r
2911                 }\r
2912                 break;\r
2913         }\r
2914         return result;\r
2915     }\r
2916     let connection = {\r
2917         sendNotification: (type, ...params) => {\r
2918             throwIfClosedOrDisposed();\r
2919             let method;\r
2920             let messageParams;\r
2921             if (Is.string(type)) {\r
2922                 method = type;\r
2923                 switch (params.length) {\r
2924                     case 0:\r
2925                         messageParams = null;\r
2926                         break;\r
2927                     case 1:\r
2928                         messageParams = params[0];\r
2929                         break;\r
2930                     default:\r
2931                         messageParams = params;\r
2932                         break;\r
2933                 }\r
2934             }\r
2935             else {\r
2936                 method = type.method;\r
2937                 messageParams = computeMessageParams(type, params);\r
2938             }\r
2939             let notificationMessage = {\r
2940                 jsonrpc: version,\r
2941                 method: method,\r
2942                 params: messageParams\r
2943             };\r
2944             traceSendingNotification(notificationMessage);\r
2945             messageWriter.write(notificationMessage);\r
2946         },\r
2947         onNotification: (type, handler) => {\r
2948             throwIfClosedOrDisposed();\r
2949             if (Is.func(type)) {\r
2950                 starNotificationHandler = type;\r
2951             }\r
2952             else if (handler) {\r
2953                 if (Is.string(type)) {\r
2954                     notificationHandlers[type] = { type: undefined, handler };\r
2955                 }\r
2956                 else {\r
2957                     notificationHandlers[type.method] = { type, handler };\r
2958                 }\r
2959             }\r
2960         },\r
2961         onProgress: (_type, token, handler) => {\r
2962             if (progressHandlers.has(token)) {\r
2963                 throw new Error(`Progress handler for token ${token} already registered`);\r
2964             }\r
2965             progressHandlers.set(token, handler);\r
2966             return {\r
2967                 dispose: () => {\r
2968                     progressHandlers.delete(token);\r
2969                 }\r
2970             };\r
2971         },\r
2972         sendProgress: (_type, token, value) => {\r
2973             connection.sendNotification(ProgressNotification.type, { token, value });\r
2974         },\r
2975         onUnhandledProgress: unhandledProgressEmitter.event,\r
2976         sendRequest: (type, ...params) => {\r
2977             throwIfClosedOrDisposed();\r
2978             throwIfNotListening();\r
2979             let method;\r
2980             let messageParams;\r
2981             let token = undefined;\r
2982             if (Is.string(type)) {\r
2983                 method = type;\r
2984                 switch (params.length) {\r
2985                     case 0:\r
2986                         messageParams = null;\r
2987                         break;\r
2988                     case 1:\r
2989                         // The cancellation token is optional so it can also be undefined.\r
2990                         if (cancellation_1.CancellationToken.is(params[0])) {\r
2991                             messageParams = null;\r
2992                             token = params[0];\r
2993                         }\r
2994                         else {\r
2995                             messageParams = undefinedToNull(params[0]);\r
2996                         }\r
2997                         break;\r
2998                     default:\r
2999                         const last = params.length - 1;\r
3000                         if (cancellation_1.CancellationToken.is(params[last])) {\r
3001                             token = params[last];\r
3002                             if (params.length === 2) {\r
3003                                 messageParams = undefinedToNull(params[0]);\r
3004                             }\r
3005                             else {\r
3006                                 messageParams = params.slice(0, last).map(value => undefinedToNull(value));\r
3007                             }\r
3008                         }\r
3009                         else {\r
3010                             messageParams = params.map(value => undefinedToNull(value));\r
3011                         }\r
3012                         break;\r
3013                 }\r
3014             }\r
3015             else {\r
3016                 method = type.method;\r
3017                 messageParams = computeMessageParams(type, params);\r
3018                 let numberOfParams = type.numberOfParams;\r
3019                 token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : undefined;\r
3020             }\r
3021             let id = sequenceNumber++;\r
3022             let result = new Promise((resolve, reject) => {\r
3023                 let requestMessage = {\r
3024                     jsonrpc: version,\r
3025                     id: id,\r
3026                     method: method,\r
3027                     params: messageParams\r
3028                 };\r
3029                 let responsePromise = { method: method, timerStart: Date.now(), resolve, reject };\r
3030                 traceSendingRequest(requestMessage);\r
3031                 try {\r
3032                     messageWriter.write(requestMessage);\r
3033                 }\r
3034                 catch (e) {\r
3035                     // Writing the message failed. So we need to reject the promise.\r
3036                     responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason'));\r
3037                     responsePromise = null;\r
3038                 }\r
3039                 if (responsePromise) {\r
3040                     responsePromises[String(id)] = responsePromise;\r
3041                 }\r
3042             });\r
3043             if (token) {\r
3044                 token.onCancellationRequested(() => {\r
3045                     connection.sendNotification(CancelNotification.type, { id });\r
3046                 });\r
3047             }\r
3048             return result;\r
3049         },\r
3050         onRequest: (type, handler) => {\r
3051             throwIfClosedOrDisposed();\r
3052             if (Is.func(type)) {\r
3053                 starRequestHandler = type;\r
3054             }\r
3055             else if (handler) {\r
3056                 if (Is.string(type)) {\r
3057                     requestHandlers[type] = { type: undefined, handler };\r
3058                 }\r
3059                 else {\r
3060                     requestHandlers[type.method] = { type, handler };\r
3061                 }\r
3062             }\r
3063         },\r
3064         trace: (_value, _tracer, sendNotificationOrTraceOptions) => {\r
3065             let _sendNotification = false;\r
3066             let _traceFormat = TraceFormat.Text;\r
3067             if (sendNotificationOrTraceOptions !== void 0) {\r
3068                 if (Is.boolean(sendNotificationOrTraceOptions)) {\r
3069                     _sendNotification = sendNotificationOrTraceOptions;\r
3070                 }\r
3071                 else {\r
3072                     _sendNotification = sendNotificationOrTraceOptions.sendNotification || false;\r
3073                     _traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;\r
3074                 }\r
3075             }\r
3076             trace = _value;\r
3077             traceFormat = _traceFormat;\r
3078             if (trace === Trace.Off) {\r
3079                 tracer = undefined;\r
3080             }\r
3081             else {\r
3082                 tracer = _tracer;\r
3083             }\r
3084             if (_sendNotification && !isClosed() && !isDisposed()) {\r
3085                 connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });\r
3086             }\r
3087         },\r
3088         onError: errorEmitter.event,\r
3089         onClose: closeEmitter.event,\r
3090         onUnhandledNotification: unhandledNotificationEmitter.event,\r
3091         onDispose: disposeEmitter.event,\r
3092         dispose: () => {\r
3093             if (isDisposed()) {\r
3094                 return;\r
3095             }\r
3096             state = ConnectionState.Disposed;\r
3097             disposeEmitter.fire(undefined);\r
3098             let error = new Error('Connection got disposed.');\r
3099             Object.keys(responsePromises).forEach((key) => {\r
3100                 responsePromises[key].reject(error);\r
3101             });\r
3102             responsePromises = Object.create(null);\r
3103             requestTokens = Object.create(null);\r
3104             messageQueue = new linkedMap_1.LinkedMap();\r
3105             // Test for backwards compatibility\r
3106             if (Is.func(messageWriter.dispose)) {\r
3107                 messageWriter.dispose();\r
3108             }\r
3109             if (Is.func(messageReader.dispose)) {\r
3110                 messageReader.dispose();\r
3111             }\r
3112         },\r
3113         listen: () => {\r
3114             throwIfClosedOrDisposed();\r
3115             throwIfListening();\r
3116             state = ConnectionState.Listening;\r
3117             messageReader.listen(callback);\r
3118         },\r
3119         inspect: () => {\r
3120             // eslint-disable-next-line no-console\r
3121             console.log('inspect');\r
3122         }\r
3123     };\r
3124     connection.onNotification(LogTraceNotification.type, (params) => {\r
3125         if (trace === Trace.Off || !tracer) {\r
3126             return;\r
3127         }\r
3128         tracer.log(params.message, trace === Trace.Verbose ? params.verbose : undefined);\r
3129     });\r
3130     connection.onNotification(ProgressNotification.type, (params) => {\r
3131         const handler = progressHandlers.get(params.token);\r
3132         if (handler) {\r
3133             handler(params.value);\r
3134         }\r
3135         else {\r
3136             unhandledProgressEmitter.fire(params);\r
3137         }\r
3138     });\r
3139     return connection;\r
3140 }\r
3141 function isMessageReader(value) {\r
3142     return value.listen !== void 0 && value.read === void 0;\r
3143 }\r
3144 function isMessageWriter(value) {\r
3145     return value.write !== void 0 && value.end === void 0;\r
3146 }\r
3147 function createMessageConnection(input, output, logger, strategy) {\r
3148     if (!logger) {\r
3149         logger = exports.NullLogger;\r
3150     }\r
3151     let reader = isMessageReader(input) ? input : new messageReader_1.StreamMessageReader(input);\r
3152     let writer = isMessageWriter(output) ? output : new messageWriter_1.StreamMessageWriter(output);\r
3153     return _createMessageConnection(reader, writer, logger, strategy);\r
3154 }\r
3155 exports.createMessageConnection = createMessageConnection;\r
3156
3157
3158 /***/ }),
3159 /* 10 */
3160 /***/ (function(module, exports, __webpack_require__) {
3161
3162 "use strict";
3163 /* --------------------------------------------------------------------------------------------\r
3164  * Copyright (c) Microsoft Corporation. All rights reserved.\r
3165  * Licensed under the MIT License. See License.txt in the project root for license information.\r
3166  * ------------------------------------------------------------------------------------------ */\r
3167 \r
3168 Object.defineProperty(exports, "__esModule", { value: true });\r
3169 function boolean(value) {\r
3170     return value === true || value === false;\r
3171 }\r
3172 exports.boolean = boolean;\r
3173 function string(value) {\r
3174     return typeof value === 'string' || value instanceof String;\r
3175 }\r
3176 exports.string = string;\r
3177 function number(value) {\r
3178     return typeof value === 'number' || value instanceof Number;\r
3179 }\r
3180 exports.number = number;\r
3181 function error(value) {\r
3182     return value instanceof Error;\r
3183 }\r
3184 exports.error = error;\r
3185 function func(value) {\r
3186     return typeof value === 'function';\r
3187 }\r
3188 exports.func = func;\r
3189 function array(value) {\r
3190     return Array.isArray(value);\r
3191 }\r
3192 exports.array = array;\r
3193 function stringArray(value) {\r
3194     return array(value) && value.every(elem => string(elem));\r
3195 }\r
3196 exports.stringArray = stringArray;\r
3197
3198
3199 /***/ }),
3200 /* 11 */
3201 /***/ (function(module, exports, __webpack_require__) {
3202
3203 "use strict";
3204 /* --------------------------------------------------------------------------------------------\r
3205  * Copyright (c) Microsoft Corporation. All rights reserved.\r
3206  * Licensed under the MIT License. See License.txt in the project root for license information.\r
3207  * ------------------------------------------------------------------------------------------ */\r
3208 \r
3209 Object.defineProperty(exports, "__esModule", { value: true });\r
3210 const is = __webpack_require__(10);\r
3211 /**\r
3212  * Predefined error codes.\r
3213  */\r
3214 var ErrorCodes;\r
3215 (function (ErrorCodes) {\r
3216     // Defined by JSON RPC\r
3217     ErrorCodes.ParseError = -32700;\r
3218     ErrorCodes.InvalidRequest = -32600;\r
3219     ErrorCodes.MethodNotFound = -32601;\r
3220     ErrorCodes.InvalidParams = -32602;\r
3221     ErrorCodes.InternalError = -32603;\r
3222     ErrorCodes.serverErrorStart = -32099;\r
3223     ErrorCodes.serverErrorEnd = -32000;\r
3224     ErrorCodes.ServerNotInitialized = -32002;\r
3225     ErrorCodes.UnknownErrorCode = -32001;\r
3226     // Defined by the protocol.\r
3227     ErrorCodes.RequestCancelled = -32800;\r
3228     ErrorCodes.ContentModified = -32801;\r
3229     // Defined by VSCode library.\r
3230     ErrorCodes.MessageWriteError = 1;\r
3231     ErrorCodes.MessageReadError = 2;\r
3232 })(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}));\r
3233 /**\r
3234  * An error object return in a response in case a request\r
3235  * has failed.\r
3236  */\r
3237 class ResponseError extends Error {\r
3238     constructor(code, message, data) {\r
3239         super(message);\r
3240         this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;\r
3241         this.data = data;\r
3242         Object.setPrototypeOf(this, ResponseError.prototype);\r
3243     }\r
3244     toJson() {\r
3245         return {\r
3246             code: this.code,\r
3247             message: this.message,\r
3248             data: this.data,\r
3249         };\r
3250     }\r
3251 }\r
3252 exports.ResponseError = ResponseError;\r
3253 /**\r
3254  * An abstract implementation of a MessageType.\r
3255  */\r
3256 class AbstractMessageType {\r
3257     constructor(_method, _numberOfParams) {\r
3258         this._method = _method;\r
3259         this._numberOfParams = _numberOfParams;\r
3260     }\r
3261     get method() {\r
3262         return this._method;\r
3263     }\r
3264     get numberOfParams() {\r
3265         return this._numberOfParams;\r
3266     }\r
3267 }\r
3268 exports.AbstractMessageType = AbstractMessageType;\r
3269 /**\r
3270  * Classes to type request response pairs\r
3271  *\r
3272  * The type parameter RO will be removed in the next major version\r
3273  * of the JSON RPC library since it is a LSP concept and doesn't\r
3274  * belong here. For now it is tagged as default never.\r
3275  */\r
3276 class RequestType0 extends AbstractMessageType {\r
3277     constructor(method) {\r
3278         super(method, 0);\r
3279     }\r
3280 }\r
3281 exports.RequestType0 = RequestType0;\r
3282 class RequestType extends AbstractMessageType {\r
3283     constructor(method) {\r
3284         super(method, 1);\r
3285     }\r
3286 }\r
3287 exports.RequestType = RequestType;\r
3288 class RequestType1 extends AbstractMessageType {\r
3289     constructor(method) {\r
3290         super(method, 1);\r
3291     }\r
3292 }\r
3293 exports.RequestType1 = RequestType1;\r
3294 class RequestType2 extends AbstractMessageType {\r
3295     constructor(method) {\r
3296         super(method, 2);\r
3297     }\r
3298 }\r
3299 exports.RequestType2 = RequestType2;\r
3300 class RequestType3 extends AbstractMessageType {\r
3301     constructor(method) {\r
3302         super(method, 3);\r
3303     }\r
3304 }\r
3305 exports.RequestType3 = RequestType3;\r
3306 class RequestType4 extends AbstractMessageType {\r
3307     constructor(method) {\r
3308         super(method, 4);\r
3309     }\r
3310 }\r
3311 exports.RequestType4 = RequestType4;\r
3312 class RequestType5 extends AbstractMessageType {\r
3313     constructor(method) {\r
3314         super(method, 5);\r
3315     }\r
3316 }\r
3317 exports.RequestType5 = RequestType5;\r
3318 class RequestType6 extends AbstractMessageType {\r
3319     constructor(method) {\r
3320         super(method, 6);\r
3321     }\r
3322 }\r
3323 exports.RequestType6 = RequestType6;\r
3324 class RequestType7 extends AbstractMessageType {\r
3325     constructor(method) {\r
3326         super(method, 7);\r
3327     }\r
3328 }\r
3329 exports.RequestType7 = RequestType7;\r
3330 class RequestType8 extends AbstractMessageType {\r
3331     constructor(method) {\r
3332         super(method, 8);\r
3333     }\r
3334 }\r
3335 exports.RequestType8 = RequestType8;\r
3336 class RequestType9 extends AbstractMessageType {\r
3337     constructor(method) {\r
3338         super(method, 9);\r
3339     }\r
3340 }\r
3341 exports.RequestType9 = RequestType9;\r
3342 /**\r
3343  * The type parameter RO will be removed in the next major version\r
3344  * of the JSON RPC library since it is a LSP concept and doesn't\r
3345  * belong here. For now it is tagged as default never.\r
3346  */\r
3347 class NotificationType extends AbstractMessageType {\r
3348     constructor(method) {\r
3349         super(method, 1);\r
3350         this._ = undefined;\r
3351     }\r
3352 }\r
3353 exports.NotificationType = NotificationType;\r
3354 class NotificationType0 extends AbstractMessageType {\r
3355     constructor(method) {\r
3356         super(method, 0);\r
3357     }\r
3358 }\r
3359 exports.NotificationType0 = NotificationType0;\r
3360 class NotificationType1 extends AbstractMessageType {\r
3361     constructor(method) {\r
3362         super(method, 1);\r
3363     }\r
3364 }\r
3365 exports.NotificationType1 = NotificationType1;\r
3366 class NotificationType2 extends AbstractMessageType {\r
3367     constructor(method) {\r
3368         super(method, 2);\r
3369     }\r
3370 }\r
3371 exports.NotificationType2 = NotificationType2;\r
3372 class NotificationType3 extends AbstractMessageType {\r
3373     constructor(method) {\r
3374         super(method, 3);\r
3375     }\r
3376 }\r
3377 exports.NotificationType3 = NotificationType3;\r
3378 class NotificationType4 extends AbstractMessageType {\r
3379     constructor(method) {\r
3380         super(method, 4);\r
3381     }\r
3382 }\r
3383 exports.NotificationType4 = NotificationType4;\r
3384 class NotificationType5 extends AbstractMessageType {\r
3385     constructor(method) {\r
3386         super(method, 5);\r
3387     }\r
3388 }\r
3389 exports.NotificationType5 = NotificationType5;\r
3390 class NotificationType6 extends AbstractMessageType {\r
3391     constructor(method) {\r
3392         super(method, 6);\r
3393     }\r
3394 }\r
3395 exports.NotificationType6 = NotificationType6;\r
3396 class NotificationType7 extends AbstractMessageType {\r
3397     constructor(method) {\r
3398         super(method, 7);\r
3399     }\r
3400 }\r
3401 exports.NotificationType7 = NotificationType7;\r
3402 class NotificationType8 extends AbstractMessageType {\r
3403     constructor(method) {\r
3404         super(method, 8);\r
3405     }\r
3406 }\r
3407 exports.NotificationType8 = NotificationType8;\r
3408 class NotificationType9 extends AbstractMessageType {\r
3409     constructor(method) {\r
3410         super(method, 9);\r
3411     }\r
3412 }\r
3413 exports.NotificationType9 = NotificationType9;\r
3414 /**\r
3415  * Tests if the given message is a request message\r
3416  */\r
3417 function isRequestMessage(message) {\r
3418     let candidate = message;\r
3419     return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));\r
3420 }\r
3421 exports.isRequestMessage = isRequestMessage;\r
3422 /**\r
3423  * Tests if the given message is a notification message\r
3424  */\r
3425 function isNotificationMessage(message) {\r
3426     let candidate = message;\r
3427     return candidate && is.string(candidate.method) && message.id === void 0;\r
3428 }\r
3429 exports.isNotificationMessage = isNotificationMessage;\r
3430 /**\r
3431  * Tests if the given message is a response message\r
3432  */\r
3433 function isResponseMessage(message) {\r
3434     let candidate = message;\r
3435     return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);\r
3436 }\r
3437 exports.isResponseMessage = isResponseMessage;\r
3438
3439
3440 /***/ }),
3441 /* 12 */
3442 /***/ (function(module, exports, __webpack_require__) {
3443
3444 "use strict";
3445 /* --------------------------------------------------------------------------------------------\r
3446  * Copyright (c) Microsoft Corporation. All rights reserved.\r
3447  * Licensed under the MIT License. See License.txt in the project root for license information.\r
3448  * ------------------------------------------------------------------------------------------ */\r
3449 \r
3450 Object.defineProperty(exports, "__esModule", { value: true });\r
3451 const events_1 = __webpack_require__(13);\r
3452 const Is = __webpack_require__(10);\r
3453 let DefaultSize = 8192;\r
3454 let CR = Buffer.from('\r', 'ascii')[0];\r
3455 let LF = Buffer.from('\n', 'ascii')[0];\r
3456 let CRLF = '\r\n';\r
3457 class MessageBuffer {\r
3458     constructor(encoding = 'utf8') {\r
3459         this.encoding = encoding;\r
3460         this.index = 0;\r
3461         this.buffer = Buffer.allocUnsafe(DefaultSize);\r
3462     }\r
3463     append(chunk) {\r
3464         var toAppend = chunk;\r
3465         if (typeof (chunk) === 'string') {\r
3466             var str = chunk;\r
3467             var bufferLen = Buffer.byteLength(str, this.encoding);\r
3468             toAppend = Buffer.allocUnsafe(bufferLen);\r
3469             toAppend.write(str, 0, bufferLen, this.encoding);\r
3470         }\r
3471         if (this.buffer.length - this.index >= toAppend.length) {\r
3472             toAppend.copy(this.buffer, this.index, 0, toAppend.length);\r
3473         }\r
3474         else {\r
3475             var newSize = (Math.ceil((this.index + toAppend.length) / DefaultSize) + 1) * DefaultSize;\r
3476             if (this.index === 0) {\r
3477                 this.buffer = Buffer.allocUnsafe(newSize);\r
3478                 toAppend.copy(this.buffer, 0, 0, toAppend.length);\r
3479             }\r
3480             else {\r
3481                 this.buffer = Buffer.concat([this.buffer.slice(0, this.index), toAppend], newSize);\r
3482             }\r
3483         }\r
3484         this.index += toAppend.length;\r
3485     }\r
3486     tryReadHeaders() {\r
3487         let result = undefined;\r
3488         let current = 0;\r
3489         while (current + 3 < this.index && (this.buffer[current] !== CR || this.buffer[current + 1] !== LF || this.buffer[current + 2] !== CR || this.buffer[current + 3] !== LF)) {\r
3490             current++;\r
3491         }\r
3492         // No header / body separator found (e.g CRLFCRLF)\r
3493         if (current + 3 >= this.index) {\r
3494             return result;\r
3495         }\r
3496         result = Object.create(null);\r
3497         let headers = this.buffer.toString('ascii', 0, current).split(CRLF);\r
3498         headers.forEach((header) => {\r
3499             let index = header.indexOf(':');\r
3500             if (index === -1) {\r
3501                 throw new Error('Message header must separate key and value using :');\r
3502             }\r
3503             let key = header.substr(0, index);\r
3504             let value = header.substr(index + 1).trim();\r
3505             result[key] = value;\r
3506         });\r
3507         let nextStart = current + 4;\r
3508         this.buffer = this.buffer.slice(nextStart);\r
3509         this.index = this.index - nextStart;\r
3510         return result;\r
3511     }\r
3512     tryReadContent(length) {\r
3513         if (this.index < length) {\r
3514             return null;\r
3515         }\r
3516         let result = this.buffer.toString(this.encoding, 0, length);\r
3517         let nextStart = length;\r
3518         this.buffer.copy(this.buffer, 0, nextStart);\r
3519         this.index = this.index - nextStart;\r
3520         return result;\r
3521     }\r
3522     get numberOfBytes() {\r
3523         return this.index;\r
3524     }\r
3525 }\r
3526 var MessageReader;\r
3527 (function (MessageReader) {\r
3528     function is(value) {\r
3529         let candidate = value;\r
3530         return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) &&\r
3531             Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);\r
3532     }\r
3533     MessageReader.is = is;\r
3534 })(MessageReader = exports.MessageReader || (exports.MessageReader = {}));\r
3535 class AbstractMessageReader {\r
3536     constructor() {\r
3537         this.errorEmitter = new events_1.Emitter();\r
3538         this.closeEmitter = new events_1.Emitter();\r
3539         this.partialMessageEmitter = new events_1.Emitter();\r
3540     }\r
3541     dispose() {\r
3542         this.errorEmitter.dispose();\r
3543         this.closeEmitter.dispose();\r
3544     }\r
3545     get onError() {\r
3546         return this.errorEmitter.event;\r
3547     }\r
3548     fireError(error) {\r
3549         this.errorEmitter.fire(this.asError(error));\r
3550     }\r
3551     get onClose() {\r
3552         return this.closeEmitter.event;\r
3553     }\r
3554     fireClose() {\r
3555         this.closeEmitter.fire(undefined);\r
3556     }\r
3557     get onPartialMessage() {\r
3558         return this.partialMessageEmitter.event;\r
3559     }\r
3560     firePartialMessage(info) {\r
3561         this.partialMessageEmitter.fire(info);\r
3562     }\r
3563     asError(error) {\r
3564         if (error instanceof Error) {\r
3565             return error;\r
3566         }\r
3567         else {\r
3568             return new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);\r
3569         }\r
3570     }\r
3571 }\r
3572 exports.AbstractMessageReader = AbstractMessageReader;\r
3573 class StreamMessageReader extends AbstractMessageReader {\r
3574     constructor(readable, encoding = 'utf8') {\r
3575         super();\r
3576         this.readable = readable;\r
3577         this.buffer = new MessageBuffer(encoding);\r
3578         this._partialMessageTimeout = 10000;\r
3579     }\r
3580     set partialMessageTimeout(timeout) {\r
3581         this._partialMessageTimeout = timeout;\r
3582     }\r
3583     get partialMessageTimeout() {\r
3584         return this._partialMessageTimeout;\r
3585     }\r
3586     listen(callback) {\r
3587         this.nextMessageLength = -1;\r
3588         this.messageToken = 0;\r
3589         this.partialMessageTimer = undefined;\r
3590         this.callback = callback;\r
3591         this.readable.on('data', (data) => {\r
3592             this.onData(data);\r
3593         });\r
3594         this.readable.on('error', (error) => this.fireError(error));\r
3595         this.readable.on('close', () => this.fireClose());\r
3596     }\r
3597     onData(data) {\r
3598         this.buffer.append(data);\r
3599         while (true) {\r
3600             if (this.nextMessageLength === -1) {\r
3601                 let headers = this.buffer.tryReadHeaders();\r
3602                 if (!headers) {\r
3603                     return;\r
3604                 }\r
3605                 let contentLength = headers['Content-Length'];\r
3606                 if (!contentLength) {\r
3607                     throw new Error('Header must provide a Content-Length property.');\r
3608                 }\r
3609                 let length = parseInt(contentLength);\r
3610                 if (isNaN(length)) {\r
3611                     throw new Error('Content-Length value must be a number.');\r
3612                 }\r
3613                 this.nextMessageLength = length;\r
3614                 // Take the encoding form the header. For compatibility\r
3615                 // treat both utf-8 and utf8 as node utf8\r
3616             }\r
3617             var msg = this.buffer.tryReadContent(this.nextMessageLength);\r
3618             if (msg === null) {\r
3619                 /** We haven't received the full message yet. */\r
3620                 this.setPartialMessageTimer();\r
3621                 return;\r
3622             }\r
3623             this.clearPartialMessageTimer();\r
3624             this.nextMessageLength = -1;\r
3625             this.messageToken++;\r
3626             var json = JSON.parse(msg);\r
3627             this.callback(json);\r
3628         }\r
3629     }\r
3630     clearPartialMessageTimer() {\r
3631         if (this.partialMessageTimer) {\r
3632             clearTimeout(this.partialMessageTimer);\r
3633             this.partialMessageTimer = undefined;\r
3634         }\r
3635     }\r
3636     setPartialMessageTimer() {\r
3637         this.clearPartialMessageTimer();\r
3638         if (this._partialMessageTimeout <= 0) {\r
3639             return;\r
3640         }\r
3641         this.partialMessageTimer = setTimeout((token, timeout) => {\r
3642             this.partialMessageTimer = undefined;\r
3643             if (token === this.messageToken) {\r
3644                 this.firePartialMessage({ messageToken: token, waitingTime: timeout });\r
3645                 this.setPartialMessageTimer();\r
3646             }\r
3647         }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);\r
3648     }\r
3649 }\r
3650 exports.StreamMessageReader = StreamMessageReader;\r
3651 class IPCMessageReader extends AbstractMessageReader {\r
3652     constructor(process) {\r
3653         super();\r
3654         this.process = process;\r
3655         let eventEmitter = this.process;\r
3656         eventEmitter.on('error', (error) => this.fireError(error));\r
3657         eventEmitter.on('close', () => this.fireClose());\r
3658     }\r
3659     listen(callback) {\r
3660         this.process.on('message', callback);\r
3661     }\r
3662 }\r
3663 exports.IPCMessageReader = IPCMessageReader;\r
3664 class SocketMessageReader extends StreamMessageReader {\r
3665     constructor(socket, encoding = 'utf-8') {\r
3666         super(socket, encoding);\r
3667     }\r
3668 }\r
3669 exports.SocketMessageReader = SocketMessageReader;\r
3670
3671
3672 /***/ }),
3673 /* 13 */
3674 /***/ (function(module, exports, __webpack_require__) {
3675
3676 "use strict";
3677 /* --------------------------------------------------------------------------------------------\r
3678  * Copyright (c) Microsoft Corporation. All rights reserved.\r
3679  * Licensed under the MIT License. See License.txt in the project root for license information.\r
3680  * ------------------------------------------------------------------------------------------ */\r
3681 \r
3682 Object.defineProperty(exports, "__esModule", { value: true });\r
3683 var Disposable;\r
3684 (function (Disposable) {\r
3685     function create(func) {\r
3686         return {\r
3687             dispose: func\r
3688         };\r
3689     }\r
3690     Disposable.create = create;\r
3691 })(Disposable = exports.Disposable || (exports.Disposable = {}));\r
3692 var Event;\r
3693 (function (Event) {\r
3694     const _disposable = { dispose() { } };\r
3695     Event.None = function () { return _disposable; };\r
3696 })(Event = exports.Event || (exports.Event = {}));\r
3697 class CallbackList {\r
3698     add(callback, context = null, bucket) {\r
3699         if (!this._callbacks) {\r
3700             this._callbacks = [];\r
3701             this._contexts = [];\r
3702         }\r
3703         this._callbacks.push(callback);\r
3704         this._contexts.push(context);\r
3705         if (Array.isArray(bucket)) {\r
3706             bucket.push({ dispose: () => this.remove(callback, context) });\r
3707         }\r
3708     }\r
3709     remove(callback, context = null) {\r
3710         if (!this._callbacks) {\r
3711             return;\r
3712         }\r
3713         var foundCallbackWithDifferentContext = false;\r
3714         for (var i = 0, len = this._callbacks.length; i < len; i++) {\r
3715             if (this._callbacks[i] === callback) {\r
3716                 if (this._contexts[i] === context) {\r
3717                     // callback & context match => remove it\r
3718                     this._callbacks.splice(i, 1);\r
3719                     this._contexts.splice(i, 1);\r
3720                     return;\r
3721                 }\r
3722                 else {\r
3723                     foundCallbackWithDifferentContext = true;\r
3724                 }\r
3725             }\r
3726         }\r
3727         if (foundCallbackWithDifferentContext) {\r
3728             throw new Error('When adding a listener with a context, you should remove it with the same context');\r
3729         }\r
3730     }\r
3731     invoke(...args) {\r
3732         if (!this._callbacks) {\r
3733             return [];\r
3734         }\r
3735         var ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);\r
3736         for (var i = 0, len = callbacks.length; i < len; i++) {\r
3737             try {\r
3738                 ret.push(callbacks[i].apply(contexts[i], args));\r
3739             }\r
3740             catch (e) {\r
3741                 // eslint-disable-next-line no-console\r
3742                 console.error(e);\r
3743             }\r
3744         }\r
3745         return ret;\r
3746     }\r
3747     isEmpty() {\r
3748         return !this._callbacks || this._callbacks.length === 0;\r
3749     }\r
3750     dispose() {\r
3751         this._callbacks = undefined;\r
3752         this._contexts = undefined;\r
3753     }\r
3754 }\r
3755 class Emitter {\r
3756     constructor(_options) {\r
3757         this._options = _options;\r
3758     }\r
3759     /**\r
3760      * For the public to allow to subscribe\r
3761      * to events from this Emitter\r
3762      */\r
3763     get event() {\r
3764         if (!this._event) {\r
3765             this._event = (listener, thisArgs, disposables) => {\r
3766                 if (!this._callbacks) {\r
3767                     this._callbacks = new CallbackList();\r
3768                 }\r
3769                 if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {\r
3770                     this._options.onFirstListenerAdd(this);\r
3771                 }\r
3772                 this._callbacks.add(listener, thisArgs);\r
3773                 let result;\r
3774                 result = {\r
3775                     dispose: () => {\r
3776                         this._callbacks.remove(listener, thisArgs);\r
3777                         result.dispose = Emitter._noop;\r
3778                         if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {\r
3779                             this._options.onLastListenerRemove(this);\r
3780                         }\r
3781                     }\r
3782                 };\r
3783                 if (Array.isArray(disposables)) {\r
3784                     disposables.push(result);\r
3785                 }\r
3786                 return result;\r
3787             };\r
3788         }\r
3789         return this._event;\r
3790     }\r
3791     /**\r
3792      * To be kept private to fire an event to\r
3793      * subscribers\r
3794      */\r
3795     fire(event) {\r
3796         if (this._callbacks) {\r
3797             this._callbacks.invoke.call(this._callbacks, event);\r
3798         }\r
3799     }\r
3800     dispose() {\r
3801         if (this._callbacks) {\r
3802             this._callbacks.dispose();\r
3803             this._callbacks = undefined;\r
3804         }\r
3805     }\r
3806 }\r
3807 exports.Emitter = Emitter;\r
3808 Emitter._noop = function () { };\r
3809
3810
3811 /***/ }),
3812 /* 14 */
3813 /***/ (function(module, exports, __webpack_require__) {
3814
3815 "use strict";
3816 /* --------------------------------------------------------------------------------------------\r
3817  * Copyright (c) Microsoft Corporation. All rights reserved.\r
3818  * Licensed under the MIT License. See License.txt in the project root for license information.\r
3819  * ------------------------------------------------------------------------------------------ */\r
3820 \r
3821 Object.defineProperty(exports, "__esModule", { value: true });\r
3822 const events_1 = __webpack_require__(13);\r
3823 const Is = __webpack_require__(10);\r
3824 let ContentLength = 'Content-Length: ';\r
3825 let CRLF = '\r\n';\r
3826 var MessageWriter;\r
3827 (function (MessageWriter) {\r
3828     function is(value) {\r
3829         let candidate = value;\r
3830         return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) &&\r
3831             Is.func(candidate.onError) && Is.func(candidate.write);\r
3832     }\r
3833     MessageWriter.is = is;\r
3834 })(MessageWriter = exports.MessageWriter || (exports.MessageWriter = {}));\r
3835 class AbstractMessageWriter {\r
3836     constructor() {\r
3837         this.errorEmitter = new events_1.Emitter();\r
3838         this.closeEmitter = new events_1.Emitter();\r
3839     }\r
3840     dispose() {\r
3841         this.errorEmitter.dispose();\r
3842         this.closeEmitter.dispose();\r
3843     }\r
3844     get onError() {\r
3845         return this.errorEmitter.event;\r
3846     }\r
3847     fireError(error, message, count) {\r
3848         this.errorEmitter.fire([this.asError(error), message, count]);\r
3849     }\r
3850     get onClose() {\r
3851         return this.closeEmitter.event;\r
3852     }\r
3853     fireClose() {\r
3854         this.closeEmitter.fire(undefined);\r
3855     }\r
3856     asError(error) {\r
3857         if (error instanceof Error) {\r
3858             return error;\r
3859         }\r
3860         else {\r
3861             return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);\r
3862         }\r
3863     }\r
3864 }\r
3865 exports.AbstractMessageWriter = AbstractMessageWriter;\r
3866 class StreamMessageWriter extends AbstractMessageWriter {\r
3867     constructor(writable, encoding = 'utf8') {\r
3868         super();\r
3869         this.writable = writable;\r
3870         this.encoding = encoding;\r
3871         this.errorCount = 0;\r
3872         this.writable.on('error', (error) => this.fireError(error));\r
3873         this.writable.on('close', () => this.fireClose());\r
3874     }\r
3875     write(msg) {\r
3876         let json = JSON.stringify(msg);\r
3877         let contentLength = Buffer.byteLength(json, this.encoding);\r
3878         let headers = [\r
3879             ContentLength, contentLength.toString(), CRLF,\r
3880             CRLF\r
3881         ];\r
3882         try {\r
3883             // Header must be written in ASCII encoding\r
3884             this.writable.write(headers.join(''), 'ascii');\r
3885             // Now write the content. This can be written in any encoding\r
3886             this.writable.write(json, this.encoding);\r
3887             this.errorCount = 0;\r
3888         }\r
3889         catch (error) {\r
3890             this.errorCount++;\r
3891             this.fireError(error, msg, this.errorCount);\r
3892         }\r
3893     }\r
3894 }\r
3895 exports.StreamMessageWriter = StreamMessageWriter;\r
3896 class IPCMessageWriter extends AbstractMessageWriter {\r
3897     constructor(process) {\r
3898         super();\r
3899         this.process = process;\r
3900         this.errorCount = 0;\r
3901         this.queue = [];\r
3902         this.sending = false;\r
3903         let eventEmitter = this.process;\r
3904         eventEmitter.on('error', (error) => this.fireError(error));\r
3905         eventEmitter.on('close', () => this.fireClose);\r
3906     }\r
3907     write(msg) {\r
3908         if (!this.sending && this.queue.length === 0) {\r
3909             // See https://github.com/nodejs/node/issues/7657\r
3910             this.doWriteMessage(msg);\r
3911         }\r
3912         else {\r
3913             this.queue.push(msg);\r
3914         }\r
3915     }\r
3916     doWriteMessage(msg) {\r
3917         try {\r
3918             if (this.process.send) {\r
3919                 this.sending = true;\r
3920                 this.process.send(msg, undefined, undefined, (error) => {\r
3921                     this.sending = false;\r
3922                     if (error) {\r
3923                         this.errorCount++;\r
3924                         this.fireError(error, msg, this.errorCount);\r
3925                     }\r
3926                     else {\r
3927                         this.errorCount = 0;\r
3928                     }\r
3929                     if (this.queue.length > 0) {\r
3930                         this.doWriteMessage(this.queue.shift());\r
3931                     }\r
3932                 });\r
3933             }\r
3934         }\r
3935         catch (error) {\r
3936             this.errorCount++;\r
3937             this.fireError(error, msg, this.errorCount);\r
3938         }\r
3939     }\r
3940 }\r
3941 exports.IPCMessageWriter = IPCMessageWriter;\r
3942 class SocketMessageWriter extends AbstractMessageWriter {\r
3943     constructor(socket, encoding = 'utf8') {\r
3944         super();\r
3945         this.socket = socket;\r
3946         this.queue = [];\r
3947         this.sending = false;\r
3948         this.encoding = encoding;\r
3949         this.errorCount = 0;\r
3950         this.socket.on('error', (error) => this.fireError(error));\r
3951         this.socket.on('close', () => this.fireClose());\r
3952     }\r
3953     dispose() {\r
3954         super.dispose();\r
3955         this.socket.destroy();\r
3956     }\r
3957     write(msg) {\r
3958         if (!this.sending && this.queue.length === 0) {\r
3959             // See https://github.com/nodejs/node/issues/7657\r
3960             this.doWriteMessage(msg);\r
3961         }\r
3962         else {\r
3963             this.queue.push(msg);\r
3964         }\r
3965     }\r
3966     doWriteMessage(msg) {\r
3967         let json = JSON.stringify(msg);\r
3968         let contentLength = Buffer.byteLength(json, this.encoding);\r
3969         let headers = [\r
3970             ContentLength, contentLength.toString(), CRLF,\r
3971             CRLF\r
3972         ];\r
3973         try {\r
3974             // Header must be written in ASCII encoding\r
3975             this.sending = true;\r
3976             this.socket.write(headers.join(''), 'ascii', (error) => {\r
3977                 if (error) {\r
3978                     this.handleError(error, msg);\r
3979                 }\r
3980                 try {\r
3981                     // Now write the content. This can be written in any encoding\r
3982                     this.socket.write(json, this.encoding, (error) => {\r
3983                         this.sending = false;\r
3984                         if (error) {\r
3985                             this.handleError(error, msg);\r
3986                         }\r
3987                         else {\r
3988                             this.errorCount = 0;\r
3989                         }\r
3990                         if (this.queue.length > 0) {\r
3991                             this.doWriteMessage(this.queue.shift());\r
3992                         }\r
3993                     });\r
3994                 }\r
3995                 catch (error) {\r
3996                     this.handleError(error, msg);\r
3997                 }\r
3998             });\r
3999         }\r
4000         catch (error) {\r
4001             this.handleError(error, msg);\r
4002         }\r
4003     }\r
4004     handleError(error, msg) {\r
4005         this.errorCount++;\r
4006         this.fireError(error, msg, this.errorCount);\r
4007     }\r
4008 }\r
4009 exports.SocketMessageWriter = SocketMessageWriter;\r
4010
4011
4012 /***/ }),
4013 /* 15 */
4014 /***/ (function(module, exports, __webpack_require__) {
4015
4016 "use strict";
4017 /*---------------------------------------------------------------------------------------------\r
4018  *  Copyright (c) Microsoft Corporation. All rights reserved.\r
4019  *  Licensed under the MIT License. See License.txt in the project root for license information.\r
4020  *--------------------------------------------------------------------------------------------*/\r
4021 \r
4022 Object.defineProperty(exports, "__esModule", { value: true });\r
4023 const events_1 = __webpack_require__(13);\r
4024 const Is = __webpack_require__(10);\r
4025 var CancellationToken;\r
4026 (function (CancellationToken) {\r
4027     CancellationToken.None = Object.freeze({\r
4028         isCancellationRequested: false,\r
4029         onCancellationRequested: events_1.Event.None\r
4030     });\r
4031     CancellationToken.Cancelled = Object.freeze({\r
4032         isCancellationRequested: true,\r
4033         onCancellationRequested: events_1.Event.None\r
4034     });\r
4035     function is(value) {\r
4036         let candidate = value;\r
4037         return candidate && (candidate === CancellationToken.None\r
4038             || candidate === CancellationToken.Cancelled\r
4039             || (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested));\r
4040     }\r
4041     CancellationToken.is = is;\r
4042 })(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {}));\r
4043 const shortcutEvent = Object.freeze(function (callback, context) {\r
4044     let handle = setTimeout(callback.bind(context), 0);\r
4045     return { dispose() { clearTimeout(handle); } };\r
4046 });\r
4047 class MutableToken {\r
4048     constructor() {\r
4049         this._isCancelled = false;\r
4050     }\r
4051     cancel() {\r
4052         if (!this._isCancelled) {\r
4053             this._isCancelled = true;\r
4054             if (this._emitter) {\r
4055                 this._emitter.fire(undefined);\r
4056                 this.dispose();\r
4057             }\r
4058         }\r
4059     }\r
4060     get isCancellationRequested() {\r
4061         return this._isCancelled;\r
4062     }\r
4063     get onCancellationRequested() {\r
4064         if (this._isCancelled) {\r
4065             return shortcutEvent;\r
4066         }\r
4067         if (!this._emitter) {\r
4068             this._emitter = new events_1.Emitter();\r
4069         }\r
4070         return this._emitter.event;\r
4071     }\r
4072     dispose() {\r
4073         if (this._emitter) {\r
4074             this._emitter.dispose();\r
4075             this._emitter = undefined;\r
4076         }\r
4077     }\r
4078 }\r
4079 class CancellationTokenSource {\r
4080     get token() {\r
4081         if (!this._token) {\r
4082             // be lazy and create the token only when\r
4083             // actually needed\r
4084             this._token = new MutableToken();\r
4085         }\r
4086         return this._token;\r
4087     }\r
4088     cancel() {\r
4089         if (!this._token) {\r
4090             // save an object by returning the default\r
4091             // cancelled token when cancellation happens\r
4092             // before someone asks for the token\r
4093             this._token = CancellationToken.Cancelled;\r
4094         }\r
4095         else {\r
4096             this._token.cancel();\r
4097         }\r
4098     }\r
4099     dispose() {\r
4100         if (!this._token) {\r
4101             // ensure to initialize with an empty token if we had none\r
4102             this._token = CancellationToken.None;\r
4103         }\r
4104         else if (this._token instanceof MutableToken) {\r
4105             // actually dispose\r
4106             this._token.dispose();\r
4107         }\r
4108     }\r
4109 }\r
4110 exports.CancellationTokenSource = CancellationTokenSource;\r
4111
4112
4113 /***/ }),
4114 /* 16 */
4115 /***/ (function(module, exports, __webpack_require__) {
4116
4117 "use strict";
4118 \r
4119 /*---------------------------------------------------------------------------------------------\r
4120  *  Copyright (c) Microsoft Corporation. All rights reserved.\r
4121  *  Licensed under the MIT License. See License.txt in the project root for license information.\r
4122  *--------------------------------------------------------------------------------------------*/\r
4123 Object.defineProperty(exports, "__esModule", { value: true });\r
4124 var Touch;\r
4125 (function (Touch) {\r
4126     Touch.None = 0;\r
4127     Touch.First = 1;\r
4128     Touch.Last = 2;\r
4129 })(Touch = exports.Touch || (exports.Touch = {}));\r
4130 class LinkedMap {\r
4131     constructor() {\r
4132         this._map = new Map();\r
4133         this._head = undefined;\r
4134         this._tail = undefined;\r
4135         this._size = 0;\r
4136     }\r
4137     clear() {\r
4138         this._map.clear();\r
4139         this._head = undefined;\r
4140         this._tail = undefined;\r
4141         this._size = 0;\r
4142     }\r
4143     isEmpty() {\r
4144         return !this._head && !this._tail;\r
4145     }\r
4146     get size() {\r
4147         return this._size;\r
4148     }\r
4149     has(key) {\r
4150         return this._map.has(key);\r
4151     }\r
4152     get(key) {\r
4153         const item = this._map.get(key);\r
4154         if (!item) {\r
4155             return undefined;\r
4156         }\r
4157         return item.value;\r
4158     }\r
4159     set(key, value, touch = Touch.None) {\r
4160         let item = this._map.get(key);\r
4161         if (item) {\r
4162             item.value = value;\r
4163             if (touch !== Touch.None) {\r
4164                 this.touch(item, touch);\r
4165             }\r
4166         }\r
4167         else {\r
4168             item = { key, value, next: undefined, previous: undefined };\r
4169             switch (touch) {\r
4170                 case Touch.None:\r
4171                     this.addItemLast(item);\r
4172                     break;\r
4173                 case Touch.First:\r
4174                     this.addItemFirst(item);\r
4175                     break;\r
4176                 case Touch.Last:\r
4177                     this.addItemLast(item);\r
4178                     break;\r
4179                 default:\r
4180                     this.addItemLast(item);\r
4181                     break;\r
4182             }\r
4183             this._map.set(key, item);\r
4184             this._size++;\r
4185         }\r
4186     }\r
4187     delete(key) {\r
4188         const item = this._map.get(key);\r
4189         if (!item) {\r
4190             return false;\r
4191         }\r
4192         this._map.delete(key);\r
4193         this.removeItem(item);\r
4194         this._size--;\r
4195         return true;\r
4196     }\r
4197     shift() {\r
4198         if (!this._head && !this._tail) {\r
4199             return undefined;\r
4200         }\r
4201         if (!this._head || !this._tail) {\r
4202             throw new Error('Invalid list');\r
4203         }\r
4204         const item = this._head;\r
4205         this._map.delete(item.key);\r
4206         this.removeItem(item);\r
4207         this._size--;\r
4208         return item.value;\r
4209     }\r
4210     forEach(callbackfn, thisArg) {\r
4211         let current = this._head;\r
4212         while (current) {\r
4213             if (thisArg) {\r
4214                 callbackfn.bind(thisArg)(current.value, current.key, this);\r
4215             }\r
4216             else {\r
4217                 callbackfn(current.value, current.key, this);\r
4218             }\r
4219             current = current.next;\r
4220         }\r
4221     }\r
4222     forEachReverse(callbackfn, thisArg) {\r
4223         let current = this._tail;\r
4224         while (current) {\r
4225             if (thisArg) {\r
4226                 callbackfn.bind(thisArg)(current.value, current.key, this);\r
4227             }\r
4228             else {\r
4229                 callbackfn(current.value, current.key, this);\r
4230             }\r
4231             current = current.previous;\r
4232         }\r
4233     }\r
4234     values() {\r
4235         let result = [];\r
4236         let current = this._head;\r
4237         while (current) {\r
4238             result.push(current.value);\r
4239             current = current.next;\r
4240         }\r
4241         return result;\r
4242     }\r
4243     keys() {\r
4244         let result = [];\r
4245         let current = this._head;\r
4246         while (current) {\r
4247             result.push(current.key);\r
4248             current = current.next;\r
4249         }\r
4250         return result;\r
4251     }\r
4252     /* JSON RPC run on es5 which has no Symbol.iterator\r
4253     public keys(): IterableIterator<K> {\r
4254         let current = this._head;\r
4255         let iterator: IterableIterator<K> = {\r
4256             [Symbol.iterator]() {\r
4257                 return iterator;\r
4258             },\r
4259             next():IteratorResult<K> {\r
4260                 if (current) {\r
4261                     let result = { value: current.key, done: false };\r
4262                     current = current.next;\r
4263                     return result;\r
4264                 } else {\r
4265                     return { value: undefined, done: true };\r
4266                 }\r
4267             }\r
4268         };\r
4269         return iterator;\r
4270     }\r
4271 \r
4272     public values(): IterableIterator<V> {\r
4273         let current = this._head;\r
4274         let iterator: IterableIterator<V> = {\r
4275             [Symbol.iterator]() {\r
4276                 return iterator;\r
4277             },\r
4278             next():IteratorResult<V> {\r
4279                 if (current) {\r
4280                     let result = { value: current.value, done: false };\r
4281                     current = current.next;\r
4282                     return result;\r
4283                 } else {\r
4284                     return { value: undefined, done: true };\r
4285                 }\r
4286             }\r
4287         };\r
4288         return iterator;\r
4289     }\r
4290     */\r
4291     addItemFirst(item) {\r
4292         // First time Insert\r
4293         if (!this._head && !this._tail) {\r
4294             this._tail = item;\r
4295         }\r
4296         else if (!this._head) {\r
4297             throw new Error('Invalid list');\r
4298         }\r
4299         else {\r
4300             item.next = this._head;\r
4301             this._head.previous = item;\r
4302         }\r
4303         this._head = item;\r
4304     }\r
4305     addItemLast(item) {\r
4306         // First time Insert\r
4307         if (!this._head && !this._tail) {\r
4308             this._head = item;\r
4309         }\r
4310         else if (!this._tail) {\r
4311             throw new Error('Invalid list');\r
4312         }\r
4313         else {\r
4314             item.previous = this._tail;\r
4315             this._tail.next = item;\r
4316         }\r
4317         this._tail = item;\r
4318     }\r
4319     removeItem(item) {\r
4320         if (item === this._head && item === this._tail) {\r
4321             this._head = undefined;\r
4322             this._tail = undefined;\r
4323         }\r
4324         else if (item === this._head) {\r
4325             this._head = item.next;\r
4326         }\r
4327         else if (item === this._tail) {\r
4328             this._tail = item.previous;\r
4329         }\r
4330         else {\r
4331             const next = item.next;\r
4332             const previous = item.previous;\r
4333             if (!next || !previous) {\r
4334                 throw new Error('Invalid list');\r
4335             }\r
4336             next.previous = previous;\r
4337             previous.next = next;\r
4338         }\r
4339     }\r
4340     touch(item, touch) {\r
4341         if (!this._head || !this._tail) {\r
4342             throw new Error('Invalid list');\r
4343         }\r
4344         if ((touch !== Touch.First && touch !== Touch.Last)) {\r
4345             return;\r
4346         }\r
4347         if (touch === Touch.First) {\r
4348             if (item === this._head) {\r
4349                 return;\r
4350             }\r
4351             const next = item.next;\r
4352             const previous = item.previous;\r
4353             // Unlink the item\r
4354             if (item === this._tail) {\r
4355                 // previous must be defined since item was not head but is tail\r
4356                 // So there are more than on item in the map\r
4357                 previous.next = undefined;\r
4358                 this._tail = previous;\r
4359             }\r
4360             else {\r
4361                 // Both next and previous are not undefined since item was neither head nor tail.\r
4362                 next.previous = previous;\r
4363                 previous.next = next;\r
4364             }\r
4365             // Insert the node at head\r
4366             item.previous = undefined;\r
4367             item.next = this._head;\r
4368             this._head.previous = item;\r
4369             this._head = item;\r
4370         }\r
4371         else if (touch === Touch.Last) {\r
4372             if (item === this._tail) {\r
4373                 return;\r
4374             }\r
4375             const next = item.next;\r
4376             const previous = item.previous;\r
4377             // Unlink the item.\r
4378             if (item === this._head) {\r
4379                 // next must be defined since item was not tail but is head\r
4380                 // So there are more than on item in the map\r
4381                 next.previous = undefined;\r
4382                 this._head = next;\r
4383             }\r
4384             else {\r
4385                 // Both next and previous are not undefined since item was neither head nor tail.\r
4386                 next.previous = previous;\r
4387                 previous.next = next;\r
4388             }\r
4389             item.next = undefined;\r
4390             item.previous = this._tail;\r
4391             this._tail.next = item;\r
4392             this._tail = item;\r
4393         }\r
4394     }\r
4395 }\r
4396 exports.LinkedMap = LinkedMap;\r
4397
4398
4399 /***/ }),
4400 /* 17 */
4401 /***/ (function(module, exports, __webpack_require__) {
4402
4403 "use strict";
4404 /* --------------------------------------------------------------------------------------------\r
4405  * Copyright (c) Microsoft Corporation. All rights reserved.\r
4406  * Licensed under the MIT License. See License.txt in the project root for license information.\r
4407  * ------------------------------------------------------------------------------------------ */\r
4408 \r
4409 Object.defineProperty(exports, "__esModule", { value: true });\r
4410 const path_1 = __webpack_require__(4);\r
4411 const os_1 = __webpack_require__(2);\r
4412 const crypto_1 = __webpack_require__(18);\r
4413 const net_1 = __webpack_require__(19);\r
4414 const messageReader_1 = __webpack_require__(12);\r
4415 const messageWriter_1 = __webpack_require__(14);\r
4416 function generateRandomPipeName() {\r
4417     const randomSuffix = crypto_1.randomBytes(21).toString('hex');\r
4418     if (process.platform === 'win32') {\r
4419         return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;\r
4420     }\r
4421     else {\r
4422         // Mac/Unix: use socket file\r
4423         return path_1.join(os_1.tmpdir(), `vscode-${randomSuffix}.sock`);\r
4424     }\r
4425 }\r
4426 exports.generateRandomPipeName = generateRandomPipeName;\r
4427 function createClientPipeTransport(pipeName, encoding = 'utf-8') {\r
4428     let connectResolve;\r
4429     let connected = new Promise((resolve, _reject) => {\r
4430         connectResolve = resolve;\r
4431     });\r
4432     return new Promise((resolve, reject) => {\r
4433         let server = net_1.createServer((socket) => {\r
4434             server.close();\r
4435             connectResolve([\r
4436                 new messageReader_1.SocketMessageReader(socket, encoding),\r
4437                 new messageWriter_1.SocketMessageWriter(socket, encoding)\r
4438             ]);\r
4439         });\r
4440         server.on('error', reject);\r
4441         server.listen(pipeName, () => {\r
4442             server.removeListener('error', reject);\r
4443             resolve({\r
4444                 onConnected: () => { return connected; }\r
4445             });\r
4446         });\r
4447     });\r
4448 }\r
4449 exports.createClientPipeTransport = createClientPipeTransport;\r
4450 function createServerPipeTransport(pipeName, encoding = 'utf-8') {\r
4451     const socket = net_1.createConnection(pipeName);\r
4452     return [\r
4453         new messageReader_1.SocketMessageReader(socket, encoding),\r
4454         new messageWriter_1.SocketMessageWriter(socket, encoding)\r
4455     ];\r
4456 }\r
4457 exports.createServerPipeTransport = createServerPipeTransport;\r
4458
4459
4460 /***/ }),
4461 /* 18 */
4462 /***/ (function(module, exports) {
4463
4464 module.exports = require("crypto");
4465
4466 /***/ }),
4467 /* 19 */
4468 /***/ (function(module, exports) {
4469
4470 module.exports = require("net");
4471
4472 /***/ }),
4473 /* 20 */
4474 /***/ (function(module, exports, __webpack_require__) {
4475
4476 "use strict";
4477 /* --------------------------------------------------------------------------------------------\r
4478  * Copyright (c) Microsoft Corporation. All rights reserved.\r
4479  * Licensed under the MIT License. See License.txt in the project root for license information.\r
4480  * ------------------------------------------------------------------------------------------ */\r
4481 \r
4482 Object.defineProperty(exports, "__esModule", { value: true });\r
4483 const net_1 = __webpack_require__(19);\r
4484 const messageReader_1 = __webpack_require__(12);\r
4485 const messageWriter_1 = __webpack_require__(14);\r
4486 function createClientSocketTransport(port, encoding = 'utf-8') {\r
4487     let connectResolve;\r
4488     let connected = new Promise((resolve, _reject) => {\r
4489         connectResolve = resolve;\r
4490     });\r
4491     return new Promise((resolve, reject) => {\r
4492         let server = net_1.createServer((socket) => {\r
4493             server.close();\r
4494             connectResolve([\r
4495                 new messageReader_1.SocketMessageReader(socket, encoding),\r
4496                 new messageWriter_1.SocketMessageWriter(socket, encoding)\r
4497             ]);\r
4498         });\r
4499         server.on('error', reject);\r
4500         server.listen(port, '127.0.0.1', () => {\r
4501             server.removeListener('error', reject);\r
4502             resolve({\r
4503                 onConnected: () => { return connected; }\r
4504             });\r
4505         });\r
4506     });\r
4507 }\r
4508 exports.createClientSocketTransport = createClientSocketTransport;\r
4509 function createServerSocketTransport(port, encoding = 'utf-8') {\r
4510     const socket = net_1.createConnection(port, '127.0.0.1');\r
4511     return [\r
4512         new messageReader_1.SocketMessageReader(socket, encoding),\r
4513         new messageWriter_1.SocketMessageWriter(socket, encoding)\r
4514     ];\r
4515 }\r
4516 exports.createServerSocketTransport = createServerSocketTransport;\r
4517
4518
4519 /***/ }),
4520 /* 21 */
4521 /***/ (function(module, exports, __webpack_require__) {
4522
4523 "use strict";
4524 /* --------------------------------------------------------------------------------------------\r
4525  * Copyright (c) Microsoft Corporation. All rights reserved.\r
4526  * Licensed under the MIT License. See License.txt in the project root for license information.\r
4527  * ------------------------------------------------------------------------------------------ */\r
4528 \r
4529 Object.defineProperty(exports, "__esModule", { value: true });\r
4530 const Is = __webpack_require__(22);\r
4531 const vscode_jsonrpc_1 = __webpack_require__(9);\r
4532 const messages_1 = __webpack_require__(23);\r
4533 const protocol_implementation_1 = __webpack_require__(24);\r
4534 exports.ImplementationRequest = protocol_implementation_1.ImplementationRequest;\r
4535 const protocol_typeDefinition_1 = __webpack_require__(25);\r
4536 exports.TypeDefinitionRequest = protocol_typeDefinition_1.TypeDefinitionRequest;\r
4537 const protocol_workspaceFolders_1 = __webpack_require__(26);\r
4538 exports.WorkspaceFoldersRequest = protocol_workspaceFolders_1.WorkspaceFoldersRequest;\r
4539 exports.DidChangeWorkspaceFoldersNotification = protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;\r
4540 const protocol_configuration_1 = __webpack_require__(27);\r
4541 exports.ConfigurationRequest = protocol_configuration_1.ConfigurationRequest;\r
4542 const protocol_colorProvider_1 = __webpack_require__(28);\r
4543 exports.DocumentColorRequest = protocol_colorProvider_1.DocumentColorRequest;\r
4544 exports.ColorPresentationRequest = protocol_colorProvider_1.ColorPresentationRequest;\r
4545 const protocol_foldingRange_1 = __webpack_require__(29);\r
4546 exports.FoldingRangeRequest = protocol_foldingRange_1.FoldingRangeRequest;\r
4547 const protocol_declaration_1 = __webpack_require__(30);\r
4548 exports.DeclarationRequest = protocol_declaration_1.DeclarationRequest;\r
4549 const protocol_selectionRange_1 = __webpack_require__(31);\r
4550 exports.SelectionRangeRequest = protocol_selectionRange_1.SelectionRangeRequest;\r
4551 const protocol_progress_1 = __webpack_require__(32);\r
4552 exports.WorkDoneProgress = protocol_progress_1.WorkDoneProgress;\r
4553 exports.WorkDoneProgressCreateRequest = protocol_progress_1.WorkDoneProgressCreateRequest;\r
4554 exports.WorkDoneProgressCancelNotification = protocol_progress_1.WorkDoneProgressCancelNotification;\r
4555 // @ts-ignore: to avoid inlining LocatioLink as dynamic import\r
4556 let __noDynamicImport;\r
4557 /**\r
4558  * The DocumentFilter namespace provides helper functions to work with\r
4559  * [DocumentFilter](#DocumentFilter) literals.\r
4560  */\r
4561 var DocumentFilter;\r
4562 (function (DocumentFilter) {\r
4563     function is(value) {\r
4564         const candidate = value;\r
4565         return Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern);\r
4566     }\r
4567     DocumentFilter.is = is;\r
4568 })(DocumentFilter = exports.DocumentFilter || (exports.DocumentFilter = {}));\r
4569 /**\r
4570  * The DocumentSelector namespace provides helper functions to work with\r
4571  * [DocumentSelector](#DocumentSelector)s.\r
4572  */\r
4573 var DocumentSelector;\r
4574 (function (DocumentSelector) {\r
4575     function is(value) {\r
4576         if (!Array.isArray(value)) {\r
4577             return false;\r
4578         }\r
4579         for (let elem of value) {\r
4580             if (!Is.string(elem) && !DocumentFilter.is(elem)) {\r
4581                 return false;\r
4582             }\r
4583         }\r
4584         return true;\r
4585     }\r
4586     DocumentSelector.is = is;\r
4587 })(DocumentSelector = exports.DocumentSelector || (exports.DocumentSelector = {}));\r
4588 /**\r
4589  * The `client/registerCapability` request is sent from the server to the client to register a new capability\r
4590  * handler on the client side.\r
4591  */\r
4592 var RegistrationRequest;\r
4593 (function (RegistrationRequest) {\r
4594     RegistrationRequest.type = new messages_1.ProtocolRequestType('client/registerCapability');\r
4595 })(RegistrationRequest = exports.RegistrationRequest || (exports.RegistrationRequest = {}));\r
4596 /**\r
4597  * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability\r
4598  * handler on the client side.\r
4599  */\r
4600 var UnregistrationRequest;\r
4601 (function (UnregistrationRequest) {\r
4602     UnregistrationRequest.type = new messages_1.ProtocolRequestType('client/unregisterCapability');\r
4603 })(UnregistrationRequest = exports.UnregistrationRequest || (exports.UnregistrationRequest = {}));\r
4604 var ResourceOperationKind;\r
4605 (function (ResourceOperationKind) {\r
4606     /**\r
4607      * Supports creating new files and folders.\r
4608      */\r
4609     ResourceOperationKind.Create = 'create';\r
4610     /**\r
4611      * Supports renaming existing files and folders.\r
4612      */\r
4613     ResourceOperationKind.Rename = 'rename';\r
4614     /**\r
4615      * Supports deleting existing files and folders.\r
4616      */\r
4617     ResourceOperationKind.Delete = 'delete';\r
4618 })(ResourceOperationKind = exports.ResourceOperationKind || (exports.ResourceOperationKind = {}));\r
4619 var FailureHandlingKind;\r
4620 (function (FailureHandlingKind) {\r
4621     /**\r
4622      * Applying the workspace change is simply aborted if one of the changes provided\r
4623      * fails. All operations executed before the failing operation stay executed.\r
4624      */\r
4625     FailureHandlingKind.Abort = 'abort';\r
4626     /**\r
4627      * All operations are executed transactional. That means they either all\r
4628      * succeed or no changes at all are applied to the workspace.\r
4629      */\r
4630     FailureHandlingKind.Transactional = 'transactional';\r
4631     /**\r
4632      * If the workspace edit contains only textual file changes they are executed transactional.\r
4633      * If resource changes (create, rename or delete file) are part of the change the failure\r
4634      * handling startegy is abort.\r
4635      */\r
4636     FailureHandlingKind.TextOnlyTransactional = 'textOnlyTransactional';\r
4637     /**\r
4638      * The client tries to undo the operations already executed. But there is no\r
4639      * guarantee that this is succeeding.\r
4640      */\r
4641     FailureHandlingKind.Undo = 'undo';\r
4642 })(FailureHandlingKind = exports.FailureHandlingKind || (exports.FailureHandlingKind = {}));\r
4643 /**\r
4644  * The StaticRegistrationOptions namespace provides helper functions to work with\r
4645  * [StaticRegistrationOptions](#StaticRegistrationOptions) literals.\r
4646  */\r
4647 var StaticRegistrationOptions;\r
4648 (function (StaticRegistrationOptions) {\r
4649     function hasId(value) {\r
4650         const candidate = value;\r
4651         return candidate && Is.string(candidate.id) && candidate.id.length > 0;\r
4652     }\r
4653     StaticRegistrationOptions.hasId = hasId;\r
4654 })(StaticRegistrationOptions = exports.StaticRegistrationOptions || (exports.StaticRegistrationOptions = {}));\r
4655 /**\r
4656  * The TextDocumentRegistrationOptions namespace provides helper functions to work with\r
4657  * [TextDocumentRegistrationOptions](#TextDocumentRegistrationOptions) literals.\r
4658  */\r
4659 var TextDocumentRegistrationOptions;\r
4660 (function (TextDocumentRegistrationOptions) {\r
4661     function is(value) {\r
4662         const candidate = value;\r
4663         return candidate && (candidate.documentSelector === null || DocumentSelector.is(candidate.documentSelector));\r
4664     }\r
4665     TextDocumentRegistrationOptions.is = is;\r
4666 })(TextDocumentRegistrationOptions = exports.TextDocumentRegistrationOptions || (exports.TextDocumentRegistrationOptions = {}));\r
4667 /**\r
4668  * The WorkDoneProgressOptions namespace provides helper functions to work with\r
4669  * [WorkDoneProgressOptions](#WorkDoneProgressOptions) literals.\r
4670  */\r
4671 var WorkDoneProgressOptions;\r
4672 (function (WorkDoneProgressOptions) {\r
4673     function is(value) {\r
4674         const candidate = value;\r
4675         return Is.objectLiteral(candidate) && (candidate.workDoneProgress === undefined || Is.boolean(candidate.workDoneProgress));\r
4676     }\r
4677     WorkDoneProgressOptions.is = is;\r
4678     function hasWorkDoneProgress(value) {\r
4679         const candidate = value;\r
4680         return candidate && Is.boolean(candidate.workDoneProgress);\r
4681     }\r
4682     WorkDoneProgressOptions.hasWorkDoneProgress = hasWorkDoneProgress;\r
4683 })(WorkDoneProgressOptions = exports.WorkDoneProgressOptions || (exports.WorkDoneProgressOptions = {}));\r
4684 /**\r
4685  * The initialize request is sent from the client to the server.\r
4686  * It is sent once as the request after starting up the server.\r
4687  * The requests parameter is of type [InitializeParams](#InitializeParams)\r
4688  * the response if of type [InitializeResult](#InitializeResult) of a Thenable that\r
4689  * resolves to such.\r
4690  */\r
4691 var InitializeRequest;\r
4692 (function (InitializeRequest) {\r
4693     InitializeRequest.type = new messages_1.ProtocolRequestType('initialize');\r
4694 })(InitializeRequest = exports.InitializeRequest || (exports.InitializeRequest = {}));\r
4695 /**\r
4696  * Known error codes for an `InitializeError`;\r
4697  */\r
4698 var InitializeError;\r
4699 (function (InitializeError) {\r
4700     /**\r
4701      * If the protocol version provided by the client can't be handled by the server.\r
4702      * @deprecated This initialize error got replaced by client capabilities. There is\r
4703      * no version handshake in version 3.0x\r
4704      */\r
4705     InitializeError.unknownProtocolVersion = 1;\r
4706 })(InitializeError = exports.InitializeError || (exports.InitializeError = {}));\r
4707 /**\r
4708  * The intialized notification is sent from the client to the\r
4709  * server after the client is fully initialized and the server\r
4710  * is allowed to send requests from the server to the client.\r
4711  */\r
4712 var InitializedNotification;\r
4713 (function (InitializedNotification) {\r
4714     InitializedNotification.type = new messages_1.ProtocolNotificationType('initialized');\r
4715 })(InitializedNotification = exports.InitializedNotification || (exports.InitializedNotification = {}));\r
4716 //---- Shutdown Method ----\r
4717 /**\r
4718  * A shutdown request is sent from the client to the server.\r
4719  * It is sent once when the client decides to shutdown the\r
4720  * server. The only notification that is sent after a shutdown request\r
4721  * is the exit event.\r
4722  */\r
4723 var ShutdownRequest;\r
4724 (function (ShutdownRequest) {\r
4725     ShutdownRequest.type = new messages_1.ProtocolRequestType0('shutdown');\r
4726 })(ShutdownRequest = exports.ShutdownRequest || (exports.ShutdownRequest = {}));\r
4727 //---- Exit Notification ----\r
4728 /**\r
4729  * The exit event is sent from the client to the server to\r
4730  * ask the server to exit its process.\r
4731  */\r
4732 var ExitNotification;\r
4733 (function (ExitNotification) {\r
4734     ExitNotification.type = new messages_1.ProtocolNotificationType0('exit');\r
4735 })(ExitNotification = exports.ExitNotification || (exports.ExitNotification = {}));\r
4736 /**\r
4737  * The configuration change notification is sent from the client to the server\r
4738  * when the client's configuration has changed. The notification contains\r
4739  * the changed configuration as defined by the language client.\r
4740  */\r
4741 var DidChangeConfigurationNotification;\r
4742 (function (DidChangeConfigurationNotification) {\r
4743     DidChangeConfigurationNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeConfiguration');\r
4744 })(DidChangeConfigurationNotification = exports.DidChangeConfigurationNotification || (exports.DidChangeConfigurationNotification = {}));\r
4745 //---- Message show and log notifications ----\r
4746 /**\r
4747  * The message type\r
4748  */\r
4749 var MessageType;\r
4750 (function (MessageType) {\r
4751     /**\r
4752      * An error message.\r
4753      */\r
4754     MessageType.Error = 1;\r
4755     /**\r
4756      * A warning message.\r
4757      */\r
4758     MessageType.Warning = 2;\r
4759     /**\r
4760      * An information message.\r
4761      */\r
4762     MessageType.Info = 3;\r
4763     /**\r
4764      * A log message.\r
4765      */\r
4766     MessageType.Log = 4;\r
4767 })(MessageType = exports.MessageType || (exports.MessageType = {}));\r
4768 /**\r
4769  * The show message notification is sent from a server to a client to ask\r
4770  * the client to display a particular message in the user interface.\r
4771  */\r
4772 var ShowMessageNotification;\r
4773 (function (ShowMessageNotification) {\r
4774     ShowMessageNotification.type = new messages_1.ProtocolNotificationType('window/showMessage');\r
4775 })(ShowMessageNotification = exports.ShowMessageNotification || (exports.ShowMessageNotification = {}));\r
4776 /**\r
4777  * The show message request is sent from the server to the client to show a message\r
4778  * and a set of options actions to the user.\r
4779  */\r
4780 var ShowMessageRequest;\r
4781 (function (ShowMessageRequest) {\r
4782     ShowMessageRequest.type = new messages_1.ProtocolRequestType('window/showMessageRequest');\r
4783 })(ShowMessageRequest = exports.ShowMessageRequest || (exports.ShowMessageRequest = {}));\r
4784 /**\r
4785  * The log message notification is sent from the server to the client to ask\r
4786  * the client to log a particular message.\r
4787  */\r
4788 var LogMessageNotification;\r
4789 (function (LogMessageNotification) {\r
4790     LogMessageNotification.type = new messages_1.ProtocolNotificationType('window/logMessage');\r
4791 })(LogMessageNotification = exports.LogMessageNotification || (exports.LogMessageNotification = {}));\r
4792 //---- Telemetry notification\r
4793 /**\r
4794  * The telemetry event notification is sent from the server to the client to ask\r
4795  * the client to log telemetry data.\r
4796  */\r
4797 var TelemetryEventNotification;\r
4798 (function (TelemetryEventNotification) {\r
4799     TelemetryEventNotification.type = new messages_1.ProtocolNotificationType('telemetry/event');\r
4800 })(TelemetryEventNotification = exports.TelemetryEventNotification || (exports.TelemetryEventNotification = {}));\r
4801 /**\r
4802  * Defines how the host (editor) should sync\r
4803  * document changes to the language server.\r
4804  */\r
4805 var TextDocumentSyncKind;\r
4806 (function (TextDocumentSyncKind) {\r
4807     /**\r
4808      * Documents should not be synced at all.\r
4809      */\r
4810     TextDocumentSyncKind.None = 0;\r
4811     /**\r
4812      * Documents are synced by always sending the full content\r
4813      * of the document.\r
4814      */\r
4815     TextDocumentSyncKind.Full = 1;\r
4816     /**\r
4817      * Documents are synced by sending the full content on open.\r
4818      * After that only incremental updates to the document are\r
4819      * send.\r
4820      */\r
4821     TextDocumentSyncKind.Incremental = 2;\r
4822 })(TextDocumentSyncKind = exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {}));\r
4823 /**\r
4824  * The document open notification is sent from the client to the server to signal\r
4825  * newly opened text documents. The document's truth is now managed by the client\r
4826  * and the server must not try to read the document's truth using the document's\r
4827  * uri. Open in this sense means it is managed by the client. It doesn't necessarily\r
4828  * mean that its content is presented in an editor. An open notification must not\r
4829  * be sent more than once without a corresponding close notification send before.\r
4830  * This means open and close notification must be balanced and the max open count\r
4831  * is one.\r
4832  */\r
4833 var DidOpenTextDocumentNotification;\r
4834 (function (DidOpenTextDocumentNotification) {\r
4835     DidOpenTextDocumentNotification.method = 'textDocument/didOpen';\r
4836     DidOpenTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification.method);\r
4837 })(DidOpenTextDocumentNotification = exports.DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = {}));\r
4838 /**\r
4839  * The document change notification is sent from the client to the server to signal\r
4840  * changes to a text document.\r
4841  */\r
4842 var DidChangeTextDocumentNotification;\r
4843 (function (DidChangeTextDocumentNotification) {\r
4844     DidChangeTextDocumentNotification.method = 'textDocument/didChange';\r
4845     DidChangeTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification.method);\r
4846 })(DidChangeTextDocumentNotification = exports.DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = {}));\r
4847 /**\r
4848  * The document close notification is sent from the client to the server when\r
4849  * the document got closed in the client. The document's truth now exists where\r
4850  * the document's uri points to (e.g. if the document's uri is a file uri the\r
4851  * truth now exists on disk). As with the open notification the close notification\r
4852  * is about managing the document's content. Receiving a close notification\r
4853  * doesn't mean that the document was open in an editor before. A close\r
4854  * notification requires a previous open notification to be sent.\r
4855  */\r
4856 var DidCloseTextDocumentNotification;\r
4857 (function (DidCloseTextDocumentNotification) {\r
4858     DidCloseTextDocumentNotification.method = 'textDocument/didClose';\r
4859     DidCloseTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification.method);\r
4860 })(DidCloseTextDocumentNotification = exports.DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = {}));\r
4861 /**\r
4862  * The document save notification is sent from the client to the server when\r
4863  * the document got saved in the client.\r
4864  */\r
4865 var DidSaveTextDocumentNotification;\r
4866 (function (DidSaveTextDocumentNotification) {\r
4867     DidSaveTextDocumentNotification.method = 'textDocument/didSave';\r
4868     DidSaveTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification.method);\r
4869 })(DidSaveTextDocumentNotification = exports.DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = {}));\r
4870 /**\r
4871  * Represents reasons why a text document is saved.\r
4872  */\r
4873 var TextDocumentSaveReason;\r
4874 (function (TextDocumentSaveReason) {\r
4875     /**\r
4876      * Manually triggered, e.g. by the user pressing save, by starting debugging,\r
4877      * or by an API call.\r
4878      */\r
4879     TextDocumentSaveReason.Manual = 1;\r
4880     /**\r
4881      * Automatic after a delay.\r
4882      */\r
4883     TextDocumentSaveReason.AfterDelay = 2;\r
4884     /**\r
4885      * When the editor lost focus.\r
4886      */\r
4887     TextDocumentSaveReason.FocusOut = 3;\r
4888 })(TextDocumentSaveReason = exports.TextDocumentSaveReason || (exports.TextDocumentSaveReason = {}));\r
4889 /**\r
4890  * A document will save notification is sent from the client to the server before\r
4891  * the document is actually saved.\r
4892  */\r
4893 var WillSaveTextDocumentNotification;\r
4894 (function (WillSaveTextDocumentNotification) {\r
4895     WillSaveTextDocumentNotification.method = 'textDocument/willSave';\r
4896     WillSaveTextDocumentNotification.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification.method);\r
4897 })(WillSaveTextDocumentNotification = exports.WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = {}));\r
4898 /**\r
4899  * A document will save request is sent from the client to the server before\r
4900  * the document is actually saved. The request can return an array of TextEdits\r
4901  * which will be applied to the text document before it is saved. Please note that\r
4902  * clients might drop results if computing the text edits took too long or if a\r
4903  * server constantly fails on this request. This is done to keep the save fast and\r
4904  * reliable.\r
4905  */\r
4906 var WillSaveTextDocumentWaitUntilRequest;\r
4907 (function (WillSaveTextDocumentWaitUntilRequest) {\r
4908     WillSaveTextDocumentWaitUntilRequest.method = 'textDocument/willSaveWaitUntil';\r
4909     WillSaveTextDocumentWaitUntilRequest.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest.method);\r
4910 })(WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = {}));\r
4911 /**\r
4912  * The watched files notification is sent from the client to the server when\r
4913  * the client detects changes to file watched by the language client.\r
4914  */\r
4915 var DidChangeWatchedFilesNotification;\r
4916 (function (DidChangeWatchedFilesNotification) {\r
4917     DidChangeWatchedFilesNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeWatchedFiles');\r
4918 })(DidChangeWatchedFilesNotification = exports.DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = {}));\r
4919 /**\r
4920  * The file event type\r
4921  */\r
4922 var FileChangeType;\r
4923 (function (FileChangeType) {\r
4924     /**\r
4925      * The file got created.\r
4926      */\r
4927     FileChangeType.Created = 1;\r
4928     /**\r
4929      * The file got changed.\r
4930      */\r
4931     FileChangeType.Changed = 2;\r
4932     /**\r
4933      * The file got deleted.\r
4934      */\r
4935     FileChangeType.Deleted = 3;\r
4936 })(FileChangeType = exports.FileChangeType || (exports.FileChangeType = {}));\r
4937 var WatchKind;\r
4938 (function (WatchKind) {\r
4939     /**\r
4940      * Interested in create events.\r
4941      */\r
4942     WatchKind.Create = 1;\r
4943     /**\r
4944      * Interested in change events\r
4945      */\r
4946     WatchKind.Change = 2;\r
4947     /**\r
4948      * Interested in delete events\r
4949      */\r
4950     WatchKind.Delete = 4;\r
4951 })(WatchKind = exports.WatchKind || (exports.WatchKind = {}));\r
4952 /**\r
4953  * Diagnostics notification are sent from the server to the client to signal\r
4954  * results of validation runs.\r
4955  */\r
4956 var PublishDiagnosticsNotification;\r
4957 (function (PublishDiagnosticsNotification) {\r
4958     PublishDiagnosticsNotification.type = new messages_1.ProtocolNotificationType('textDocument/publishDiagnostics');\r
4959 })(PublishDiagnosticsNotification = exports.PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = {}));\r
4960 /**\r
4961  * How a completion was triggered\r
4962  */\r
4963 var CompletionTriggerKind;\r
4964 (function (CompletionTriggerKind) {\r
4965     /**\r
4966      * Completion was triggered by typing an identifier (24x7 code\r
4967      * complete), manual invocation (e.g Ctrl+Space) or via API.\r
4968      */\r
4969     CompletionTriggerKind.Invoked = 1;\r
4970     /**\r
4971      * Completion was triggered by a trigger character specified by\r
4972      * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.\r
4973      */\r
4974     CompletionTriggerKind.TriggerCharacter = 2;\r
4975     /**\r
4976      * Completion was re-triggered as current completion list is incomplete\r
4977      */\r
4978     CompletionTriggerKind.TriggerForIncompleteCompletions = 3;\r
4979 })(CompletionTriggerKind = exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {}));\r
4980 /**\r
4981  * Request to request completion at a given text document position. The request's\r
4982  * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response\r
4983  * is of type [CompletionItem[]](#CompletionItem) or [CompletionList](#CompletionList)\r
4984  * or a Thenable that resolves to such.\r
4985  *\r
4986  * The request can delay the computation of the [`detail`](#CompletionItem.detail)\r
4987  * and [`documentation`](#CompletionItem.documentation) properties to the `completionItem/resolve`\r
4988  * request. However, properties that are needed for the initial sorting and filtering, like `sortText`,\r
4989  * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.\r
4990  */\r
4991 var CompletionRequest;\r
4992 (function (CompletionRequest) {\r
4993     CompletionRequest.method = 'textDocument/completion';\r
4994     CompletionRequest.type = new messages_1.ProtocolRequestType(CompletionRequest.method);\r
4995     /** @deprecated Use CompletionRequest.type */\r
4996     CompletionRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
4997 })(CompletionRequest = exports.CompletionRequest || (exports.CompletionRequest = {}));\r
4998 /**\r
4999  * Request to resolve additional information for a given completion item.The request's\r
5000  * parameter is of type [CompletionItem](#CompletionItem) the response\r
5001  * is of type [CompletionItem](#CompletionItem) or a Thenable that resolves to such.\r
5002  */\r
5003 var CompletionResolveRequest;\r
5004 (function (CompletionResolveRequest) {\r
5005     CompletionResolveRequest.method = 'completionItem/resolve';\r
5006     CompletionResolveRequest.type = new messages_1.ProtocolRequestType(CompletionResolveRequest.method);\r
5007 })(CompletionResolveRequest = exports.CompletionResolveRequest || (exports.CompletionResolveRequest = {}));\r
5008 /**\r
5009  * Request to request hover information at a given text document position. The request's\r
5010  * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response is of\r
5011  * type [Hover](#Hover) or a Thenable that resolves to such.\r
5012  */\r
5013 var HoverRequest;\r
5014 (function (HoverRequest) {\r
5015     HoverRequest.method = 'textDocument/hover';\r
5016     HoverRequest.type = new messages_1.ProtocolRequestType(HoverRequest.method);\r
5017 })(HoverRequest = exports.HoverRequest || (exports.HoverRequest = {}));\r
5018 /**\r
5019  * How a signature help was triggered.\r
5020  *\r
5021  * @since 3.15.0\r
5022  */\r
5023 var SignatureHelpTriggerKind;\r
5024 (function (SignatureHelpTriggerKind) {\r
5025     /**\r
5026      * Signature help was invoked manually by the user or by a command.\r
5027      */\r
5028     SignatureHelpTriggerKind.Invoked = 1;\r
5029     /**\r
5030      * Signature help was triggered by a trigger character.\r
5031      */\r
5032     SignatureHelpTriggerKind.TriggerCharacter = 2;\r
5033     /**\r
5034      * Signature help was triggered by the cursor moving or by the document content changing.\r
5035      */\r
5036     SignatureHelpTriggerKind.ContentChange = 3;\r
5037 })(SignatureHelpTriggerKind = exports.SignatureHelpTriggerKind || (exports.SignatureHelpTriggerKind = {}));\r
5038 var SignatureHelpRequest;\r
5039 (function (SignatureHelpRequest) {\r
5040     SignatureHelpRequest.method = 'textDocument/signatureHelp';\r
5041     SignatureHelpRequest.type = new messages_1.ProtocolRequestType(SignatureHelpRequest.method);\r
5042 })(SignatureHelpRequest = exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {}));\r
5043 /**\r
5044  * A request to resolve the definition location of a symbol at a given text\r
5045  * document position. The request's parameter is of type [TextDocumentPosition]\r
5046  * (#TextDocumentPosition) the response is of either type [Definition](#Definition)\r
5047  * or a typed array of [DefinitionLink](#DefinitionLink) or a Thenable that resolves\r
5048  * to such.\r
5049  */\r
5050 var DefinitionRequest;\r
5051 (function (DefinitionRequest) {\r
5052     DefinitionRequest.method = 'textDocument/definition';\r
5053     DefinitionRequest.type = new messages_1.ProtocolRequestType(DefinitionRequest.method);\r
5054     /** @deprecated Use DefinitionRequest.type */\r
5055     DefinitionRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5056 })(DefinitionRequest = exports.DefinitionRequest || (exports.DefinitionRequest = {}));\r
5057 /**\r
5058  * A request to resolve project-wide references for the symbol denoted\r
5059  * by the given text document position. The request's parameter is of\r
5060  * type [ReferenceParams](#ReferenceParams) the response is of type\r
5061  * [Location[]](#Location) or a Thenable that resolves to such.\r
5062  */\r
5063 var ReferencesRequest;\r
5064 (function (ReferencesRequest) {\r
5065     ReferencesRequest.method = 'textDocument/references';\r
5066     ReferencesRequest.type = new messages_1.ProtocolRequestType(ReferencesRequest.method);\r
5067     /** @deprecated Use ReferencesRequest.type */\r
5068     ReferencesRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5069 })(ReferencesRequest = exports.ReferencesRequest || (exports.ReferencesRequest = {}));\r
5070 /**\r
5071  * Request to resolve a [DocumentHighlight](#DocumentHighlight) for a given\r
5072  * text document position. The request's parameter is of type [TextDocumentPosition]\r
5073  * (#TextDocumentPosition) the request response is of type [DocumentHighlight[]]\r
5074  * (#DocumentHighlight) or a Thenable that resolves to such.\r
5075  */\r
5076 var DocumentHighlightRequest;\r
5077 (function (DocumentHighlightRequest) {\r
5078     DocumentHighlightRequest.method = 'textDocument/documentHighlight';\r
5079     DocumentHighlightRequest.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest.method);\r
5080     /** @deprecated Use DocumentHighlightRequest.type */\r
5081     DocumentHighlightRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5082 })(DocumentHighlightRequest = exports.DocumentHighlightRequest || (exports.DocumentHighlightRequest = {}));\r
5083 /**\r
5084  * A request to list all symbols found in a given text document. The request's\r
5085  * parameter is of type [TextDocumentIdentifier](#TextDocumentIdentifier) the\r
5086  * response is of type [SymbolInformation[]](#SymbolInformation) or a Thenable\r
5087  * that resolves to such.\r
5088  */\r
5089 var DocumentSymbolRequest;\r
5090 (function (DocumentSymbolRequest) {\r
5091     DocumentSymbolRequest.method = 'textDocument/documentSymbol';\r
5092     DocumentSymbolRequest.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest.method);\r
5093     /** @deprecated Use DocumentSymbolRequest.type */\r
5094     DocumentSymbolRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5095 })(DocumentSymbolRequest = exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {}));\r
5096 /**\r
5097  * A request to provide commands for the given text document and range.\r
5098  */\r
5099 var CodeActionRequest;\r
5100 (function (CodeActionRequest) {\r
5101     CodeActionRequest.method = 'textDocument/codeAction';\r
5102     CodeActionRequest.type = new messages_1.ProtocolRequestType(CodeActionRequest.method);\r
5103     /** @deprecated Use CodeActionRequest.type */\r
5104     CodeActionRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5105 })(CodeActionRequest = exports.CodeActionRequest || (exports.CodeActionRequest = {}));\r
5106 /**\r
5107  * A request to list project-wide symbols matching the query string given\r
5108  * by the [WorkspaceSymbolParams](#WorkspaceSymbolParams). The response is\r
5109  * of type [SymbolInformation[]](#SymbolInformation) or a Thenable that\r
5110  * resolves to such.\r
5111  */\r
5112 var WorkspaceSymbolRequest;\r
5113 (function (WorkspaceSymbolRequest) {\r
5114     WorkspaceSymbolRequest.method = 'workspace/symbol';\r
5115     WorkspaceSymbolRequest.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest.method);\r
5116     /** @deprecated Use WorkspaceSymbolRequest.type */\r
5117     WorkspaceSymbolRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5118 })(WorkspaceSymbolRequest = exports.WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = {}));\r
5119 /**\r
5120  * A request to provide code lens for the given text document.\r
5121  */\r
5122 var CodeLensRequest;\r
5123 (function (CodeLensRequest) {\r
5124     CodeLensRequest.type = new messages_1.ProtocolRequestType('textDocument/codeLens');\r
5125     /** @deprecated Use CodeLensRequest.type */\r
5126     CodeLensRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5127 })(CodeLensRequest = exports.CodeLensRequest || (exports.CodeLensRequest = {}));\r
5128 /**\r
5129  * A request to resolve a command for a given code lens.\r
5130  */\r
5131 var CodeLensResolveRequest;\r
5132 (function (CodeLensResolveRequest) {\r
5133     CodeLensResolveRequest.type = new messages_1.ProtocolRequestType('codeLens/resolve');\r
5134 })(CodeLensResolveRequest = exports.CodeLensResolveRequest || (exports.CodeLensResolveRequest = {}));\r
5135 /**\r
5136  * A request to provide document links\r
5137  */\r
5138 var DocumentLinkRequest;\r
5139 (function (DocumentLinkRequest) {\r
5140     DocumentLinkRequest.method = 'textDocument/documentLink';\r
5141     DocumentLinkRequest.type = new messages_1.ProtocolRequestType(DocumentLinkRequest.method);\r
5142     /** @deprecated Use DocumentLinkRequest.type */\r
5143     DocumentLinkRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5144 })(DocumentLinkRequest = exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {}));\r
5145 /**\r
5146  * Request to resolve additional information for a given document link. The request's\r
5147  * parameter is of type [DocumentLink](#DocumentLink) the response\r
5148  * is of type [DocumentLink](#DocumentLink) or a Thenable that resolves to such.\r
5149  */\r
5150 var DocumentLinkResolveRequest;\r
5151 (function (DocumentLinkResolveRequest) {\r
5152     DocumentLinkResolveRequest.type = new messages_1.ProtocolRequestType('documentLink/resolve');\r
5153 })(DocumentLinkResolveRequest = exports.DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = {}));\r
5154 /**\r
5155  * A request to to format a whole document.\r
5156  */\r
5157 var DocumentFormattingRequest;\r
5158 (function (DocumentFormattingRequest) {\r
5159     DocumentFormattingRequest.method = 'textDocument/formatting';\r
5160     DocumentFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest.method);\r
5161 })(DocumentFormattingRequest = exports.DocumentFormattingRequest || (exports.DocumentFormattingRequest = {}));\r
5162 /**\r
5163  * A request to to format a range in a document.\r
5164  */\r
5165 var DocumentRangeFormattingRequest;\r
5166 (function (DocumentRangeFormattingRequest) {\r
5167     DocumentRangeFormattingRequest.method = 'textDocument/rangeFormatting';\r
5168     DocumentRangeFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest.method);\r
5169 })(DocumentRangeFormattingRequest = exports.DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = {}));\r
5170 /**\r
5171  * A request to format a document on type.\r
5172  */\r
5173 var DocumentOnTypeFormattingRequest;\r
5174 (function (DocumentOnTypeFormattingRequest) {\r
5175     DocumentOnTypeFormattingRequest.method = 'textDocument/onTypeFormatting';\r
5176     DocumentOnTypeFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest.method);\r
5177 })(DocumentOnTypeFormattingRequest = exports.DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = {}));\r
5178 /**\r
5179  * A request to rename a symbol.\r
5180  */\r
5181 var RenameRequest;\r
5182 (function (RenameRequest) {\r
5183     RenameRequest.method = 'textDocument/rename';\r
5184     RenameRequest.type = new messages_1.ProtocolRequestType(RenameRequest.method);\r
5185 })(RenameRequest = exports.RenameRequest || (exports.RenameRequest = {}));\r
5186 /**\r
5187  * A request to test and perform the setup necessary for a rename.\r
5188  */\r
5189 var PrepareRenameRequest;\r
5190 (function (PrepareRenameRequest) {\r
5191     PrepareRenameRequest.method = 'textDocument/prepareRename';\r
5192     PrepareRenameRequest.type = new messages_1.ProtocolRequestType(PrepareRenameRequest.method);\r
5193 })(PrepareRenameRequest = exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {}));\r
5194 /**\r
5195  * A request send from the client to the server to execute a command. The request might return\r
5196  * a workspace edit which the client will apply to the workspace.\r
5197  */\r
5198 var ExecuteCommandRequest;\r
5199 (function (ExecuteCommandRequest) {\r
5200     ExecuteCommandRequest.type = new messages_1.ProtocolRequestType('workspace/executeCommand');\r
5201 })(ExecuteCommandRequest = exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {}));\r
5202 /**\r
5203  * A request sent from the server to the client to modified certain resources.\r
5204  */\r
5205 var ApplyWorkspaceEditRequest;\r
5206 (function (ApplyWorkspaceEditRequest) {\r
5207     ApplyWorkspaceEditRequest.type = new messages_1.ProtocolRequestType('workspace/applyEdit');\r
5208 })(ApplyWorkspaceEditRequest = exports.ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = {}));\r
5209
5210
5211 /***/ }),
5212 /* 22 */
5213 /***/ (function(module, exports, __webpack_require__) {
5214
5215 "use strict";
5216 /* --------------------------------------------------------------------------------------------\r
5217  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5218  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5219  * ------------------------------------------------------------------------------------------ */\r
5220 \r
5221 Object.defineProperty(exports, "__esModule", { value: true });\r
5222 function boolean(value) {\r
5223     return value === true || value === false;\r
5224 }\r
5225 exports.boolean = boolean;\r
5226 function string(value) {\r
5227     return typeof value === 'string' || value instanceof String;\r
5228 }\r
5229 exports.string = string;\r
5230 function number(value) {\r
5231     return typeof value === 'number' || value instanceof Number;\r
5232 }\r
5233 exports.number = number;\r
5234 function error(value) {\r
5235     return value instanceof Error;\r
5236 }\r
5237 exports.error = error;\r
5238 function func(value) {\r
5239     return typeof value === 'function';\r
5240 }\r
5241 exports.func = func;\r
5242 function array(value) {\r
5243     return Array.isArray(value);\r
5244 }\r
5245 exports.array = array;\r
5246 function stringArray(value) {\r
5247     return array(value) && value.every(elem => string(elem));\r
5248 }\r
5249 exports.stringArray = stringArray;\r
5250 function typedArray(value, check) {\r
5251     return Array.isArray(value) && value.every(check);\r
5252 }\r
5253 exports.typedArray = typedArray;\r
5254 function objectLiteral(value) {\r
5255     // Strictly speaking class instances pass this check as well. Since the LSP\r
5256     // doesn't use classes we ignore this for now. If we do we need to add something\r
5257     // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`\r
5258     return value !== null && typeof value === 'object';\r
5259 }\r
5260 exports.objectLiteral = objectLiteral;\r
5261
5262
5263 /***/ }),
5264 /* 23 */
5265 /***/ (function(module, exports, __webpack_require__) {
5266
5267 "use strict";
5268 /* --------------------------------------------------------------------------------------------\r
5269  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5270  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5271  * ------------------------------------------------------------------------------------------ */\r
5272 \r
5273 Object.defineProperty(exports, "__esModule", { value: true });\r
5274 const vscode_jsonrpc_1 = __webpack_require__(9);\r
5275 class ProtocolRequestType0 extends vscode_jsonrpc_1.RequestType0 {\r
5276     constructor(method) {\r
5277         super(method);\r
5278     }\r
5279 }\r
5280 exports.ProtocolRequestType0 = ProtocolRequestType0;\r
5281 class ProtocolRequestType extends vscode_jsonrpc_1.RequestType {\r
5282     constructor(method) {\r
5283         super(method);\r
5284     }\r
5285 }\r
5286 exports.ProtocolRequestType = ProtocolRequestType;\r
5287 class ProtocolNotificationType extends vscode_jsonrpc_1.NotificationType {\r
5288     constructor(method) {\r
5289         super(method);\r
5290     }\r
5291 }\r
5292 exports.ProtocolNotificationType = ProtocolNotificationType;\r
5293 class ProtocolNotificationType0 extends vscode_jsonrpc_1.NotificationType0 {\r
5294     constructor(method) {\r
5295         super(method);\r
5296     }\r
5297 }\r
5298 exports.ProtocolNotificationType0 = ProtocolNotificationType0;\r
5299
5300
5301 /***/ }),
5302 /* 24 */
5303 /***/ (function(module, exports, __webpack_require__) {
5304
5305 "use strict";
5306 /* --------------------------------------------------------------------------------------------\r
5307  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5308  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5309  * ------------------------------------------------------------------------------------------ */\r
5310 \r
5311 Object.defineProperty(exports, "__esModule", { value: true });\r
5312 const vscode_jsonrpc_1 = __webpack_require__(9);\r
5313 const messages_1 = __webpack_require__(23);\r
5314 // @ts-ignore: to avoid inlining LocatioLink as dynamic import\r
5315 let __noDynamicImport;\r
5316 /**\r
5317  * A request to resolve the implementation locations of a symbol at a given text\r
5318  * document position. The request's parameter is of type [TextDocumentPositioParams]\r
5319  * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a\r
5320  * Thenable that resolves to such.\r
5321  */\r
5322 var ImplementationRequest;\r
5323 (function (ImplementationRequest) {\r
5324     ImplementationRequest.method = 'textDocument/implementation';\r
5325     ImplementationRequest.type = new messages_1.ProtocolRequestType(ImplementationRequest.method);\r
5326     /** @deprecated Use ImplementationRequest.type */\r
5327     ImplementationRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5328 })(ImplementationRequest = exports.ImplementationRequest || (exports.ImplementationRequest = {}));\r
5329
5330
5331 /***/ }),
5332 /* 25 */
5333 /***/ (function(module, exports, __webpack_require__) {
5334
5335 "use strict";
5336 /* --------------------------------------------------------------------------------------------\r
5337  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5338  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5339  * ------------------------------------------------------------------------------------------ */\r
5340 \r
5341 Object.defineProperty(exports, "__esModule", { value: true });\r
5342 const vscode_jsonrpc_1 = __webpack_require__(9);\r
5343 const messages_1 = __webpack_require__(23);\r
5344 // @ts-ignore: to avoid inlining LocatioLink as dynamic import\r
5345 let __noDynamicImport;\r
5346 /**\r
5347  * A request to resolve the type definition locations of a symbol at a given text\r
5348  * document position. The request's parameter is of type [TextDocumentPositioParams]\r
5349  * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a\r
5350  * Thenable that resolves to such.\r
5351  */\r
5352 var TypeDefinitionRequest;\r
5353 (function (TypeDefinitionRequest) {\r
5354     TypeDefinitionRequest.method = 'textDocument/typeDefinition';\r
5355     TypeDefinitionRequest.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest.method);\r
5356     /** @deprecated Use TypeDefinitionRequest.type */\r
5357     TypeDefinitionRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5358 })(TypeDefinitionRequest = exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {}));\r
5359
5360
5361 /***/ }),
5362 /* 26 */
5363 /***/ (function(module, exports, __webpack_require__) {
5364
5365 "use strict";
5366 /* --------------------------------------------------------------------------------------------\r
5367  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5368  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5369  * ------------------------------------------------------------------------------------------ */\r
5370 \r
5371 Object.defineProperty(exports, "__esModule", { value: true });\r
5372 const messages_1 = __webpack_require__(23);\r
5373 /**\r
5374  * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.\r
5375  */\r
5376 var WorkspaceFoldersRequest;\r
5377 (function (WorkspaceFoldersRequest) {\r
5378     WorkspaceFoldersRequest.type = new messages_1.ProtocolRequestType0('workspace/workspaceFolders');\r
5379 })(WorkspaceFoldersRequest = exports.WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = {}));\r
5380 /**\r
5381  * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace\r
5382  * folder configuration changes.\r
5383  */\r
5384 var DidChangeWorkspaceFoldersNotification;\r
5385 (function (DidChangeWorkspaceFoldersNotification) {\r
5386     DidChangeWorkspaceFoldersNotification.type = new messages_1.ProtocolNotificationType('workspace/didChangeWorkspaceFolders');\r
5387 })(DidChangeWorkspaceFoldersNotification = exports.DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = {}));\r
5388
5389
5390 /***/ }),
5391 /* 27 */
5392 /***/ (function(module, exports, __webpack_require__) {
5393
5394 "use strict";
5395 /* --------------------------------------------------------------------------------------------\r
5396  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5397  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5398  * ------------------------------------------------------------------------------------------ */\r
5399 \r
5400 Object.defineProperty(exports, "__esModule", { value: true });\r
5401 const messages_1 = __webpack_require__(23);\r
5402 /**\r
5403  * The 'workspace/configuration' request is sent from the server to the client to fetch a certain\r
5404  * configuration setting.\r
5405  *\r
5406  * This pull model replaces the old push model were the client signaled configuration change via an\r
5407  * event. If the server still needs to react to configuration changes (since the server caches the\r
5408  * result of `workspace/configuration` requests) the server should register for an empty configuration\r
5409  * change event and empty the cache if such an event is received.\r
5410  */\r
5411 var ConfigurationRequest;\r
5412 (function (ConfigurationRequest) {\r
5413     ConfigurationRequest.type = new messages_1.ProtocolRequestType('workspace/configuration');\r
5414 })(ConfigurationRequest = exports.ConfigurationRequest || (exports.ConfigurationRequest = {}));\r
5415
5416
5417 /***/ }),
5418 /* 28 */
5419 /***/ (function(module, exports, __webpack_require__) {
5420
5421 "use strict";
5422 /* --------------------------------------------------------------------------------------------\r
5423  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5424  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5425  * ------------------------------------------------------------------------------------------ */\r
5426 \r
5427 Object.defineProperty(exports, "__esModule", { value: true });\r
5428 const vscode_jsonrpc_1 = __webpack_require__(9);\r
5429 const messages_1 = __webpack_require__(23);\r
5430 /**\r
5431  * A request to list all color symbols found in a given text document. The request's\r
5432  * parameter is of type [DocumentColorParams](#DocumentColorParams) the\r
5433  * response is of type [ColorInformation[]](#ColorInformation) or a Thenable\r
5434  * that resolves to such.\r
5435  */\r
5436 var DocumentColorRequest;\r
5437 (function (DocumentColorRequest) {\r
5438     DocumentColorRequest.method = 'textDocument/documentColor';\r
5439     DocumentColorRequest.type = new messages_1.ProtocolRequestType(DocumentColorRequest.method);\r
5440     /** @deprecated Use DocumentColorRequest.type */\r
5441     DocumentColorRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5442 })(DocumentColorRequest = exports.DocumentColorRequest || (exports.DocumentColorRequest = {}));\r
5443 /**\r
5444  * A request to list all presentation for a color. The request's\r
5445  * parameter is of type [ColorPresentationParams](#ColorPresentationParams) the\r
5446  * response is of type [ColorInformation[]](#ColorInformation) or a Thenable\r
5447  * that resolves to such.\r
5448  */\r
5449 var ColorPresentationRequest;\r
5450 (function (ColorPresentationRequest) {\r
5451     ColorPresentationRequest.type = new messages_1.ProtocolRequestType('textDocument/colorPresentation');\r
5452 })(ColorPresentationRequest = exports.ColorPresentationRequest || (exports.ColorPresentationRequest = {}));\r
5453
5454
5455 /***/ }),
5456 /* 29 */
5457 /***/ (function(module, exports, __webpack_require__) {
5458
5459 "use strict";
5460 \r
5461 /*---------------------------------------------------------------------------------------------\r
5462  *  Copyright (c) Microsoft Corporation. All rights reserved.\r
5463  *  Licensed under the MIT License. See License.txt in the project root for license information.\r
5464  *--------------------------------------------------------------------------------------------*/\r
5465 Object.defineProperty(exports, "__esModule", { value: true });\r
5466 const vscode_jsonrpc_1 = __webpack_require__(9);\r
5467 const messages_1 = __webpack_require__(23);\r
5468 /**\r
5469  * Enum of known range kinds\r
5470  */\r
5471 var FoldingRangeKind;\r
5472 (function (FoldingRangeKind) {\r
5473     /**\r
5474      * Folding range for a comment\r
5475      */\r
5476     FoldingRangeKind["Comment"] = "comment";\r
5477     /**\r
5478      * Folding range for a imports or includes\r
5479      */\r
5480     FoldingRangeKind["Imports"] = "imports";\r
5481     /**\r
5482      * Folding range for a region (e.g. `#region`)\r
5483      */\r
5484     FoldingRangeKind["Region"] = "region";\r
5485 })(FoldingRangeKind = exports.FoldingRangeKind || (exports.FoldingRangeKind = {}));\r
5486 /**\r
5487  * A request to provide folding ranges in a document. The request's\r
5488  * parameter is of type [FoldingRangeParams](#FoldingRangeParams), the\r
5489  * response is of type [FoldingRangeList](#FoldingRangeList) or a Thenable\r
5490  * that resolves to such.\r
5491  */\r
5492 var FoldingRangeRequest;\r
5493 (function (FoldingRangeRequest) {\r
5494     FoldingRangeRequest.method = 'textDocument/foldingRange';\r
5495     FoldingRangeRequest.type = new messages_1.ProtocolRequestType(FoldingRangeRequest.method);\r
5496     /** @deprecated Use FoldingRangeRequest.type */\r
5497     FoldingRangeRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5498 })(FoldingRangeRequest = exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {}));\r
5499
5500
5501 /***/ }),
5502 /* 30 */
5503 /***/ (function(module, exports, __webpack_require__) {
5504
5505 "use strict";
5506 /* --------------------------------------------------------------------------------------------\r
5507  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5508  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5509  * ------------------------------------------------------------------------------------------ */\r
5510 \r
5511 Object.defineProperty(exports, "__esModule", { value: true });\r
5512 const vscode_jsonrpc_1 = __webpack_require__(9);\r
5513 const messages_1 = __webpack_require__(23);\r
5514 // @ts-ignore: to avoid inlining LocatioLink as dynamic import\r
5515 let __noDynamicImport;\r
5516 /**\r
5517  * A request to resolve the type definition locations of a symbol at a given text\r
5518  * document position. The request's parameter is of type [TextDocumentPositioParams]\r
5519  * (#TextDocumentPositionParams) the response is of type [Declaration](#Declaration)\r
5520  * or a typed array of [DeclarationLink](#DeclarationLink) or a Thenable that resolves\r
5521  * to such.\r
5522  */\r
5523 var DeclarationRequest;\r
5524 (function (DeclarationRequest) {\r
5525     DeclarationRequest.method = 'textDocument/declaration';\r
5526     DeclarationRequest.type = new messages_1.ProtocolRequestType(DeclarationRequest.method);\r
5527     /** @deprecated Use DeclarationRequest.type */\r
5528     DeclarationRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5529 })(DeclarationRequest = exports.DeclarationRequest || (exports.DeclarationRequest = {}));\r
5530
5531
5532 /***/ }),
5533 /* 31 */
5534 /***/ (function(module, exports, __webpack_require__) {
5535
5536 "use strict";
5537 \r
5538 /*---------------------------------------------------------------------------------------------\r
5539  *  Copyright (c) Microsoft Corporation. All rights reserved.\r
5540  *  Licensed under the MIT License. See License.txt in the project root for license information.\r
5541  *--------------------------------------------------------------------------------------------*/\r
5542 Object.defineProperty(exports, "__esModule", { value: true });\r
5543 const vscode_jsonrpc_1 = __webpack_require__(9);\r
5544 const messages_1 = __webpack_require__(23);\r
5545 /**\r
5546  * A request to provide selection ranges in a document. The request's\r
5547  * parameter is of type [SelectionRangeParams](#SelectionRangeParams), the\r
5548  * response is of type [SelectionRange[]](#SelectionRange[]) or a Thenable\r
5549  * that resolves to such.\r
5550  */\r
5551 var SelectionRangeRequest;\r
5552 (function (SelectionRangeRequest) {\r
5553     SelectionRangeRequest.method = 'textDocument/selectionRange';\r
5554     SelectionRangeRequest.type = new messages_1.ProtocolRequestType(SelectionRangeRequest.method);\r
5555     /** @deprecated  Use SelectionRangeRequest.type */\r
5556     SelectionRangeRequest.resultType = new vscode_jsonrpc_1.ProgressType();\r
5557 })(SelectionRangeRequest = exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {}));\r
5558
5559
5560 /***/ }),
5561 /* 32 */
5562 /***/ (function(module, exports, __webpack_require__) {
5563
5564 "use strict";
5565 /* --------------------------------------------------------------------------------------------\r
5566  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5567  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5568  * ------------------------------------------------------------------------------------------ */\r
5569 \r
5570 Object.defineProperty(exports, "__esModule", { value: true });\r
5571 const vscode_jsonrpc_1 = __webpack_require__(9);\r
5572 const messages_1 = __webpack_require__(23);\r
5573 var WorkDoneProgress;\r
5574 (function (WorkDoneProgress) {\r
5575     WorkDoneProgress.type = new vscode_jsonrpc_1.ProgressType();\r
5576 })(WorkDoneProgress = exports.WorkDoneProgress || (exports.WorkDoneProgress = {}));\r
5577 /**\r
5578  * The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress\r
5579  * reporting from the server.\r
5580  */\r
5581 var WorkDoneProgressCreateRequest;\r
5582 (function (WorkDoneProgressCreateRequest) {\r
5583     WorkDoneProgressCreateRequest.type = new messages_1.ProtocolRequestType('window/workDoneProgress/create');\r
5584 })(WorkDoneProgressCreateRequest = exports.WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = {}));\r
5585 /**\r
5586  * The `window/workDoneProgress/cancel` notification is sent from  the client to the server to cancel a progress\r
5587  * initiated on the server side.\r
5588  */\r
5589 var WorkDoneProgressCancelNotification;\r
5590 (function (WorkDoneProgressCancelNotification) {\r
5591     WorkDoneProgressCancelNotification.type = new messages_1.ProtocolNotificationType('window/workDoneProgress/cancel');\r
5592 })(WorkDoneProgressCancelNotification = exports.WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = {}));\r
5593
5594
5595 /***/ }),
5596 /* 33 */
5597 /***/ (function(module, exports, __webpack_require__) {
5598
5599 "use strict";
5600 /* --------------------------------------------------------------------------------------------\r
5601  * Copyright (c) TypeFox and others. All rights reserved.\r
5602  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5603  * ------------------------------------------------------------------------------------------ */\r
5604 \r
5605 Object.defineProperty(exports, "__esModule", { value: true });\r
5606 const messages_1 = __webpack_require__(23);\r
5607 /**\r
5608  * A request to result a `CallHierarchyItem` in a document at a given position.\r
5609  * Can be used as an input to a incoming or outgoing call hierarchy.\r
5610  *\r
5611  * @since 3.16.0 - Proposed state\r
5612  */\r
5613 var CallHierarchyPrepareRequest;\r
5614 (function (CallHierarchyPrepareRequest) {\r
5615     CallHierarchyPrepareRequest.method = 'textDocument/prepareCallHierarchy';\r
5616     CallHierarchyPrepareRequest.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest.method);\r
5617 })(CallHierarchyPrepareRequest = exports.CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = {}));\r
5618 /**\r
5619  * A request to resolve the incoming calls for a given `CallHierarchyItem`.\r
5620  *\r
5621  * @since 3.16.0 - Proposed state\r
5622  */\r
5623 var CallHierarchyIncomingCallsRequest;\r
5624 (function (CallHierarchyIncomingCallsRequest) {\r
5625     CallHierarchyIncomingCallsRequest.method = 'callHierarchy/incomingCalls';\r
5626     CallHierarchyIncomingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest.method);\r
5627 })(CallHierarchyIncomingCallsRequest = exports.CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = {}));\r
5628 /**\r
5629  * A request to resolve the outgoing calls for a given `CallHierarchyItem`.\r
5630  *\r
5631  * @since 3.16.0 - Proposed state\r
5632  */\r
5633 var CallHierarchyOutgoingCallsRequest;\r
5634 (function (CallHierarchyOutgoingCallsRequest) {\r
5635     CallHierarchyOutgoingCallsRequest.method = 'callHierarchy/outgoingCalls';\r
5636     CallHierarchyOutgoingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest.method);\r
5637 })(CallHierarchyOutgoingCallsRequest = exports.CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = {}));\r
5638
5639
5640 /***/ }),
5641 /* 34 */
5642 /***/ (function(module, exports, __webpack_require__) {
5643
5644 "use strict";
5645 /* --------------------------------------------------------------------------------------------\r
5646  * Copyright (c) Microsoft Corporation. All rights reserved.\r
5647  * Licensed under the MIT License. See License.txt in the project root for license information.\r
5648  * ------------------------------------------------------------------------------------------ */\r
5649 \r
5650 Object.defineProperty(exports, "__esModule", { value: true });\r
5651 const messages_1 = __webpack_require__(23);\r
5652 /**\r
5653  * A set of predefined token types. This set is not fixed\r
5654  * an clients can specify additional token types via the\r
5655  * corresponding client capabilities.\r
5656  *\r
5657  * @since 3.16.0 - Proposed state\r
5658  */\r
5659 var SemanticTokenTypes;\r
5660 (function (SemanticTokenTypes) {\r
5661     SemanticTokenTypes["comment"] = "comment";\r
5662     SemanticTokenTypes["keyword"] = "keyword";\r
5663     SemanticTokenTypes["string"] = "string";\r
5664     SemanticTokenTypes["number"] = "number";\r
5665     SemanticTokenTypes["regexp"] = "regexp";\r
5666     SemanticTokenTypes["operator"] = "operator";\r
5667     SemanticTokenTypes["namespace"] = "namespace";\r
5668     SemanticTokenTypes["type"] = "type";\r
5669     SemanticTokenTypes["struct"] = "struct";\r
5670     SemanticTokenTypes["class"] = "class";\r
5671     SemanticTokenTypes["interface"] = "interface";\r
5672     SemanticTokenTypes["enum"] = "enum";\r
5673     SemanticTokenTypes["typeParameter"] = "typeParameter";\r
5674     SemanticTokenTypes["function"] = "function";\r
5675     SemanticTokenTypes["member"] = "member";\r
5676     SemanticTokenTypes["property"] = "property";\r
5677     SemanticTokenTypes["macro"] = "macro";\r
5678     SemanticTokenTypes["variable"] = "variable";\r
5679     SemanticTokenTypes["parameter"] = "parameter";\r
5680     SemanticTokenTypes["label"] = "label";\r
5681 })(SemanticTokenTypes = exports.SemanticTokenTypes || (exports.SemanticTokenTypes = {}));\r
5682 /**\r
5683  * A set of predefined token modifiers. This set is not fixed\r
5684  * an clients can specify additional token types via the\r
5685  * corresponding client capabilities.\r
5686  *\r
5687  * @since 3.16.0 - Proposed state\r
5688  */\r
5689 var SemanticTokenModifiers;\r
5690 (function (SemanticTokenModifiers) {\r
5691     SemanticTokenModifiers["documentation"] = "documentation";\r
5692     SemanticTokenModifiers["declaration"] = "declaration";\r
5693     SemanticTokenModifiers["definition"] = "definition";\r
5694     SemanticTokenModifiers["reference"] = "reference";\r
5695     SemanticTokenModifiers["static"] = "static";\r
5696     SemanticTokenModifiers["abstract"] = "abstract";\r
5697     SemanticTokenModifiers["deprecated"] = "deprecated";\r
5698     SemanticTokenModifiers["async"] = "async";\r
5699     SemanticTokenModifiers["volatile"] = "volatile";\r
5700     SemanticTokenModifiers["readonly"] = "readonly";\r
5701 })(SemanticTokenModifiers = exports.SemanticTokenModifiers || (exports.SemanticTokenModifiers = {}));\r
5702 /**\r
5703  * @since 3.16.0 - Proposed state\r
5704  */\r
5705 var SemanticTokens;\r
5706 (function (SemanticTokens) {\r
5707     function is(value) {\r
5708         const candidate = value;\r
5709         return candidate !== undefined && (candidate.resultId === undefined || typeof candidate.resultId === 'string') &&\r
5710             Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number');\r
5711     }\r
5712     SemanticTokens.is = is;\r
5713 })(SemanticTokens = exports.SemanticTokens || (exports.SemanticTokens = {}));\r
5714 /**\r
5715  * @since 3.16.0 - Proposed state\r
5716  */\r
5717 var SemanticTokensRequest;\r
5718 (function (SemanticTokensRequest) {\r
5719     SemanticTokensRequest.method = 'textDocument/semanticTokens';\r
5720     SemanticTokensRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRequest.method);\r
5721 })(SemanticTokensRequest = exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {}));\r
5722 /**\r
5723  * @since 3.16.0 - Proposed state\r
5724  */\r
5725 var SemanticTokensEditsRequest;\r
5726 (function (SemanticTokensEditsRequest) {\r
5727     SemanticTokensEditsRequest.method = 'textDocument/semanticTokens/edits';\r
5728     SemanticTokensEditsRequest.type = new messages_1.ProtocolRequestType(SemanticTokensEditsRequest.method);\r
5729 })(SemanticTokensEditsRequest = exports.SemanticTokensEditsRequest || (exports.SemanticTokensEditsRequest = {}));\r
5730 /**\r
5731  * @since 3.16.0 - Proposed state\r
5732  */\r
5733 var SemanticTokensRangeRequest;\r
5734 (function (SemanticTokensRangeRequest) {\r
5735     SemanticTokensRangeRequest.method = 'textDocument/semanticTokens/range';\r
5736     SemanticTokensRangeRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest.method);\r
5737 })(SemanticTokensRangeRequest = exports.SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = {}));\r
5738
5739
5740 /***/ }),
5741 /* 35 */
5742 /***/ (function(module, exports, __webpack_require__) {
5743
5744 "use strict";
5745
5746 var __importDefault = (this && this.__importDefault) || function (mod) {
5747     return (mod && mod.__esModule) ? mod : { "default": mod };
5748 };
5749 Object.defineProperty(exports, "__esModule", { value: true });
5750 /******************************************************************
5751 MIT License http://www.opensource.org/licenses/mit-license.php
5752 Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
5753 *******************************************************************/
5754 const coc_nvim_1 = __webpack_require__(1);
5755 const path_1 = __importDefault(__webpack_require__(4));
5756 const vscode_languageserver_protocol_1 = __webpack_require__(8);
5757 const types_1 = __webpack_require__(36);
5758 const util_1 = __webpack_require__(37);
5759 class ProviderManager {
5760     constructor() {
5761         this.providers = new Map();
5762     }
5763     regist(provider, name) {
5764         this.providers.set(name, provider);
5765         return vscode_languageserver_protocol_1.Disposable.create(() => {
5766             this.providers.delete(name);
5767         });
5768     }
5769     get hasProvider() {
5770         return this.providers.size > 0;
5771     }
5772     async init() {
5773         let providers = Array.from(this.providers.values());
5774         await Promise.all(providers.map(provider => {
5775             return provider.init();
5776         }));
5777     }
5778     async getSnippets(filetype) {
5779         let names = Array.from(this.providers.keys());
5780         let list = [];
5781         for (let name of names) {
5782             let provider = this.providers.get(name);
5783             let snippets = await provider.getSnippets(filetype);
5784             snippets.map(s => s.provider = name);
5785             list.push(...snippets);
5786         }
5787         return list;
5788     }
5789     async getSnippetFiles(filetype) {
5790         let files = [];
5791         for (let provider of this.providers.values()) {
5792             let res = await provider.getSnippetFiles(filetype);
5793             files = files.concat(res);
5794         }
5795         return files;
5796     }
5797     async getTriggerSnippets(autoTrigger = false) {
5798         let bufnr = await coc_nvim_1.workspace.nvim.call('bufnr', '%');
5799         let doc = coc_nvim_1.workspace.getDocument(bufnr);
5800         if (!doc)
5801             return [];
5802         await doc.patchChange();
5803         let position = await coc_nvim_1.workspace.getCursorPosition();
5804         let names = Array.from(this.providers.keys());
5805         let list = [];
5806         for (let name of names) {
5807             let provider = this.providers.get(name);
5808             let items = await provider.getTriggerSnippets(doc, position, autoTrigger);
5809             for (let item of items) {
5810                 if (list.findIndex(o => o.prefix == item.prefix) == -1) {
5811                     list.push(item);
5812                 }
5813             }
5814         }
5815         list.sort((a, b) => b.priority - a.priority);
5816         if (list.length > 1 && list[0].priority > 0) {
5817             list = list.filter(o => o.priority > 0);
5818         }
5819         return list;
5820     }
5821     async provideCompletionItems(document, position, _token, context) {
5822         let doc = coc_nvim_1.workspace.getDocument(document.uri);
5823         if (!doc)
5824             return [];
5825         let snippets = await this.getSnippets(doc.filetype);
5826         let currline = doc.getline(position.line, true);
5827         let { input, col } = context.option;
5828         let character = characterIndex(currline, col);
5829         let before_content = currline.slice(0, character);
5830         let res = [];
5831         let contextPrefixes = [];
5832         for (let snip of snippets) {
5833             let contentBehind = before_content;
5834             if (contextPrefixes.indexOf(snip.prefix) !== -1)
5835                 continue;
5836             if (snip.regex != null && snip.prefix == '')
5837                 continue;
5838             if (snip.context) {
5839                 let provider = this.providers.get(snip.provider);
5840                 let valid = await provider.checkContext(snip.context);
5841                 if (!valid)
5842                     continue;
5843                 contextPrefixes.push(snip.prefix);
5844             }
5845             let head = this.getPrefixHead(doc, snip.prefix);
5846             if (input.length == 0 && !before_content.endsWith(snip.prefix))
5847                 continue;
5848             let item = {
5849                 label: snip.prefix,
5850                 kind: vscode_languageserver_protocol_1.CompletionItemKind.Snippet,
5851                 filterText: snip.prefix,
5852                 detail: snip.description,
5853                 insertTextFormat: vscode_languageserver_protocol_1.InsertTextFormat.Snippet
5854             };
5855             item.data = {
5856                 snip,
5857                 provider: snip.provider,
5858                 filepath: `${path_1.default.basename(snip.filepath)}:${snip.lnum}`
5859             };
5860             if (snip.regex) {
5861                 if (!input.length || snip.prefix && input[0] != snip.prefix[0])
5862                     continue;
5863                 let content = before_content + snip.prefix;
5864                 let ms = content.match(snip.regex);
5865                 if (!ms)
5866                     continue;
5867             }
5868             else if (head && before_content.endsWith(head)) {
5869                 contentBehind = before_content.slice(0, -head.length);
5870                 let prefix = snip.prefix.slice(head.length);
5871                 Object.assign(item, {
5872                     textEdit: {
5873                         range: vscode_languageserver_protocol_1.Range.create({ line: position.line, character: character - head.length }, position),
5874                         newText: prefix
5875                     }
5876                 });
5877             }
5878             else if (input.length == 0) {
5879                 let { prefix } = snip;
5880                 contentBehind = before_content.slice(0, -prefix.length);
5881                 Object.assign(item, {
5882                     preselect: true,
5883                     textEdit: {
5884                         range: vscode_languageserver_protocol_1.Range.create({ line: position.line, character: character - prefix.length }, position),
5885                         newText: prefix
5886                     }
5887                 });
5888             }
5889             if (snip.triggerKind == types_1.TriggerKind.LineBegin && contentBehind.trim().length)
5890                 continue;
5891             if (snip.triggerKind == types_1.TriggerKind.SpaceBefore) {
5892                 if (contentBehind.length && !/\s/.test(contentBehind[contentBehind.length - 1])) {
5893                     continue;
5894                 }
5895             }
5896             if (!item.textEdit) {
5897                 item.textEdit = {
5898                     range: vscode_languageserver_protocol_1.Range.create({ line: position.line, character }, position),
5899                     newText: item.label
5900                 };
5901             }
5902             item.data.location = `${snip.filepath}:${snip.lnum}`;
5903             item.data.line = contentBehind + snip.prefix;
5904             res.push(item);
5905         }
5906         return res;
5907     }
5908     async resolveCompletionItem(item) {
5909         let provider = this.providers.get(item.data.provider);
5910         if (provider) {
5911             let filetype = await coc_nvim_1.workspace.nvim.eval('&filetype');
5912             let insertSnippet = await provider.resolveSnippetBody(item.data.snip, item.textEdit.range, item.data.line);
5913             item.textEdit.newText = insertSnippet;
5914             if (coc_nvim_1.snippetManager) {
5915                 let snip = await Promise.resolve(coc_nvim_1.snippetManager.resolveSnippet(insertSnippet));
5916                 item.documentation = {
5917                     kind: 'markdown',
5918                     value: util_1.markdownBlock(snip.toString(), filetype)
5919                 };
5920             }
5921         }
5922         return item;
5923     }
5924     getPrefixHead(doc, prefix) {
5925         let res = 0;
5926         for (let idx = prefix.length - 1; idx >= 0; idx--) {
5927             if (!doc.isWord(prefix[idx])) {
5928                 res = idx;
5929                 break;
5930             }
5931         }
5932         return res == 0 ? '' : prefix.slice(0, res + 1);
5933     }
5934 }
5935 exports.ProviderManager = ProviderManager;
5936 function characterIndex(content, byteIndex) {
5937     let buf = Buffer.from(content, 'utf8');
5938     return buf.slice(0, byteIndex).toString('utf8').length;
5939 }
5940 exports.characterIndex = characterIndex;
5941
5942
5943 /***/ }),
5944 /* 36 */
5945 /***/ (function(module, exports, __webpack_require__) {
5946
5947 "use strict";
5948
5949 Object.defineProperty(exports, "__esModule", { value: true });
5950 var TriggerKind;
5951 (function (TriggerKind) {
5952     TriggerKind[TriggerKind["SpaceBefore"] = 0] = "SpaceBefore";
5953     TriggerKind[TriggerKind["LineBegin"] = 1] = "LineBegin";
5954     TriggerKind[TriggerKind["WordBoundary"] = 2] = "WordBoundary";
5955     TriggerKind[TriggerKind["InWord"] = 3] = "InWord";
5956 })(TriggerKind = exports.TriggerKind || (exports.TriggerKind = {}));
5957
5958
5959 /***/ }),
5960 /* 37 */
5961 /***/ (function(module, exports, __webpack_require__) {
5962
5963 "use strict";
5964
5965 var __importDefault = (this && this.__importDefault) || function (mod) {
5966     return (mod && mod.__esModule) ? mod : { "default": mod };
5967 };
5968 Object.defineProperty(exports, "__esModule", { value: true });
5969 /******************************************************************
5970 MIT License http://www.opensource.org/licenses/mit-license.php
5971 Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
5972 *******************************************************************/
5973 const pify_1 = __importDefault(__webpack_require__(38));
5974 const fs_1 = __importDefault(__webpack_require__(3));
5975 const crypto_1 = __importDefault(__webpack_require__(18));
5976 const BASE64 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_';
5977 function tostr(bytes) {
5978     let r = [];
5979     let i;
5980     for (i = 0; i < bytes.length; i++) {
5981         r.push(BASE64[bytes[i] % 64]);
5982     }
5983     return r.join('');
5984 }
5985 function uid() {
5986     return tostr(crypto_1.default.randomBytes(10));
5987 }
5988 exports.uid = uid;
5989 function replaceText(content, items) {
5990     let res = '';
5991     items.sort((a, b) => a.index - b.index);
5992     let item = items.shift();
5993     for (let i = 0; i < content.length; i++) {
5994         let idx = item ? item.index : null;
5995         if (idx == null || i != idx) {
5996             res = res + content[i];
5997             continue;
5998         }
5999         res = res + item.newText;
6000         i = i + item.length;
6001     }
6002     return res;
6003 }
6004 exports.replaceText = replaceText;
6005 function flatten(arr) {
6006     return arr.reduce((p, curr) => p.concat(curr), []);
6007 }
6008 exports.flatten = flatten;
6009 async function statAsync(filepath) {
6010     try {
6011         return await pify_1.default(fs_1.default.stat)(filepath);
6012     }
6013     catch (e) {
6014         return null;
6015     }
6016 }
6017 exports.statAsync = statAsync;
6018 async function writeFileAsync(fullpath, content) {
6019     await pify_1.default(fs_1.default.writeFile)(fullpath, content, 'utf8');
6020 }
6021 exports.writeFileAsync = writeFileAsync;
6022 async function readFileAsync(fullpath, encoding = 'utf8') {
6023     return await pify_1.default(fs_1.default.readFile)(fullpath, encoding);
6024 }
6025 exports.readFileAsync = readFileAsync;
6026 async function readdirAsync(filepath) {
6027     try {
6028         return await pify_1.default(fs_1.default.readdir)(filepath);
6029     }
6030     catch (e) {
6031         return null;
6032     }
6033 }
6034 exports.readdirAsync = readdirAsync;
6035 function headTail(line) {
6036     line = line.trim();
6037     let ms = line.match(/^(\S+)\s+(.*)/);
6038     if (!ms)
6039         return [line, ''];
6040     return [ms[1], ms[2]];
6041 }
6042 exports.headTail = headTail;
6043 function memorize(_target, key, descriptor) {
6044     let fn = descriptor.get;
6045     if (typeof fn !== 'function')
6046         return;
6047     let memoKey = '$' + key;
6048     descriptor.get = function (...args) {
6049         if (this.hasOwnProperty(memoKey))
6050             return Promise.resolve(this[memoKey]);
6051         return new Promise((resolve, reject) => {
6052             Promise.resolve(fn.apply(this, args)).then(res => {
6053                 this[memoKey] = res;
6054                 resolve(res);
6055             }, e => {
6056                 reject(e);
6057             });
6058         });
6059     };
6060 }
6061 exports.memorize = memorize;
6062 function trimQuote(str) {
6063     if (str.startsWith('"') || str.startsWith("'"))
6064         return str.slice(1, -1);
6065     return str;
6066 }
6067 exports.trimQuote = trimQuote;
6068 function distinct(array, keyFn) {
6069     if (!keyFn) {
6070         return array.filter((element, position) => {
6071             return array.indexOf(element) === position;
6072         });
6073     }
6074     const seen = Object.create(null);
6075     return array.filter(elem => {
6076         const key = keyFn(elem);
6077         if (seen[key]) {
6078             return false;
6079         }
6080         seen[key] = true;
6081         return true;
6082     });
6083 }
6084 exports.distinct = distinct;
6085 const conditionRe = /\(\?\(\?:\w+\).+\|/;
6086 const bellRe = /\\a/;
6087 const commentRe = /\(\?#.*?\)/;
6088 const stringStartRe = /\\A/;
6089 const namedCaptureRe = /\(\?P<\w+>.*?\)/;
6090 const namedReferenceRe = /\(\?P=(\w+)\)/;
6091 const braceRe = /\^\]/;
6092 const regex = new RegExp(`${bellRe.source}|${commentRe.source}|${stringStartRe.source}|${namedCaptureRe.source}|${namedReferenceRe.source}|${braceRe}`, 'g');
6093 /**
6094  * Convert python regex to javascript regex,
6095  * throw error when unsupported pattern found
6096  *
6097  * @public
6098  * @param {string} str
6099  * @returns {string}
6100  */
6101 function convertRegex(str) {
6102     if (str.indexOf('\\z') !== -1) {
6103         throw new Error('pattern \\z not supported');
6104     }
6105     if (str.indexOf('(?s)') !== -1) {
6106         throw new Error('pattern (?s) not supported');
6107     }
6108     if (str.indexOf('(?x)') !== -1) {
6109         throw new Error('pattern (?x) not supported');
6110     }
6111     if (str.indexOf('\n') !== -1) {
6112         throw new Error('multiple line pattern not supported');
6113     }
6114     if (conditionRe.test(str)) {
6115         throw new Error('condition pattern not supported');
6116     }
6117     return str.replace(regex, (match, p1) => {
6118         if (match == '^]')
6119             return '^\\]';
6120         if (match == '\\a')
6121             return '';
6122         if (match.startsWith('(?#'))
6123             return '';
6124         if (match == '\\A')
6125             return '^';
6126         if (match.startsWith('(?P<'))
6127             return '(?' + match.slice(3);
6128         if (match.startsWith('(?P='))
6129             return `\\k<${p1}>`;
6130         return '';
6131     });
6132 }
6133 exports.convertRegex = convertRegex;
6134 function wait(ms) {
6135     return new Promise(resolve => {
6136         setTimeout(() => {
6137             resolve();
6138         }, ms);
6139     });
6140 }
6141 exports.wait = wait;
6142 function getRegexText(prefix) {
6143     if (prefix.startsWith('^'))
6144         prefix = prefix.slice(1);
6145     if (prefix.endsWith('$'))
6146         prefix = prefix.slice(0, -1);
6147     let content = prefix.replace(/\(.*\)\??/g, '');
6148     content = content.replace(/\\/g, '');
6149     return content;
6150 }
6151 exports.getRegexText = getRegexText;
6152 function markdownBlock(code, filetype) {
6153     filetype = filetype == 'javascriptreact' ? 'javascript' : filetype;
6154     filetype = filetype == 'typescriptreact' ? 'typescript' : filetype;
6155     return '``` ' + filetype + '\n' + code + '\n```';
6156 }
6157 exports.markdownBlock = markdownBlock;
6158
6159
6160 /***/ }),
6161 /* 38 */
6162 /***/ (function(module, exports, __webpack_require__) {
6163
6164 "use strict";
6165
6166
6167 const processFn = (fn, options, proxy, unwrapped) => function (...arguments_) {
6168         const P = options.promiseModule;
6169
6170         return new P((resolve, reject) => {
6171                 if (options.multiArgs) {
6172                         arguments_.push((...result) => {
6173                                 if (options.errorFirst) {
6174                                         if (result[0]) {
6175                                                 reject(result);
6176                                         } else {
6177                                                 result.shift();
6178                                                 resolve(result);
6179                                         }
6180                                 } else {
6181                                         resolve(result);
6182                                 }
6183                         });
6184                 } else if (options.errorFirst) {
6185                         arguments_.push((error, result) => {
6186                                 if (error) {
6187                                         reject(error);
6188                                 } else {
6189                                         resolve(result);
6190                                 }
6191                         });
6192                 } else {
6193                         arguments_.push(resolve);
6194                 }
6195
6196                 const self = this === proxy ? unwrapped : this;
6197                 Reflect.apply(fn, self, arguments_);
6198         });
6199 };
6200
6201 const filterCache = new WeakMap();
6202
6203 module.exports = (input, options) => {
6204         options = {
6205                 exclude: [/.+(?:Sync|Stream)$/],
6206                 errorFirst: true,
6207                 promiseModule: Promise,
6208                 ...options
6209         };
6210
6211         const objectType = typeof input;
6212         if (!(input !== null && (objectType === 'object' || objectType === 'function'))) {
6213                 throw new TypeError(`Expected \`input\` to be a \`Function\` or \`Object\`, got \`${input === null ? 'null' : objectType}\``);
6214         }
6215
6216         const filter = (target, key) => {
6217                 let cached = filterCache.get(target);
6218
6219                 if (!cached) {
6220                         cached = {};
6221                         filterCache.set(target, cached);
6222                 }
6223
6224                 if (key in cached) {
6225                         return cached[key];
6226                 }
6227
6228                 const match = pattern => (typeof pattern === 'string' || typeof key === 'symbol') ? key === pattern : pattern.test(key);
6229                 const desc = Reflect.getOwnPropertyDescriptor(target, key);
6230                 const writableOrConfigurableOwn = (desc === undefined || desc.writable || desc.configurable);
6231                 const included = options.include ? options.include.some(match) : !options.exclude.some(match);
6232                 const shouldFilter = included && writableOrConfigurableOwn;
6233                 cached[key] = shouldFilter;
6234                 return shouldFilter;
6235         };
6236
6237         const cache = new WeakMap();
6238
6239         const proxy = new Proxy(input, {
6240                 apply(target, thisArg, args) {
6241                         const cached = cache.get(target);
6242
6243                         if (cached) {
6244                                 return Reflect.apply(cached, thisArg, args);
6245                         }
6246
6247                         const pified = options.excludeMain ? target : processFn(target, options, proxy, target);
6248                         cache.set(target, pified);
6249                         return Reflect.apply(pified, thisArg, args);
6250                 },
6251
6252                 get(target, key) {
6253                         const property = target[key];
6254
6255                         // eslint-disable-next-line no-use-extend-native/no-use-extend-native
6256                         if (!filter(target, key) || property === Function.prototype[key]) {
6257                                 return property;
6258                         }
6259
6260                         const cached = cache.get(property);
6261
6262                         if (cached) {
6263                                 return cached;
6264                         }
6265
6266                         if (typeof property === 'function') {
6267                                 const pified = processFn(property, options, proxy, target);
6268                                 cache.set(property, pified);
6269                                 return pified;
6270                         }
6271
6272                         return property;
6273                 }
6274         });
6275
6276         return proxy;
6277 };
6278
6279
6280 /***/ }),
6281 /* 39 */
6282 /***/ (function(module, exports, __webpack_require__) {
6283
6284 "use strict";
6285
6286 var __importDefault = (this && this.__importDefault) || function (mod) {
6287     return (mod && mod.__esModule) ? mod : { "default": mod };
6288 };
6289 Object.defineProperty(exports, "__esModule", { value: true });
6290 /******************************************************************
6291 MIT License http://www.opensource.org/licenses/mit-license.php
6292 Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
6293 *******************************************************************/
6294 const coc_nvim_1 = __webpack_require__(1);
6295 const fs_1 = __importDefault(__webpack_require__(3));
6296 const path_1 = __importDefault(__webpack_require__(4));
6297 const readline_1 = __importDefault(__webpack_require__(40));
6298 const vscode_languageserver_types_1 = __webpack_require__(6);
6299 const baseProvider_1 = __importDefault(__webpack_require__(41));
6300 const types_1 = __webpack_require__(36);
6301 const util_1 = __webpack_require__(37);
6302 const parser_1 = __importDefault(__webpack_require__(42));
6303 class SnipmateProvider extends baseProvider_1.default {
6304     constructor(channel, trace, config) {
6305         super(config);
6306         this.channel = channel;
6307         this.trace = trace;
6308         this.snippetFiles = [];
6309         this.disposables = [];
6310         coc_nvim_1.workspace.onDidSaveTextDocument(async (doc) => {
6311             let uri = coc_nvim_1.Uri.parse(doc.uri);
6312             if (uri.scheme != 'file')
6313                 return;
6314             let filepath = uri.fsPath;
6315             if (!fs_1.default.existsSync(filepath))
6316                 return;
6317             let snippetFile = this.snippetFiles.find(s => s.filepath == filepath);
6318             if (snippetFile)
6319                 await this.loadSnippetsFromFile(snippetFile.filetype, snippetFile.directory, filepath);
6320         }, null, this.disposables);
6321     }
6322     async init() {
6323         let arr = await this.getAllSnippetFiles();
6324         let { nvim } = coc_nvim_1.workspace;
6325         let author = await nvim.getVar('snips_author');
6326         if (!author)
6327             await nvim.setVar('snips_author', this.config.author);
6328         await Promise.all(arr.map(({ filepath, directory, filetype }) => {
6329             return this.loadSnippetsFromFile(filetype, directory, filepath);
6330         }));
6331     }
6332     async loadSnippetsFromFile(filetype, directory, filepath) {
6333         let snippets = await this.parseSnippetsFile(filepath);
6334         let idx = this.snippetFiles.findIndex(o => o.filepath == filepath);
6335         if (idx !== -1)
6336             this.snippetFiles.splice(idx, 1);
6337         this.snippetFiles.push({
6338             directory,
6339             filepath,
6340             filetype,
6341             snippets
6342         });
6343         if (this.trace == 'verbose') {
6344             this.channel.appendLine(`[Info ${(new Date()).toLocaleTimeString()}] Loaded ${snippets.length} snippets from: ${filepath}`);
6345         }
6346     }
6347     /**
6348      * Resolve snippet body to inserted text.
6349      *
6350      * @public
6351      * @param {Snippet} snippet
6352      * @param {Range} _range
6353      * @param {string} _line
6354      * @returns {Promise<string>}
6355      */
6356     async resolveSnippetBody(snippet, _range, _line) {
6357         let parser = new parser_1.default(snippet.body);
6358         let resolved = '';
6359         let { nvim } = coc_nvim_1.workspace;
6360         while (!parser.eof()) {
6361             if (parser.curr == '`') {
6362                 let idx = parser.nextIndex('`', true, false);
6363                 if (idx == -1) {
6364                     resolved = resolved + parser.eatTo(parser.len);
6365                     break;
6366                 }
6367                 let code = parser.eatTo(idx + 1);
6368                 code = code.slice(1, -1);
6369                 if (code.startsWith('Filename')) {
6370                     resolved = resolved + await nvim.call('expand', '%:p:t');
6371                 }
6372                 else {
6373                     try {
6374                         resolved = resolved + await nvim.eval(code);
6375                     }
6376                     catch (e) {
6377                         this.channel.appendLine(`[Error ${(new Date()).toLocaleTimeString()}] Error on eval: ${code}`);
6378                     }
6379                 }
6380                 continue;
6381             }
6382             parser.iterate(ch => {
6383                 if (ch == '`') {
6384                     return false;
6385                 }
6386                 else {
6387                     resolved = resolved + ch;
6388                 }
6389                 return true;
6390             });
6391         }
6392         return resolved;
6393     }
6394     /**
6395      * Parse snippets from snippets file.
6396      *
6397      * @public
6398      * @param {string} filepath
6399      * @returns {Promise<Snippet[]>}
6400      */
6401     parseSnippetsFile(filepath) {
6402         let res = [];
6403         const rl = readline_1.default.createInterface({
6404             input: fs_1.default.createReadStream(filepath, 'utf8'),
6405             crlfDelay: Infinity
6406         });
6407         let lnum = 0;
6408         let lines = [];
6409         let prefix = '';
6410         let description = '';
6411         rl.on('line', line => {
6412             lnum += 1;
6413             if (line.startsWith('#'))
6414                 return;
6415             if (line.startsWith('snippet')) {
6416                 line = line.replace(/\s*$/, '');
6417                 if (lines.length && prefix) {
6418                     res.push({
6419                         filepath,
6420                         lnum: lnum - lines.length - 1,
6421                         body: lines.join('\n').replace(/\s+$/, ''),
6422                         prefix,
6423                         description,
6424                         triggerKind: types_1.TriggerKind.SpaceBefore
6425                     });
6426                     lines = [];
6427                 }
6428                 let ms = line.match(/^snippet\s+(\S+)(?:\s(.+))?$/);
6429                 if (!ms) {
6430                     prefix = '';
6431                     this.channel.appendLine(`[Error ${(new Date()).toLocaleTimeString()}] Broken line on ${filepath}:${lnum}`);
6432                     return;
6433                 }
6434                 prefix = ms[1];
6435                 description = ms[2] || '';
6436                 return;
6437             }
6438             if (prefix) {
6439                 if (line.indexOf('VISUAL') !== -1) {
6440                     line = line.replace(/\$(\{?)VISUAL\b(:[^\}])?(\}?)/g, '$$$1TM_SELECTED_TEXT$2$3');
6441                 }
6442                 if (line.startsWith('\t')) {
6443                     lines.push(line.slice(1));
6444                 }
6445                 else {
6446                     lines.push(line);
6447                 }
6448             }
6449         });
6450         return new Promise(resolve => {
6451             rl.on('close', async () => {
6452                 if (lines.length) {
6453                     res.push({
6454                         filepath,
6455                         lnum: lnum - lines.length - 1,
6456                         body: lines.join('\n'),
6457                         prefix,
6458                         description,
6459                         triggerKind: types_1.TriggerKind.SpaceBefore
6460                     });
6461                 }
6462                 resolve(res);
6463             });
6464         });
6465     }
6466     async getTriggerSnippets(document, position, autoTrigger) {
6467         if (autoTrigger)
6468             return [];
6469         let snippets = await this.getSnippets(document.filetype);
6470         let line = document.getline(position.line);
6471         line = line.slice(0, position.character);
6472         if (!line || line[line.length - 1] == ' ')
6473             return [];
6474         snippets = snippets.filter(s => {
6475             let { prefix } = s;
6476             if (!line.endsWith(prefix))
6477                 return false;
6478             let pre = line.slice(0, line.length - prefix.length);
6479             return pre.length == 0 || /\s/.test(pre[pre.length - 1]);
6480         });
6481         let edits = [];
6482         for (let s of snippets) {
6483             let character = position.character - s.prefix.length;
6484             let range = vscode_languageserver_types_1.Range.create(position.line, character, position.line, position.character);
6485             let newText = await this.resolveSnippetBody(s, range, line);
6486             edits.push({
6487                 prefix: s.prefix,
6488                 description: s.description,
6489                 location: s.filepath,
6490                 range,
6491                 newText,
6492                 priority: -1
6493             });
6494         }
6495         return edits;
6496     }
6497     async getSnippetFiles(filetype) {
6498         let filetypes = this.getFiletypes(filetype);
6499         let res = [];
6500         for (let s of this.snippetFiles) {
6501             if (filetypes.indexOf(s.filetype) !== -1) {
6502                 res.push(s.filepath);
6503             }
6504         }
6505         return res;
6506     }
6507     async getSnippets(filetype) {
6508         let filetypes = this.getFiletypes(filetype);
6509         filetypes.push('_');
6510         let snippetFiles = this.snippetFiles.filter(o => filetypes.indexOf(o.filetype) !== -1);
6511         let result = [];
6512         snippetFiles.sort((a, b) => {
6513             if (a.filetype == b.filetype)
6514                 return 1;
6515             if (a.filetype == filetype)
6516                 return -1;
6517             return 1;
6518         });
6519         for (let file of snippetFiles) {
6520             let { snippets } = file;
6521             for (let snip of snippets) {
6522                 result.push(snip);
6523             }
6524         }
6525         return result;
6526     }
6527     async getAllSnippetFiles() {
6528         let { nvim } = coc_nvim_1.workspace;
6529         let opt = await nvim.eval('&rtp');
6530         let rtps = opt.split(',');
6531         let res = [];
6532         for (let rtp of rtps) {
6533             let items = await this.getSnippetFileItems(path_1.default.join(rtp, 'snippets'));
6534             res.push(...items);
6535         }
6536         return res;
6537     }
6538     async getSnippetFileItems(directory) {
6539         let res = [];
6540         let stat = await util_1.statAsync(directory);
6541         if (stat && stat.isDirectory()) {
6542             let files = await util_1.readdirAsync(directory);
6543             if (files.length) {
6544                 for (let f of files) {
6545                     let file = path_1.default.join(directory, f);
6546                     if (file.endsWith('.snippets')) {
6547                         let basename = path_1.default.basename(f, '.snippets');
6548                         let filetype = basename.split('-', 2)[0];
6549                         res.push({ filepath: file, directory, filetype });
6550                     }
6551                     else {
6552                         let stat = await util_1.statAsync(file);
6553                         if (stat && stat.isDirectory()) {
6554                             let files = await util_1.readdirAsync(file);
6555                             for (let filename of files) {
6556                                 if (filename.endsWith('.snippets')) {
6557                                     res.push({ filepath: path_1.default.join(file, filename), directory, filetype: f });
6558                                 }
6559                             }
6560                         }
6561                     }
6562                 }
6563             }
6564         }
6565         return res;
6566     }
6567 }
6568 exports.SnipmateProvider = SnipmateProvider;
6569
6570
6571 /***/ }),
6572 /* 40 */
6573 /***/ (function(module, exports) {
6574
6575 module.exports = require("readline");
6576
6577 /***/ }),
6578 /* 41 */
6579 /***/ (function(module, exports, __webpack_require__) {
6580
6581 "use strict";
6582
6583 Object.defineProperty(exports, "__esModule", { value: true });
6584 const coc_nvim_1 = __webpack_require__(1);
6585 const util_1 = __webpack_require__(37);
6586 class BaseProvider {
6587     constructor(config) {
6588         this.config = config;
6589     }
6590     async checkContext(_context) {
6591         return true;
6592     }
6593     getExtendsFiletypes(filetype, exists = new Set()) {
6594         if (exists.has(filetype))
6595             return [];
6596         let extend = this.config.extends ? this.config.extends[filetype] : null;
6597         exists.add(filetype);
6598         if (!extend || extend.length == 0)
6599             return [];
6600         return extend.reduce((arr, curr) => {
6601             return arr.concat([curr], this.getExtendsFiletypes(curr, exists));
6602         }, []);
6603     }
6604     getFiletypes(filetype) {
6605         let filetypes = [filetype];
6606         if (filetype.indexOf('.') !== -1) {
6607             filetypes.push(...filetype.split('.'));
6608         }
6609         if (filetype == 'javascript.jsx')
6610             filetypes.push('javascriptreact');
6611         if (filetype == 'typescript.jsx' || filetype == 'typescript.tsx')
6612             filetypes.push('typescriptreact');
6613         let map = coc_nvim_1.workspace.env.filetypeMap;
6614         if (map && map[filetype]) {
6615             filetypes.push(map[filetype]);
6616         }
6617         let extendFiletypes = filetypes.reduce((arr, curr) => {
6618             return arr.concat(this.getExtendsFiletypes(curr));
6619         }, []);
6620         filetypes.push(...extendFiletypes);
6621         filetypes.reverse();
6622         return util_1.distinct(filetypes);
6623     }
6624 }
6625 exports.default = BaseProvider;
6626
6627
6628 /***/ }),
6629 /* 42 */
6630 /***/ (function(module, exports, __webpack_require__) {
6631
6632 "use strict";
6633
6634 /******************************************************************
6635 MIT License http://www.opensource.org/licenses/mit-license.php
6636 Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
6637 *******************************************************************/
6638 Object.defineProperty(exports, "__esModule", { value: true });
6639 /**
6640  * A very basic parser
6641  *
6642  * @public
6643  */
6644 class Parser {
6645     constructor(_content) {
6646         this._content = _content;
6647         this._curr = 0;
6648     }
6649     eof() {
6650         return this._curr >= this._content.length;
6651     }
6652     skipSpaces() {
6653         for (let i = this._curr; i <= this._content.length; i++) {
6654             let ch = this._content[i];
6655             if (!ch || /\S/.test(ch)) {
6656                 this._curr = i;
6657                 break;
6658             }
6659         }
6660     }
6661     get index() {
6662         return this._curr;
6663     }
6664     get curr() {
6665         return this._content[this._curr] || '';
6666     }
6667     get len() {
6668         return this._content.length;
6669     }
6670     next(count = 1) {
6671         return this._content.slice(this._curr + 1, this._curr + 1 + count);
6672     }
6673     nextIndex(character, checkEscape = true, allowEnd = true) {
6674         if (this._curr >= this.len - 1)
6675             return allowEnd ? this.len - 1 : -1;
6676         let i = this._curr + 1;
6677         let pre = this.curr || '';
6678         while (i != this.len - 1) {
6679             let ch = this._content[i];
6680             if (ch == character && (!checkEscape || pre !== '\\')) {
6681                 break;
6682             }
6683             pre = ch;
6684             i = i + 1;
6685         }
6686         if (!allowEnd && i == this.len - 1 && character != this._content[i]) {
6687             return -1;
6688         }
6689         return i;
6690     }
6691     prev() {
6692         return this._content[this._curr - 1] || '';
6693     }
6694     iterate(fn) {
6695         while (this._curr < this._content.length) {
6696             let fine = fn(this.curr, this._curr);
6697             if (fine === false) {
6698                 break;
6699             }
6700             this._curr = this._curr + 1;
6701         }
6702     }
6703     eat(count) {
6704         let end = this._curr + count;
6705         end = Math.min(end, this.len);
6706         let str = this._content.slice(this._curr, end);
6707         this._curr = end;
6708         return str;
6709     }
6710     // make curr to index, return contnet between curr (inclusive) and index (exclusive)
6711     eatTo(index) {
6712         if (index == this._curr)
6713             return '';
6714         let str = this._content.slice(this._curr, index);
6715         this._curr = index;
6716         return str;
6717     }
6718 }
6719 exports.default = Parser;
6720
6721
6722 /***/ }),
6723 /* 43 */
6724 /***/ (function(module, exports, __webpack_require__) {
6725
6726 "use strict";
6727
6728 var __importDefault = (this && this.__importDefault) || function (mod) {
6729     return (mod && mod.__esModule) ? mod : { "default": mod };
6730 };
6731 Object.defineProperty(exports, "__esModule", { value: true });
6732 const coc_nvim_1 = __webpack_require__(1);
6733 const fs_1 = __importDefault(__webpack_require__(3));
6734 const jsonc_parser_1 = __webpack_require__(44);
6735 const os_1 = __importDefault(__webpack_require__(2));
6736 const path_1 = __importDefault(__webpack_require__(4));
6737 const util_1 = __importDefault(__webpack_require__(5));
6738 const vscode_languageserver_types_1 = __webpack_require__(6);
6739 const baseProvider_1 = __importDefault(__webpack_require__(41));
6740 const types_1 = __webpack_require__(36);
6741 const util_2 = __webpack_require__(37);
6742 class TextmateProvider extends baseProvider_1.default {
6743     constructor(channel, trace, config) {
6744         super(config);
6745         this.channel = channel;
6746         this.trace = trace;
6747         this._snippetCache = {};
6748         this._userSnippets = {};
6749         if (config.loadFromExtensions) {
6750             coc_nvim_1.extensions.onDidLoadExtension(extension => {
6751                 this.loadSnippetsFromExtension(extension).catch(e => {
6752                     channel.appendLine(`[Error] ${e.message}`);
6753                 });
6754             });
6755             coc_nvim_1.extensions.onDidUnloadExtension(id => {
6756                 delete this._snippetCache[id];
6757             });
6758         }
6759     }
6760     async init() {
6761         if (this.config.loadFromExtensions) {
6762             for (let extension of coc_nvim_1.extensions.all) {
6763                 await this.loadSnippetsFromExtension(extension);
6764             }
6765         }
6766         let paths = this.config.snippetsRoots;
6767         if (paths && paths.length) {
6768             for (let dir of paths) {
6769                 await this.loadSnippetsFromRoot(dir);
6770             }
6771         }
6772     }
6773     async getSnippetFiles(filetype) {
6774         let filetypes = this.getFiletypes(filetype);
6775         let filepaths = [];
6776         if (this.config.loadFromExtensions) {
6777             for (let key of Object.keys(this._snippetCache)) {
6778                 let cache = this._snippetCache[key];
6779                 for (let filetype of filetypes) {
6780                     let snippets = cache[filetype];
6781                     if (snippets && snippets.length) {
6782                         filepaths.push(snippets[0].filepath);
6783                     }
6784                 }
6785             }
6786         }
6787         for (let filetype of filetypes) {
6788             let snippets = this._userSnippets[filetype];
6789             if (snippets && snippets.length) {
6790                 for (let snip of snippets) {
6791                     let { filepath } = snip;
6792                     if (filepaths.indexOf(filepath) == -1) {
6793                         filepaths.push(filepath);
6794                     }
6795                 }
6796             }
6797         }
6798         return util_2.distinct(filepaths);
6799     }
6800     async getTriggerSnippets(document, position, autoTrigger) {
6801         if (autoTrigger)
6802             return [];
6803         let line = document.getline(position.line);
6804         line = line.slice(0, position.character);
6805         let snippets = await this.getSnippets(document.filetype);
6806         if (!snippets || !snippets.length)
6807             return [];
6808         let edits = [];
6809         for (let snip of snippets) {
6810             let { prefix } = snip;
6811             if (!line.endsWith(prefix))
6812                 continue;
6813             let pre = line.slice(0, line.length - prefix.length);
6814             // not allowed after word
6815             if (pre.length && /\w/.test(pre[pre.length - 1]))
6816                 continue;
6817             edits.push({
6818                 prefix,
6819                 range: vscode_languageserver_types_1.Range.create(position.line, position.character - prefix.length, position.line, position.character),
6820                 newText: snip.body,
6821                 location: snip.filepath,
6822                 description: snip.description,
6823                 priority: -1
6824             });
6825         }
6826         return edits;
6827     }
6828     async getSnippets(filetype) {
6829         let res = [];
6830         let filetypes = this.getFiletypes(filetype);
6831         let added = new Set();
6832         for (let key of Object.keys(this._snippetCache)) {
6833             let cache = this._snippetCache[key];
6834             for (let filetype of filetypes) {
6835                 let snippets = cache[filetype];
6836                 if (snippets) {
6837                     for (let snip of snippets) {
6838                         if (!added.has(snip.prefix)) {
6839                             added.add(snip.prefix);
6840                             res.push(snip);
6841                         }
6842                     }
6843                 }
6844             }
6845         }
6846         for (let filetype of filetypes) {
6847             let snippets = this._userSnippets[filetype];
6848             if (snippets && snippets.length) {
6849                 for (let snip of snippets) {
6850                     if (!added.has(snip.prefix)) {
6851                         added.add(snip.prefix);
6852                         res.push(snip);
6853                     }
6854                 }
6855             }
6856         }
6857         return res;
6858     }
6859     async resolveSnippetBody(snip, _range) {
6860         return snip.body;
6861     }
6862     async loadSnippetsFromExtension(extension) {
6863         let { packageJSON } = extension;
6864         if (packageJSON.contributes && packageJSON.contributes.snippets) {
6865             let { snippets } = packageJSON.contributes;
6866             let def = {
6867                 extensionId: extension.id,
6868                 snippets: []
6869             };
6870             for (let item of snippets) {
6871                 let p = path_1.default.join(extension.extensionPath, item.path);
6872                 let { language } = item;
6873                 def.snippets.push({
6874                     languageId: language,
6875                     filepath: p
6876                 });
6877             }
6878             if (snippets && snippets.length) {
6879                 await this.loadSnippetsFromDefinition(def);
6880             }
6881         }
6882     }
6883     async loadSnippetsFromRoot(root) {
6884         let { _userSnippets } = this;
6885         if (root.startsWith('~'))
6886             root = root.replace(/^~/, os_1.default.homedir());
6887         let files = await util_1.default.promisify(fs_1.default.readdir)(root, 'utf8');
6888         files = files.filter(f => f.endsWith('.json') || f.endsWith('.code-snippets'));
6889         await Promise.all(files.map(file => {
6890             file = path_1.default.join(root, file);
6891             let basename = path_1.default.basename(file, '.json');
6892             basename = basename.replace(/\.code-snippets$/, '');
6893             return this.loadSnippetsFromFile(file).then(snippets => {
6894                 _userSnippets[basename] = snippets;
6895             });
6896         }));
6897     }
6898     async loadSnippetsFromDefinition(def) {
6899         let { extensionId, snippets } = def;
6900         let cache = this._snippetCache[extensionId] = {};
6901         for (let item of snippets) {
6902             let { languageId } = item;
6903             if (!fs_1.default.existsSync(item.filepath))
6904                 continue;
6905             let arr = await this.loadSnippetsFromFile(item.filepath);
6906             let exists = cache[languageId] || [];
6907             cache[languageId] = [...exists, ...arr];
6908         }
6909     }
6910     async loadSnippetsFromFile(snippetFilePath) {
6911         const contents = await new Promise((resolve, reject) => {
6912             fs_1.default.readFile(snippetFilePath, "utf8", (err, data) => {
6913                 if (err)
6914                     return reject(err);
6915                 resolve(data);
6916             });
6917         });
6918         const snippets = this.loadSnippetsFromText(snippetFilePath, contents);
6919         if (this.trace == 'verbose') {
6920             this.channel.appendLine(`[Info ${(new Date()).toLocaleDateString()}] Loaded ${snippets.length} snippets from ${snippetFilePath}`);
6921         }
6922         return snippets;
6923     }
6924     loadSnippetsFromText(filepath, contents) {
6925         let snippets = [];
6926         try {
6927             let errors = [];
6928             let snippetObject = jsonc_parser_1.parse(contents, errors, { allowTrailingComma: true });
6929             if (errors.length) {
6930                 this.channel.appendLine(`[Error ${(new Date()).toLocaleDateString()}] parser error: ${errors[0].error}`);
6931             }
6932             if (snippetObject) {
6933                 for (let key of Object.keys(snippetObject)) {
6934                     snippets.push(snippetObject[key]);
6935                 }
6936             }
6937         }
6938         catch (ex) {
6939             this.channel.appendLine(`[Error ${(new Date()).toLocaleDateString()}] ${ex.stack}`);
6940             snippets = [];
6941         }
6942         const normalizedSnippets = snippets.map((snip) => {
6943             let prefix = Array.isArray(snip.prefix) ? snip.prefix[0] : snip.prefix;
6944             return {
6945                 filepath,
6946                 lnum: 0,
6947                 body: typeof snip.body === 'string' ? snip.body : snip.body.join('\n'),
6948                 prefix,
6949                 description: typeof snip.description === 'string' ? snip.description : typeof snip.description !== 'undefined' ? snip.description.join('\n') : '',
6950                 triggerKind: types_1.TriggerKind.WordBoundary
6951             };
6952         });
6953         return normalizedSnippets;
6954     }
6955 }
6956 exports.TextmateProvider = TextmateProvider;
6957
6958
6959 /***/ }),
6960 /* 44 */
6961 /***/ (function(module, __webpack_exports__, __webpack_require__) {
6962
6963 "use strict";
6964 __webpack_require__.r(__webpack_exports__);
6965 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createScanner", function() { return createScanner; });
6966 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getLocation", function() { return getLocation; });
6967 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parse", function() { return parse; });
6968 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseTree", function() { return parseTree; });
6969 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findNodeAtLocation", function() { return findNodeAtLocation; });
6970 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findNodeAtOffset", function() { return findNodeAtOffset; });
6971 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getNodePath", function() { return getNodePath; });
6972 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getNodeValue", function() { return getNodeValue; });
6973 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "visit", function() { return visit; });
6974 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stripComments", function() { return stripComments; });
6975 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "printParseErrorCode", function() { return printParseErrorCode; });
6976 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "format", function() { return format; });
6977 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "modify", function() { return modify; });
6978 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "applyEdits", function() { return applyEdits; });
6979 /* harmony import */ var _impl_format__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(45);
6980 /* harmony import */ var _impl_edit__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(47);
6981 /* harmony import */ var _impl_scanner__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(46);
6982 /* harmony import */ var _impl_parser__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(48);
6983 /*---------------------------------------------------------------------------------------------
6984  *  Copyright (c) Microsoft Corporation. All rights reserved.
6985  *  Licensed under the MIT License. See License.txt in the project root for license information.
6986  *--------------------------------------------------------------------------------------------*/
6987
6988
6989
6990
6991
6992 /**
6993  * Creates a JSON scanner on the given text.
6994  * If ignoreTrivia is set, whitespaces or comments are ignored.
6995  */
6996 var createScanner = _impl_scanner__WEBPACK_IMPORTED_MODULE_2__["createScanner"];
6997 /**
6998  * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
6999  */
7000 var getLocation = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["getLocation"];
7001 /**
7002  * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
7003  * Therefore, always check the errors list to find out if the input was valid.
7004  */
7005 var parse = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["parse"];
7006 /**
7007  * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
7008  */
7009 var parseTree = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["parseTree"];
7010 /**
7011  * Finds the node at the given path in a JSON DOM.
7012  */
7013 var findNodeAtLocation = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["findNodeAtLocation"];
7014 /**
7015  * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
7016  */
7017 var findNodeAtOffset = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["findNodeAtOffset"];
7018 /**
7019  * Gets the JSON path of the given JSON DOM node
7020  */
7021 var getNodePath = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["getNodePath"];
7022 /**
7023  * Evaluates the JavaScript object of the given JSON DOM node
7024  */
7025 var getNodeValue = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["getNodeValue"];
7026 /**
7027  * Parses the given text and invokes the visitor functions for each object, array and literal reached.
7028  */
7029 var visit = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["visit"];
7030 /**
7031  * Takes JSON with JavaScript-style comments and remove
7032  * them. Optionally replaces every none-newline character
7033  * of comments with a replaceCharacter
7034  */
7035 var stripComments = _impl_parser__WEBPACK_IMPORTED_MODULE_3__["stripComments"];
7036 function printParseErrorCode(code) {
7037     switch (code) {
7038         case 1 /* InvalidSymbol */: return 'InvalidSymbol';
7039         case 2 /* InvalidNumberFormat */: return 'InvalidNumberFormat';
7040         case 3 /* PropertyNameExpected */: return 'PropertyNameExpected';
7041         case 4 /* ValueExpected */: return 'ValueExpected';
7042         case 5 /* ColonExpected */: return 'ColonExpected';
7043         case 6 /* CommaExpected */: return 'CommaExpected';
7044         case 7 /* CloseBraceExpected */: return 'CloseBraceExpected';
7045         case 8 /* CloseBracketExpected */: return 'CloseBracketExpected';
7046         case 9 /* EndOfFileExpected */: return 'EndOfFileExpected';
7047         case 10 /* InvalidCommentToken */: return 'InvalidCommentToken';
7048         case 11 /* UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';
7049         case 12 /* UnexpectedEndOfString */: return 'UnexpectedEndOfString';
7050         case 13 /* UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';
7051         case 14 /* InvalidUnicode */: return 'InvalidUnicode';
7052         case 15 /* InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';
7053         case 16 /* InvalidCharacter */: return 'InvalidCharacter';
7054     }
7055     return '<unknown ParseErrorCode>';
7056 }
7057 /**
7058  * Computes the edits needed to format a JSON document.
7059  *
7060  * @param documentText The input text
7061  * @param range The range to format or `undefined` to format the full content
7062  * @param options The formatting options
7063  * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or
7064  * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of
7065  * text in the original document. However, multiple edits can have
7066  * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.
7067  * To apply edits to an input, you can use `applyEdits`.
7068  */
7069 function format(documentText, range, options) {
7070     return _impl_format__WEBPACK_IMPORTED_MODULE_0__["format"](documentText, range, options);
7071 }
7072 /**
7073  * Computes the edits needed to modify a value in the JSON document.
7074  *
7075  * @param documentText The input text
7076  * @param path The path of the value to change. The path represents either to the document root, a property or an array item.
7077  * If the path points to an non-existing property or item, it will be created.
7078  * @param value The new value for the specified property or item. If the value is undefined,
7079  * the property or item will be removed.
7080  * @param options Options
7081  * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or
7082  * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of
7083  * text in the original document. However, multiple edits can have
7084  * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.
7085  * To apply edits to an input, you can use `applyEdits`.
7086  */
7087 function modify(text, path, value, options) {
7088     return _impl_edit__WEBPACK_IMPORTED_MODULE_1__["setProperty"](text, path, value, options.formattingOptions, options.getInsertionIndex);
7089 }
7090 /**
7091  * Applies edits to a input string.
7092  */
7093 function applyEdits(text, edits) {
7094     for (var i = edits.length - 1; i >= 0; i--) {
7095         text = _impl_edit__WEBPACK_IMPORTED_MODULE_1__["applyEdit"](text, edits[i]);
7096     }
7097     return text;
7098 }
7099
7100
7101 /***/ }),
7102 /* 45 */
7103 /***/ (function(module, __webpack_exports__, __webpack_require__) {
7104
7105 "use strict";
7106 __webpack_require__.r(__webpack_exports__);
7107 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "format", function() { return format; });
7108 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isEOL", function() { return isEOL; });
7109 /* harmony import */ var _scanner__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(46);
7110 /*---------------------------------------------------------------------------------------------
7111  *  Copyright (c) Microsoft Corporation. All rights reserved.
7112  *  Licensed under the MIT License. See License.txt in the project root for license information.
7113  *--------------------------------------------------------------------------------------------*/
7114
7115
7116 function format(documentText, range, options) {
7117     var initialIndentLevel;
7118     var formatText;
7119     var formatTextStart;
7120     var rangeStart;
7121     var rangeEnd;
7122     if (range) {
7123         rangeStart = range.offset;
7124         rangeEnd = rangeStart + range.length;
7125         formatTextStart = rangeStart;
7126         while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
7127             formatTextStart--;
7128         }
7129         var endOffset = rangeEnd;
7130         while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
7131             endOffset++;
7132         }
7133         formatText = documentText.substring(formatTextStart, endOffset);
7134         initialIndentLevel = computeIndentLevel(formatText, options);
7135     }
7136     else {
7137         formatText = documentText;
7138         initialIndentLevel = 0;
7139         formatTextStart = 0;
7140         rangeStart = 0;
7141         rangeEnd = documentText.length;
7142     }
7143     var eol = getEOL(options, documentText);
7144     var lineBreak = false;
7145     var indentLevel = 0;
7146     var indentValue;
7147     if (options.insertSpaces) {
7148         indentValue = repeat(' ', options.tabSize || 4);
7149     }
7150     else {
7151         indentValue = '\t';
7152     }
7153     var scanner = Object(_scanner__WEBPACK_IMPORTED_MODULE_0__["createScanner"])(formatText, false);
7154     var hasError = false;
7155     function newLineAndIndent() {
7156         return eol + repeat(indentValue, initialIndentLevel + indentLevel);
7157     }
7158     function scanNext() {
7159         var token = scanner.scan();
7160         lineBreak = false;
7161         while (token === 15 /* Trivia */ || token === 14 /* LineBreakTrivia */) {
7162             lineBreak = lineBreak || (token === 14 /* LineBreakTrivia */);
7163             token = scanner.scan();
7164         }
7165         hasError = token === 16 /* Unknown */ || scanner.getTokenError() !== 0 /* None */;
7166         return token;
7167     }
7168     var editOperations = [];
7169     function addEdit(text, startOffset, endOffset) {
7170         if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
7171             editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
7172         }
7173     }
7174     var firstToken = scanNext();
7175     if (firstToken !== 17 /* EOF */) {
7176         var firstTokenStart = scanner.getTokenOffset() + formatTextStart;
7177         var initialIndent = repeat(indentValue, initialIndentLevel);
7178         addEdit(initialIndent, formatTextStart, firstTokenStart);
7179     }
7180     while (firstToken !== 17 /* EOF */) {
7181         var firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
7182         var secondToken = scanNext();
7183         var replaceContent = '';
7184         while (!lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {
7185             // comments on the same line: keep them on the same line, but ignore them otherwise
7186             var commentTokenStart = scanner.getTokenOffset() + formatTextStart;
7187             addEdit(' ', firstTokenEnd, commentTokenStart);
7188             firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
7189             replaceContent = secondToken === 12 /* LineCommentTrivia */ ? newLineAndIndent() : '';
7190             secondToken = scanNext();
7191         }
7192         if (secondToken === 2 /* CloseBraceToken */) {
7193             if (firstToken !== 1 /* OpenBraceToken */) {
7194                 indentLevel--;
7195                 replaceContent = newLineAndIndent();
7196             }
7197         }
7198         else if (secondToken === 4 /* CloseBracketToken */) {
7199             if (firstToken !== 3 /* OpenBracketToken */) {
7200                 indentLevel--;
7201                 replaceContent = newLineAndIndent();
7202             }
7203         }
7204         else {
7205             switch (firstToken) {
7206                 case 3 /* OpenBracketToken */:
7207                 case 1 /* OpenBraceToken */:
7208                     indentLevel++;
7209                     replaceContent = newLineAndIndent();
7210                     break;
7211                 case 5 /* CommaToken */:
7212                 case 12 /* LineCommentTrivia */:
7213                     replaceContent = newLineAndIndent();
7214                     break;
7215                 case 13 /* BlockCommentTrivia */:
7216                     if (lineBreak) {
7217                         replaceContent = newLineAndIndent();
7218                     }
7219                     else {
7220                         // symbol following comment on the same line: keep on same line, separate with ' '
7221                         replaceContent = ' ';
7222                     }
7223                     break;
7224                 case 6 /* ColonToken */:
7225                     replaceContent = ' ';
7226                     break;
7227                 case 10 /* StringLiteral */:
7228                     if (secondToken === 6 /* ColonToken */) {
7229                         replaceContent = '';
7230                         break;
7231                     }
7232                 // fall through
7233                 case 7 /* NullKeyword */:
7234                 case 8 /* TrueKeyword */:
7235                 case 9 /* FalseKeyword */:
7236                 case 11 /* NumericLiteral */:
7237                 case 2 /* CloseBraceToken */:
7238                 case 4 /* CloseBracketToken */:
7239                     if (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */) {
7240                         replaceContent = ' ';
7241                     }
7242                     else if (secondToken !== 5 /* CommaToken */ && secondToken !== 17 /* EOF */) {
7243                         hasError = true;
7244                     }
7245                     break;
7246                 case 16 /* Unknown */:
7247                     hasError = true;
7248                     break;
7249             }
7250             if (lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {
7251                 replaceContent = newLineAndIndent();
7252             }
7253         }
7254         var secondTokenStart = scanner.getTokenOffset() + formatTextStart;
7255         addEdit(replaceContent, firstTokenEnd, secondTokenStart);
7256         firstToken = secondToken;
7257     }
7258     return editOperations;
7259 }
7260 function repeat(s, count) {
7261     var result = '';
7262     for (var i = 0; i < count; i++) {
7263         result += s;
7264     }
7265     return result;
7266 }
7267 function computeIndentLevel(content, options) {
7268     var i = 0;
7269     var nChars = 0;
7270     var tabSize = options.tabSize || 4;
7271     while (i < content.length) {
7272         var ch = content.charAt(i);
7273         if (ch === ' ') {
7274             nChars++;
7275         }
7276         else if (ch === '\t') {
7277             nChars += tabSize;
7278         }
7279         else {
7280             break;
7281         }
7282         i++;
7283     }
7284     return Math.floor(nChars / tabSize);
7285 }
7286 function getEOL(options, text) {
7287     for (var i = 0; i < text.length; i++) {
7288         var ch = text.charAt(i);
7289         if (ch === '\r') {
7290             if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
7291                 return '\r\n';
7292             }
7293             return '\r';
7294         }
7295         else if (ch === '\n') {
7296             return '\n';
7297         }
7298     }
7299     return (options && options.eol) || '\n';
7300 }
7301 function isEOL(text, offset) {
7302     return '\r\n'.indexOf(text.charAt(offset)) !== -1;
7303 }
7304
7305
7306 /***/ }),
7307 /* 46 */
7308 /***/ (function(module, __webpack_exports__, __webpack_require__) {
7309
7310 "use strict";
7311 __webpack_require__.r(__webpack_exports__);
7312 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createScanner", function() { return createScanner; });
7313 /*---------------------------------------------------------------------------------------------
7314  *  Copyright (c) Microsoft Corporation. All rights reserved.
7315  *  Licensed under the MIT License. See License.txt in the project root for license information.
7316  *--------------------------------------------------------------------------------------------*/
7317
7318 /**
7319  * Creates a JSON scanner on the given text.
7320  * If ignoreTrivia is set, whitespaces or comments are ignored.
7321  */
7322 function createScanner(text, ignoreTrivia) {
7323     if (ignoreTrivia === void 0) { ignoreTrivia = false; }
7324     var len = text.length;
7325     var pos = 0, value = '', tokenOffset = 0, token = 16 /* Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* None */;
7326     function scanHexDigits(count, exact) {
7327         var digits = 0;
7328         var value = 0;
7329         while (digits < count || !exact) {
7330             var ch = text.charCodeAt(pos);
7331             if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {
7332                 value = value * 16 + ch - 48 /* _0 */;
7333             }
7334             else if (ch >= 65 /* A */ && ch <= 70 /* F */) {
7335                 value = value * 16 + ch - 65 /* A */ + 10;
7336             }
7337             else if (ch >= 97 /* a */ && ch <= 102 /* f */) {
7338                 value = value * 16 + ch - 97 /* a */ + 10;
7339             }
7340             else {
7341                 break;
7342             }
7343             pos++;
7344             digits++;
7345         }
7346         if (digits < count) {
7347             value = -1;
7348         }
7349         return value;
7350     }
7351     function setPosition(newPosition) {
7352         pos = newPosition;
7353         value = '';
7354         tokenOffset = 0;
7355         token = 16 /* Unknown */;
7356         scanError = 0 /* None */;
7357     }
7358     function scanNumber() {
7359         var start = pos;
7360         if (text.charCodeAt(pos) === 48 /* _0 */) {
7361             pos++;
7362         }
7363         else {
7364             pos++;
7365             while (pos < text.length && isDigit(text.charCodeAt(pos))) {
7366                 pos++;
7367             }
7368         }
7369         if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {
7370             pos++;
7371             if (pos < text.length && isDigit(text.charCodeAt(pos))) {
7372                 pos++;
7373                 while (pos < text.length && isDigit(text.charCodeAt(pos))) {
7374                     pos++;
7375                 }
7376             }
7377             else {
7378                 scanError = 3 /* UnexpectedEndOfNumber */;
7379                 return text.substring(start, pos);
7380             }
7381         }
7382         var end = pos;
7383         if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {
7384             pos++;
7385             if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {
7386                 pos++;
7387             }
7388             if (pos < text.length && isDigit(text.charCodeAt(pos))) {
7389                 pos++;
7390                 while (pos < text.length && isDigit(text.charCodeAt(pos))) {
7391                     pos++;
7392                 }
7393                 end = pos;
7394             }
7395             else {
7396                 scanError = 3 /* UnexpectedEndOfNumber */;
7397             }
7398         }
7399         return text.substring(start, end);
7400     }
7401     function scanString() {
7402         var result = '', start = pos;
7403         while (true) {
7404             if (pos >= len) {
7405                 result += text.substring(start, pos);
7406                 scanError = 2 /* UnexpectedEndOfString */;
7407                 break;
7408             }
7409             var ch = text.charCodeAt(pos);
7410             if (ch === 34 /* doubleQuote */) {
7411                 result += text.substring(start, pos);
7412                 pos++;
7413                 break;
7414             }
7415             if (ch === 92 /* backslash */) {
7416                 result += text.substring(start, pos);
7417                 pos++;
7418                 if (pos >= len) {
7419                     scanError = 2 /* UnexpectedEndOfString */;
7420                     break;
7421                 }
7422                 var ch2 = text.charCodeAt(pos++);
7423                 switch (ch2) {
7424                     case 34 /* doubleQuote */:
7425                         result += '\"';
7426                         break;
7427                     case 92 /* backslash */:
7428                         result += '\\';
7429                         break;
7430                     case 47 /* slash */:
7431                         result += '/';
7432                         break;
7433                     case 98 /* b */:
7434                         result += '\b';
7435                         break;
7436                     case 102 /* f */:
7437                         result += '\f';
7438                         break;
7439                     case 110 /* n */:
7440                         result += '\n';
7441                         break;
7442                     case 114 /* r */:
7443                         result += '\r';
7444                         break;
7445                     case 116 /* t */:
7446                         result += '\t';
7447                         break;
7448                     case 117 /* u */:
7449                         var ch3 = scanHexDigits(4, true);
7450                         if (ch3 >= 0) {
7451                             result += String.fromCharCode(ch3);
7452                         }
7453                         else {
7454                             scanError = 4 /* InvalidUnicode */;
7455                         }
7456                         break;
7457                     default:
7458                         scanError = 5 /* InvalidEscapeCharacter */;
7459                 }
7460                 start = pos;
7461                 continue;
7462             }
7463             if (ch >= 0 && ch <= 0x1f) {
7464                 if (isLineBreak(ch)) {
7465                     result += text.substring(start, pos);
7466                     scanError = 2 /* UnexpectedEndOfString */;
7467                     break;
7468                 }
7469                 else {
7470                     scanError = 6 /* InvalidCharacter */;
7471                     // mark as error but continue with string
7472                 }
7473             }
7474             pos++;
7475         }
7476         return result;
7477     }
7478     function scanNext() {
7479         value = '';
7480         scanError = 0 /* None */;
7481         tokenOffset = pos;
7482         lineStartOffset = lineNumber;
7483         prevTokenLineStartOffset = tokenLineStartOffset;
7484         if (pos >= len) {
7485             // at the end
7486             tokenOffset = len;
7487             return token = 17 /* EOF */;
7488         }
7489         var code = text.charCodeAt(pos);
7490         // trivia: whitespace
7491         if (isWhiteSpace(code)) {
7492             do {
7493                 pos++;
7494                 value += String.fromCharCode(code);
7495                 code = text.charCodeAt(pos);
7496             } while (isWhiteSpace(code));
7497             return token = 15 /* Trivia */;
7498         }
7499         // trivia: newlines
7500         if (isLineBreak(code)) {
7501             pos++;
7502             value += String.fromCharCode(code);
7503             if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
7504                 pos++;
7505                 value += '\n';
7506             }
7507             lineNumber++;
7508             tokenLineStartOffset = pos;
7509             return token = 14 /* LineBreakTrivia */;
7510         }
7511         switch (code) {
7512             // tokens: []{}:,
7513             case 123 /* openBrace */:
7514                 pos++;
7515                 return token = 1 /* OpenBraceToken */;
7516             case 125 /* closeBrace */:
7517                 pos++;
7518                 return token = 2 /* CloseBraceToken */;
7519             case 91 /* openBracket */:
7520                 pos++;
7521                 return token = 3 /* OpenBracketToken */;
7522             case 93 /* closeBracket */:
7523                 pos++;
7524                 return token = 4 /* CloseBracketToken */;
7525             case 58 /* colon */:
7526                 pos++;
7527                 return token = 6 /* ColonToken */;
7528             case 44 /* comma */:
7529                 pos++;
7530                 return token = 5 /* CommaToken */;
7531             // strings
7532             case 34 /* doubleQuote */:
7533                 pos++;
7534                 value = scanString();
7535                 return token = 10 /* StringLiteral */;
7536             // comments
7537             case 47 /* slash */:
7538                 var start = pos - 1;
7539                 // Single-line comment
7540                 if (text.charCodeAt(pos + 1) === 47 /* slash */) {
7541                     pos += 2;
7542                     while (pos < len) {
7543                         if (isLineBreak(text.charCodeAt(pos))) {
7544                             break;
7545                         }
7546                         pos++;
7547                     }
7548                     value = text.substring(start, pos);
7549                     return token = 12 /* LineCommentTrivia */;
7550                 }
7551                 // Multi-line comment
7552                 if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
7553                     pos += 2;
7554                     var safeLength = len - 1; // For lookahead.
7555                     var commentClosed = false;
7556                     while (pos < safeLength) {
7557                         var ch = text.charCodeAt(pos);
7558                         if (ch === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
7559                             pos += 2;
7560                             commentClosed = true;
7561                             break;
7562                         }
7563                         pos++;
7564                         if (isLineBreak(ch)) {
7565                             if (ch === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
7566                                 pos++;
7567                             }
7568                             lineNumber++;
7569                             tokenLineStartOffset = pos;
7570                         }
7571                     }
7572                     if (!commentClosed) {
7573                         pos++;
7574                         scanError = 1 /* UnexpectedEndOfComment */;
7575                     }
7576                     value = text.substring(start, pos);
7577                     return token = 13 /* BlockCommentTrivia */;
7578                 }
7579                 // just a single slash
7580                 value += String.fromCharCode(code);
7581                 pos++;
7582                 return token = 16 /* Unknown */;
7583             // numbers
7584             case 45 /* minus */:
7585                 value += String.fromCharCode(code);
7586                 pos++;
7587                 if (pos === len || !isDigit(text.charCodeAt(pos))) {
7588                     return token = 16 /* Unknown */;
7589                 }
7590             // found a minus, followed by a number so
7591             // we fall through to proceed with scanning
7592             // numbers
7593             case 48 /* _0 */:
7594             case 49 /* _1 */:
7595             case 50 /* _2 */:
7596             case 51 /* _3 */:
7597             case 52 /* _4 */:
7598             case 53 /* _5 */:
7599             case 54 /* _6 */:
7600             case 55 /* _7 */:
7601             case 56 /* _8 */:
7602             case 57 /* _9 */:
7603                 value += scanNumber();
7604                 return token = 11 /* NumericLiteral */;
7605             // literals and unknown symbols
7606             default:
7607                 // is a literal? Read the full word.
7608                 while (pos < len && isUnknownContentCharacter(code)) {
7609                     pos++;
7610                     code = text.charCodeAt(pos);
7611                 }
7612                 if (tokenOffset !== pos) {
7613                     value = text.substring(tokenOffset, pos);
7614                     // keywords: true, false, null
7615                     switch (value) {
7616                         case 'true': return token = 8 /* TrueKeyword */;
7617                         case 'false': return token = 9 /* FalseKeyword */;
7618                         case 'null': return token = 7 /* NullKeyword */;
7619                     }
7620                     return token = 16 /* Unknown */;
7621                 }
7622                 // some
7623                 value += String.fromCharCode(code);
7624                 pos++;
7625                 return token = 16 /* Unknown */;
7626         }
7627     }
7628     function isUnknownContentCharacter(code) {
7629         if (isWhiteSpace(code) || isLineBreak(code)) {
7630             return false;
7631         }
7632         switch (code) {
7633             case 125 /* closeBrace */:
7634             case 93 /* closeBracket */:
7635             case 123 /* openBrace */:
7636             case 91 /* openBracket */:
7637             case 34 /* doubleQuote */:
7638             case 58 /* colon */:
7639             case 44 /* comma */:
7640             case 47 /* slash */:
7641                 return false;
7642         }
7643         return true;
7644     }
7645     function scanNextNonTrivia() {
7646         var result;
7647         do {
7648             result = scanNext();
7649         } while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);
7650         return result;
7651     }
7652     return {
7653         setPosition: setPosition,
7654         getPosition: function () { return pos; },
7655         scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
7656         getToken: function () { return token; },
7657         getTokenValue: function () { return value; },
7658         getTokenOffset: function () { return tokenOffset; },
7659         getTokenLength: function () { return pos - tokenOffset; },
7660         getTokenStartLine: function () { return lineStartOffset; },
7661         getTokenStartCharacter: function () { return tokenOffset - prevTokenLineStartOffset; },
7662         getTokenError: function () { return scanError; },
7663     };
7664 }
7665 function isWhiteSpace(ch) {
7666     return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ ||
7667         ch === 160 /* nonBreakingSpace */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||
7668         ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;
7669 }
7670 function isLineBreak(ch) {
7671     return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;
7672 }
7673 function isDigit(ch) {
7674     return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
7675 }
7676
7677
7678 /***/ }),
7679 /* 47 */
7680 /***/ (function(module, __webpack_exports__, __webpack_require__) {
7681
7682 "use strict";
7683 __webpack_require__.r(__webpack_exports__);
7684 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeProperty", function() { return removeProperty; });
7685 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setProperty", function() { return setProperty; });
7686 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "applyEdit", function() { return applyEdit; });
7687 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isWS", function() { return isWS; });
7688 /* harmony import */ var _format__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(45);
7689 /* harmony import */ var _parser__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(48);
7690 /*---------------------------------------------------------------------------------------------
7691  *  Copyright (c) Microsoft Corporation. All rights reserved.
7692  *  Licensed under the MIT License. See License.txt in the project root for license information.
7693  *--------------------------------------------------------------------------------------------*/
7694
7695
7696
7697 function removeProperty(text, path, formattingOptions) {
7698     return setProperty(text, path, void 0, formattingOptions);
7699 }
7700 function setProperty(text, originalPath, value, formattingOptions, getInsertionIndex) {
7701     var _a;
7702     var path = originalPath.slice();
7703     var errors = [];
7704     var root = Object(_parser__WEBPACK_IMPORTED_MODULE_1__["parseTree"])(text, errors);
7705     var parent = void 0;
7706     var lastSegment = void 0;
7707     while (path.length > 0) {
7708         lastSegment = path.pop();
7709         parent = Object(_parser__WEBPACK_IMPORTED_MODULE_1__["findNodeAtLocation"])(root, path);
7710         if (parent === void 0 && value !== void 0) {
7711             if (typeof lastSegment === 'string') {
7712                 value = (_a = {}, _a[lastSegment] = value, _a);
7713             }
7714             else {
7715                 value = [value];
7716             }
7717         }
7718         else {
7719             break;
7720         }
7721     }
7722     if (!parent) {
7723         // empty document
7724         if (value === void 0) { // delete
7725             throw new Error('Can not delete in empty document');
7726         }
7727         return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, formattingOptions);
7728     }
7729     else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
7730         var existing = Object(_parser__WEBPACK_IMPORTED_MODULE_1__["findNodeAtLocation"])(parent, [lastSegment]);
7731         if (existing !== void 0) {
7732             if (value === void 0) { // delete
7733                 if (!existing.parent) {
7734                     throw new Error('Malformed AST');
7735                 }
7736                 var propertyIndex = parent.children.indexOf(existing.parent);
7737                 var removeBegin = void 0;
7738                 var removeEnd = existing.parent.offset + existing.parent.length;
7739                 if (propertyIndex > 0) {
7740                     // remove the comma of the previous node
7741                     var previous = parent.children[propertyIndex - 1];
7742                     removeBegin = previous.offset + previous.length;
7743                 }
7744                 else {
7745                     removeBegin = parent.offset + 1;
7746                     if (parent.children.length > 1) {
7747                         // remove the comma of the next node
7748                         var next = parent.children[1];
7749                         removeEnd = next.offset;
7750                     }
7751                 }
7752                 return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, formattingOptions);
7753             }
7754             else {
7755                 // set value of existing property
7756                 return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, formattingOptions);
7757             }
7758         }
7759         else {
7760             if (value === void 0) { // delete
7761                 return []; // property does not exist, nothing to do
7762             }
7763             var newProperty = JSON.stringify(lastSegment) + ": " + JSON.stringify(value);
7764             var index = getInsertionIndex ? getInsertionIndex(parent.children.map(function (p) { return p.children[0].value; })) : parent.children.length;
7765             var edit = void 0;
7766             if (index > 0) {
7767                 var previous = parent.children[index - 1];
7768                 edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
7769             }
7770             else if (parent.children.length === 0) {
7771                 edit = { offset: parent.offset + 1, length: 0, content: newProperty };
7772             }
7773             else {
7774                 edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
7775             }
7776             return withFormatting(text, edit, formattingOptions);
7777         }
7778     }
7779     else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
7780         var insertIndex = lastSegment;
7781         if (insertIndex === -1) {
7782             // Insert
7783             var newProperty = "" + JSON.stringify(value);
7784             var edit = void 0;
7785             if (parent.children.length === 0) {
7786                 edit = { offset: parent.offset + 1, length: 0, content: newProperty };
7787             }
7788             else {
7789                 var previous = parent.children[parent.children.length - 1];
7790                 edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
7791             }
7792             return withFormatting(text, edit, formattingOptions);
7793         }
7794         else {
7795             if (value === void 0 && parent.children.length >= 0) {
7796                 //Removal
7797                 var removalIndex = lastSegment;
7798                 var toRemove = parent.children[removalIndex];
7799                 var edit = void 0;
7800                 if (parent.children.length === 1) {
7801                     // only item
7802                     edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
7803                 }
7804                 else if (parent.children.length - 1 === removalIndex) {
7805                     // last item
7806                     var previous = parent.children[removalIndex - 1];
7807                     var offset = previous.offset + previous.length;
7808                     var parentEndOffset = parent.offset + parent.length;
7809                     edit = { offset: offset, length: parentEndOffset - 2 - offset, content: '' };
7810                 }
7811                 else {
7812                     edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
7813                 }
7814                 return withFormatting(text, edit, formattingOptions);
7815             }
7816             else {
7817                 throw new Error('Array modification not supported yet');
7818             }
7819         }
7820     }
7821     else {
7822         throw new Error("Can not add " + (typeof lastSegment !== 'number' ? 'index' : 'property') + " to parent of type " + parent.type);
7823     }
7824 }
7825 function withFormatting(text, edit, formattingOptions) {
7826     // apply the edit
7827     var newText = applyEdit(text, edit);
7828     // format the new text
7829     var begin = edit.offset;
7830     var end = edit.offset + edit.content.length;
7831     if (edit.length === 0 || edit.content.length === 0) { // insert or remove
7832         while (begin > 0 && !Object(_format__WEBPACK_IMPORTED_MODULE_0__["isEOL"])(newText, begin - 1)) {
7833             begin--;
7834         }
7835         while (end < newText.length && !Object(_format__WEBPACK_IMPORTED_MODULE_0__["isEOL"])(newText, end)) {
7836             end++;
7837         }
7838     }
7839     var edits = Object(_format__WEBPACK_IMPORTED_MODULE_0__["format"])(newText, { offset: begin, length: end - begin }, formattingOptions);
7840     // apply the formatting edits and track the begin and end offsets of the changes
7841     for (var i = edits.length - 1; i >= 0; i--) {
7842         var edit_1 = edits[i];
7843         newText = applyEdit(newText, edit_1);
7844         begin = Math.min(begin, edit_1.offset);
7845         end = Math.max(end, edit_1.offset + edit_1.length);
7846         end += edit_1.content.length - edit_1.length;
7847     }
7848     // create a single edit with all changes
7849     var editLength = text.length - (newText.length - end) - begin;
7850     return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
7851 }
7852 function applyEdit(text, edit) {
7853     return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
7854 }
7855 function isWS(text, offset) {
7856     return '\r\n \t'.indexOf(text.charAt(offset)) !== -1;
7857 }
7858
7859
7860 /***/ }),
7861 /* 48 */
7862 /***/ (function(module, __webpack_exports__, __webpack_require__) {
7863
7864 "use strict";
7865 __webpack_require__.r(__webpack_exports__);
7866 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getLocation", function() { return getLocation; });
7867 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parse", function() { return parse; });
7868 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseTree", function() { return parseTree; });
7869 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findNodeAtLocation", function() { return findNodeAtLocation; });
7870 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getNodePath", function() { return getNodePath; });
7871 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getNodeValue", function() { return getNodeValue; });
7872 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "contains", function() { return contains; });
7873 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findNodeAtOffset", function() { return findNodeAtOffset; });
7874 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "visit", function() { return visit; });
7875 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stripComments", function() { return stripComments; });
7876 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getNodeType", function() { return getNodeType; });
7877 /* harmony import */ var _scanner__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(46);
7878 /*---------------------------------------------------------------------------------------------
7879  *  Copyright (c) Microsoft Corporation. All rights reserved.
7880  *  Licensed under the MIT License. See License.txt in the project root for license information.
7881  *--------------------------------------------------------------------------------------------*/
7882
7883
7884 var ParseOptions;
7885 (function (ParseOptions) {
7886     ParseOptions.DEFAULT = {
7887         allowTrailingComma: false
7888     };
7889 })(ParseOptions || (ParseOptions = {}));
7890 /**
7891  * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
7892  */
7893 function getLocation(text, position) {
7894     var segments = []; // strings or numbers
7895     var earlyReturnException = new Object();
7896     var previousNode = undefined;
7897     var previousNodeInst = {
7898         value: {},
7899         offset: 0,
7900         length: 0,
7901         type: 'object',
7902         parent: undefined
7903     };
7904     var isAtPropertyKey = false;
7905     function setPreviousNode(value, offset, length, type) {
7906         previousNodeInst.value = value;
7907         previousNodeInst.offset = offset;
7908         previousNodeInst.length = length;
7909         previousNodeInst.type = type;
7910         previousNodeInst.colonOffset = undefined;
7911         previousNode = previousNodeInst;
7912     }
7913     try {
7914         visit(text, {
7915             onObjectBegin: function (offset, length) {
7916                 if (position <= offset) {
7917                     throw earlyReturnException;
7918                 }
7919                 previousNode = undefined;
7920                 isAtPropertyKey = position > offset;
7921                 segments.push(''); // push a placeholder (will be replaced)
7922             },
7923             onObjectProperty: function (name, offset, length) {
7924                 if (position < offset) {
7925                     throw earlyReturnException;
7926                 }
7927                 setPreviousNode(name, offset, length, 'property');
7928                 segments[segments.length - 1] = name;
7929                 if (position <= offset + length) {
7930                     throw earlyReturnException;
7931                 }
7932             },
7933             onObjectEnd: function (offset, length) {
7934                 if (position <= offset) {
7935                     throw earlyReturnException;
7936                 }
7937                 previousNode = undefined;
7938                 segments.pop();
7939             },
7940             onArrayBegin: function (offset, length) {
7941                 if (position <= offset) {
7942                     throw earlyReturnException;
7943                 }
7944                 previousNode = undefined;
7945                 segments.push(0);
7946             },
7947             onArrayEnd: function (offset, length) {
7948                 if (position <= offset) {
7949                     throw earlyReturnException;
7950                 }
7951                 previousNode = undefined;
7952                 segments.pop();
7953             },
7954             onLiteralValue: function (value, offset, length) {
7955                 if (position < offset) {
7956                     throw earlyReturnException;
7957                 }
7958                 setPreviousNode(value, offset, length, getNodeType(value));
7959                 if (position <= offset + length) {
7960                     throw earlyReturnException;
7961                 }
7962             },
7963             onSeparator: function (sep, offset, length) {
7964                 if (position <= offset) {
7965                     throw earlyReturnException;
7966                 }
7967                 if (sep === ':' && previousNode && previousNode.type === 'property') {
7968                     previousNode.colonOffset = offset;
7969                     isAtPropertyKey = false;
7970                     previousNode = undefined;
7971                 }
7972                 else if (sep === ',') {
7973                     var last = segments[segments.length - 1];
7974                     if (typeof last === 'number') {
7975                         segments[segments.length - 1] = last + 1;
7976                     }
7977                     else {
7978                         isAtPropertyKey = true;
7979                         segments[segments.length - 1] = '';
7980                     }
7981                     previousNode = undefined;
7982                 }
7983             }
7984         });
7985     }
7986     catch (e) {
7987         if (e !== earlyReturnException) {
7988             throw e;
7989         }
7990     }
7991     return {
7992         path: segments,
7993         previousNode: previousNode,
7994         isAtPropertyKey: isAtPropertyKey,
7995         matches: function (pattern) {
7996             var k = 0;
7997             for (var i = 0; k < pattern.length && i < segments.length; i++) {
7998                 if (pattern[k] === segments[i] || pattern[k] === '*') {
7999                     k++;
8000                 }
8001                 else if (pattern[k] !== '**') {
8002                     return false;
8003                 }
8004             }
8005             return k === pattern.length;
8006         }
8007     };
8008 }
8009 /**
8010  * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
8011  * Therefore always check the errors list to find out if the input was valid.
8012  */
8013 function parse(text, errors, options) {
8014     if (errors === void 0) { errors = []; }
8015     if (options === void 0) { options = ParseOptions.DEFAULT; }
8016     var currentProperty = null;
8017     var currentParent = [];
8018     var previousParents = [];
8019     function onValue(value) {
8020         if (Array.isArray(currentParent)) {
8021             currentParent.push(value);
8022         }
8023         else if (currentProperty !== null) {
8024             currentParent[currentProperty] = value;
8025         }
8026     }
8027     var visitor = {
8028         onObjectBegin: function () {
8029             var object = {};
8030             onValue(object);
8031             previousParents.push(currentParent);
8032             currentParent = object;
8033             currentProperty = null;
8034         },
8035         onObjectProperty: function (name) {
8036             currentProperty = name;
8037         },
8038         onObjectEnd: function () {
8039             currentParent = previousParents.pop();
8040         },
8041         onArrayBegin: function () {
8042             var array = [];
8043             onValue(array);
8044             previousParents.push(currentParent);
8045             currentParent = array;
8046             currentProperty = null;
8047         },
8048         onArrayEnd: function () {
8049             currentParent = previousParents.pop();
8050         },
8051         onLiteralValue: onValue,
8052         onError: function (error, offset, length) {
8053             errors.push({ error: error, offset: offset, length: length });
8054         }
8055     };
8056     visit(text, visitor, options);
8057     return currentParent[0];
8058 }
8059 /**
8060  * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
8061  */
8062 function parseTree(text, errors, options) {
8063     if (errors === void 0) { errors = []; }
8064     if (options === void 0) { options = ParseOptions.DEFAULT; }
8065     var currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
8066     function ensurePropertyComplete(endOffset) {
8067         if (currentParent.type === 'property') {
8068             currentParent.length = endOffset - currentParent.offset;
8069             currentParent = currentParent.parent;
8070         }
8071     }
8072     function onValue(valueNode) {
8073         currentParent.children.push(valueNode);
8074         return valueNode;
8075     }
8076     var visitor = {
8077         onObjectBegin: function (offset) {
8078             currentParent = onValue({ type: 'object', offset: offset, length: -1, parent: currentParent, children: [] });
8079         },
8080         onObjectProperty: function (name, offset, length) {
8081             currentParent = onValue({ type: 'property', offset: offset, length: -1, parent: currentParent, children: [] });
8082             currentParent.children.push({ type: 'string', value: name, offset: offset, length: length, parent: currentParent });
8083         },
8084         onObjectEnd: function (offset, length) {
8085             ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete
8086             currentParent.length = offset + length - currentParent.offset;
8087             currentParent = currentParent.parent;
8088             ensurePropertyComplete(offset + length);
8089         },
8090         onArrayBegin: function (offset, length) {
8091             currentParent = onValue({ type: 'array', offset: offset, length: -1, parent: currentParent, children: [] });
8092         },
8093         onArrayEnd: function (offset, length) {
8094             currentParent.length = offset + length - currentParent.offset;
8095             currentParent = currentParent.parent;
8096             ensurePropertyComplete(offset + length);
8097         },
8098         onLiteralValue: function (value, offset, length) {
8099             onValue({ type: getNodeType(value), offset: offset, length: length, parent: currentParent, value: value });
8100             ensurePropertyComplete(offset + length);
8101         },
8102         onSeparator: function (sep, offset, length) {
8103             if (currentParent.type === 'property') {
8104                 if (sep === ':') {
8105                     currentParent.colonOffset = offset;
8106                 }
8107                 else if (sep === ',') {
8108                     ensurePropertyComplete(offset);
8109                 }
8110             }
8111         },
8112         onError: function (error, offset, length) {
8113             errors.push({ error: error, offset: offset, length: length });
8114         }
8115     };
8116     visit(text, visitor, options);
8117     var result = currentParent.children[0];
8118     if (result) {
8119         delete result.parent;
8120     }
8121     return result;
8122 }
8123 /**
8124  * Finds the node at the given path in a JSON DOM.
8125  */
8126 function findNodeAtLocation(root, path) {
8127     if (!root) {
8128         return undefined;
8129     }
8130     var node = root;
8131     for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
8132         var segment = path_1[_i];
8133         if (typeof segment === 'string') {
8134             if (node.type !== 'object' || !Array.isArray(node.children)) {
8135                 return undefined;
8136             }
8137             var found = false;
8138             for (var _a = 0, _b = node.children; _a < _b.length; _a++) {
8139                 var propertyNode = _b[_a];
8140                 if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {
8141                     node = propertyNode.children[1];
8142                     found = true;
8143                     break;
8144                 }
8145             }
8146             if (!found) {
8147                 return undefined;
8148             }
8149         }
8150         else {
8151             var index = segment;
8152             if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
8153                 return undefined;
8154             }
8155             node = node.children[index];
8156         }
8157     }
8158     return node;
8159 }
8160 /**
8161  * Gets the JSON path of the given JSON DOM node
8162  */
8163 function getNodePath(node) {
8164     if (!node.parent || !node.parent.children) {
8165         return [];
8166     }
8167     var path = getNodePath(node.parent);
8168     if (node.parent.type === 'property') {
8169         var key = node.parent.children[0].value;
8170         path.push(key);
8171     }
8172     else if (node.parent.type === 'array') {
8173         var index = node.parent.children.indexOf(node);
8174         if (index !== -1) {
8175             path.push(index);
8176         }
8177     }
8178     return path;
8179 }
8180 /**
8181  * Evaluates the JavaScript object of the given JSON DOM node
8182  */
8183 function getNodeValue(node) {
8184     switch (node.type) {
8185         case 'array':
8186             return node.children.map(getNodeValue);
8187         case 'object':
8188             var obj = Object.create(null);
8189             for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
8190                 var prop = _a[_i];
8191                 var valueNode = prop.children[1];
8192                 if (valueNode) {
8193                     obj[prop.children[0].value] = getNodeValue(valueNode);
8194                 }
8195             }
8196             return obj;
8197         case 'null':
8198         case 'string':
8199         case 'number':
8200         case 'boolean':
8201             return node.value;
8202         default:
8203             return undefined;
8204     }
8205 }
8206 function contains(node, offset, includeRightBound) {
8207     if (includeRightBound === void 0) { includeRightBound = false; }
8208     return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
8209 }
8210 /**
8211  * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
8212  */
8213 function findNodeAtOffset(node, offset, includeRightBound) {
8214     if (includeRightBound === void 0) { includeRightBound = false; }
8215     if (contains(node, offset, includeRightBound)) {
8216         var children = node.children;
8217         if (Array.isArray(children)) {
8218             for (var i = 0; i < children.length && children[i].offset <= offset; i++) {
8219                 var item = findNodeAtOffset(children[i], offset, includeRightBound);
8220                 if (item) {
8221                     return item;
8222                 }
8223             }
8224         }
8225         return node;
8226     }
8227     return undefined;
8228 }
8229 /**
8230  * Parses the given text and invokes the visitor functions for each object, array and literal reached.
8231  */
8232 function visit(text, visitor, options) {
8233     if (options === void 0) { options = ParseOptions.DEFAULT; }
8234     var _scanner = Object(_scanner__WEBPACK_IMPORTED_MODULE_0__["createScanner"])(text, false);
8235     function toNoArgVisit(visitFunction) {
8236         return visitFunction ? function () { return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };
8237     }
8238     function toOneArgVisit(visitFunction) {
8239         return visitFunction ? function (arg) { return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };
8240     }
8241     var onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
8242     var disallowComments = options && options.disallowComments;
8243     var allowTrailingComma = options && options.allowTrailingComma;
8244     function scanNext() {
8245         while (true) {
8246             var token = _scanner.scan();
8247             switch (_scanner.getTokenError()) {
8248                 case 4 /* InvalidUnicode */:
8249                     handleError(14 /* InvalidUnicode */);
8250                     break;
8251                 case 5 /* InvalidEscapeCharacter */:
8252                     handleError(15 /* InvalidEscapeCharacter */);
8253                     break;
8254                 case 3 /* UnexpectedEndOfNumber */:
8255                     handleError(13 /* UnexpectedEndOfNumber */);
8256                     break;
8257                 case 1 /* UnexpectedEndOfComment */:
8258                     if (!disallowComments) {
8259                         handleError(11 /* UnexpectedEndOfComment */);
8260                     }
8261                     break;
8262                 case 2 /* UnexpectedEndOfString */:
8263                     handleError(12 /* UnexpectedEndOfString */);
8264                     break;
8265                 case 6 /* InvalidCharacter */:
8266                     handleError(16 /* InvalidCharacter */);
8267                     break;
8268             }
8269             switch (token) {
8270                 case 12 /* LineCommentTrivia */:
8271                 case 13 /* BlockCommentTrivia */:
8272                     if (disallowComments) {
8273                         handleError(10 /* InvalidCommentToken */);
8274                     }
8275                     else {
8276                         onComment();
8277                     }
8278                     break;
8279                 case 16 /* Unknown */:
8280                     handleError(1 /* InvalidSymbol */);
8281                     break;
8282                 case 15 /* Trivia */:
8283                 case 14 /* LineBreakTrivia */:
8284                     break;
8285                 default:
8286                     return token;
8287             }
8288         }
8289     }
8290     function handleError(error, skipUntilAfter, skipUntil) {
8291         if (skipUntilAfter === void 0) { skipUntilAfter = []; }
8292         if (skipUntil === void 0) { skipUntil = []; }
8293         onError(error);
8294         if (skipUntilAfter.length + skipUntil.length > 0) {
8295             var token = _scanner.getToken();
8296             while (token !== 17 /* EOF */) {
8297                 if (skipUntilAfter.indexOf(token) !== -1) {
8298                     scanNext();
8299                     break;
8300                 }
8301                 else if (skipUntil.indexOf(token) !== -1) {
8302                     break;
8303                 }
8304                 token = scanNext();
8305             }
8306         }
8307     }
8308     function parseString(isValue) {
8309         var value = _scanner.getTokenValue();
8310         if (isValue) {
8311             onLiteralValue(value);
8312         }
8313         else {
8314             onObjectProperty(value);
8315         }
8316         scanNext();
8317         return true;
8318     }
8319     function parseLiteral() {
8320         switch (_scanner.getToken()) {
8321             case 11 /* NumericLiteral */:
8322                 var value = 0;
8323                 try {
8324                     value = JSON.parse(_scanner.getTokenValue());
8325                     if (typeof value !== 'number') {
8326                         handleError(2 /* InvalidNumberFormat */);
8327                         value = 0;
8328                     }
8329                 }
8330                 catch (e) {
8331                     handleError(2 /* InvalidNumberFormat */);
8332                 }
8333                 onLiteralValue(value);
8334                 break;
8335             case 7 /* NullKeyword */:
8336                 onLiteralValue(null);
8337                 break;
8338             case 8 /* TrueKeyword */:
8339                 onLiteralValue(true);
8340                 break;
8341             case 9 /* FalseKeyword */:
8342                 onLiteralValue(false);
8343                 break;
8344             default:
8345                 return false;
8346         }
8347         scanNext();
8348         return true;
8349     }
8350     function parseProperty() {
8351         if (_scanner.getToken() !== 10 /* StringLiteral */) {
8352             handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
8353             return false;
8354         }
8355         parseString(false);
8356         if (_scanner.getToken() === 6 /* ColonToken */) {
8357             onSeparator(':');
8358             scanNext(); // consume colon
8359             if (!parseValue()) {
8360                 handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
8361             }
8362         }
8363         else {
8364             handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
8365         }
8366         return true;
8367     }
8368     function parseObject() {
8369         onObjectBegin();
8370         scanNext(); // consume open brace
8371         var needsComma = false;
8372         while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {
8373             if (_scanner.getToken() === 5 /* CommaToken */) {
8374                 if (!needsComma) {
8375                     handleError(4 /* ValueExpected */, [], []);
8376                 }
8377                 onSeparator(',');
8378                 scanNext(); // consume comma
8379                 if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {
8380                     break;
8381                 }
8382             }
8383             else if (needsComma) {
8384                 handleError(6 /* CommaExpected */, [], []);
8385             }
8386             if (!parseProperty()) {
8387                 handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
8388             }
8389             needsComma = true;
8390         }
8391         onObjectEnd();
8392         if (_scanner.getToken() !== 2 /* CloseBraceToken */) {
8393             handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);
8394         }
8395         else {
8396             scanNext(); // consume close brace
8397         }
8398         return true;
8399     }
8400     function parseArray() {
8401         onArrayBegin();
8402         scanNext(); // consume open bracket
8403         var needsComma = false;
8404         while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {
8405             if (_scanner.getToken() === 5 /* CommaToken */) {
8406                 if (!needsComma) {
8407                     handleError(4 /* ValueExpected */, [], []);
8408                 }
8409                 onSeparator(',');
8410                 scanNext(); // consume comma
8411                 if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {
8412                     break;
8413                 }
8414             }
8415             else if (needsComma) {
8416                 handleError(6 /* CommaExpected */, [], []);
8417             }
8418             if (!parseValue()) {
8419                 handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
8420             }
8421             needsComma = true;
8422         }
8423         onArrayEnd();
8424         if (_scanner.getToken() !== 4 /* CloseBracketToken */) {
8425             handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);
8426         }
8427         else {
8428             scanNext(); // consume close bracket
8429         }
8430         return true;
8431     }
8432     function parseValue() {
8433         switch (_scanner.getToken()) {
8434             case 3 /* OpenBracketToken */:
8435                 return parseArray();
8436             case 1 /* OpenBraceToken */:
8437                 return parseObject();
8438             case 10 /* StringLiteral */:
8439                 return parseString(true);
8440             default:
8441                 return parseLiteral();
8442         }
8443     }
8444     scanNext();
8445     if (_scanner.getToken() === 17 /* EOF */) {
8446         if (options.allowEmptyContent) {
8447             return true;
8448         }
8449         handleError(4 /* ValueExpected */, [], []);
8450         return false;
8451     }
8452     if (!parseValue()) {
8453         handleError(4 /* ValueExpected */, [], []);
8454         return false;
8455     }
8456     if (_scanner.getToken() !== 17 /* EOF */) {
8457         handleError(9 /* EndOfFileExpected */, [], []);
8458     }
8459     return true;
8460 }
8461 /**
8462  * Takes JSON with JavaScript-style comments and remove
8463  * them. Optionally replaces every none-newline character
8464  * of comments with a replaceCharacter
8465  */
8466 function stripComments(text, replaceCh) {
8467     var _scanner = Object(_scanner__WEBPACK_IMPORTED_MODULE_0__["createScanner"])(text), parts = [], kind, offset = 0, pos;
8468     do {
8469         pos = _scanner.getPosition();
8470         kind = _scanner.scan();
8471         switch (kind) {
8472             case 12 /* LineCommentTrivia */:
8473             case 13 /* BlockCommentTrivia */:
8474             case 17 /* EOF */:
8475                 if (offset !== pos) {
8476                     parts.push(text.substring(offset, pos));
8477                 }
8478                 if (replaceCh !== undefined) {
8479                     parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
8480                 }
8481                 offset = _scanner.getPosition();
8482                 break;
8483         }
8484     } while (kind !== 17 /* EOF */);
8485     return parts.join('');
8486 }
8487 function getNodeType(value) {
8488     switch (typeof value) {
8489         case 'boolean': return 'boolean';
8490         case 'number': return 'number';
8491         case 'string': return 'string';
8492         case 'object': {
8493             if (!value) {
8494                 return 'null';
8495             }
8496             else if (Array.isArray(value)) {
8497                 return 'array';
8498             }
8499             return 'object';
8500         }
8501         default: return 'null';
8502     }
8503 }
8504
8505
8506 /***/ }),
8507 /* 49 */
8508 /***/ (function(module, exports, __webpack_require__) {
8509
8510 "use strict";
8511
8512 var __importDefault = (this && this.__importDefault) || function (mod) {
8513     return (mod && mod.__esModule) ? mod : { "default": mod };
8514 };
8515 Object.defineProperty(exports, "__esModule", { value: true });
8516 /******************************************************************
8517 MIT License http://www.opensource.org/licenses/mit-license.php
8518 Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
8519 *******************************************************************/
8520 const coc_nvim_1 = __webpack_require__(1);
8521 const fs_1 = __importDefault(__webpack_require__(3));
8522 const os_1 = __importDefault(__webpack_require__(2));
8523 const path_1 = __importDefault(__webpack_require__(4));
8524 const vscode_languageserver_types_1 = __webpack_require__(6);
8525 const baseProvider_1 = __importDefault(__webpack_require__(41));
8526 const types_1 = __webpack_require__(36);
8527 const ultisnipsParser_1 = __importDefault(__webpack_require__(50));
8528 const util_1 = __webpack_require__(37);
8529 const pythonCodes = new Map();
8530 class UltiSnippetsProvider extends baseProvider_1.default {
8531     constructor(channel, trace, config, context) {
8532         super(config);
8533         this.channel = channel;
8534         this.trace = trace;
8535         this.config = config;
8536         this.context = context;
8537         this.snippetFiles = [];
8538         this.disposables = [];
8539         this.directories = [];
8540         this.runtimeDirs = [];
8541         this.runtimeDirs = coc_nvim_1.workspace.env.runtimepath.split(',');
8542         coc_nvim_1.workspace.watchOption('runtimepath', async (_, newValue) => {
8543             let parts = newValue.split(',');
8544             let subFolders = await this.getSubFolders();
8545             let items = [];
8546             for (let dir of parts) {
8547                 if (this.runtimeDirs.indexOf(dir) == -1) {
8548                     this.runtimeDirs.push(dir);
8549                     let res = await this.getSnippetsFromPlugin(dir, subFolders);
8550                     items.push(...res);
8551                 }
8552             }
8553             if (items.length) {
8554                 await Promise.all(items.map(({ filepath, directory, filetype }) => {
8555                     return this.loadSnippetsFromFile(filetype, directory, filepath);
8556                 }));
8557                 let files = items.map(o => o.filepath);
8558                 let pythonCode = '';
8559                 for (let file of files) {
8560                     let code = pythonCodes.get(file);
8561                     if (code) {
8562                         pythonCode += `# ${file}\n` + code + '\n';
8563                     }
8564                 }
8565                 if (pythonCode) {
8566                     pythonCodes.clear();
8567                     await this.executePythonCode(pythonCode);
8568                 }
8569             }
8570         }, this.disposables);
8571     }
8572     checkLoaded(filepath) {
8573         return this.snippetFiles.findIndex(o => o.filepath == filepath) !== -1;
8574     }
8575     async init() {
8576         let { nvim, env } = coc_nvim_1.workspace;
8577         let { runtimepath } = env;
8578         let { config } = this;
8579         for (let dir of config.directories) {
8580             if (dir.startsWith('~') || dir.indexOf('$') !== -1) {
8581                 let res = await coc_nvim_1.workspace.nvim.call('expand', [dir]);
8582                 this.directories.push(res);
8583             }
8584             else {
8585                 this.directories.push(dir);
8586             }
8587         }
8588         this.channel.appendLine(`[Info ${(new Date()).toLocaleTimeString()}] Using ultisnips directories: ${this.directories.join(' ')}`);
8589         let hasPythonx = await nvim.call('has', ['pythonx']);
8590         let pythonCode = await util_1.readFileAsync(this.context.asAbsolutePath('python/ultisnips.py'), 'utf8');
8591         if (hasPythonx && config.usePythonx) {
8592             this.pyMethod = 'pyx';
8593         }
8594         else {
8595             this.pyMethod = config.pythonVersion == 3 ? 'py3' : 'py';
8596         }
8597         this.channel.appendLine(`[Info ${(new Date()).toLocaleTimeString()}] Using ultisnips python command: ${this.pyMethod}`);
8598         this.parser = new ultisnipsParser_1.default(this.pyMethod, this.channel, this.trace);
8599         let arr = await this.getAllSnippetFiles(runtimepath);
8600         let files = arr.map(o => o.filepath);
8601         await Promise.all(arr.map(({ filepath, directory, filetype }) => {
8602             return this.loadSnippetsFromFile(filetype, directory, filepath);
8603         }));
8604         for (let file of files) {
8605             let code = pythonCodes.get(file);
8606             if (code) {
8607                 pythonCode += `\n# ${file}\n` + code + '\n';
8608             }
8609         }
8610         await this.executePythonCode(pythonCode);
8611         coc_nvim_1.workspace.onDidSaveTextDocument(async (doc) => {
8612             let uri = coc_nvim_1.Uri.parse(doc.uri);
8613             if (uri.scheme != 'file' || !doc.uri.endsWith('.snippets'))
8614                 return;
8615             let filepath = uri.fsPath;
8616             if (!fs_1.default.existsSync(filepath))
8617                 return;
8618             let snippetFile = this.snippetFiles.find(s => s.filepath == filepath);
8619             if (snippetFile) {
8620                 await this.loadSnippetsFromFile(snippetFile.filetype, snippetFile.directory, filepath);
8621             }
8622             else {
8623                 let filetype = path_1.default.basename(filepath, '.snippets');
8624                 await this.loadSnippetsFromFile(filetype, path_1.default.dirname(filepath), filepath);
8625             }
8626         }, null, this.disposables);
8627     }
8628     async loadSnippetsFromFile(filetype, directory, filepath) {
8629         let { snippets, pythonCode, extendFiletypes, clearsnippets } = await this.parser.parseUltisnipsFile(filepath);
8630         let idx = this.snippetFiles.findIndex(o => o.filepath == filepath);
8631         if (idx !== -1)
8632             this.snippetFiles.splice(idx, 1);
8633         this.snippetFiles.push({
8634             extendFiletypes,
8635             clearsnippets,
8636             directory,
8637             filepath,
8638             filetype,
8639             snippets
8640         });
8641         if (extendFiletypes) {
8642             let filetypes = this.config.extends[filetype] || [];
8643             filetypes = filetypes.concat(extendFiletypes);
8644             this.config.extends[filetype] = util_1.distinct(filetypes);
8645         }
8646         if (this.trace == 'verbose') {
8647             this.channel.appendLine(`[Info ${(new Date()).toLocaleTimeString()}] Loaded ${snippets.length} snippets from: ${filepath}`);
8648         }
8649         pythonCodes.set(filepath, pythonCode);
8650     }
8651     async resolveSnippetBody(snippet, range, line) {
8652         let { nvim } = coc_nvim_1.workspace;
8653         let { body, context, originRegex } = snippet;
8654         let buf = await nvim.buffer;
8655         let filepath = await buf.name;
8656         let indentCount = await nvim.call('indent', '.');
8657         let ind = ' '.repeat(indentCount);
8658         if (body.indexOf('`!p') !== -1) {
8659             let values = new Map();
8660             let re = /\$\{(\d+)(?::([^}]+))?\}/g;
8661             let r;
8662             // tslint:disable-next-line: no-conditional-assignment
8663             while (r = re.exec(body)) {
8664                 let idx = parseInt(r[1], 10);
8665                 let val = r[2] || '';
8666                 let exists = values.get(idx);
8667                 if (exists == null || (val && exists == "''")) {
8668                     if (/^`!\w/.test(val) && val.endsWith('`')) {
8669                         let code = val.slice(1).slice(0, -1);
8670                         val = await this.parser.execute(code, this.pyMethod, ind);
8671                     }
8672                     val = val.replace(/'/g, "\\'").replace(/\n/g, '\\n');
8673                     values.set(idx, "'" + val + "'");
8674                 }
8675             }
8676             re = /\$(\d+)/g;
8677             // tslint:disable-next-line: no-conditional-assignment
8678             while (r = re.exec(body)) {
8679                 let idx = parseInt(r[1], 10);
8680                 if (!values.has(idx)) {
8681                     values.set(idx, "''");
8682                 }
8683             }
8684             let len = values.size == 0 ? 0 : Math.max.apply(null, Array.from(values.keys()));
8685             let vals = (new Array(len)).fill('""');
8686             for (let [idx, val] of values.entries()) {
8687                 vals[idx] = val;
8688             }
8689             let pyCodes = [];
8690             pyCodes.push('import re, os, vim, string, random');
8691             pyCodes.push(`t = ('', ${vals.join(',')})`);
8692             pyCodes.push(`fn = '${path_1.default.basename(filepath)}'`);
8693             pyCodes.push(`path = '${filepath}'`);
8694             if (context) {
8695                 pyCodes.push(`snip = ContextSnippet()`);
8696                 pyCodes.push(`context = ${context}`);
8697             }
8698             else {
8699                 pyCodes.push(`context = {}`);
8700             }
8701             let start = `(${range.start.line},${Buffer.byteLength(line.slice(0, range.start.character))})`;
8702             let end = `(${range.end.line},${Buffer.byteLength(line.slice(0, range.end.character))})`;
8703             pyCodes.push(`snip = SnippetUtil('${ind}', ${start}, ${end}, context)`);
8704             if (originRegex) {
8705                 pyCodes.push(`pattern = re.compile(r"${originRegex.replace(/"/g, '\\"')}")`);
8706                 pyCodes.push(`match = pattern.search("${line.replace(/"/g, '\\"')}")`);
8707             }
8708             try {
8709                 await nvim.command(`${this.pyMethod} ${pyCodes.join('\n')}`);
8710             }
8711             catch (e) {
8712                 this.channel.appendLine(`[Error ${(new Date()).toLocaleTimeString()}]: ${e.message}`);
8713                 this.channel.appendLine(`code: ${pyCodes.join('\n')}`);
8714             }
8715         }
8716         return this.parser.resolveUltisnipsBody(body);
8717     }
8718     async checkContext(context) {
8719         let { nvim } = coc_nvim_1.workspace;
8720         let pyCodes = [];
8721         pyCodes.push('import re, os, vim, string, random');
8722         pyCodes.push(`snip = ContextSnippet()`);
8723         pyCodes.push(`context = ${context}`);
8724         await nvim.command(`${this.pyMethod} ${pyCodes.join('\n')}`);
8725         let res = await nvim.call(`${this.pyMethod}eval`, 'True if context else False');
8726         return res;
8727     }
8728     async getTriggerSnippets(document, position, autoTrigger) {
8729         let snippets = await this.getSnippets(document.filetype);
8730         let line = document.getline(position.line);
8731         line = line.slice(0, position.character);
8732         if (!line || line[line.length - 1] == ' ')
8733             return [];
8734         snippets = snippets.filter(s => {
8735             let { prefix, regex } = s;
8736             if (autoTrigger && !s.autoTrigger)
8737                 return false;
8738             if (regex) {
8739                 let ms = line.match(regex);
8740                 if (!ms)
8741                     return false;
8742                 prefix = ms[0];
8743             }
8744             if (!line.endsWith(prefix))
8745                 return false;
8746             if (s.triggerKind == types_1.TriggerKind.InWord)
8747                 return true;
8748             let pre = line.slice(0, line.length - prefix.length);
8749             if (s.triggerKind == types_1.TriggerKind.LineBegin)
8750                 return pre.trim() == '';
8751             if (s.triggerKind == types_1.TriggerKind.SpaceBefore)
8752                 return pre.length == 0 || /\s/.test(pre[pre.length - 1]);
8753             if (s.triggerKind == types_1.TriggerKind.WordBoundary)
8754                 return pre.length == 0 || !document.isWord(pre[pre.length - 1]);
8755             return false;
8756         });
8757         snippets.sort((a, b) => {
8758             if (a.context && !b.context)
8759                 return -1;
8760             if (b.context && !a.context)
8761                 return 1;
8762             return 0;
8763         });
8764         let edits = [];
8765         let contextPrefixes = [];
8766         for (let s of snippets) {
8767             let character;
8768             if (s.context) {
8769                 let valid = await this.checkContext(s.context);
8770                 if (!valid)
8771                     continue;
8772                 contextPrefixes.push(s.context);
8773             }
8774             else if (contextPrefixes.indexOf(s.prefix) !== -1) {
8775                 continue;
8776             }
8777             if (s.regex == null) {
8778                 character = position.character - s.prefix.length;
8779             }
8780             else {
8781                 let len = line.match(s.regex)[0].length;
8782                 character = position.character - len;
8783             }
8784             let range = vscode_languageserver_types_1.Range.create(position.line, character, position.line, position.character);
8785             let newText = await this.resolveSnippetBody(s, range, line);
8786             edits.push({
8787                 prefix: s.prefix,
8788                 description: s.description,
8789                 location: s.filepath,
8790                 priority: s.priority,
8791                 range,
8792                 newText,
8793             });
8794         }
8795         return edits;
8796     }
8797     async getSnippetFiles(filetype) {
8798         let filetypes = this.getFiletypes(filetype);
8799         let res = [];
8800         for (let s of this.snippetFiles) {
8801             if (filetypes.indexOf(s.filetype) !== -1) {
8802                 res.push(s.filepath);
8803             }
8804         }
8805         return res;
8806     }
8807     async getSnippets(filetype) {
8808         let filetypes = this.getFiletypes(filetype);
8809         filetypes.push('all');
8810         let snippetFiles = this.snippetFiles.filter(o => filetypes.indexOf(o.filetype) !== -1);
8811         let min = null;
8812         let result = [];
8813         snippetFiles.sort((a, b) => {
8814             if (a.filetype == b.filetype)
8815                 return 1;
8816             if (a.filetype == filetype)
8817                 return -1;
8818             return 1;
8819         });
8820         for (let file of snippetFiles) {
8821             let { snippets, clearsnippets } = file;
8822             if (typeof clearsnippets == 'number') {
8823                 min = min ? Math.max(min, clearsnippets) : clearsnippets;
8824             }
8825             for (let snip of snippets) {
8826                 if (snip.regex || snip.context) {
8827                     result.push(snip);
8828                 }
8829                 else {
8830                     let idx = result.findIndex(o => o.prefix == snip.prefix && o.triggerKind == snip.triggerKind);
8831                     if (idx == -1) {
8832                         result.push(snip);
8833                     }
8834                     else {
8835                         let item = result[idx];
8836                         if (snip.priority > item.priority) {
8837                             result[idx] = item;
8838                         }
8839                     }
8840                 }
8841             }
8842         }
8843         if (min != null)
8844             result = result.filter(o => o.priority >= min);
8845         result.sort((a, b) => {
8846             if (a.context && !b.context)
8847                 return -1;
8848             if (b.context && !a.context)
8849                 return 1;
8850             return 0;
8851         });
8852         return result;
8853     }
8854     async getAllSnippetFiles(runtimepath) {
8855         let { directories } = this;
8856         let res = [];
8857         for (let directory of directories) {
8858             if (path_1.default.isAbsolute(directory)) {
8859                 let items = await this.getSnippetFileItems(directory);
8860                 res.push(...items);
8861             }
8862         }
8863         let subFolders = await this.getSubFolders();
8864         let rtps = runtimepath.split(',');
8865         this.runtimeDirs = rtps;
8866         for (let rtp of rtps) {
8867             let items = await this.getSnippetsFromPlugin(rtp, subFolders);
8868             res.push(...items);
8869         }
8870         return res;
8871     }
8872     async getSubFolders() {
8873         let { directories } = this;
8874         directories = directories.filter(s => !path_1.default.isAbsolute(s));
8875         // use UltiSnipsSnippetDirectories
8876         let dirs = await coc_nvim_1.workspace.nvim.eval('get(g:, "UltiSnipsSnippetDirectories", [])');
8877         for (let dir of dirs) {
8878             if (directories.indexOf(dir) == -1) {
8879                 directories.push(dir);
8880             }
8881         }
8882         return directories;
8883     }
8884     async getSnippetsFromPlugin(directory, subFolders) {
8885         let res = [];
8886         for (let folder of subFolders) {
8887             let items = await this.getSnippetFileItems(path_1.default.join(directory, folder));
8888             res.push(...items);
8889         }
8890         return res;
8891     }
8892     async getSnippetFileItems(directory) {
8893         let res = [];
8894         let stat = await util_1.statAsync(directory);
8895         if (stat && stat.isDirectory()) {
8896             let files = await util_1.readdirAsync(directory);
8897             if (files.length) {
8898                 for (let f of files) {
8899                     let file = path_1.default.join(directory, f);
8900                     if (file.endsWith('.snippets')) {
8901                         let basename = path_1.default.basename(f, '.snippets');
8902                         let filetype = basename.split('_', 2)[0];
8903                         res.push({ filepath: file, directory, filetype });
8904                     }
8905                     else {
8906                         let stat = await util_1.statAsync(file);
8907                         if (stat && stat.isDirectory()) {
8908                             let files = await util_1.readdirAsync(file);
8909                             for (let filename of files) {
8910                                 if (filename.endsWith('.snippets')) {
8911                                     res.push({ filepath: path_1.default.join(file, filename), directory, filetype: f });
8912                                 }
8913                             }
8914                         }
8915                     }
8916                 }
8917             }
8918         }
8919         return res;
8920     }
8921     async executePythonCode(pythonCode) {
8922         try {
8923             let dir = path_1.default.join(os_1.default.tmpdir(), `coc.nvim-${process.pid}`);
8924             if (!fs_1.default.existsSync(dir))
8925                 fs_1.default.mkdirSync(dir);
8926             let tmpfile = path_1.default.join(os_1.default.tmpdir(), `coc.nvim-${process.pid}`, `coc-ultisnips-${util_1.uid()}.py`);
8927             fs_1.default.writeFileSync(tmpfile, '# -*- coding: utf-8 -*-\n' + pythonCode, 'utf8');
8928             await coc_nvim_1.workspace.nvim.command(`exe '${this.pyMethod}file '.fnameescape('${tmpfile}')`);
8929             pythonCodes.clear();
8930         }
8931         catch (e) {
8932             this.channel.appendLine(`Error on execute python script:`);
8933             this.channel.append(e.message);
8934             coc_nvim_1.workspace.showMessage(`Error on execute python script: ${e.message}`, 'error');
8935         }
8936     }
8937     dispose() {
8938         coc_nvim_1.disposeAll(this.disposables);
8939     }
8940 }
8941 exports.UltiSnippetsProvider = UltiSnippetsProvider;
8942
8943
8944 /***/ }),
8945 /* 50 */
8946 /***/ (function(module, exports, __webpack_require__) {
8947
8948 "use strict";
8949
8950 var __importDefault = (this && this.__importDefault) || function (mod) {
8951     return (mod && mod.__esModule) ? mod : { "default": mod };
8952 };
8953 Object.defineProperty(exports, "__esModule", { value: true });
8954 /******************************************************************
8955 MIT License http://www.opensource.org/licenses/mit-license.php
8956 Author Qiming Zhao <chemzqm@gmail> (https://github.com/chemzqm)
8957 *******************************************************************/
8958 const child_process_1 = __webpack_require__(51);
8959 const coc_nvim_1 = __webpack_require__(1);
8960 const fs_1 = __importDefault(__webpack_require__(3));
8961 const pify_1 = __importDefault(__webpack_require__(38));
8962 const readline_1 = __importDefault(__webpack_require__(40));
8963 const parser_1 = __importDefault(__webpack_require__(42));
8964 const types_1 = __webpack_require__(36);
8965 const util_1 = __webpack_require__(37);
8966 class UltiSnipsParser {
8967     constructor(pyMethod, channel, trace = 'error') {
8968         this.pyMethod = pyMethod;
8969         this.channel = channel;
8970         this.trace = trace;
8971     }
8972     parseUltisnipsFile(filepath) {
8973         const rl = readline_1.default.createInterface({
8974             input: fs_1.default.createReadStream(filepath, 'utf8'),
8975             crlfDelay: Infinity
8976         });
8977         let pycodes = [];
8978         let snippets = [];
8979         let block;
8980         let preLines = [];
8981         let first;
8982         let priority = 0;
8983         let lnum = 0;
8984         let clearsnippets = null;
8985         let parsedContext = null;
8986         let extendFiletypes = [];
8987         rl.on('line', line => {
8988             lnum += 1;
8989             if (!block && (line.startsWith('#') || line.length == 0))
8990                 return;
8991             const [head, tail] = util_1.headTail(line);
8992             if (!block) {
8993                 switch (head) {
8994                     case 'priority':
8995                         let n = parseInt(tail.trim(), 10);
8996                         if (!isNaN(n))
8997                             priority = n;
8998                         break;
8999                     case 'extends':
9000                         let fts = tail.trim().split(/,\s+/);
9001                         for (let ft of fts) {
9002                             if (extendFiletypes.indexOf(ft) == -1) {
9003                                 extendFiletypes.push(ft);
9004                             }
9005                         }
9006                         break;
9007                     case 'clearsnippets':
9008                         clearsnippets = priority;
9009                         break;
9010                     case 'context':
9011                         parsedContext = tail.replace(/^"(.+)"$/, '$1');
9012                         break;
9013                     case 'snippet':
9014                     case 'global':
9015                         block = head;
9016                         first = tail;
9017                         break;
9018                 }
9019                 return;
9020             }
9021             if (head == 'endglobal' && block == 'global') {
9022                 block = null;
9023                 pycodes.push(...preLines);
9024                 preLines = [];
9025                 return;
9026             }
9027             if (head == 'endsnippet' && block == 'snippet') {
9028                 block = null;
9029                 try {
9030                     let originRegex;
9031                     let body = preLines.join('\n');
9032                     // convert placeholder regex to javascript regex
9033                     body = body.replace(/((?:[^\\]?\$\{\w+?)\/)([^\n]*?[^\\])(?=\/)/g, (_match, p1, p2) => {
9034                         return p1 + util_1.convertRegex(p2);
9035                     });
9036                     let ms = first.match(/^(.+?)(?:\s+(?:"(.*?)")?(?:\s+"(.*?)")?(?:\s+(\w+))?)?\s*$/);
9037                     let prefix = ms[1];
9038                     let description = ms[2] || '';
9039                     let context = ms[3];
9040                     let option = ms[4] || '';
9041                     if (prefix.length > 2 && prefix[0] == prefix[prefix.length - 1] && !/\w/.test(prefix[0])) {
9042                         prefix = prefix.slice(1, prefix.length - 1);
9043                     }
9044                     let isExpression = option.indexOf('r') !== -1;
9045                     let regex = null;
9046                     if (isExpression) {
9047                         originRegex = prefix;
9048                         prefix = util_1.convertRegex(prefix);
9049                         prefix = prefix.endsWith('$') ? prefix : prefix + '$';
9050                         try {
9051                             regex = new RegExp(prefix);
9052                             // get the real text
9053                             prefix = util_1.getRegexText(prefix);
9054                         }
9055                         catch (e) {
9056                             this.error(`Convert regex error for: ${prefix}`);
9057                         }
9058                     }
9059                     if (parsedContext) {
9060                         context = parsedContext;
9061                     }
9062                     else if (option.indexOf('e') == -1) {
9063                         context = null;
9064                     }
9065                     let snippet = {
9066                         filepath,
9067                         context,
9068                         originRegex,
9069                         autoTrigger: option.indexOf('A') !== -1,
9070                         lnum: lnum - preLines.length - 2,
9071                         triggerKind: getTriggerKind(option),
9072                         prefix,
9073                         description,
9074                         regex,
9075                         body,
9076                         priority
9077                     };
9078                     snippets.push(snippet);
9079                 }
9080                 catch (e) {
9081                     this.error(`Create snippet error on: ${filepath}:${lnum - preLines.length - 1} ${e.message}`);
9082                 }
9083                 finally {
9084                     parsedContext = null;
9085                     preLines = [];
9086                 }
9087             }
9088             if (block == 'snippet' || block == 'global') {
9089                 preLines.push(line);
9090                 return;
9091             }
9092         });
9093         return new Promise(resolve => {
9094             rl.on('close', async () => {
9095                 resolve({ snippets, clearsnippets, pythonCode: pycodes.join('\n'), extendFiletypes });
9096             });
9097         });
9098     }
9099     async resolveUltisnipsBody(body) {
9100         let { pyMethod } = this;
9101         let parser = new parser_1.default(body);
9102         let resolved = '';
9103         while (!parser.eof()) {
9104             let p = parser.prev();
9105             if (parser.curr == '`' && (!p || p != '\\')) {
9106                 let idx = parser.nextIndex('`', true, false);
9107                 if (idx == -1) {
9108                     resolved = resolved + parser.eatTo(parser.len);
9109                     break;
9110                 }
9111                 let code = parser.eatTo(idx + 1);
9112                 code = code.slice(1, -1);
9113                 let indent = resolved.split(/\n/).slice(-1)[0].match(/^\s*/)[0];
9114                 resolved = resolved + await this.execute(code, pyMethod, indent);
9115                 continue;
9116             }
9117             else if (parser.curr == '$') {
9118                 let text = parser.next(7);
9119                 if (text.startsWith('VISUAL') || text.startsWith('{VISUAL')) {
9120                     parser.eat(8);
9121                     resolved += '$' + text.replace('VISUAL', 'TM_SELECTED_TEXT');
9122                 }
9123                 else if (!/^\d/.test(text) && !text.startsWith('{') && p != '\\') {
9124                     // escape $ if it's not escaped and not a placeholder, ultisnips sucks
9125                     resolved += '\\' + parser.eat(1);
9126                 }
9127                 else {
9128                     // skip current
9129                     resolved += parser.eat(1);
9130                 }
9131             }
9132             let prev = parser.prev() || '';
9133             parser.iterate(ch => {
9134                 if (prev !== '\\' && (ch == '`' || ch == '$')) {
9135                     return false;
9136                 }
9137                 else {
9138                     resolved = resolved + ch;
9139                 }
9140                 prev = ch;
9141                 return true;
9142             });
9143         }
9144         resolved = decode(resolved);
9145         this.debug(`resolved: ${resolved}`);
9146         return resolved;
9147     }
9148     async execute(code, pyMethod, indent) {
9149         let { nvim } = coc_nvim_1.workspace;
9150         let res = '';
9151         if (code.startsWith('!')) {
9152             code = code.trim().slice(1);
9153             if (code.startsWith('p')) {
9154                 code = code.slice(1).trim();
9155                 let lines = code.split('\n');
9156                 lines = lines.map(line => line.replace(/\t/g, '    '));
9157                 lines = lines.map(line => `    ${line}`);
9158                 lines.unshift('try:');
9159                 lines.unshift('import traceback');
9160                 lines.push('except Exception as e:');
9161                 lines.push('    snip.rv = traceback.format_exc()');
9162                 await nvim.command(`${pyMethod} ${lines.join('\n')}`);
9163                 res = await nvim.call(`${pyMethod}eval`, 'snip.rv');
9164             }
9165             else if (code.startsWith('v')) {
9166                 code = code.replace(/^v\s*/, '');
9167                 try {
9168                     res = await nvim.eval(code);
9169                 }
9170                 catch (e) {
9171                     res = `Error: ${e.message}`;
9172                     this.error(e.stack);
9173                 }
9174             }
9175         }
9176         else {
9177             try {
9178                 res = await pify_1.default(child_process_1.exec)(code);
9179             }
9180             catch (e) {
9181                 res = `Error: ${e.message}`;
9182                 this.error(`Error on eval ${code}: ` + e.stack);
9183             }
9184         }
9185         res = res.toString();
9186         res = res.replace(/\r?\n$/, '');
9187         let parts = res.split(/\r?\n/);
9188         if (parts.length > 1) {
9189             res = parts.map((s, idx) => {
9190                 if (idx == 0 || s.length == 0)
9191                     return s;
9192                 return `${indent}${s}`;
9193             }).join('\n');
9194         }
9195         return res;
9196     }
9197     error(str) {
9198         if (!this.channel)
9199             return;
9200         this.channel.appendLine(`[Error ${(new Date()).toLocaleTimeString()}] ${str}`);
9201     }
9202     debug(str) {
9203         if (!this.channel || this.trace == 'error')
9204             return;
9205         this.channel.appendLine(`[Debug ${(new Date()).toLocaleTimeString()}] ${str}`);
9206     }
9207 }
9208 exports.default = UltiSnipsParser;
9209 function decode(str) {
9210     return str.replace(/\\`/g, '`').replace(/\\{/g, '{');
9211 }
9212 function getTriggerKind(option) {
9213     if (option.indexOf('w') !== -1) {
9214         return types_1.TriggerKind.WordBoundary;
9215     }
9216     if (option.indexOf('b') !== -1) {
9217         return types_1.TriggerKind.LineBegin;
9218     }
9219     if (option.indexOf('i') !== -1) {
9220         return types_1.TriggerKind.InWord;
9221     }
9222     return types_1.TriggerKind.SpaceBefore;
9223 }
9224
9225
9226 /***/ }),
9227 /* 51 */
9228 /***/ (function(module, exports) {
9229
9230 module.exports = require("child_process");
9231
9232 /***/ }),
9233 /* 52 */
9234 /***/ (function(module, exports) {
9235
9236 /**
9237  * Returns a function, that, as long as it continues to be invoked, will not
9238  * be triggered. The function will be called after it stops being called for
9239  * N milliseconds. If `immediate` is passed, trigger the function on the
9240  * leading edge, instead of the trailing. The function also has a property 'clear'
9241  * that is a function which will clear the timer to prevent previously scheduled executions.
9242  *
9243  * @source underscore.js
9244  * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/
9245  * @param {Function} function to wrap
9246  * @param {Number} timeout in ms (`100`)
9247  * @param {Boolean} whether to execute at the beginning (`false`)
9248  * @api public
9249  */
9250 function debounce(func, wait, immediate){
9251   var timeout, args, context, timestamp, result;
9252   if (null == wait) wait = 100;
9253
9254   function later() {
9255     var last = Date.now() - timestamp;
9256
9257     if (last < wait && last >= 0) {
9258       timeout = setTimeout(later, wait - last);
9259     } else {
9260       timeout = null;
9261       if (!immediate) {
9262         result = func.apply(context, args);
9263         context = args = null;
9264       }
9265     }
9266   };
9267
9268   var debounced = function(){
9269     context = this;
9270     args = arguments;
9271     timestamp = Date.now();
9272     var callNow = immediate && !timeout;
9273     if (!timeout) timeout = setTimeout(later, wait);
9274     if (callNow) {
9275       result = func.apply(context, args);
9276       context = args = null;
9277     }
9278
9279     return result;
9280   };
9281
9282   debounced.clear = function() {
9283     if (timeout) {
9284       clearTimeout(timeout);
9285       timeout = null;
9286     }
9287   };
9288
9289   debounced.flush = function() {
9290     if (timeout) {
9291       result = func.apply(context, args);
9292       context = args = null;
9293
9294       clearTimeout(timeout);
9295       timeout = null;
9296     }
9297   };
9298
9299   return debounced;
9300 };
9301
9302 // Adds compatibility for ES modules
9303 debounce.debounce = debounce;
9304
9305 module.exports = debounce;
9306
9307
9308 /***/ }),
9309 /* 53 */
9310 /***/ (function(module, exports, __webpack_require__) {
9311
9312 "use strict";
9313
9314 Object.defineProperty(exports, "__esModule", { value: true });
9315 const coc_nvim_1 = __webpack_require__(1);
9316 const vscode_languageserver_protocol_1 = __webpack_require__(8);
9317 const util_1 = __webpack_require__(37);
9318 const codesMap = new Map();
9319 codesMap.set(1, 'invalid snippet line, trigger requried.');
9320 codesMap.set(2, 'invalid snippet option, option "$1" not supported.');
9321 codesMap.set(3, 'invalid python expression, $1');
9322 codesMap.set(4, 'invalid code interpolation, #! not supported.');
9323 const validOptions = ['b', 'i', 'w', 'r', 'e', 'A'];
9324 class LanguageProvider {
9325     constructor(channel, trace = 'error') {
9326         this.channel = channel;
9327         this.trace = trace;
9328         this.disposables = [];
9329         this.collection = coc_nvim_1.languages.createDiagnosticCollection('snippets');
9330         for (let doc of coc_nvim_1.workspace.documents) {
9331             if (this.shouldValidate(doc.uri)) {
9332                 this.validate(doc.uri, doc.getDocumentContent()).catch(e => {
9333                     channel.appendLine(`[Error ${(new Date()).toLocaleTimeString()}]: ${e.message}`);
9334                 });
9335             }
9336         }
9337         coc_nvim_1.workspace.onDidOpenTextDocument(async (textDocument) => {
9338             let doc = coc_nvim_1.workspace.getDocument(textDocument.uri);
9339             if (!this.shouldValidate(doc.uri))
9340                 return;
9341             await this.validate(doc.uri, doc.getDocumentContent());
9342         }, null, this.disposables);
9343         coc_nvim_1.workspace.onDidChangeTextDocument(async (ev) => {
9344             let doc = coc_nvim_1.workspace.getDocument(ev.textDocument.uri);
9345             if (!doc || !this.shouldValidate(doc.uri))
9346                 return;
9347             await this.validate(doc.uri, doc.getDocumentContent());
9348         }, null, this.disposables);
9349         coc_nvim_1.workspace.onDidCloseTextDocument(e => {
9350             this.collection.delete(e.uri);
9351         }, null, this.disposables);
9352     }
9353     shouldValidate(uri) {
9354         return uri.endsWith('.snippets');
9355     }
9356     async validate(uri, content) {
9357         let lines = content.split('\n');
9358         let diagnostics = [];
9359         let curr = 0;
9360         for (let line of lines) {
9361             if (/^snippet\s*$/.test(line)) {
9362                 let range = vscode_languageserver_protocol_1.Range.create(curr, 0, curr, line.length);
9363                 diagnostics.push(vscode_languageserver_protocol_1.Diagnostic.create(range, codesMap.get(1), vscode_languageserver_protocol_1.DiagnosticSeverity.Error, 1));
9364                 continue;
9365             }
9366             if (line.startsWith('snippet ')) {
9367                 let content = util_1.headTail(line)[1];
9368                 let ms = content.match(/^(.+?)(?:\s+(?:"(.*?)")?(?:\s+"(.*?)")?(?:\s+(\w+))?)?$/);
9369                 let prefix = ms[1];
9370                 if (prefix.length > 2 && prefix[0] == prefix[prefix.length - 1] && !/\w/.test(prefix[0])) {
9371                     prefix = prefix.slice(1, prefix.length - 1);
9372                 }
9373                 let option = ms[4] || '';
9374                 let isExpression = option.indexOf('r') !== -1;
9375                 let startCharacter = line.length - option.length;
9376                 for (let ch of option) {
9377                     if (validOptions.indexOf(ch) == -1) {
9378                         let range = vscode_languageserver_protocol_1.Range.create(curr, startCharacter, curr, startCharacter + 1);
9379                         let message = codesMap.get(2).replace('$1', ch);
9380                         diagnostics.push(vscode_languageserver_protocol_1.Diagnostic.create(range, message, vscode_languageserver_protocol_1.DiagnosticSeverity.Error, 2));
9381                     }
9382                     startCharacter = startCharacter + 1;
9383                 }
9384                 if (isExpression) {
9385                     try {
9386                         util_1.convertRegex(prefix);
9387                     }
9388                     catch (e) {
9389                         let start = line.indexOf(prefix);
9390                         let range = vscode_languageserver_protocol_1.Range.create(curr, start, curr, start + prefix.length);
9391                         let message = codesMap.get(3).replace('$1', e.message);
9392                         diagnostics.push(vscode_languageserver_protocol_1.Diagnostic.create(range, message, vscode_languageserver_protocol_1.DiagnosticSeverity.Error, 3));
9393                     }
9394                 }
9395             }
9396             else {
9397                 let idx = line.indexOf('`#!');
9398                 if (idx !== -1) {
9399                     let range = vscode_languageserver_protocol_1.Range.create(curr, idx, curr, idx + 3);
9400                     let message = codesMap.get(4);
9401                     diagnostics.push(vscode_languageserver_protocol_1.Diagnostic.create(range, message, vscode_languageserver_protocol_1.DiagnosticSeverity.Error, 4));
9402                 }
9403             }
9404             curr++;
9405         }
9406         if (this.trace == 'verbose') {
9407             this.channel.appendLine(`[Debug ${(new Date()).toLocaleTimeString()}] diagnostics of ${uri} -> ${JSON.stringify(diagnostics)}`);
9408         }
9409         this.collection.set(uri, diagnostics);
9410     }
9411     provideCompletionItems(_document, position, _token, context) {
9412         let { input, col } = context.option;
9413         if (context.triggerCharacter == '$') {
9414             return [{
9415                     label: '$VISUAL',
9416                     kind: vscode_languageserver_protocol_1.CompletionItemKind.Snippet,
9417                     // tslint:disable-next-line: no-invalid-template-strings
9418                     detail: '${VISUAL}',
9419                     insertTextFormat: vscode_languageserver_protocol_1.InsertTextFormat.Snippet,
9420                     textEdit: {
9421                         range: vscode_languageserver_protocol_1.Range.create(position.line, position.character - 1, position.line, position.character),
9422                         // tslint:disable-next-line: no-invalid-template-strings
9423                         newText: '\\${VISUAL${1::default}\\}'
9424                     }
9425                 }];
9426         }
9427         if (col == 0 && 'snippet'.startsWith(input)) {
9428             return [{
9429                     label: 'snippet',
9430                     kind: vscode_languageserver_protocol_1.CompletionItemKind.Snippet,
9431                     detail: 'Snippet definition',
9432                     insertTextFormat: vscode_languageserver_protocol_1.InsertTextFormat.Snippet,
9433                     // tslint:disable-next-line: no-invalid-template-strings
9434                     insertText: 'snippet ${1:Tab_trigger} "${2:Description}" ${3:b}\n$0\nendsnippet'
9435                 }];
9436         }
9437         return [];
9438     }
9439     async resolveCompletionItem(item) {
9440         // tslint:disable-next-line: deprecation
9441         let text = item.insertText || item.textEdit.newText;
9442         // tslint:disable-next-line: deprecation
9443         let snip = await Promise.resolve(coc_nvim_1.snippetManager.resolveSnippet(text));
9444         item.documentation = {
9445             kind: 'markdown',
9446             value: util_1.markdownBlock(snip.toString(), 'snippets')
9447         };
9448         return item;
9449     }
9450 }
9451 exports.default = LanguageProvider;
9452
9453
9454 /***/ })
9455 /******/ ])));