rinri
/
dots
1
1
Çatalla 0
Kod Konular 0 Değişiklik İstekleri 0 Sürümler 0 Wiki Aktivite
My dotfiles
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.
1 İşle
1 Dal
45 MiB
 
 
Ağaç: a30576f93f
Dallar Biçim İmleri
${ item.name }
${ searchTerm } dalı oluştur
'a30576f93f'den
${ noResults }
dots/.config/coc/extensions/node_modules/coc-json/lib/index.js

5403 satır
243 KiB
Ham Suçlama Geçmiş 

  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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {

  94.     return new (P || (P = Promise))(function (resolve, reject) {

  95.         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }

  96.         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }

  97.         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }

  98.         step((generator = generator.apply(thisArg, _arguments || [])).next());

  99.     });

  100. };

  101. var __importDefault = (this && this.__importDefault) || function (mod) {

  102.     return (mod && mod.__esModule) ? mod : { "default": mod };

  103. };

  104. Object.defineProperty(exports, "__esModule", { value: true });

  105. const path_1 = __importDefault(__webpack_require__(1));

  106. const fs_1 = __importDefault(__webpack_require__(2));

  107. const vscode_languageserver_protocol_1 = __webpack_require__(3);

  108. const catalog_json_1 = __importDefault(__webpack_require__(30));

  109. const hash_1 = __webpack_require__(31);

  110. const coc_nvim_1 = __webpack_require__(32);

  111. var ForceValidateRequest;

  112. (function (ForceValidateRequest) {

  113.     ForceValidateRequest.type = new vscode_languageserver_protocol_1.RequestType('json/validate');

  114. })(ForceValidateRequest || (ForceValidateRequest = {}));

  115. function activate(context) {

  116.     return __awaiter(this, void 0, void 0, function* () {

  117.         let { subscriptions, logger } = context;

  118.         const config = coc_nvim_1.workspace.getConfiguration().get('json', {});

  119.         if (!config.enable)

  120.             return;

  121.         const file = context.asAbsolutePath('lib/server.js');

  122.         const selector = ['json', 'jsonc'];

  123.         let schemaContent = yield readFile(path_1.default.join(coc_nvim_1.workspace.pluginRoot, 'data/schema.json'), 'utf8');

  124.         let settingsSchema = JSON.parse(schemaContent);

  125.         let fileSchemaErrors = new Map();

  126.         coc_nvim_1.events.on('BufEnter', bufnr => {

  127.             let doc = coc_nvim_1.workspace.getDocument(bufnr);

  128.             if (!doc)

  129.                 return;

  130.             let msg = fileSchemaErrors.get(doc.uri);

  131.             if (msg)

  132.                 coc_nvim_1.workspace.showMessage(`Schema error: ${msg}`, 'warning');

  133.         }, null, subscriptions);

  134.         let serverOptions = {

  135.             module: file,

  136.             transport: coc_nvim_1.TransportKind.ipc,

  137.             options: {

  138.                 cwd: coc_nvim_1.workspace.root,

  139.                 execArgv: config.execArgv

  140.             }

  141.         };

  142.         let clientOptions = {

  143.             documentSelector: selector,

  144.             synchronize: {

  145.                 configurationSection: ['json', 'http'],

  146.                 fileEvents: coc_nvim_1.workspace.createFileSystemWatcher('**/*.json')

  147.             },

  148.             outputChannelName: 'json',

  149.             diagnosticCollectionName: 'json',

  150.             middleware: {

  151.                 workspace: {

  152.                     didChangeConfiguration: () => client.sendNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, { settings: getSettings() })

  153.                 },

  154.                 handleDiagnostics: (uri, diagnostics, next) => {

  155.                     const schemaErrorIndex = diagnostics.findIndex(candidate => candidate.code === /* SchemaResolveError */ 0x300);

  156.                     if (uri.endsWith('coc-settings.json')) {

  157.                         diagnostics = diagnostics.filter(o => o.code != 521);

  158.                     }

  159.                     if (schemaErrorIndex === -1) {

  160.                         fileSchemaErrors.delete(uri.toString());

  161.                         return next(uri, diagnostics);

  162.                     }

  163.                     const schemaResolveDiagnostic = diagnostics[schemaErrorIndex];

  164.                     fileSchemaErrors.set(uri.toString(), schemaResolveDiagnostic.message);

  165.                     let doc = coc_nvim_1.workspace.getDocument(uri);

  166.                     if (doc && doc.uri == uri) {

  167.                         coc_nvim_1.workspace.showMessage(`Schema error: ${schemaResolveDiagnostic.message}`, 'warning');

  168.                     }

  169.                     next(uri, diagnostics);

  170.                 },

  171.                 resolveCompletionItem: (item, token, next) => {

  172.                     return Promise.resolve(next(item, token)).then((item) => {

  173.                         if (item.data.detail) {

  174.                             item.detail = item.data.detail;

  175.                         }

  176.                         return item;

  177.                     });

  178.                 },

  179.                 // fix completeItem

  180.                 provideCompletionItem: (document, position, context, token, next) => {

  181.                     return Promise.resolve(next(document, position, context, token)).then((res) => {

  182.                         let doc = coc_nvim_1.workspace.getDocument(document.uri);

  183.                         if (!doc)

  184.                             return [];

  185.                         let items = res.hasOwnProperty('isIncomplete') ? res.items : res;

  186.                         let line = doc.getline(position.line);

  187.                         for (let item of items) {

  188.                             let { textEdit, insertText, label, filterText } = item; // tslint:disable-line

  189.                             item.insertText = null; // tslint:disable-line

  190.                             if (textEdit && textEdit.newText) {

  191.                                 let newText = insertText || textEdit.newText;

  192.                                 textEdit.newText = newText;

  193.                                 let { start, end } = textEdit.range;

  194.                                 if (line[start.character] && line[end.character - 1] && /^".*"$/.test(label)) {

  195.                                     item.label = item.label.slice(1, -1);

  196.                                 }

  197.                             }

  198.                             if (filterText && /^".*"$/.test(filterText)) {

  199.                                 item.filterText = filterText.slice(1, -1);

  200.                             }

  201.                         }

  202.                         let result = {

  203.                             isIncomplete: false,

  204.                             items

  205.                         };

  206.                         if (items.length && items.every(o => o.kind == vscode_languageserver_protocol_1.CompletionItemKind.Property)) {

  207.                             result.startcol = doc.fixStartcol(position, ['.']);

  208.                         }

  209.                         return result;

  210.                     });

  211.                 }

  212.             }

  213.         };

  214.         let client = new coc_nvim_1.LanguageClient('json', 'Json language server', serverOptions, clientOptions);

  215.         subscriptions.push(coc_nvim_1.services.registLanguageClient(client));

  216.         client.onReady().then(() => {

  217.             for (let doc of coc_nvim_1.workspace.documents) {

  218.                 onDocumentCreate(doc.textDocument).catch(_e => {

  219.                     // noop

  220.                 });

  221.             }

  222.             let associations = {};

  223.             for (let item of catalog_json_1.default.schemas) {

  224.                 let { fileMatch, url } = item;

  225.                 if (Array.isArray(fileMatch)) {

  226.                     for (let key of fileMatch) {

  227.                         associations[key] = [url];

  228.                     }

  229.                 }

  230.                 else if (typeof fileMatch === 'string') {

  231.                     associations[fileMatch] = [url];

  232.                 }

  233.             }

  234.             coc_nvim_1.extensions.all.forEach(extension => {

  235.                 let { packageJSON } = extension;

  236.                 let { contributes } = packageJSON;

  237.                 if (!contributes)

  238.                     return;

  239.                 let { jsonValidation } = contributes;

  240.                 if (jsonValidation && jsonValidation.length) {

  241.                     for (let item of jsonValidation) {

  242.                         let { url, fileMatch } = item;

  243.                         // fileMatch

  244.                         if (url && !/^http(s)?:/.test(url)) {

  245.                             let file = path_1.default.join(extension.extensionPath, url);

  246.                             if (fs_1.default.existsSync(file))

  247.                                 url = coc_nvim_1.Uri.file(file).toString();

  248.                         }

  249.                         if (url) {

  250.                             let curr = associations[fileMatch];

  251.                             if (!curr) {

  252.                                 associations[fileMatch] = [url];

  253.                             }

  254.                             else if (curr && curr.indexOf(url) == -1) {

  255.                                 curr.push(url);

  256.                             }

  257.                         }

  258.                     }

  259.                 }

  260.             });

  261.             associations['coc-settings.json'] = ['vscode://settings'];

  262.             client.sendNotification('json/schemaAssociations', associations);

  263.             client.onRequest('vscode/content', (uri) => __awaiter(this, void 0, void 0, function* () {

  264.                 if (uri == 'vscode://settings') {

  265.                     let schema = Object.assign({}, settingsSchema);

  266.                     schema.properties = schema.properties || {};

  267.                     if (coc_nvim_1.extensions.schemes)

  268.                         Object.assign(schema.properties, coc_nvim_1.extensions.schemes);

  269.                     coc_nvim_1.extensions.all.forEach(extension => {

  270.                         let { packageJSON } = extension;

  271.                         let { contributes } = packageJSON;

  272.                         if (!contributes)

  273.                             return;

  274.                         let { configuration } = contributes;

  275.                         if (configuration) {

  276.                             let { properties, definitions } = configuration;

  277.                             if (properties)

  278.                                 Object.assign(schema.properties, properties);

  279.                             if (definitions)

  280.                                 Object.assign(schema.definitions, definitions);

  281.                         }

  282.                     });

  283.                     return JSON.stringify(schema);

  284.                 }

  285.                 logger.error(`Unknown schema for ${uri}`);

  286.                 return '{}';

  287.             }));

  288.         }, _e => {

  289.             // noop

  290.         });

  291.         function onDocumentCreate(document) {

  292.             return __awaiter(this, void 0, void 0, function* () {

  293.                 if (!coc_nvim_1.workspace.match(selector, document))

  294.                     return;

  295.                 if (client.serviceState !== coc_nvim_1.ServiceStat.Running)

  296.                     return;

  297.                 let file = coc_nvim_1.Uri.parse(document.uri).fsPath;

  298.                 let associations = {};

  299.                 let content = document.getText();

  300.                 if (content.indexOf('"$schema"') !== -1)

  301.                     return;

  302.                 let miniProgrameRoot = yield coc_nvim_1.workspace.resolveRootFolder(coc_nvim_1.Uri.parse(document.uri), ['project.config.json']);

  303.                 if (miniProgrameRoot) {

  304.                     if (path_1.default.dirname(file) == miniProgrameRoot) {

  305.                         return;

  306.                     }

  307.                     let arr = ['page', 'component'].map(str => {

  308.                         return coc_nvim_1.Uri.file(context.asAbsolutePath(`data/${str}.json`)).toString();

  309.                     });

  310.                     associations['/' + file] = arr;

  311.                     associations['app.json'] = [coc_nvim_1.Uri.file(context.asAbsolutePath('data/app.json')).toString()];

  312.                 }

  313.                 if (Object.keys(associations).length > 0) {

  314.                     client.sendNotification('json/schemaAssociations', associations);

  315.                 }

  316.             });

  317.         }

  318.         coc_nvim_1.workspace.onDidOpenTextDocument(onDocumentCreate, null, subscriptions);

  319.         coc_nvim_1.workspace.onDidCloseTextDocument(doc => {

  320.             fileSchemaErrors.delete(doc.uri);

  321.         }, null, subscriptions);

  322.         let statusItem = coc_nvim_1.workspace.createStatusBarItem(0, { progress: true });

  323.         subscriptions.push(statusItem);

  324.         subscriptions.push(coc_nvim_1.commands.registerCommand('json.retryResolveSchema', () => __awaiter(this, void 0, void 0, function* () {

  325.             let doc = yield coc_nvim_1.workspace.document;

  326.             if (!doc || ['json', 'jsonc'].indexOf(doc.filetype) == -1)

  327.                 return;

  328.             statusItem.isProgress = true;

  329.             statusItem.text = 'loading schema';

  330.             statusItem.show();

  331.             client.sendRequest(ForceValidateRequest.type, doc.uri).then(diagnostics => {

  332.                 statusItem.text = '⚠️';

  333.                 statusItem.isProgress = false;

  334.                 const schemaErrorIndex = diagnostics.findIndex(candidate => candidate.code === /* SchemaResolveError */ 0x300);

  335.                 if (schemaErrorIndex !== -1) {

  336.                     // Show schema resolution errors in status bar only; ref: #51032

  337.                     const schemaResolveDiagnostic = diagnostics[schemaErrorIndex];

  338.                     fileSchemaErrors.set(doc.uri, schemaResolveDiagnostic.message);

  339.                     statusItem.show();

  340.                 }

  341.                 else {

  342.                     statusItem.hide();

  343.                 }

  344.             }, () => {

  345.                 statusItem.show();

  346.                 statusItem.isProgress = false;

  347.                 statusItem.text = '⚠️';

  348.             });

  349.         })));

  350.     });

  351. }

  352. exports.activate = activate;

  353. function getSettings() {

  354.     let httpSettings = coc_nvim_1.workspace.getConfiguration('http');

  355.     let settings = {

  356.         http: {

  357.             proxy: httpSettings.get('proxy'),

  358.             proxyStrictSSL: httpSettings.get('proxyStrictSSL')

  359.         },

  360.         json: {

  361.             format: coc_nvim_1.workspace.getConfiguration('json').get('format'),

  362.             schemas: []

  363.         }

  364.     };

  365.     let schemaSettingsById = Object.create(null);

  366.     let collectSchemaSettings = (schemaSettings, rootPath, fileMatchPrefix) => {

  367.         for (let setting of schemaSettings) {

  368.             let url = getSchemaId(setting, rootPath);

  369.             if (!url) {

  370.                 continue;

  371.             }

  372.             let schemaSetting = schemaSettingsById[url];

  373.             if (!schemaSetting) {

  374.                 schemaSetting = schemaSettingsById[url] = { url, fileMatch: [] };

  375.                 settings.json.schemas.push(schemaSetting);

  376.             }

  377.             let fileMatches = setting.fileMatch;

  378.             let resultingFileMatches = schemaSetting.fileMatch;

  379.             if (Array.isArray(fileMatches)) {

  380.                 if (fileMatchPrefix) {

  381.                     for (let fileMatch of fileMatches) {

  382.                         if (fileMatch[0] === '/') {

  383.                             resultingFileMatches.push(fileMatchPrefix + fileMatch);

  384.                             resultingFileMatches.push(fileMatchPrefix + '/*' + fileMatch);

  385.                         }

  386.                         else {

  387.                             resultingFileMatches.push(fileMatchPrefix + '/' + fileMatch);

  388.                             resultingFileMatches.push(fileMatchPrefix + '/*/' + fileMatch);

  389.                         }

  390.                     }

  391.                 }

  392.                 else {

  393.                     resultingFileMatches.push(...fileMatches);

  394.                 }

  395.             }

  396.             if (setting.schema) {

  397.                 schemaSetting.schema = setting.schema;

  398.             }

  399.         }

  400.     };

  401.     // merge global and folder settings. Qualify all file matches with the folder path.

  402.     let globalSettings = coc_nvim_1.workspace.getConfiguration('json', null).get('schemas');

  403.     if (Array.isArray(globalSettings)) {

  404.         collectSchemaSettings(globalSettings, coc_nvim_1.workspace.root);

  405.     }

  406.     return settings;

  407. }

  408. function getSchemaId(schema, rootPath) {

  409.     let url = schema.url;

  410.     if (!url) {

  411.         if (schema.schema) {

  412.             url = schema.schema.id || `vscode://schemas/custom/${encodeURIComponent(hash_1.hash(schema.schema).toString(16))}`;

  413.         }

  414.     }

  415.     else if (rootPath && (url[0] === '.' || url[0] === '/')) {

  416.         url = coc_nvim_1.Uri.file(path_1.default.normalize(path_1.default.join(rootPath, url))).toString();

  417.     }

  418.     return url;

  419. }

  420. function readFile(fullpath, encoding) {

  421.     return new Promise((resolve, reject) => {

  422.         fs_1.default.readFile(fullpath, encoding, (err, content) => {

  423.             if (err)

  424.                 reject(err);

  425.             resolve(content);

  426.         });

  427.     });

  428. }

  429. 

  430. 

  431. /***/ }),

  432. /* 1 */

  433. /***/ (function(module, exports) {

  434. 

  435. module.exports = require("path");

  436. 

  437. /***/ }),

  438. /* 2 */

  439. /***/ (function(module, exports) {

  440. 

  441. module.exports = require("fs");

  442. 

  443. /***/ }),

  444. /* 3 */

  445. /***/ (function(module, exports, __webpack_require__) {

  446. 

  447. "use strict";

  448. /* --------------------------------------------------------------------------------------------

  449.  * Copyright (c) Microsoft Corporation. All rights reserved.

  450.  * Licensed under the MIT License. See License.txt in the project root for license information.

  451.  * ------------------------------------------------------------------------------------------ */

  452. 

  453. function __export(m) {

  454.     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];

  455. }

  456. Object.defineProperty(exports, "__esModule", { value: true });

  457. const vscode_jsonrpc_1 = __webpack_require__(4);

  458. exports.ErrorCodes = vscode_jsonrpc_1.ErrorCodes;

  459. exports.ResponseError = vscode_jsonrpc_1.ResponseError;

  460. exports.CancellationToken = vscode_jsonrpc_1.CancellationToken;

  461. exports.CancellationTokenSource = vscode_jsonrpc_1.CancellationTokenSource;

  462. exports.Disposable = vscode_jsonrpc_1.Disposable;

  463. exports.Event = vscode_jsonrpc_1.Event;

  464. exports.Emitter = vscode_jsonrpc_1.Emitter;

  465. exports.Trace = vscode_jsonrpc_1.Trace;

  466. exports.TraceFormat = vscode_jsonrpc_1.TraceFormat;

  467. exports.SetTraceNotification = vscode_jsonrpc_1.SetTraceNotification;

  468. exports.LogTraceNotification = vscode_jsonrpc_1.LogTraceNotification;

  469. exports.RequestType = vscode_jsonrpc_1.RequestType;

  470. exports.RequestType0 = vscode_jsonrpc_1.RequestType0;

  471. exports.NotificationType = vscode_jsonrpc_1.NotificationType;

  472. exports.NotificationType0 = vscode_jsonrpc_1.NotificationType0;

  473. exports.MessageReader = vscode_jsonrpc_1.MessageReader;

  474. exports.MessageWriter = vscode_jsonrpc_1.MessageWriter;

  475. exports.ConnectionStrategy = vscode_jsonrpc_1.ConnectionStrategy;

  476. exports.StreamMessageReader = vscode_jsonrpc_1.StreamMessageReader;

  477. exports.StreamMessageWriter = vscode_jsonrpc_1.StreamMessageWriter;

  478. exports.IPCMessageReader = vscode_jsonrpc_1.IPCMessageReader;

  479. exports.IPCMessageWriter = vscode_jsonrpc_1.IPCMessageWriter;

  480. exports.createClientPipeTransport = vscode_jsonrpc_1.createClientPipeTransport;

  481. exports.createServerPipeTransport = vscode_jsonrpc_1.createServerPipeTransport;

  482. exports.generateRandomPipeName = vscode_jsonrpc_1.generateRandomPipeName;

  483. exports.createClientSocketTransport = vscode_jsonrpc_1.createClientSocketTransport;

  484. exports.createServerSocketTransport = vscode_jsonrpc_1.createServerSocketTransport;

  485. __export(__webpack_require__(17));

  486. __export(__webpack_require__(18));

  487. const callHierarchy = __webpack_require__(27);

  488. const progress = __webpack_require__(28);

  489. const sr = __webpack_require__(29);

  490. var Proposed;

  491. (function (Proposed) {

  492.     let SelectionRangeRequest;

  493.     (function (SelectionRangeRequest) {

  494.         SelectionRangeRequest.type = sr.SelectionRangeRequest.type;

  495.     })(SelectionRangeRequest = Proposed.SelectionRangeRequest || (Proposed.SelectionRangeRequest = {}));

  496.     let CallHierarchyRequest;

  497.     (function (CallHierarchyRequest) {

  498.         CallHierarchyRequest.type = callHierarchy.CallHierarchyRequest.type;

  499.     })(CallHierarchyRequest = Proposed.CallHierarchyRequest || (Proposed.CallHierarchyRequest = {}));

  500.     let CallHierarchyDirection;

  501.     (function (CallHierarchyDirection) {

  502.         CallHierarchyDirection.CallsFrom = callHierarchy.CallHierarchyDirection.CallsFrom;

  503.         CallHierarchyDirection.CallsTo = callHierarchy.CallHierarchyDirection.CallsTo;

  504.     })(CallHierarchyDirection = Proposed.CallHierarchyDirection || (Proposed.CallHierarchyDirection = {}));

  505.     let ProgressStartNotification;

  506.     (function (ProgressStartNotification) {

  507.         ProgressStartNotification.type = progress.ProgressStartNotification.type;

  508.     })(ProgressStartNotification = Proposed.ProgressStartNotification || (Proposed.ProgressStartNotification = {}));

  509.     let ProgressReportNotification;

  510.     (function (ProgressReportNotification) {

  511.         ProgressReportNotification.type = progress.ProgressReportNotification.type;

  512.     })(ProgressReportNotification = Proposed.ProgressReportNotification || (Proposed.ProgressReportNotification = {}));

  513.     let ProgressDoneNotification;

  514.     (function (ProgressDoneNotification) {

  515.         ProgressDoneNotification.type = progress.ProgressDoneNotification.type;

  516.     })(ProgressDoneNotification = Proposed.ProgressDoneNotification || (Proposed.ProgressDoneNotification = {}));

  517.     let ProgressCancelNotification;

  518.     (function (ProgressCancelNotification) {

  519.         ProgressCancelNotification.type = progress.ProgressCancelNotification.type;

  520.     })(ProgressCancelNotification = Proposed.ProgressCancelNotification || (Proposed.ProgressCancelNotification = {}));

  521. })(Proposed = exports.Proposed || (exports.Proposed = {}));

  522. function createProtocolConnection(reader, writer, logger, strategy) {

  523.     return vscode_jsonrpc_1.createMessageConnection(reader, writer, logger, strategy);

  524. }

  525. exports.createProtocolConnection = createProtocolConnection;

  526. 

  527. 

  528. /***/ }),

  529. /* 4 */

  530. /***/ (function(module, exports, __webpack_require__) {

  531. 

  532. "use strict";

  533. /* --------------------------------------------------------------------------------------------

  534.  * Copyright (c) Microsoft Corporation. All rights reserved.

  535.  * Licensed under the MIT License. See License.txt in the project root for license information.

  536.  * ------------------------------------------------------------------------------------------ */

  537. /// <reference path="./thenable.ts" />

  538. 

  539. function __export(m) {

  540.     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];

  541. }

  542. Object.defineProperty(exports, "__esModule", { value: true });

  543. const Is = __webpack_require__(5);

  544. const messages_1 = __webpack_require__(6);

  545. exports.RequestType = messages_1.RequestType;

  546. exports.RequestType0 = messages_1.RequestType0;

  547. exports.RequestType1 = messages_1.RequestType1;

  548. exports.RequestType2 = messages_1.RequestType2;

  549. exports.RequestType3 = messages_1.RequestType3;

  550. exports.RequestType4 = messages_1.RequestType4;

  551. exports.RequestType5 = messages_1.RequestType5;

  552. exports.RequestType6 = messages_1.RequestType6;

  553. exports.RequestType7 = messages_1.RequestType7;

  554. exports.RequestType8 = messages_1.RequestType8;

  555. exports.RequestType9 = messages_1.RequestType9;

  556. exports.ResponseError = messages_1.ResponseError;

  557. exports.ErrorCodes = messages_1.ErrorCodes;

  558. exports.NotificationType = messages_1.NotificationType;

  559. exports.NotificationType0 = messages_1.NotificationType0;

  560. exports.NotificationType1 = messages_1.NotificationType1;

  561. exports.NotificationType2 = messages_1.NotificationType2;

  562. exports.NotificationType3 = messages_1.NotificationType3;

  563. exports.NotificationType4 = messages_1.NotificationType4;

  564. exports.NotificationType5 = messages_1.NotificationType5;

  565. exports.NotificationType6 = messages_1.NotificationType6;

  566. exports.NotificationType7 = messages_1.NotificationType7;

  567. exports.NotificationType8 = messages_1.NotificationType8;

  568. exports.NotificationType9 = messages_1.NotificationType9;

  569. const messageReader_1 = __webpack_require__(7);

  570. exports.MessageReader = messageReader_1.MessageReader;

  571. exports.StreamMessageReader = messageReader_1.StreamMessageReader;

  572. exports.IPCMessageReader = messageReader_1.IPCMessageReader;

  573. exports.SocketMessageReader = messageReader_1.SocketMessageReader;

  574. const messageWriter_1 = __webpack_require__(9);

  575. exports.MessageWriter = messageWriter_1.MessageWriter;

  576. exports.StreamMessageWriter = messageWriter_1.StreamMessageWriter;

  577. exports.IPCMessageWriter = messageWriter_1.IPCMessageWriter;

  578. exports.SocketMessageWriter = messageWriter_1.SocketMessageWriter;

  579. const events_1 = __webpack_require__(8);

  580. exports.Disposable = events_1.Disposable;

  581. exports.Event = events_1.Event;

  582. exports.Emitter = events_1.Emitter;

  583. const cancellation_1 = __webpack_require__(10);

  584. exports.CancellationTokenSource = cancellation_1.CancellationTokenSource;

  585. exports.CancellationToken = cancellation_1.CancellationToken;

  586. const linkedMap_1 = __webpack_require__(11);

  587. __export(__webpack_require__(12));

  588. __export(__webpack_require__(16));

  589. var CancelNotification;

  590. (function (CancelNotification) {

  591.     CancelNotification.type = new messages_1.NotificationType('$/cancelRequest');

  592. })(CancelNotification || (CancelNotification = {}));

  593. exports.NullLogger = Object.freeze({

  594.     error: () => { },

  595.     warn: () => { },

  596.     info: () => { },

  597.     log: () => { }

  598. });

  599. var Trace;

  600. (function (Trace) {

  601.     Trace[Trace["Off"] = 0] = "Off";

  602.     Trace[Trace["Messages"] = 1] = "Messages";

  603.     Trace[Trace["Verbose"] = 2] = "Verbose";

  604. })(Trace = exports.Trace || (exports.Trace = {}));

  605. (function (Trace) {

  606.     function fromString(value) {

  607.         value = value.toLowerCase();

  608.         switch (value) {

  609.             case 'off':

  610.                 return Trace.Off;

  611.             case 'messages':

  612.                 return Trace.Messages;

  613.             case 'verbose':

  614.                 return Trace.Verbose;

  615.             default:

  616.                 return Trace.Off;

  617.         }

  618.     }

  619.     Trace.fromString = fromString;

  620.     function toString(value) {

  621.         switch (value) {

  622.             case Trace.Off:

  623.                 return 'off';

  624.             case Trace.Messages:

  625.                 return 'messages';

  626.             case Trace.Verbose:

  627.                 return 'verbose';

  628.             default:

  629.                 return 'off';

  630.         }

  631.     }

  632.     Trace.toString = toString;

  633. })(Trace = exports.Trace || (exports.Trace = {}));

  634. var TraceFormat;

  635. (function (TraceFormat) {

  636.     TraceFormat["Text"] = "text";

  637.     TraceFormat["JSON"] = "json";

  638. })(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));

  639. (function (TraceFormat) {

  640.     function fromString(value) {

  641.         value = value.toLowerCase();

  642.         if (value === 'json') {

  643.             return TraceFormat.JSON;

  644.         }

  645.         else {

  646.             return TraceFormat.Text;

  647.         }

  648.     }

  649.     TraceFormat.fromString = fromString;

  650. })(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));

  651. var SetTraceNotification;

  652. (function (SetTraceNotification) {

  653.     SetTraceNotification.type = new messages_1.NotificationType('$/setTraceNotification');

  654. })(SetTraceNotification = exports.SetTraceNotification || (exports.SetTraceNotification = {}));

  655. var LogTraceNotification;

  656. (function (LogTraceNotification) {

  657.     LogTraceNotification.type = new messages_1.NotificationType('$/logTraceNotification');

  658. })(LogTraceNotification = exports.LogTraceNotification || (exports.LogTraceNotification = {}));

  659. var ConnectionErrors;

  660. (function (ConnectionErrors) {

  661.     /**

  662.      * The connection is closed.

  663.      */

  664.     ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";

  665.     /**

  666.      * The connection got disposed.

  667.      */

  668.     ConnectionErrors[ConnectionErrors["Disposed"] = 2] = "Disposed";

  669.     /**

  670.      * The connection is already in listening mode.

  671.      */

  672.     ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";

  673. })(ConnectionErrors = exports.ConnectionErrors || (exports.ConnectionErrors = {}));

  674. class ConnectionError extends Error {

  675.     constructor(code, message) {

  676.         super(message);

  677.         this.code = code;

  678.         Object.setPrototypeOf(this, ConnectionError.prototype);

  679.     }

  680. }

  681. exports.ConnectionError = ConnectionError;

  682. var ConnectionStrategy;

  683. (function (ConnectionStrategy) {

  684.     function is(value) {

  685.         let candidate = value;

  686.         return candidate && Is.func(candidate.cancelUndispatched);

  687.     }

  688.     ConnectionStrategy.is = is;

  689. })(ConnectionStrategy = exports.ConnectionStrategy || (exports.ConnectionStrategy = {}));

  690. var ConnectionState;

  691. (function (ConnectionState) {

  692.     ConnectionState[ConnectionState["New"] = 1] = "New";

  693.     ConnectionState[ConnectionState["Listening"] = 2] = "Listening";

  694.     ConnectionState[ConnectionState["Closed"] = 3] = "Closed";

  695.     ConnectionState[ConnectionState["Disposed"] = 4] = "Disposed";

  696. })(ConnectionState || (ConnectionState = {}));

  697. function _createMessageConnection(messageReader, messageWriter, logger, strategy) {

  698.     let sequenceNumber = 0;

  699.     let notificationSquenceNumber = 0;

  700.     let unknownResponseSquenceNumber = 0;

  701.     const version = '2.0';

  702.     let starRequestHandler = undefined;

  703.     let requestHandlers = Object.create(null);

  704.     let starNotificationHandler = undefined;

  705.     let notificationHandlers = Object.create(null);

  706.     let timer;

  707.     let messageQueue = new linkedMap_1.LinkedMap();

  708.     let responsePromises = Object.create(null);

  709.     let requestTokens = Object.create(null);

  710.     let trace = Trace.Off;

  711.     let traceFormat = TraceFormat.Text;

  712.     let tracer;

  713.     let state = ConnectionState.New;

  714.     let errorEmitter = new events_1.Emitter();

  715.     let closeEmitter = new events_1.Emitter();

  716.     let unhandledNotificationEmitter = new events_1.Emitter();

  717.     let disposeEmitter = new events_1.Emitter();

  718.     function createRequestQueueKey(id) {

  719.         return 'req-' + id.toString();

  720.     }

  721.     function createResponseQueueKey(id) {

  722.         if (id === null) {

  723.             return 'res-unknown-' + (++unknownResponseSquenceNumber).toString();

  724.         }

  725.         else {

  726.             return 'res-' + id.toString();

  727.         }

  728.     }

  729.     function createNotificationQueueKey() {

  730.         return 'not-' + (++notificationSquenceNumber).toString();

  731.     }

  732.     function addMessageToQueue(queue, message) {

  733.         if (messages_1.isRequestMessage(message)) {

  734.             queue.set(createRequestQueueKey(message.id), message);

  735.         }

  736.         else if (messages_1.isResponseMessage(message)) {

  737.             queue.set(createResponseQueueKey(message.id), message);

  738.         }

  739.         else {

  740.             queue.set(createNotificationQueueKey(), message);

  741.         }

  742.     }

  743.     function cancelUndispatched(_message) {

  744.         return undefined;

  745.     }

  746.     function isListening() {

  747.         return state === ConnectionState.Listening;

  748.     }

  749.     function isClosed() {

  750.         return state === ConnectionState.Closed;

  751.     }

  752.     function isDisposed() {

  753.         return state === ConnectionState.Disposed;

  754.     }

  755.     function closeHandler() {

  756.         if (state === ConnectionState.New || state === ConnectionState.Listening) {

  757.             state = ConnectionState.Closed;

  758.             closeEmitter.fire(undefined);

  759.         }

  760.         // If the connection is disposed don't sent close events.

  761.     }

  762.     ;

  763.     function readErrorHandler(error) {

  764.         errorEmitter.fire([error, undefined, undefined]);

  765.     }

  766.     function writeErrorHandler(data) {

  767.         errorEmitter.fire(data);

  768.     }

  769.     messageReader.onClose(closeHandler);

  770.     messageReader.onError(readErrorHandler);

  771.     messageWriter.onClose(closeHandler);

  772.     messageWriter.onError(writeErrorHandler);

  773.     function triggerMessageQueue() {

  774.         if (timer || messageQueue.size === 0) {

  775.             return;

  776.         }

  777.         timer = setImmediate(() => {

  778.             timer = undefined;

  779.             processMessageQueue();

  780.         });

  781.     }

  782.     function processMessageQueue() {

  783.         if (messageQueue.size === 0) {

  784.             return;

  785.         }

  786.         let message = messageQueue.shift();

  787.         try {

  788.             if (messages_1.isRequestMessage(message)) {

  789.                 handleRequest(message);

  790.             }

  791.             else if (messages_1.isNotificationMessage(message)) {

  792.                 handleNotification(message);

  793.             }

  794.             else if (messages_1.isResponseMessage(message)) {

  795.                 handleResponse(message);

  796.             }

  797.             else {

  798.                 handleInvalidMessage(message);

  799.             }

  800.         }

  801.         finally {

  802.             triggerMessageQueue();

  803.         }

  804.     }

  805.     let callback = (message) => {

  806.         try {

  807.             // We have received a cancellation message. Check if the message is still in the queue

  808.             // and cancel it if allowed to do so.

  809.             if (messages_1.isNotificationMessage(message) && message.method === CancelNotification.type.method) {

  810.                 let key = createRequestQueueKey(message.params.id);

  811.                 let toCancel = messageQueue.get(key);

  812.                 if (messages_1.isRequestMessage(toCancel)) {

  813.                     let response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);

  814.                     if (response && (response.error !== void 0 || response.result !== void 0)) {

  815.                         messageQueue.delete(key);

  816.                         response.id = toCancel.id;

  817.                         traceSendingResponse(response, message.method, Date.now());

  818.                         messageWriter.write(response);

  819.                         return;

  820.                     }

  821.                 }

  822.             }

  823.             addMessageToQueue(messageQueue, message);

  824.         }

  825.         finally {

  826.             triggerMessageQueue();

  827.         }

  828.     };

  829.     function handleRequest(requestMessage) {

  830.         if (isDisposed()) {

  831.             // we return here silently since we fired an event when the

  832.             // connection got disposed.

  833.             return;

  834.         }

  835.         function reply(resultOrError, method, startTime) {

  836.             let message = {

  837.                 jsonrpc: version,

  838.                 id: requestMessage.id

  839.             };

  840.             if (resultOrError instanceof messages_1.ResponseError) {

  841.                 message.error = resultOrError.toJson();

  842.             }

  843.             else {

  844.                 message.result = resultOrError === void 0 ? null : resultOrError;

  845.             }

  846.             traceSendingResponse(message, method, startTime);

  847.             messageWriter.write(message);

  848.         }

  849.         function replyError(error, method, startTime) {

  850.             let message = {

  851.                 jsonrpc: version,

  852.                 id: requestMessage.id,

  853.                 error: error.toJson()

  854.             };

  855.             traceSendingResponse(message, method, startTime);

  856.             messageWriter.write(message);

  857.         }

  858.         function replySuccess(result, method, startTime) {

  859.             // The JSON RPC defines that a response must either have a result or an error

  860.             // So we can't treat undefined as a valid response result.

  861.             if (result === void 0) {

  862.                 result = null;

  863.             }

  864.             let message = {

  865.                 jsonrpc: version,

  866.                 id: requestMessage.id,

  867.                 result: result

  868.             };

  869.             traceSendingResponse(message, method, startTime);

  870.             messageWriter.write(message);

  871.         }

  872.         traceReceivedRequest(requestMessage);

  873.         let element = requestHandlers[requestMessage.method];

  874.         let type;

  875.         let requestHandler;

  876.         if (element) {

  877.             type = element.type;

  878.             requestHandler = element.handler;

  879.         }

  880.         let startTime = Date.now();

  881.         if (requestHandler || starRequestHandler) {

  882.             let cancellationSource = new cancellation_1.CancellationTokenSource();

  883.             let tokenKey = String(requestMessage.id);

  884.             requestTokens[tokenKey] = cancellationSource;

  885.             try {

  886.                 let handlerResult;

  887.                 if (requestMessage.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) {

  888.                     handlerResult = requestHandler

  889.                         ? requestHandler(cancellationSource.token)

  890.                         : starRequestHandler(requestMessage.method, cancellationSource.token);

  891.                 }

  892.                 else if (Is.array(requestMessage.params) && (type === void 0 || type.numberOfParams > 1)) {

  893.                     handlerResult = requestHandler

  894.                         ? requestHandler(...requestMessage.params, cancellationSource.token)

  895.                         : starRequestHandler(requestMessage.method, ...requestMessage.params, cancellationSource.token);

  896.                 }

  897.                 else {

  898.                     handlerResult = requestHandler

  899.                         ? requestHandler(requestMessage.params, cancellationSource.token)

  900.                         : starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);

  901.                 }

  902.                 let promise = handlerResult;

  903.                 if (!handlerResult) {

  904.                     delete requestTokens[tokenKey];

  905.                     replySuccess(handlerResult, requestMessage.method, startTime);

  906.                 }

  907.                 else if (promise.then) {

  908.                     promise.then((resultOrError) => {

  909.                         delete requestTokens[tokenKey];

  910.                         reply(resultOrError, requestMessage.method, startTime);

  911.                     }, error => {

  912.                         delete requestTokens[tokenKey];

  913.                         if (error instanceof messages_1.ResponseError) {

  914.                             replyError(error, requestMessage.method, startTime);

  915.                         }

  916.                         else if (error && Is.string(error.message)) {

  917.                             replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);

  918.                         }

  919.                         else {

  920.                             replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);

  921.                         }

  922.                     });

  923.                 }

  924.                 else {

  925.                     delete requestTokens[tokenKey];

  926.                     reply(handlerResult, requestMessage.method, startTime);

  927.                 }

  928.             }

  929.             catch (error) {

  930.                 delete requestTokens[tokenKey];

  931.                 if (error instanceof messages_1.ResponseError) {

  932.                     reply(error, requestMessage.method, startTime);

  933.                 }

  934.                 else if (error && Is.string(error.message)) {

  935.                     replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);

  936.                 }

  937.                 else {

  938.                     replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);

  939.                 }

  940.             }

  941.         }

  942.         else {

  943.             replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);

  944.         }

  945.     }

  946.     function handleResponse(responseMessage) {

  947.         if (isDisposed()) {

  948.             // See handle request.

  949.             return;

  950.         }

  951.         if (responseMessage.id === null) {

  952.             if (responseMessage.error) {

  953.                 logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);

  954.             }

  955.             else {

  956.                 logger.error(`Received response message without id. No further error information provided.`);

  957.             }

  958.         }

  959.         else {

  960.             let key = String(responseMessage.id);

  961.             let responsePromise = responsePromises[key];

  962.             traceReceivedResponse(responseMessage, responsePromise);

  963.             if (responsePromise) {

  964.                 delete responsePromises[key];

  965.                 try {

  966.                     if (responseMessage.error) {

  967.                         let error = responseMessage.error;

  968.                         responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));

  969.                     }

  970.                     else if (responseMessage.result !== void 0) {

  971.                         responsePromise.resolve(responseMessage.result);

  972.                     }

  973.                     else {

  974.                         throw new Error('Should never happen.');

  975.                     }

  976.                 }

  977.                 catch (error) {

  978.                     if (error.message) {

  979.                         logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);

  980.                     }

  981.                     else {

  982.                         logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);

  983.                     }

  984.                 }

  985.             }

  986.         }

  987.     }

  988.     function handleNotification(message) {

  989.         if (isDisposed()) {

  990.             // See handle request.

  991.             return;

  992.         }

  993.         let type = undefined;

  994.         let notificationHandler;

  995.         if (message.method === CancelNotification.type.method) {

  996.             notificationHandler = (params) => {

  997.                 let id = params.id;

  998.                 let source = requestTokens[String(id)];

  999.                 if (source) {

  1000.                     source.cancel();

  1001.                 }

  1002.             };

  1003.         }

  1004.         else {

  1005.             let element = notificationHandlers[message.method];

  1006.             if (element) {

  1007.                 notificationHandler = element.handler;

  1008.                 type = element.type;

  1009.             }

  1010.         }

  1011.         if (notificationHandler || starNotificationHandler) {

  1012.             try {

  1013.                 traceReceivedNotification(message);

  1014.                 if (message.params === void 0 || (type !== void 0 && type.numberOfParams === 0)) {

  1015.                     notificationHandler ? notificationHandler() : starNotificationHandler(message.method);

  1016.                 }

  1017.                 else if (Is.array(message.params) && (type === void 0 || type.numberOfParams > 1)) {

  1018.                     notificationHandler ? notificationHandler(...message.params) : starNotificationHandler(message.method, ...message.params);

  1019.                 }

  1020.                 else {

  1021.                     notificationHandler ? notificationHandler(message.params) : starNotificationHandler(message.method, message.params);

  1022.                 }

  1023.             }

  1024.             catch (error) {

  1025.                 if (error.message) {

  1026.                     logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);

  1027.                 }

  1028.                 else {

  1029.                     logger.error(`Notification handler '${message.method}' failed unexpectedly.`);

  1030.                 }

  1031.             }

  1032.         }

  1033.         else {

  1034.             unhandledNotificationEmitter.fire(message);

  1035.         }

  1036.     }

  1037.     function handleInvalidMessage(message) {

  1038.         if (!message) {

  1039.             logger.error('Received empty message.');

  1040.             return;

  1041.         }

  1042.         logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);

  1043.         // Test whether we find an id to reject the promise

  1044.         let responseMessage = message;

  1045.         if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {

  1046.             let key = String(responseMessage.id);

  1047.             let responseHandler = responsePromises[key];

  1048.             if (responseHandler) {

  1049.                 responseHandler.reject(new Error('The received response has neither a result nor an error property.'));

  1050.             }

  1051.         }

  1052.     }

  1053.     function traceSendingRequest(message) {

  1054.         if (trace === Trace.Off || !tracer) {

  1055.             return;

  1056.         }

  1057.         if (traceFormat === TraceFormat.Text) {

  1058.             let data = undefined;

  1059.             if (trace === Trace.Verbose && message.params) {

  1060.                 data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;

  1061.             }

  1062.             tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);

  1063.         }

  1064.         else {

  1065.             logLSPMessage('send-request', message);

  1066.         }

  1067.     }

  1068.     function traceSendingNotification(message) {

  1069.         if (trace === Trace.Off || !tracer) {

  1070.             return;

  1071.         }

  1072.         if (traceFormat === TraceFormat.Text) {

  1073.             let data = undefined;

  1074.             if (trace === Trace.Verbose) {

  1075.                 if (message.params) {

  1076.                     data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;

  1077.                 }

  1078.                 else {

  1079.                     data = 'No parameters provided.\n\n';

  1080.                 }

  1081.             }

  1082.             tracer.log(`Sending notification '${message.method}'.`, data);

  1083.         }

  1084.         else {

  1085.             logLSPMessage('send-notification', message);

  1086.         }

  1087.     }

  1088.     function traceSendingResponse(message, method, startTime) {

  1089.         if (trace === Trace.Off || !tracer) {

  1090.             return;

  1091.         }

  1092.         if (traceFormat === TraceFormat.Text) {

  1093.             let data = undefined;

  1094.             if (trace === Trace.Verbose) {

  1095.                 if (message.error && message.error.data) {

  1096.                     data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`;

  1097.                 }

  1098.                 else {

  1099.                     if (message.result) {

  1100.                         data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`;

  1101.                     }

  1102.                     else if (message.error === void 0) {

  1103.                         data = 'No result returned.\n\n';

  1104.                     }

  1105.                 }

  1106.             }

  1107.             tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);

  1108.         }

  1109.         else {

  1110.             logLSPMessage('send-response', message);

  1111.         }

  1112.     }

  1113.     function traceReceivedRequest(message) {

  1114.         if (trace === Trace.Off || !tracer) {

  1115.             return;

  1116.         }

  1117.         if (traceFormat === TraceFormat.Text) {

  1118.             let data = undefined;

  1119.             if (trace === Trace.Verbose && message.params) {

  1120.                 data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;

  1121.             }

  1122.             tracer.log(`Received request '${message.method} - (${message.id})'.`, data);

  1123.         }

  1124.         else {

  1125.             logLSPMessage('receive-request', message);

  1126.         }

  1127.     }

  1128.     function traceReceivedNotification(message) {

  1129.         if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {

  1130.             return;

  1131.         }

  1132.         if (traceFormat === TraceFormat.Text) {

  1133.             let data = undefined;

  1134.             if (trace === Trace.Verbose) {

  1135.                 if (message.params) {

  1136.                     data = `Params: ${JSON.stringify(message.params, null, 4)}\n\n`;

  1137.                 }

  1138.                 else {

  1139.                     data = 'No parameters provided.\n\n';

  1140.                 }

  1141.             }

  1142.             tracer.log(`Received notification '${message.method}'.`, data);

  1143.         }

  1144.         else {

  1145.             logLSPMessage('receive-notification', message);

  1146.         }

  1147.     }

  1148.     function traceReceivedResponse(message, responsePromise) {

  1149.         if (trace === Trace.Off || !tracer) {

  1150.             return;

  1151.         }

  1152.         if (traceFormat === TraceFormat.Text) {

  1153.             let data = undefined;

  1154.             if (trace === Trace.Verbose) {

  1155.                 if (message.error && message.error.data) {

  1156.                     data = `Error data: ${JSON.stringify(message.error.data, null, 4)}\n\n`;

  1157.                 }

  1158.                 else {

  1159.                     if (message.result) {

  1160.                         data = `Result: ${JSON.stringify(message.result, null, 4)}\n\n`;

  1161.                     }

  1162.                     else if (message.error === void 0) {

  1163.                         data = 'No result returned.\n\n';

  1164.                     }

  1165.                 }

  1166.             }

  1167.             if (responsePromise) {

  1168.                 let error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : '';

  1169.                 tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);

  1170.             }

  1171.             else {

  1172.                 tracer.log(`Received response ${message.id} without active response promise.`, data);

  1173.             }

  1174.         }

  1175.         else {

  1176.             logLSPMessage('receive-response', message);

  1177.         }

  1178.     }

  1179.     function logLSPMessage(type, message) {

  1180.         if (!tracer || trace === Trace.Off) {

  1181.             return;

  1182.         }

  1183.         const lspMessage = {

  1184.             isLSPMessage: true,

  1185.             type,

  1186.             message,

  1187.             timestamp: Date.now()

  1188.         };

  1189.         tracer.log(lspMessage);

  1190.     }

  1191.     function throwIfClosedOrDisposed() {

  1192.         if (isClosed()) {

  1193.             throw new ConnectionError(ConnectionErrors.Closed, 'Connection is closed.');

  1194.         }

  1195.         if (isDisposed()) {

  1196.             throw new ConnectionError(ConnectionErrors.Disposed, 'Connection is disposed.');

  1197.         }

  1198.     }

  1199.     function throwIfListening() {

  1200.         if (isListening()) {

  1201.             throw new ConnectionError(ConnectionErrors.AlreadyListening, 'Connection is already listening');

  1202.         }

  1203.     }

  1204.     function throwIfNotListening() {

  1205.         if (!isListening()) {

  1206.             throw new Error('Call listen() first.');

  1207.         }

  1208.     }

  1209.     function undefinedToNull(param) {

  1210.         if (param === void 0) {

  1211.             return null;

  1212.         }

  1213.         else {

  1214.             return param;

  1215.         }

  1216.     }

  1217.     function computeMessageParams(type, params) {

  1218.         let result;

  1219.         let numberOfParams = type.numberOfParams;

  1220.         switch (numberOfParams) {

  1221.             case 0:

  1222.                 result = null;

  1223.                 break;

  1224.             case 1:

  1225.                 result = undefinedToNull(params[0]);

  1226.                 break;

  1227.             default:

  1228.                 result = [];

  1229.                 for (let i = 0; i < params.length && i < numberOfParams; i++) {

  1230.                     result.push(undefinedToNull(params[i]));

  1231.                 }

  1232.                 if (params.length < numberOfParams) {

  1233.                     for (let i = params.length; i < numberOfParams; i++) {

  1234.                         result.push(null);

  1235.                     }

  1236.                 }

  1237.                 break;

  1238.         }

  1239.         return result;

  1240.     }

  1241.     let connection = {

  1242.         sendNotification: (type, ...params) => {

  1243.             throwIfClosedOrDisposed();

  1244.             let method;

  1245.             let messageParams;

  1246.             if (Is.string(type)) {

  1247.                 method = type;

  1248.                 switch (params.length) {

  1249.                     case 0:

  1250.                         messageParams = null;

  1251.                         break;

  1252.                     case 1:

  1253.                         messageParams = params[0];

  1254.                         break;

  1255.                     default:

  1256.                         messageParams = params;

  1257.                         break;

  1258.                 }

  1259.             }

  1260.             else {

  1261.                 method = type.method;

  1262.                 messageParams = computeMessageParams(type, params);

  1263.             }

  1264.             let notificationMessage = {

  1265.                 jsonrpc: version,

  1266.                 method: method,

  1267.                 params: messageParams

  1268.             };

  1269.             traceSendingNotification(notificationMessage);

  1270.             messageWriter.write(notificationMessage);

  1271.         },

  1272.         onNotification: (type, handler) => {

  1273.             throwIfClosedOrDisposed();

  1274.             if (Is.func(type)) {

  1275.                 starNotificationHandler = type;

  1276.             }

  1277.             else if (handler) {

  1278.                 if (Is.string(type)) {

  1279.                     notificationHandlers[type] = { type: undefined, handler };

  1280.                 }

  1281.                 else {

  1282.                     notificationHandlers[type.method] = { type, handler };

  1283.                 }

  1284.             }

  1285.         },

  1286.         sendRequest: (type, ...params) => {

  1287.             throwIfClosedOrDisposed();

  1288.             throwIfNotListening();

  1289.             let method;

  1290.             let messageParams;

  1291.             let token = undefined;

  1292.             if (Is.string(type)) {

  1293.                 method = type;

  1294.                 switch (params.length) {

  1295.                     case 0:

  1296.                         messageParams = null;

  1297.                         break;

  1298.                     case 1:

  1299.                         // The cancellation token is optional so it can also be undefined.

  1300.                         if (cancellation_1.CancellationToken.is(params[0])) {

  1301.                             messageParams = null;

  1302.                             token = params[0];

  1303.                         }

  1304.                         else {

  1305.                             messageParams = undefinedToNull(params[0]);

  1306.                         }

  1307.                         break;

  1308.                     default:

  1309.                         const last = params.length - 1;

  1310.                         if (cancellation_1.CancellationToken.is(params[last])) {

  1311.                             token = params[last];

  1312.                             if (params.length === 2) {

  1313.                                 messageParams = undefinedToNull(params[0]);

  1314.                             }

  1315.                             else {

  1316.                                 messageParams = params.slice(0, last).map(value => undefinedToNull(value));

  1317.                             }

  1318.                         }

  1319.                         else {

  1320.                             messageParams = params.map(value => undefinedToNull(value));

  1321.                         }

  1322.                         break;

  1323.                 }

  1324.             }

  1325.             else {

  1326.                 method = type.method;

  1327.                 messageParams = computeMessageParams(type, params);

  1328.                 let numberOfParams = type.numberOfParams;

  1329.                 token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : undefined;

  1330.             }

  1331.             let id = sequenceNumber++;

  1332.             let result = new Promise((resolve, reject) => {

  1333.                 let requestMessage = {

  1334.                     jsonrpc: version,

  1335.                     id: id,

  1336.                     method: method,

  1337.                     params: messageParams

  1338.                 };

  1339.                 let responsePromise = { method: method, timerStart: Date.now(), resolve, reject };

  1340.                 traceSendingRequest(requestMessage);

  1341.                 try {

  1342.                     messageWriter.write(requestMessage);

  1343.                 }

  1344.                 catch (e) {

  1345.                     // Writing the message failed. So we need to reject the promise.

  1346.                     responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason'));

  1347.                     responsePromise = null;

  1348.                 }

  1349.                 if (responsePromise) {

  1350.                     responsePromises[String(id)] = responsePromise;

  1351.                 }

  1352.             });

  1353.             if (token) {

  1354.                 token.onCancellationRequested(() => {

  1355.                     connection.sendNotification(CancelNotification.type, { id });

  1356.                 });

  1357.             }

  1358.             return result;

  1359.         },

  1360.         onRequest: (type, handler) => {

  1361.             throwIfClosedOrDisposed();

  1362.             if (Is.func(type)) {

  1363.                 starRequestHandler = type;

  1364.             }

  1365.             else if (handler) {

  1366.                 if (Is.string(type)) {

  1367.                     requestHandlers[type] = { type: undefined, handler };

  1368.                 }

  1369.                 else {

  1370.                     requestHandlers[type.method] = { type, handler };

  1371.                 }

  1372.             }

  1373.         },

  1374.         trace: (_value, _tracer, sendNotificationOrTraceOptions) => {

  1375.             let _sendNotification = false;

  1376.             let _traceFormat = TraceFormat.Text;

  1377.             if (sendNotificationOrTraceOptions !== void 0) {

  1378.                 if (Is.boolean(sendNotificationOrTraceOptions)) {

  1379.                     _sendNotification = sendNotificationOrTraceOptions;

  1380.                 }

  1381.                 else {

  1382.                     _sendNotification = sendNotificationOrTraceOptions.sendNotification || false;

  1383.                     _traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;

  1384.                 }

  1385.             }

  1386.             trace = _value;

  1387.             traceFormat = _traceFormat;

  1388.             if (trace === Trace.Off) {

  1389.                 tracer = undefined;

  1390.             }

  1391.             else {

  1392.                 tracer = _tracer;

  1393.             }

  1394.             if (_sendNotification && !isClosed() && !isDisposed()) {

  1395.                 connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });

  1396.             }

  1397.         },

  1398.         onError: errorEmitter.event,

  1399.         onClose: closeEmitter.event,

  1400.         onUnhandledNotification: unhandledNotificationEmitter.event,

  1401.         onDispose: disposeEmitter.event,

  1402.         dispose: () => {

  1403.             if (isDisposed()) {

  1404.                 return;

  1405.             }

  1406.             state = ConnectionState.Disposed;

  1407.             disposeEmitter.fire(undefined);

  1408.             let error = new Error('Connection got disposed.');

  1409.             Object.keys(responsePromises).forEach((key) => {

  1410.                 responsePromises[key].reject(error);

  1411.             });

  1412.             responsePromises = Object.create(null);

  1413.             requestTokens = Object.create(null);

  1414.             messageQueue = new linkedMap_1.LinkedMap();

  1415.             // Test for backwards compatibility

  1416.             if (Is.func(messageWriter.dispose)) {

  1417.                 messageWriter.dispose();

  1418.             }

  1419.             if (Is.func(messageReader.dispose)) {

  1420.                 messageReader.dispose();

  1421.             }

  1422.         },

  1423.         listen: () => {

  1424.             throwIfClosedOrDisposed();

  1425.             throwIfListening();

  1426.             state = ConnectionState.Listening;

  1427.             messageReader.listen(callback);

  1428.         },

  1429.         inspect: () => {

  1430.             console.log("inspect");

  1431.         }

  1432.     };

  1433.     connection.onNotification(LogTraceNotification.type, (params) => {

  1434.         if (trace === Trace.Off || !tracer) {

  1435.             return;

  1436.         }

  1437.         tracer.log(params.message, trace === Trace.Verbose ? params.verbose : undefined);

  1438.     });

  1439.     return connection;

  1440. }

  1441. function isMessageReader(value) {

  1442.     return value.listen !== void 0 && value.read === void 0;

  1443. }

  1444. function isMessageWriter(value) {

  1445.     return value.write !== void 0 && value.end === void 0;

  1446. }

  1447. function createMessageConnection(input, output, logger, strategy) {

  1448.     if (!logger) {

  1449.         logger = exports.NullLogger;

  1450.     }

  1451.     let reader = isMessageReader(input) ? input : new messageReader_1.StreamMessageReader(input);

  1452.     let writer = isMessageWriter(output) ? output : new messageWriter_1.StreamMessageWriter(output);

  1453.     return _createMessageConnection(reader, writer, logger, strategy);

  1454. }

  1455. exports.createMessageConnection = createMessageConnection;

  1456. 

  1457. 

  1458. /***/ }),

  1459. /* 5 */

  1460. /***/ (function(module, exports, __webpack_require__) {

  1461. 

  1462. "use strict";

  1463. /* --------------------------------------------------------------------------------------------

  1464.  * Copyright (c) Microsoft Corporation. All rights reserved.

  1465.  * Licensed under the MIT License. See License.txt in the project root for license information.

  1466.  * ------------------------------------------------------------------------------------------ */

  1467. 

  1468. Object.defineProperty(exports, "__esModule", { value: true });

  1469. function boolean(value) {

  1470.     return value === true || value === false;

  1471. }

  1472. exports.boolean = boolean;

  1473. function string(value) {

  1474.     return typeof value === 'string' || value instanceof String;

  1475. }

  1476. exports.string = string;

  1477. function number(value) {

  1478.     return typeof value === 'number' || value instanceof Number;

  1479. }

  1480. exports.number = number;

  1481. function error(value) {

  1482.     return value instanceof Error;

  1483. }

  1484. exports.error = error;

  1485. function func(value) {

  1486.     return typeof value === 'function';

  1487. }

  1488. exports.func = func;

  1489. function array(value) {

  1490.     return Array.isArray(value);

  1491. }

  1492. exports.array = array;

  1493. function stringArray(value) {

  1494.     return array(value) && value.every(elem => string(elem));

  1495. }

  1496. exports.stringArray = stringArray;

  1497. 

  1498. 

  1499. /***/ }),

  1500. /* 6 */

  1501. /***/ (function(module, exports, __webpack_require__) {

  1502. 

  1503. "use strict";

  1504. /* --------------------------------------------------------------------------------------------

  1505.  * Copyright (c) Microsoft Corporation. All rights reserved.

  1506.  * Licensed under the MIT License. See License.txt in the project root for license information.

  1507.  * ------------------------------------------------------------------------------------------ */

  1508. 

  1509. Object.defineProperty(exports, "__esModule", { value: true });

  1510. const is = __webpack_require__(5);

  1511. /**

  1512.  * Predefined error codes.

  1513.  */

  1514. var ErrorCodes;

  1515. (function (ErrorCodes) {

  1516.     // Defined by JSON RPC

  1517.     ErrorCodes.ParseError = -32700;

  1518.     ErrorCodes.InvalidRequest = -32600;

  1519.     ErrorCodes.MethodNotFound = -32601;

  1520.     ErrorCodes.InvalidParams = -32602;

  1521.     ErrorCodes.InternalError = -32603;

  1522.     ErrorCodes.serverErrorStart = -32099;

  1523.     ErrorCodes.serverErrorEnd = -32000;

  1524.     ErrorCodes.ServerNotInitialized = -32002;

  1525.     ErrorCodes.UnknownErrorCode = -32001;

  1526.     // Defined by the protocol.

  1527.     ErrorCodes.RequestCancelled = -32800;

  1528.     ErrorCodes.ContentModified = -32801;

  1529.     // Defined by VSCode library.

  1530.     ErrorCodes.MessageWriteError = 1;

  1531.     ErrorCodes.MessageReadError = 2;

  1532. })(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}));

  1533. /**

  1534.  * An error object return in a response in case a request

  1535.  * has failed.

  1536.  */

  1537. class ResponseError extends Error {

  1538.     constructor(code, message, data) {

  1539.         super(message);

  1540.         this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;

  1541.         this.data = data;

  1542.         Object.setPrototypeOf(this, ResponseError.prototype);

  1543.     }

  1544.     toJson() {

  1545.         return {

  1546.             code: this.code,

  1547.             message: this.message,

  1548.             data: this.data,

  1549.         };

  1550.     }

  1551. }

  1552. exports.ResponseError = ResponseError;

  1553. /**

  1554.  * An abstract implementation of a MessageType.

  1555.  */

  1556. class AbstractMessageType {

  1557.     constructor(_method, _numberOfParams) {

  1558.         this._method = _method;

  1559.         this._numberOfParams = _numberOfParams;

  1560.     }

  1561.     get method() {

  1562.         return this._method;

  1563.     }

  1564.     get numberOfParams() {

  1565.         return this._numberOfParams;

  1566.     }

  1567. }

  1568. exports.AbstractMessageType = AbstractMessageType;

  1569. /**

  1570.  * Classes to type request response pairs

  1571.  */

  1572. class RequestType0 extends AbstractMessageType {

  1573.     constructor(method) {

  1574.         super(method, 0);

  1575.         this._ = undefined;

  1576.     }

  1577. }

  1578. exports.RequestType0 = RequestType0;

  1579. class RequestType extends AbstractMessageType {

  1580.     constructor(method) {

  1581.         super(method, 1);

  1582.         this._ = undefined;

  1583.     }

  1584. }

  1585. exports.RequestType = RequestType;

  1586. class RequestType1 extends AbstractMessageType {

  1587.     constructor(method) {

  1588.         super(method, 1);

  1589.         this._ = undefined;

  1590.     }

  1591. }

  1592. exports.RequestType1 = RequestType1;

  1593. class RequestType2 extends AbstractMessageType {

  1594.     constructor(method) {

  1595.         super(method, 2);

  1596.         this._ = undefined;

  1597.     }

  1598. }

  1599. exports.RequestType2 = RequestType2;

  1600. class RequestType3 extends AbstractMessageType {

  1601.     constructor(method) {

  1602.         super(method, 3);

  1603.         this._ = undefined;

  1604.     }

  1605. }

  1606. exports.RequestType3 = RequestType3;

  1607. class RequestType4 extends AbstractMessageType {

  1608.     constructor(method) {

  1609.         super(method, 4);

  1610.         this._ = undefined;

  1611.     }

  1612. }

  1613. exports.RequestType4 = RequestType4;

  1614. class RequestType5 extends AbstractMessageType {

  1615.     constructor(method) {

  1616.         super(method, 5);

  1617.         this._ = undefined;

  1618.     }

  1619. }

  1620. exports.RequestType5 = RequestType5;

  1621. class RequestType6 extends AbstractMessageType {

  1622.     constructor(method) {

  1623.         super(method, 6);

  1624.         this._ = undefined;

  1625.     }

  1626. }

  1627. exports.RequestType6 = RequestType6;

  1628. class RequestType7 extends AbstractMessageType {

  1629.     constructor(method) {

  1630.         super(method, 7);

  1631.         this._ = undefined;

  1632.     }

  1633. }

  1634. exports.RequestType7 = RequestType7;

  1635. class RequestType8 extends AbstractMessageType {

  1636.     constructor(method) {

  1637.         super(method, 8);

  1638.         this._ = undefined;

  1639.     }

  1640. }

  1641. exports.RequestType8 = RequestType8;

  1642. class RequestType9 extends AbstractMessageType {

  1643.     constructor(method) {

  1644.         super(method, 9);

  1645.         this._ = undefined;

  1646.     }

  1647. }

  1648. exports.RequestType9 = RequestType9;

  1649. class NotificationType extends AbstractMessageType {

  1650.     constructor(method) {

  1651.         super(method, 1);

  1652.         this._ = undefined;

  1653.     }

  1654. }

  1655. exports.NotificationType = NotificationType;

  1656. class NotificationType0 extends AbstractMessageType {

  1657.     constructor(method) {

  1658.         super(method, 0);

  1659.         this._ = undefined;

  1660.     }

  1661. }

  1662. exports.NotificationType0 = NotificationType0;

  1663. class NotificationType1 extends AbstractMessageType {

  1664.     constructor(method) {

  1665.         super(method, 1);

  1666.         this._ = undefined;

  1667.     }

  1668. }

  1669. exports.NotificationType1 = NotificationType1;

  1670. class NotificationType2 extends AbstractMessageType {

  1671.     constructor(method) {

  1672.         super(method, 2);

  1673.         this._ = undefined;

  1674.     }

  1675. }

  1676. exports.NotificationType2 = NotificationType2;

  1677. class NotificationType3 extends AbstractMessageType {

  1678.     constructor(method) {

  1679.         super(method, 3);

  1680.         this._ = undefined;

  1681.     }

  1682. }

  1683. exports.NotificationType3 = NotificationType3;

  1684. class NotificationType4 extends AbstractMessageType {

  1685.     constructor(method) {

  1686.         super(method, 4);

  1687.         this._ = undefined;

  1688.     }

  1689. }

  1690. exports.NotificationType4 = NotificationType4;

  1691. class NotificationType5 extends AbstractMessageType {

  1692.     constructor(method) {

  1693.         super(method, 5);

  1694.         this._ = undefined;

  1695.     }

  1696. }

  1697. exports.NotificationType5 = NotificationType5;

  1698. class NotificationType6 extends AbstractMessageType {

  1699.     constructor(method) {

  1700.         super(method, 6);

  1701.         this._ = undefined;

  1702.     }

  1703. }

  1704. exports.NotificationType6 = NotificationType6;

  1705. class NotificationType7 extends AbstractMessageType {

  1706.     constructor(method) {

  1707.         super(method, 7);

  1708.         this._ = undefined;

  1709.     }

  1710. }

  1711. exports.NotificationType7 = NotificationType7;

  1712. class NotificationType8 extends AbstractMessageType {

  1713.     constructor(method) {

  1714.         super(method, 8);

  1715.         this._ = undefined;

  1716.     }

  1717. }

  1718. exports.NotificationType8 = NotificationType8;

  1719. class NotificationType9 extends AbstractMessageType {

  1720.     constructor(method) {

  1721.         super(method, 9);

  1722.         this._ = undefined;

  1723.     }

  1724. }

  1725. exports.NotificationType9 = NotificationType9;

  1726. /**

  1727.  * Tests if the given message is a request message

  1728.  */

  1729. function isRequestMessage(message) {

  1730.     let candidate = message;

  1731.     return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));

  1732. }

  1733. exports.isRequestMessage = isRequestMessage;

  1734. /**

  1735.  * Tests if the given message is a notification message

  1736.  */

  1737. function isNotificationMessage(message) {

  1738.     let candidate = message;

  1739.     return candidate && is.string(candidate.method) && message.id === void 0;

  1740. }

  1741. exports.isNotificationMessage = isNotificationMessage;

  1742. /**

  1743.  * Tests if the given message is a response message

  1744.  */

  1745. function isResponseMessage(message) {

  1746.     let candidate = message;

  1747.     return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);

  1748. }

  1749. exports.isResponseMessage = isResponseMessage;

  1750. 

  1751. 

  1752. /***/ }),

  1753. /* 7 */

  1754. /***/ (function(module, exports, __webpack_require__) {

  1755. 

  1756. "use strict";

  1757. /* --------------------------------------------------------------------------------------------

  1758.  * Copyright (c) Microsoft Corporation. All rights reserved.

  1759.  * Licensed under the MIT License. See License.txt in the project root for license information.

  1760.  * ------------------------------------------------------------------------------------------ */

  1761. 

  1762. Object.defineProperty(exports, "__esModule", { value: true });

  1763. const events_1 = __webpack_require__(8);

  1764. const Is = __webpack_require__(5);

  1765. let DefaultSize = 8192;

  1766. let CR = Buffer.from('\r', 'ascii')[0];

  1767. let LF = Buffer.from('\n', 'ascii')[0];

  1768. let CRLF = '\r\n';

  1769. class MessageBuffer {

  1770.     constructor(encoding = 'utf8') {

  1771.         this.encoding = encoding;

  1772.         this.index = 0;

  1773.         this.buffer = Buffer.allocUnsafe(DefaultSize);

  1774.     }

  1775.     append(chunk) {

  1776.         var toAppend = chunk;

  1777.         if (typeof (chunk) === 'string') {

  1778.             var str = chunk;

  1779.             var bufferLen = Buffer.byteLength(str, this.encoding);

  1780.             toAppend = Buffer.allocUnsafe(bufferLen);

  1781.             toAppend.write(str, 0, bufferLen, this.encoding);

  1782.         }

  1783.         if (this.buffer.length - this.index >= toAppend.length) {

  1784.             toAppend.copy(this.buffer, this.index, 0, toAppend.length);

  1785.         }

  1786.         else {

  1787.             var newSize = (Math.ceil((this.index + toAppend.length) / DefaultSize) + 1) * DefaultSize;

  1788.             if (this.index === 0) {

  1789.                 this.buffer = Buffer.allocUnsafe(newSize);

  1790.                 toAppend.copy(this.buffer, 0, 0, toAppend.length);

  1791.             }

  1792.             else {

  1793.                 this.buffer = Buffer.concat([this.buffer.slice(0, this.index), toAppend], newSize);

  1794.             }

  1795.         }

  1796.         this.index += toAppend.length;

  1797.     }

  1798.     tryReadHeaders() {

  1799.         let result = undefined;

  1800.         let current = 0;

  1801.         while (current + 3 < this.index && (this.buffer[current] !== CR || this.buffer[current + 1] !== LF || this.buffer[current + 2] !== CR || this.buffer[current + 3] !== LF)) {

  1802.             current++;

  1803.         }

  1804.         // No header / body separator found (e.g CRLFCRLF)

  1805.         if (current + 3 >= this.index) {

  1806.             return result;

  1807.         }

  1808.         result = Object.create(null);

  1809.         let headers = this.buffer.toString('ascii', 0, current).split(CRLF);

  1810.         headers.forEach((header) => {

  1811.             let index = header.indexOf(':');

  1812.             if (index === -1) {

  1813.                 throw new Error('Message header must separate key and value using :');

  1814.             }

  1815.             let key = header.substr(0, index);

  1816.             let value = header.substr(index + 1).trim();

  1817.             result[key] = value;

  1818.         });

  1819.         let nextStart = current + 4;

  1820.         this.buffer = this.buffer.slice(nextStart);

  1821.         this.index = this.index - nextStart;

  1822.         return result;

  1823.     }

  1824.     tryReadContent(length) {

  1825.         if (this.index < length) {

  1826.             return null;

  1827.         }

  1828.         let result = this.buffer.toString(this.encoding, 0, length);

  1829.         let nextStart = length;

  1830.         this.buffer.copy(this.buffer, 0, nextStart);

  1831.         this.index = this.index - nextStart;

  1832.         return result;

  1833.     }

  1834.     get numberOfBytes() {

  1835.         return this.index;

  1836.     }

  1837. }

  1838. var MessageReader;

  1839. (function (MessageReader) {

  1840.     function is(value) {

  1841.         let candidate = value;

  1842.         return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) &&

  1843.             Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);

  1844.     }

  1845.     MessageReader.is = is;

  1846. })(MessageReader = exports.MessageReader || (exports.MessageReader = {}));

  1847. class AbstractMessageReader {

  1848.     constructor() {

  1849.         this.errorEmitter = new events_1.Emitter();

  1850.         this.closeEmitter = new events_1.Emitter();

  1851.         this.partialMessageEmitter = new events_1.Emitter();

  1852.     }

  1853.     dispose() {

  1854.         this.errorEmitter.dispose();

  1855.         this.closeEmitter.dispose();

  1856.     }

  1857.     get onError() {

  1858.         return this.errorEmitter.event;

  1859.     }

  1860.     fireError(error) {

  1861.         this.errorEmitter.fire(this.asError(error));

  1862.     }

  1863.     get onClose() {

  1864.         return this.closeEmitter.event;

  1865.     }

  1866.     fireClose() {

  1867.         this.closeEmitter.fire(undefined);

  1868.     }

  1869.     get onPartialMessage() {

  1870.         return this.partialMessageEmitter.event;

  1871.     }

  1872.     firePartialMessage(info) {

  1873.         this.partialMessageEmitter.fire(info);

  1874.     }

  1875.     asError(error) {

  1876.         if (error instanceof Error) {

  1877.             return error;

  1878.         }

  1879.         else {

  1880.             return new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);

  1881.         }

  1882.     }

  1883. }

  1884. exports.AbstractMessageReader = AbstractMessageReader;

  1885. class StreamMessageReader extends AbstractMessageReader {

  1886.     constructor(readable, encoding = 'utf8') {

  1887.         super();

  1888.         this.readable = readable;

  1889.         this.buffer = new MessageBuffer(encoding);

  1890.         this._partialMessageTimeout = 10000;

  1891.     }

  1892.     set partialMessageTimeout(timeout) {

  1893.         this._partialMessageTimeout = timeout;

  1894.     }

  1895.     get partialMessageTimeout() {

  1896.         return this._partialMessageTimeout;

  1897.     }

  1898.     listen(callback) {

  1899.         this.nextMessageLength = -1;

  1900.         this.messageToken = 0;

  1901.         this.partialMessageTimer = undefined;

  1902.         this.callback = callback;

  1903.         this.readable.on('data', (data) => {

  1904.             this.onData(data);

  1905.         });

  1906.         this.readable.on('error', (error) => this.fireError(error));

  1907.         this.readable.on('close', () => this.fireClose());

  1908.     }

  1909.     onData(data) {

  1910.         this.buffer.append(data);

  1911.         while (true) {

  1912.             if (this.nextMessageLength === -1) {

  1913.                 let headers = this.buffer.tryReadHeaders();

  1914.                 if (!headers) {

  1915.                     return;

  1916.                 }

  1917.                 let contentLength = headers['Content-Length'];

  1918.                 if (!contentLength) {

  1919.                     throw new Error('Header must provide a Content-Length property.');

  1920.                 }

  1921.                 let length = parseInt(contentLength);

  1922.                 if (isNaN(length)) {

  1923.                     throw new Error('Content-Length value must be a number.');

  1924.                 }

  1925.                 this.nextMessageLength = length;

  1926.                 // Take the encoding form the header. For compatibility

  1927.                 // treat both utf-8 and utf8 as node utf8

  1928.             }

  1929.             var msg = this.buffer.tryReadContent(this.nextMessageLength);

  1930.             if (msg === null) {

  1931.                 /** We haven't received the full message yet. */

  1932.                 this.setPartialMessageTimer();

  1933.                 return;

  1934.             }

  1935.             this.clearPartialMessageTimer();

  1936.             this.nextMessageLength = -1;

  1937.             this.messageToken++;

  1938.             var json = JSON.parse(msg);

  1939.             this.callback(json);

  1940.         }

  1941.     }

  1942.     clearPartialMessageTimer() {

  1943.         if (this.partialMessageTimer) {

  1944.             clearTimeout(this.partialMessageTimer);

  1945.             this.partialMessageTimer = undefined;

  1946.         }

  1947.     }

  1948.     setPartialMessageTimer() {

  1949.         this.clearPartialMessageTimer();

  1950.         if (this._partialMessageTimeout <= 0) {

  1951.             return;

  1952.         }

  1953.         this.partialMessageTimer = setTimeout((token, timeout) => {

  1954.             this.partialMessageTimer = undefined;

  1955.             if (token === this.messageToken) {

  1956.                 this.firePartialMessage({ messageToken: token, waitingTime: timeout });

  1957.                 this.setPartialMessageTimer();

  1958.             }

  1959.         }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);

  1960.     }

  1961. }

  1962. exports.StreamMessageReader = StreamMessageReader;

  1963. class IPCMessageReader extends AbstractMessageReader {

  1964.     constructor(process) {

  1965.         super();

  1966.         this.process = process;

  1967.         let eventEmitter = this.process;

  1968.         eventEmitter.on('error', (error) => this.fireError(error));

  1969.         eventEmitter.on('close', () => this.fireClose());

  1970.     }

  1971.     listen(callback) {

  1972.         this.process.on('message', callback);

  1973.     }

  1974. }

  1975. exports.IPCMessageReader = IPCMessageReader;

  1976. class SocketMessageReader extends StreamMessageReader {

  1977.     constructor(socket, encoding = 'utf-8') {

  1978.         super(socket, encoding);

  1979.     }

  1980. }

  1981. exports.SocketMessageReader = SocketMessageReader;

  1982. 

  1983. 

  1984. /***/ }),

  1985. /* 8 */

  1986. /***/ (function(module, exports, __webpack_require__) {

  1987. 

  1988. "use strict";

  1989. /* --------------------------------------------------------------------------------------------

  1990.  * Copyright (c) Microsoft Corporation. All rights reserved.

  1991.  * Licensed under the MIT License. See License.txt in the project root for license information.

  1992.  * ------------------------------------------------------------------------------------------ */

  1993. 

  1994. Object.defineProperty(exports, "__esModule", { value: true });

  1995. var Disposable;

  1996. (function (Disposable) {

  1997.     function create(func) {

  1998.         return {

  1999.             dispose: func

  2000.         };

  2001.     }

  2002.     Disposable.create = create;

  2003. })(Disposable = exports.Disposable || (exports.Disposable = {}));

  2004. var Event;

  2005. (function (Event) {

  2006.     const _disposable = { dispose() { } };

  2007.     Event.None = function () { return _disposable; };

  2008. })(Event = exports.Event || (exports.Event = {}));

  2009. class CallbackList {

  2010.     add(callback, context = null, bucket) {

  2011.         if (!this._callbacks) {

  2012.             this._callbacks = [];

  2013.             this._contexts = [];

  2014.         }

  2015.         this._callbacks.push(callback);

  2016.         this._contexts.push(context);

  2017.         if (Array.isArray(bucket)) {

  2018.             bucket.push({ dispose: () => this.remove(callback, context) });

  2019.         }

  2020.     }

  2021.     remove(callback, context = null) {

  2022.         if (!this._callbacks) {

  2023.             return;

  2024.         }

  2025.         var foundCallbackWithDifferentContext = false;

  2026.         for (var i = 0, len = this._callbacks.length; i < len; i++) {

  2027.             if (this._callbacks[i] === callback) {

  2028.                 if (this._contexts[i] === context) {

  2029.                     // callback & context match => remove it

  2030.                     this._callbacks.splice(i, 1);

  2031.                     this._contexts.splice(i, 1);

  2032.                     return;

  2033.                 }

  2034.                 else {

  2035.                     foundCallbackWithDifferentContext = true;

  2036.                 }

  2037.             }

  2038.         }

  2039.         if (foundCallbackWithDifferentContext) {

  2040.             throw new Error('When adding a listener with a context, you should remove it with the same context');

  2041.         }

  2042.     }

  2043.     invoke(...args) {

  2044.         if (!this._callbacks) {

  2045.             return [];

  2046.         }

  2047.         var ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);

  2048.         for (var i = 0, len = callbacks.length; i < len; i++) {

  2049.             try {

  2050.                 ret.push(callbacks[i].apply(contexts[i], args));

  2051.             }

  2052.             catch (e) {

  2053.                 console.error(e);

  2054.             }

  2055.         }

  2056.         return ret;

  2057.     }

  2058.     isEmpty() {

  2059.         return !this._callbacks || this._callbacks.length === 0;

  2060.     }

  2061.     dispose() {

  2062.         this._callbacks = undefined;

  2063.         this._contexts = undefined;

  2064.     }

  2065. }

  2066. class Emitter {

  2067.     constructor(_options) {

  2068.         this._options = _options;

  2069.     }

  2070.     /**

  2071.      * For the public to allow to subscribe

  2072.      * to events from this Emitter

  2073.      */

  2074.     get event() {

  2075.         if (!this._event) {

  2076.             this._event = (listener, thisArgs, disposables) => {

  2077.                 if (!this._callbacks) {

  2078.                     this._callbacks = new CallbackList();

  2079.                 }

  2080.                 if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {

  2081.                     this._options.onFirstListenerAdd(this);

  2082.                 }

  2083.                 this._callbacks.add(listener, thisArgs);

  2084.                 let result;

  2085.                 result = {

  2086.                     dispose: () => {

  2087.                         this._callbacks.remove(listener, thisArgs);

  2088.                         result.dispose = Emitter._noop;

  2089.                         if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {

  2090.                             this._options.onLastListenerRemove(this);

  2091.                         }

  2092.                     }

  2093.                 };

  2094.                 if (Array.isArray(disposables)) {

  2095.                     disposables.push(result);

  2096.                 }

  2097.                 return result;

  2098.             };

  2099.         }

  2100.         return this._event;

  2101.     }

  2102.     /**

  2103.      * To be kept private to fire an event to

  2104.      * subscribers

  2105.      */

  2106.     fire(event) {

  2107.         if (this._callbacks) {

  2108.             this._callbacks.invoke.call(this._callbacks, event);

  2109.         }

  2110.     }

  2111.     dispose() {

  2112.         if (this._callbacks) {

  2113.             this._callbacks.dispose();

  2114.             this._callbacks = undefined;

  2115.         }

  2116.     }

  2117. }

  2118. Emitter._noop = function () { };

  2119. exports.Emitter = Emitter;

  2120. 

  2121. 

  2122. /***/ }),

  2123. /* 9 */

  2124. /***/ (function(module, exports, __webpack_require__) {

  2125. 

  2126. "use strict";

  2127. /* --------------------------------------------------------------------------------------------

  2128.  * Copyright (c) Microsoft Corporation. All rights reserved.

  2129.  * Licensed under the MIT License. See License.txt in the project root for license information.

  2130.  * ------------------------------------------------------------------------------------------ */

  2131. 

  2132. Object.defineProperty(exports, "__esModule", { value: true });

  2133. const events_1 = __webpack_require__(8);

  2134. const Is = __webpack_require__(5);

  2135. let ContentLength = 'Content-Length: ';

  2136. let CRLF = '\r\n';

  2137. var MessageWriter;

  2138. (function (MessageWriter) {

  2139.     function is(value) {

  2140.         let candidate = value;

  2141.         return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) &&

  2142.             Is.func(candidate.onError) && Is.func(candidate.write);

  2143.     }

  2144.     MessageWriter.is = is;

  2145. })(MessageWriter = exports.MessageWriter || (exports.MessageWriter = {}));

  2146. class AbstractMessageWriter {

  2147.     constructor() {

  2148.         this.errorEmitter = new events_1.Emitter();

  2149.         this.closeEmitter = new events_1.Emitter();

  2150.     }

  2151.     dispose() {

  2152.         this.errorEmitter.dispose();

  2153.         this.closeEmitter.dispose();

  2154.     }

  2155.     get onError() {

  2156.         return this.errorEmitter.event;

  2157.     }

  2158.     fireError(error, message, count) {

  2159.         this.errorEmitter.fire([this.asError(error), message, count]);

  2160.     }

  2161.     get onClose() {

  2162.         return this.closeEmitter.event;

  2163.     }

  2164.     fireClose() {

  2165.         this.closeEmitter.fire(undefined);

  2166.     }

  2167.     asError(error) {

  2168.         if (error instanceof Error) {

  2169.             return error;

  2170.         }

  2171.         else {

  2172.             return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);

  2173.         }

  2174.     }

  2175. }

  2176. exports.AbstractMessageWriter = AbstractMessageWriter;

  2177. class StreamMessageWriter extends AbstractMessageWriter {

  2178.     constructor(writable, encoding = 'utf8') {

  2179.         super();

  2180.         this.writable = writable;

  2181.         this.encoding = encoding;

  2182.         this.errorCount = 0;

  2183.         this.writable.on('error', (error) => this.fireError(error));

  2184.         this.writable.on('close', () => this.fireClose());

  2185.     }

  2186.     write(msg) {

  2187.         let json = JSON.stringify(msg);

  2188.         let contentLength = Buffer.byteLength(json, this.encoding);

  2189.         let headers = [

  2190.             ContentLength, contentLength.toString(), CRLF,

  2191.             CRLF

  2192.         ];

  2193.         try {

  2194.             // Header must be written in ASCII encoding

  2195.             this.writable.write(headers.join(''), 'ascii');

  2196.             // Now write the content. This can be written in any encoding

  2197.             this.writable.write(json, this.encoding);

  2198.             this.errorCount = 0;

  2199.         }

  2200.         catch (error) {

  2201.             this.errorCount++;

  2202.             this.fireError(error, msg, this.errorCount);

  2203.         }

  2204.     }

  2205. }

  2206. exports.StreamMessageWriter = StreamMessageWriter;

  2207. class IPCMessageWriter extends AbstractMessageWriter {

  2208.     constructor(process) {

  2209.         super();

  2210.         this.process = process;

  2211.         this.errorCount = 0;

  2212.         this.queue = [];

  2213.         this.sending = false;

  2214.         let eventEmitter = this.process;

  2215.         eventEmitter.on('error', (error) => this.fireError(error));

  2216.         eventEmitter.on('close', () => this.fireClose);

  2217.     }

  2218.     write(msg) {

  2219.         if (!this.sending && this.queue.length === 0) {

  2220.             // See https://github.com/nodejs/node/issues/7657

  2221.             this.doWriteMessage(msg);

  2222.         }

  2223.         else {

  2224.             this.queue.push(msg);

  2225.         }

  2226.     }

  2227.     doWriteMessage(msg) {

  2228.         try {

  2229.             if (this.process.send) {

  2230.                 this.sending = true;

  2231.                 this.process.send(msg, undefined, undefined, (error) => {

  2232.                     this.sending = false;

  2233.                     if (error) {

  2234.                         this.errorCount++;

  2235.                         this.fireError(error, msg, this.errorCount);

  2236.                     }

  2237.                     else {

  2238.                         this.errorCount = 0;

  2239.                     }

  2240.                     if (this.queue.length > 0) {

  2241.                         this.doWriteMessage(this.queue.shift());

  2242.                     }

  2243.                 });

  2244.             }

  2245.         }

  2246.         catch (error) {

  2247.             this.errorCount++;

  2248.             this.fireError(error, msg, this.errorCount);

  2249.         }

  2250.     }

  2251. }

  2252. exports.IPCMessageWriter = IPCMessageWriter;

  2253. class SocketMessageWriter extends AbstractMessageWriter {

  2254.     constructor(socket, encoding = 'utf8') {

  2255.         super();

  2256.         this.socket = socket;

  2257.         this.queue = [];

  2258.         this.sending = false;

  2259.         this.encoding = encoding;

  2260.         this.errorCount = 0;

  2261.         this.socket.on('error', (error) => this.fireError(error));

  2262.         this.socket.on('close', () => this.fireClose());

  2263.     }

  2264.     dispose() {

  2265.         super.dispose();

  2266.         this.socket.destroy();

  2267.     }

  2268.     write(msg) {

  2269.         if (!this.sending && this.queue.length === 0) {

  2270.             // See https://github.com/nodejs/node/issues/7657

  2271.             this.doWriteMessage(msg);

  2272.         }

  2273.         else {

  2274.             this.queue.push(msg);

  2275.         }

  2276.     }

  2277.     doWriteMessage(msg) {

  2278.         let json = JSON.stringify(msg);

  2279.         let contentLength = Buffer.byteLength(json, this.encoding);

  2280.         let headers = [

  2281.             ContentLength, contentLength.toString(), CRLF,

  2282.             CRLF

  2283.         ];

  2284.         try {

  2285.             // Header must be written in ASCII encoding

  2286.             this.sending = true;

  2287.             this.socket.write(headers.join(''), 'ascii', (error) => {

  2288.                 if (error) {

  2289.                     this.handleError(error, msg);

  2290.                 }

  2291.                 try {

  2292.                     // Now write the content. This can be written in any encoding

  2293.                     this.socket.write(json, this.encoding, (error) => {

  2294.                         this.sending = false;

  2295.                         if (error) {

  2296.                             this.handleError(error, msg);

  2297.                         }

  2298.                         else {

  2299.                             this.errorCount = 0;

  2300.                         }

  2301.                         if (this.queue.length > 0) {

  2302.                             this.doWriteMessage(this.queue.shift());

  2303.                         }

  2304.                     });

  2305.                 }

  2306.                 catch (error) {

  2307.                     this.handleError(error, msg);

  2308.                 }

  2309.             });

  2310.         }

  2311.         catch (error) {

  2312.             this.handleError(error, msg);

  2313.         }

  2314.     }

  2315.     handleError(error, msg) {

  2316.         this.errorCount++;

  2317.         this.fireError(error, msg, this.errorCount);

  2318.     }

  2319. }

  2320. exports.SocketMessageWriter = SocketMessageWriter;

  2321. 

  2322. 

  2323. /***/ }),

  2324. /* 10 */

  2325. /***/ (function(module, exports, __webpack_require__) {

  2326. 

  2327. "use strict";

  2328. /*---------------------------------------------------------------------------------------------

  2329.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  2330.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  2331.  *--------------------------------------------------------------------------------------------*/

  2332. 

  2333. Object.defineProperty(exports, "__esModule", { value: true });

  2334. const events_1 = __webpack_require__(8);

  2335. const Is = __webpack_require__(5);

  2336. var CancellationToken;

  2337. (function (CancellationToken) {

  2338.     CancellationToken.None = Object.freeze({

  2339.         isCancellationRequested: false,

  2340.         onCancellationRequested: events_1.Event.None

  2341.     });

  2342.     CancellationToken.Cancelled = Object.freeze({

  2343.         isCancellationRequested: true,

  2344.         onCancellationRequested: events_1.Event.None

  2345.     });

  2346.     function is(value) {

  2347.         let candidate = value;

  2348.         return candidate && (candidate === CancellationToken.None

  2349.             || candidate === CancellationToken.Cancelled

  2350.             || (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested));

  2351.     }

  2352.     CancellationToken.is = is;

  2353. })(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {}));

  2354. const shortcutEvent = Object.freeze(function (callback, context) {

  2355.     let handle = setTimeout(callback.bind(context), 0);

  2356.     return { dispose() { clearTimeout(handle); } };

  2357. });

  2358. class MutableToken {

  2359.     constructor() {

  2360.         this._isCancelled = false;

  2361.     }

  2362.     cancel() {

  2363.         if (!this._isCancelled) {

  2364.             this._isCancelled = true;

  2365.             if (this._emitter) {

  2366.                 this._emitter.fire(undefined);

  2367.                 this.dispose();

  2368.             }

  2369.         }

  2370.     }

  2371.     get isCancellationRequested() {

  2372.         return this._isCancelled;

  2373.     }

  2374.     get onCancellationRequested() {

  2375.         if (this._isCancelled) {

  2376.             return shortcutEvent;

  2377.         }

  2378.         if (!this._emitter) {

  2379.             this._emitter = new events_1.Emitter();

  2380.         }

  2381.         return this._emitter.event;

  2382.     }

  2383.     dispose() {

  2384.         if (this._emitter) {

  2385.             this._emitter.dispose();

  2386.             this._emitter = undefined;

  2387.         }

  2388.     }

  2389. }

  2390. class CancellationTokenSource {

  2391.     get token() {

  2392.         if (!this._token) {

  2393.             // be lazy and create the token only when

  2394.             // actually needed

  2395.             this._token = new MutableToken();

  2396.         }

  2397.         return this._token;

  2398.     }

  2399.     cancel() {

  2400.         if (!this._token) {

  2401.             // save an object by returning the default

  2402.             // cancelled token when cancellation happens

  2403.             // before someone asks for the token

  2404.             this._token = CancellationToken.Cancelled;

  2405.         }

  2406.         else {

  2407.             this._token.cancel();

  2408.         }

  2409.     }

  2410.     dispose() {

  2411.         if (!this._token) {

  2412.             // ensure to initialize with an empty token if we had none

  2413.             this._token = CancellationToken.None;

  2414.         }

  2415.         else if (this._token instanceof MutableToken) {

  2416.             // actually dispose

  2417.             this._token.dispose();

  2418.         }

  2419.     }

  2420. }

  2421. exports.CancellationTokenSource = CancellationTokenSource;

  2422. 

  2423. 

  2424. /***/ }),

  2425. /* 11 */

  2426. /***/ (function(module, exports, __webpack_require__) {

  2427. 

  2428. "use strict";

  2429. 

  2430. /*---------------------------------------------------------------------------------------------

  2431.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  2432.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  2433.  *--------------------------------------------------------------------------------------------*/

  2434. Object.defineProperty(exports, "__esModule", { value: true });

  2435. var Touch;

  2436. (function (Touch) {

  2437.     Touch.None = 0;

  2438.     Touch.First = 1;

  2439.     Touch.Last = 2;

  2440. })(Touch = exports.Touch || (exports.Touch = {}));

  2441. class LinkedMap {

  2442.     constructor() {

  2443.         this._map = new Map();

  2444.         this._head = undefined;

  2445.         this._tail = undefined;

  2446.         this._size = 0;

  2447.     }

  2448.     clear() {

  2449.         this._map.clear();

  2450.         this._head = undefined;

  2451.         this._tail = undefined;

  2452.         this._size = 0;

  2453.     }

  2454.     isEmpty() {

  2455.         return !this._head && !this._tail;

  2456.     }

  2457.     get size() {

  2458.         return this._size;

  2459.     }

  2460.     has(key) {

  2461.         return this._map.has(key);

  2462.     }

  2463.     get(key) {

  2464.         const item = this._map.get(key);

  2465.         if (!item) {

  2466.             return undefined;

  2467.         }

  2468.         return item.value;

  2469.     }

  2470.     set(key, value, touch = Touch.None) {

  2471.         let item = this._map.get(key);

  2472.         if (item) {

  2473.             item.value = value;

  2474.             if (touch !== Touch.None) {

  2475.                 this.touch(item, touch);

  2476.             }

  2477.         }

  2478.         else {

  2479.             item = { key, value, next: undefined, previous: undefined };

  2480.             switch (touch) {

  2481.                 case Touch.None:

  2482.                     this.addItemLast(item);

  2483.                     break;

  2484.                 case Touch.First:

  2485.                     this.addItemFirst(item);

  2486.                     break;

  2487.                 case Touch.Last:

  2488.                     this.addItemLast(item);

  2489.                     break;

  2490.                 default:

  2491.                     this.addItemLast(item);

  2492.                     break;

  2493.             }

  2494.             this._map.set(key, item);

  2495.             this._size++;

  2496.         }

  2497.     }

  2498.     delete(key) {

  2499.         const item = this._map.get(key);

  2500.         if (!item) {

  2501.             return false;

  2502.         }

  2503.         this._map.delete(key);

  2504.         this.removeItem(item);

  2505.         this._size--;

  2506.         return true;

  2507.     }

  2508.     shift() {

  2509.         if (!this._head && !this._tail) {

  2510.             return undefined;

  2511.         }

  2512.         if (!this._head || !this._tail) {

  2513.             throw new Error('Invalid list');

  2514.         }

  2515.         const item = this._head;

  2516.         this._map.delete(item.key);

  2517.         this.removeItem(item);

  2518.         this._size--;

  2519.         return item.value;

  2520.     }

  2521.     forEach(callbackfn, thisArg) {

  2522.         let current = this._head;

  2523.         while (current) {

  2524.             if (thisArg) {

  2525.                 callbackfn.bind(thisArg)(current.value, current.key, this);

  2526.             }

  2527.             else {

  2528.                 callbackfn(current.value, current.key, this);

  2529.             }

  2530.             current = current.next;

  2531.         }

  2532.     }

  2533.     forEachReverse(callbackfn, thisArg) {

  2534.         let current = this._tail;

  2535.         while (current) {

  2536.             if (thisArg) {

  2537.                 callbackfn.bind(thisArg)(current.value, current.key, this);

  2538.             }

  2539.             else {

  2540.                 callbackfn(current.value, current.key, this);

  2541.             }

  2542.             current = current.previous;

  2543.         }

  2544.     }

  2545.     values() {

  2546.         let result = [];

  2547.         let current = this._head;

  2548.         while (current) {

  2549.             result.push(current.value);

  2550.             current = current.next;

  2551.         }

  2552.         return result;

  2553.     }

  2554.     keys() {

  2555.         let result = [];

  2556.         let current = this._head;

  2557.         while (current) {

  2558.             result.push(current.key);

  2559.             current = current.next;

  2560.         }

  2561.         return result;

  2562.     }

  2563.     /* JSON RPC run on es5 which has no Symbol.iterator

  2564.     public keys(): IterableIterator<K> {

  2565.         let current = this._head;

  2566.         let iterator: IterableIterator<K> = {

  2567.             [Symbol.iterator]() {

  2568.                 return iterator;

  2569.             },

  2570.             next():IteratorResult<K> {

  2571.                 if (current) {

  2572.                     let result = { value: current.key, done: false };

  2573.                     current = current.next;

  2574.                     return result;

  2575.                 } else {

  2576.                     return { value: undefined, done: true };

  2577.                 }

  2578.             }

  2579.         };

  2580.         return iterator;

  2581.     }

  2582. 

  2583.     public values(): IterableIterator<V> {

  2584.         let current = this._head;

  2585.         let iterator: IterableIterator<V> = {

  2586.             [Symbol.iterator]() {

  2587.                 return iterator;

  2588.             },

  2589.             next():IteratorResult<V> {

  2590.                 if (current) {

  2591.                     let result = { value: current.value, done: false };

  2592.                     current = current.next;

  2593.                     return result;

  2594.                 } else {

  2595.                     return { value: undefined, done: true };

  2596.                 }

  2597.             }

  2598.         };

  2599.         return iterator;

  2600.     }

  2601.     */

  2602.     addItemFirst(item) {

  2603.         // First time Insert

  2604.         if (!this._head && !this._tail) {

  2605.             this._tail = item;

  2606.         }

  2607.         else if (!this._head) {

  2608.             throw new Error('Invalid list');

  2609.         }

  2610.         else {

  2611.             item.next = this._head;

  2612.             this._head.previous = item;

  2613.         }

  2614.         this._head = item;

  2615.     }

  2616.     addItemLast(item) {

  2617.         // First time Insert

  2618.         if (!this._head && !this._tail) {

  2619.             this._head = item;

  2620.         }

  2621.         else if (!this._tail) {

  2622.             throw new Error('Invalid list');

  2623.         }

  2624.         else {

  2625.             item.previous = this._tail;

  2626.             this._tail.next = item;

  2627.         }

  2628.         this._tail = item;

  2629.     }

  2630.     removeItem(item) {

  2631.         if (item === this._head && item === this._tail) {

  2632.             this._head = undefined;

  2633.             this._tail = undefined;

  2634.         }

  2635.         else if (item === this._head) {

  2636.             this._head = item.next;

  2637.         }

  2638.         else if (item === this._tail) {

  2639.             this._tail = item.previous;

  2640.         }

  2641.         else {

  2642.             const next = item.next;

  2643.             const previous = item.previous;

  2644.             if (!next || !previous) {

  2645.                 throw new Error('Invalid list');

  2646.             }

  2647.             next.previous = previous;

  2648.             previous.next = next;

  2649.         }

  2650.     }

  2651.     touch(item, touch) {

  2652.         if (!this._head || !this._tail) {

  2653.             throw new Error('Invalid list');

  2654.         }

  2655.         if ((touch !== Touch.First && touch !== Touch.Last)) {

  2656.             return;

  2657.         }

  2658.         if (touch === Touch.First) {

  2659.             if (item === this._head) {

  2660.                 return;

  2661.             }

  2662.             const next = item.next;

  2663.             const previous = item.previous;

  2664.             // Unlink the item

  2665.             if (item === this._tail) {

  2666.                 // previous must be defined since item was not head but is tail

  2667.                 // So there are more than on item in the map

  2668.                 previous.next = undefined;

  2669.                 this._tail = previous;

  2670.             }

  2671.             else {

  2672.                 // Both next and previous are not undefined since item was neither head nor tail.

  2673.                 next.previous = previous;

  2674.                 previous.next = next;

  2675.             }

  2676.             // Insert the node at head

  2677.             item.previous = undefined;

  2678.             item.next = this._head;

  2679.             this._head.previous = item;

  2680.             this._head = item;

  2681.         }

  2682.         else if (touch === Touch.Last) {

  2683.             if (item === this._tail) {

  2684.                 return;

  2685.             }

  2686.             const next = item.next;

  2687.             const previous = item.previous;

  2688.             // Unlink the item.

  2689.             if (item === this._head) {

  2690.                 // next must be defined since item was not tail but is head

  2691.                 // So there are more than on item in the map

  2692.                 next.previous = undefined;

  2693.                 this._head = next;

  2694.             }

  2695.             else {

  2696.                 // Both next and previous are not undefined since item was neither head nor tail.

  2697.                 next.previous = previous;

  2698.                 previous.next = next;

  2699.             }

  2700.             item.next = undefined;

  2701.             item.previous = this._tail;

  2702.             this._tail.next = item;

  2703.             this._tail = item;

  2704.         }

  2705.     }

  2706. }

  2707. exports.LinkedMap = LinkedMap;

  2708. 

  2709. 

  2710. /***/ }),

  2711. /* 12 */

  2712. /***/ (function(module, exports, __webpack_require__) {

  2713. 

  2714. "use strict";

  2715. /* --------------------------------------------------------------------------------------------

  2716.  * Copyright (c) Microsoft Corporation. All rights reserved.

  2717.  * Licensed under the MIT License. See License.txt in the project root for license information.

  2718.  * ------------------------------------------------------------------------------------------ */

  2719. 

  2720. Object.defineProperty(exports, "__esModule", { value: true });

  2721. const path_1 = __webpack_require__(1);

  2722. const os_1 = __webpack_require__(13);

  2723. const crypto_1 = __webpack_require__(14);

  2724. const net_1 = __webpack_require__(15);

  2725. const messageReader_1 = __webpack_require__(7);

  2726. const messageWriter_1 = __webpack_require__(9);

  2727. function generateRandomPipeName() {

  2728.     const randomSuffix = crypto_1.randomBytes(21).toString('hex');

  2729.     if (process.platform === 'win32') {

  2730.         return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;

  2731.     }

  2732.     else {

  2733.         // Mac/Unix: use socket file

  2734.         return path_1.join(os_1.tmpdir(), `vscode-${randomSuffix}.sock`);

  2735.     }

  2736. }

  2737. exports.generateRandomPipeName = generateRandomPipeName;

  2738. function createClientPipeTransport(pipeName, encoding = 'utf-8') {

  2739.     let connectResolve;

  2740.     let connected = new Promise((resolve, _reject) => {

  2741.         connectResolve = resolve;

  2742.     });

  2743.     return new Promise((resolve, reject) => {

  2744.         let server = net_1.createServer((socket) => {

  2745.             server.close();

  2746.             connectResolve([

  2747.                 new messageReader_1.SocketMessageReader(socket, encoding),

  2748.                 new messageWriter_1.SocketMessageWriter(socket, encoding)

  2749.             ]);

  2750.         });

  2751.         server.on('error', reject);

  2752.         server.listen(pipeName, () => {

  2753.             server.removeListener('error', reject);

  2754.             resolve({

  2755.                 onConnected: () => { return connected; }

  2756.             });

  2757.         });

  2758.     });

  2759. }

  2760. exports.createClientPipeTransport = createClientPipeTransport;

  2761. function createServerPipeTransport(pipeName, encoding = 'utf-8') {

  2762.     const socket = net_1.createConnection(pipeName);

  2763.     return [

  2764.         new messageReader_1.SocketMessageReader(socket, encoding),

  2765.         new messageWriter_1.SocketMessageWriter(socket, encoding)

  2766.     ];

  2767. }

  2768. exports.createServerPipeTransport = createServerPipeTransport;

  2769. 

  2770. 

  2771. /***/ }),

  2772. /* 13 */

  2773. /***/ (function(module, exports) {

  2774. 

  2775. module.exports = require("os");

  2776. 

  2777. /***/ }),

  2778. /* 14 */

  2779. /***/ (function(module, exports) {

  2780. 

  2781. module.exports = require("crypto");

  2782. 

  2783. /***/ }),

  2784. /* 15 */

  2785. /***/ (function(module, exports) {

  2786. 

  2787. module.exports = require("net");

  2788. 

  2789. /***/ }),

  2790. /* 16 */

  2791. /***/ (function(module, exports, __webpack_require__) {

  2792. 

  2793. "use strict";

  2794. /* --------------------------------------------------------------------------------------------

  2795.  * Copyright (c) Microsoft Corporation. All rights reserved.

  2796.  * Licensed under the MIT License. See License.txt in the project root for license information.

  2797.  * ------------------------------------------------------------------------------------------ */

  2798. 

  2799. Object.defineProperty(exports, "__esModule", { value: true });

  2800. const net_1 = __webpack_require__(15);

  2801. const messageReader_1 = __webpack_require__(7);

  2802. const messageWriter_1 = __webpack_require__(9);

  2803. function createClientSocketTransport(port, encoding = 'utf-8') {

  2804.     let connectResolve;

  2805.     let connected = new Promise((resolve, _reject) => {

  2806.         connectResolve = resolve;

  2807.     });

  2808.     return new Promise((resolve, reject) => {

  2809.         let server = net_1.createServer((socket) => {

  2810.             server.close();

  2811.             connectResolve([

  2812.                 new messageReader_1.SocketMessageReader(socket, encoding),

  2813.                 new messageWriter_1.SocketMessageWriter(socket, encoding)

  2814.             ]);

  2815.         });

  2816.         server.on('error', reject);

  2817.         server.listen(port, '127.0.0.1', () => {

  2818.             server.removeListener('error', reject);

  2819.             resolve({

  2820.                 onConnected: () => { return connected; }

  2821.             });

  2822.         });

  2823.     });

  2824. }

  2825. exports.createClientSocketTransport = createClientSocketTransport;

  2826. function createServerSocketTransport(port, encoding = 'utf-8') {

  2827.     const socket = net_1.createConnection(port, '127.0.0.1');

  2828.     return [

  2829.         new messageReader_1.SocketMessageReader(socket, encoding),

  2830.         new messageWriter_1.SocketMessageWriter(socket, encoding)

  2831.     ];

  2832. }

  2833. exports.createServerSocketTransport = createServerSocketTransport;

  2834. 

  2835. 

  2836. /***/ }),

  2837. /* 17 */

  2838. /***/ (function(module, __webpack_exports__, __webpack_require__) {

  2839. 

  2840. "use strict";

  2841. __webpack_require__.r(__webpack_exports__);

  2842. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Position", function() { return Position; });

  2843. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Range", function() { return Range; });

  2844. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Location", function() { return Location; });

  2845. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LocationLink", function() { return LocationLink; });

  2846. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Color", function() { return Color; });

  2847. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ColorInformation", function() { return ColorInformation; });

  2848. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ColorPresentation", function() { return ColorPresentation; });

  2849. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FoldingRangeKind", function() { return FoldingRangeKind; });

  2850. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FoldingRange", function() { return FoldingRange; });

  2851. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DiagnosticRelatedInformation", function() { return DiagnosticRelatedInformation; });

  2852. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DiagnosticSeverity", function() { return DiagnosticSeverity; });

  2853. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DiagnosticTag", function() { return DiagnosticTag; });

  2854. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Diagnostic", function() { return Diagnostic; });

  2855. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Command", function() { return Command; });

  2856. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextEdit", function() { return TextEdit; });

  2857. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocumentEdit", function() { return TextDocumentEdit; });

  2858. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CreateFile", function() { return CreateFile; });

  2859. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RenameFile", function() { return RenameFile; });

  2860. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DeleteFile", function() { return DeleteFile; });

  2861. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "WorkspaceEdit", function() { return WorkspaceEdit; });

  2862. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "WorkspaceChange", function() { return WorkspaceChange; });

  2863. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocumentIdentifier", function() { return TextDocumentIdentifier; });

  2864. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "VersionedTextDocumentIdentifier", function() { return VersionedTextDocumentIdentifier; });

  2865. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocumentItem", function() { return TextDocumentItem; });

  2866. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MarkupKind", function() { return MarkupKind; });

  2867. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MarkupContent", function() { return MarkupContent; });

  2868. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionItemKind", function() { return CompletionItemKind; });

  2869. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "InsertTextFormat", function() { return InsertTextFormat; });

  2870. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionItem", function() { return CompletionItem; });

  2871. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompletionList", function() { return CompletionList; });

  2872. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MarkedString", function() { return MarkedString; });

  2873. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Hover", function() { return Hover; });

  2874. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ParameterInformation", function() { return ParameterInformation; });

  2875. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SignatureInformation", function() { return SignatureInformation; });

  2876. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentHighlightKind", function() { return DocumentHighlightKind; });

  2877. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentHighlight", function() { return DocumentHighlight; });

  2878. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SymbolKind", function() { return SymbolKind; });

  2879. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SymbolInformation", function() { return SymbolInformation; });

  2880. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentSymbol", function() { return DocumentSymbol; });

  2881. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodeActionKind", function() { return CodeActionKind; });

  2882. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodeActionContext", function() { return CodeActionContext; });

  2883. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodeAction", function() { return CodeAction; });

  2884. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CodeLens", function() { return CodeLens; });

  2885. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FormattingOptions", function() { return FormattingOptions; });

  2886. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DocumentLink", function() { return DocumentLink; });

  2887. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EOL", function() { return EOL; });

  2888. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocument", function() { return TextDocument; });

  2889. /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextDocumentSaveReason", function() { return TextDocumentSaveReason; });

  2890. /* --------------------------------------------------------------------------------------------

  2891.  * Copyright (c) Microsoft Corporation. All rights reserved.

  2892.  * Licensed under the MIT License. See License.txt in the project root for license information.

  2893.  * ------------------------------------------------------------------------------------------ */

  2894. 

  2895. /**

  2896.  * The Position namespace provides helper functions to work with

  2897.  * [Position](#Position) literals.

  2898.  */

  2899. var Position;

  2900. (function (Position) {

  2901.     /**

  2902.      * Creates a new Position literal from the given line and character.

  2903.      * @param line The position's line.

  2904.      * @param character The position's character.

  2905.      */

  2906.     function create(line, character) {

  2907.         return { line: line, character: character };

  2908.     }

  2909.     Position.create = create;

  2910.     /**

  2911.      * Checks whether the given liternal conforms to the [Position](#Position) interface.

  2912.      */

  2913.     function is(value) {

  2914.         var candidate = value;

  2915.         return Is.objectLiteral(candidate) && Is.number(candidate.line) && Is.number(candidate.character);

  2916.     }

  2917.     Position.is = is;

  2918. })(Position || (Position = {}));

  2919. /**

  2920.  * The Range namespace provides helper functions to work with

  2921.  * [Range](#Range) literals.

  2922.  */

  2923. var Range;

  2924. (function (Range) {

  2925.     function create(one, two, three, four) {

  2926.         if (Is.number(one) && Is.number(two) && Is.number(three) && Is.number(four)) {

  2927.             return { start: Position.create(one, two), end: Position.create(three, four) };

  2928.         }

  2929.         else if (Position.is(one) && Position.is(two)) {

  2930.             return { start: one, end: two };

  2931.         }

  2932.         else {

  2933.             throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");

  2934.         }

  2935.     }

  2936.     Range.create = create;

  2937.     /**

  2938.      * Checks whether the given literal conforms to the [Range](#Range) interface.

  2939.      */

  2940.     function is(value) {

  2941.         var candidate = value;

  2942.         return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);

  2943.     }

  2944.     Range.is = is;

  2945. })(Range || (Range = {}));

  2946. /**

  2947.  * The Location namespace provides helper functions to work with

  2948.  * [Location](#Location) literals.

  2949.  */

  2950. var Location;

  2951. (function (Location) {

  2952.     /**

  2953.      * Creates a Location literal.

  2954.      * @param uri The location's uri.

  2955.      * @param range The location's range.

  2956.      */

  2957.     function create(uri, range) {

  2958.         return { uri: uri, range: range };

  2959.     }

  2960.     Location.create = create;

  2961.     /**

  2962.      * Checks whether the given literal conforms to the [Location](#Location) interface.

  2963.      */

  2964.     function is(value) {

  2965.         var candidate = value;

  2966.         return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));

  2967.     }

  2968.     Location.is = is;

  2969. })(Location || (Location = {}));

  2970. /**

  2971.  * The LocationLink namespace provides helper functions to work with

  2972.  * [LocationLink](#LocationLink) literals.

  2973.  */

  2974. var LocationLink;

  2975. (function (LocationLink) {

  2976.     /**

  2977.      * Creates a LocationLink literal.

  2978.      * @param targetUri The definition's uri.

  2979.      * @param targetRange The full range of the definition.

  2980.      * @param targetSelectionRange The span of the symbol definition at the target.

  2981.      * @param originSelectionRange The span of the symbol being defined in the originating source file.

  2982.      */

  2983.     function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {

  2984.         return { targetUri: targetUri, targetRange: targetRange, targetSelectionRange: targetSelectionRange, originSelectionRange: originSelectionRange };

  2985.     }

  2986.     LocationLink.create = create;

  2987.     /**

  2988.      * Checks whether the given literal conforms to the [LocationLink](#LocationLink) interface.

  2989.      */

  2990.     function is(value) {

  2991.         var candidate = value;

  2992.         return Is.defined(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri)

  2993.             && (Range.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange))

  2994.             && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));

  2995.     }

  2996.     LocationLink.is = is;

  2997. })(LocationLink || (LocationLink = {}));

  2998. /**

  2999.  * The Color namespace provides helper functions to work with

  3000.  * [Color](#Color) literals.

  3001.  */

  3002. var Color;

  3003. (function (Color) {

  3004.     /**

  3005.      * Creates a new Color literal.

  3006.      */

  3007.     function create(red, green, blue, alpha) {

  3008.         return {

  3009.             red: red,

  3010.             green: green,

  3011.             blue: blue,

  3012.             alpha: alpha,

  3013.         };

  3014.     }

  3015.     Color.create = create;

  3016.     /**

  3017.      * Checks whether the given literal conforms to the [Color](#Color) interface.

  3018.      */

  3019.     function is(value) {

  3020.         var candidate = value;

  3021.         return Is.number(candidate.red)

  3022.             && Is.number(candidate.green)

  3023.             && Is.number(candidate.blue)

  3024.             && Is.number(candidate.alpha);

  3025.     }

  3026.     Color.is = is;

  3027. })(Color || (Color = {}));

  3028. /**

  3029.  * The ColorInformation namespace provides helper functions to work with

  3030.  * [ColorInformation](#ColorInformation) literals.

  3031.  */

  3032. var ColorInformation;

  3033. (function (ColorInformation) {

  3034.     /**

  3035.      * Creates a new ColorInformation literal.

  3036.      */

  3037.     function create(range, color) {

  3038.         return {

  3039.             range: range,

  3040.             color: color,

  3041.         };

  3042.     }

  3043.     ColorInformation.create = create;

  3044.     /**

  3045.      * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.

  3046.      */

  3047.     function is(value) {

  3048.         var candidate = value;

  3049.         return Range.is(candidate.range) && Color.is(candidate.color);

  3050.     }

  3051.     ColorInformation.is = is;

  3052. })(ColorInformation || (ColorInformation = {}));

  3053. /**

  3054.  * The Color namespace provides helper functions to work with

  3055.  * [ColorPresentation](#ColorPresentation) literals.

  3056.  */

  3057. var ColorPresentation;

  3058. (function (ColorPresentation) {

  3059.     /**

  3060.      * Creates a new ColorInformation literal.

  3061.      */

  3062.     function create(label, textEdit, additionalTextEdits) {

  3063.         return {

  3064.             label: label,

  3065.             textEdit: textEdit,

  3066.             additionalTextEdits: additionalTextEdits,

  3067.         };

  3068.     }

  3069.     ColorPresentation.create = create;

  3070.     /**

  3071.      * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.

  3072.      */

  3073.     function is(value) {

  3074.         var candidate = value;

  3075.         return Is.string(candidate.label)

  3076.             && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))

  3077.             && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));

  3078.     }

  3079.     ColorPresentation.is = is;

  3080. })(ColorPresentation || (ColorPresentation = {}));

  3081. /**

  3082.  * Enum of known range kinds

  3083.  */

  3084. var FoldingRangeKind;

  3085. (function (FoldingRangeKind) {

  3086.     /**

  3087.      * Folding range for a comment

  3088.      */

  3089.     FoldingRangeKind["Comment"] = "comment";

  3090.     /**

  3091.      * Folding range for a imports or includes

  3092.      */

  3093.     FoldingRangeKind["Imports"] = "imports";

  3094.     /**

  3095.      * Folding range for a region (e.g. `#region`)

  3096.      */

  3097.     FoldingRangeKind["Region"] = "region";

  3098. })(FoldingRangeKind || (FoldingRangeKind = {}));

  3099. /**

  3100.  * The folding range namespace provides helper functions to work with

  3101.  * [FoldingRange](#FoldingRange) literals.

  3102.  */

  3103. var FoldingRange;

  3104. (function (FoldingRange) {

  3105.     /**

  3106.      * Creates a new FoldingRange literal.

  3107.      */

  3108.     function create(startLine, endLine, startCharacter, endCharacter, kind) {

  3109.         var result = {

  3110.             startLine: startLine,

  3111.             endLine: endLine

  3112.         };

  3113.         if (Is.defined(startCharacter)) {

  3114.             result.startCharacter = startCharacter;

  3115.         }

  3116.         if (Is.defined(endCharacter)) {

  3117.             result.endCharacter = endCharacter;

  3118.         }

  3119.         if (Is.defined(kind)) {

  3120.             result.kind = kind;

  3121.         }

  3122.         return result;

  3123.     }

  3124.     FoldingRange.create = create;

  3125.     /**

  3126.      * Checks whether the given literal conforms to the [FoldingRange](#FoldingRange) interface.

  3127.      */

  3128.     function is(value) {

  3129.         var candidate = value;

  3130.         return Is.number(candidate.startLine) && Is.number(candidate.startLine)

  3131.             && (Is.undefined(candidate.startCharacter) || Is.number(candidate.startCharacter))

  3132.             && (Is.undefined(candidate.endCharacter) || Is.number(candidate.endCharacter))

  3133.             && (Is.undefined(candidate.kind) || Is.string(candidate.kind));

  3134.     }

  3135.     FoldingRange.is = is;

  3136. })(FoldingRange || (FoldingRange = {}));

  3137. /**

  3138.  * The DiagnosticRelatedInformation namespace provides helper functions to work with

  3139.  * [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) literals.

  3140.  */

  3141. var DiagnosticRelatedInformation;

  3142. (function (DiagnosticRelatedInformation) {

  3143.     /**

  3144.      * Creates a new DiagnosticRelatedInformation literal.

  3145.      */

  3146.     function create(location, message) {

  3147.         return {

  3148.             location: location,

  3149.             message: message

  3150.         };

  3151.     }

  3152.     DiagnosticRelatedInformation.create = create;

  3153.     /**

  3154.      * Checks whether the given literal conforms to the [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) interface.

  3155.      */

  3156.     function is(value) {

  3157.         var candidate = value;

  3158.         return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);

  3159.     }

  3160.     DiagnosticRelatedInformation.is = is;

  3161. })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));

  3162. /**

  3163.  * The diagnostic's severity.

  3164.  */

  3165. var DiagnosticSeverity;

  3166. (function (DiagnosticSeverity) {

  3167.     /**

  3168.      * Reports an error.

  3169.      */

  3170.     DiagnosticSeverity.Error = 1;

  3171.     /**

  3172.      * Reports a warning.

  3173.      */

  3174.     DiagnosticSeverity.Warning = 2;

  3175.     /**

  3176.      * Reports an information.

  3177.      */

  3178.     DiagnosticSeverity.Information = 3;

  3179.     /**

  3180.      * Reports a hint.

  3181.      */

  3182.     DiagnosticSeverity.Hint = 4;

  3183. })(DiagnosticSeverity || (DiagnosticSeverity = {}));

  3184. var DiagnosticTag;

  3185. (function (DiagnosticTag) {

  3186.     /**

  3187.      * Unused or unnecessary code.

  3188.      *

  3189.      * Clients are allowed to render diagnostics with this tag faded out instead of having

  3190.      * an error squiggle.

  3191.      */

  3192.     DiagnosticTag.Unnecessary = 1;

  3193. })(DiagnosticTag || (DiagnosticTag = {}));

  3194. /**

  3195.  * The Diagnostic namespace provides helper functions to work with

  3196.  * [Diagnostic](#Diagnostic) literals.

  3197.  */

  3198. var Diagnostic;

  3199. (function (Diagnostic) {

  3200.     /**

  3201.      * Creates a new Diagnostic literal.

  3202.      */

  3203.     function create(range, message, severity, code, source, relatedInformation) {

  3204.         var result = { range: range, message: message };

  3205.         if (Is.defined(severity)) {

  3206.             result.severity = severity;

  3207.         }

  3208.         if (Is.defined(code)) {

  3209.             result.code = code;

  3210.         }

  3211.         if (Is.defined(source)) {

  3212.             result.source = source;

  3213.         }

  3214.         if (Is.defined(relatedInformation)) {

  3215.             result.relatedInformation = relatedInformation;

  3216.         }

  3217.         return result;

  3218.     }

  3219.     Diagnostic.create = create;

  3220.     /**

  3221.      * Checks whether the given literal conforms to the [Diagnostic](#Diagnostic) interface.

  3222.      */

  3223.     function is(value) {

  3224.         var candidate = value;

  3225.         return Is.defined(candidate)

  3226.             && Range.is(candidate.range)

  3227.             && Is.string(candidate.message)

  3228.             && (Is.number(candidate.severity) || Is.undefined(candidate.severity))

  3229.             && (Is.number(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code))

  3230.             && (Is.string(candidate.source) || Is.undefined(candidate.source))

  3231.             && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));

  3232.     }

  3233.     Diagnostic.is = is;

  3234. })(Diagnostic || (Diagnostic = {}));

  3235. /**

  3236.  * The Command namespace provides helper functions to work with

  3237.  * [Command](#Command) literals.

  3238.  */

  3239. var Command;

  3240. (function (Command) {

  3241.     /**

  3242.      * Creates a new Command literal.

  3243.      */

  3244.     function create(title, command) {

  3245.         var args = [];

  3246.         for (var _i = 2; _i < arguments.length; _i++) {

  3247.             args[_i - 2] = arguments[_i];

  3248.         }

  3249.         var result = { title: title, command: command };

  3250.         if (Is.defined(args) && args.length > 0) {

  3251.             result.arguments = args;

  3252.         }

  3253.         return result;

  3254.     }

  3255.     Command.create = create;

  3256.     /**

  3257.      * Checks whether the given literal conforms to the [Command](#Command) interface.

  3258.      */

  3259.     function is(value) {

  3260.         var candidate = value;

  3261.         return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);

  3262.     }

  3263.     Command.is = is;

  3264. })(Command || (Command = {}));

  3265. /**

  3266.  * The TextEdit namespace provides helper function to create replace,

  3267.  * insert and delete edits more easily.

  3268.  */

  3269. var TextEdit;

  3270. (function (TextEdit) {

  3271.     /**

  3272.      * Creates a replace text edit.

  3273.      * @param range The range of text to be replaced.

  3274.      * @param newText The new text.

  3275.      */

  3276.     function replace(range, newText) {

  3277.         return { range: range, newText: newText };

  3278.     }

  3279.     TextEdit.replace = replace;

  3280.     /**

  3281.      * Creates a insert text edit.

  3282.      * @param position The position to insert the text at.

  3283.      * @param newText The text to be inserted.

  3284.      */

  3285.     function insert(position, newText) {

  3286.         return { range: { start: position, end: position }, newText: newText };

  3287.     }

  3288.     TextEdit.insert = insert;

  3289.     /**

  3290.      * Creates a delete text edit.

  3291.      * @param range The range of text to be deleted.

  3292.      */

  3293.     function del(range) {

  3294.         return { range: range, newText: '' };

  3295.     }

  3296.     TextEdit.del = del;

  3297.     function is(value) {

  3298.         var candidate = value;

  3299.         return Is.objectLiteral(candidate)

  3300.             && Is.string(candidate.newText)

  3301.             && Range.is(candidate.range);

  3302.     }

  3303.     TextEdit.is = is;

  3304. })(TextEdit || (TextEdit = {}));

  3305. /**

  3306.  * The TextDocumentEdit namespace provides helper function to create

  3307.  * an edit that manipulates a text document.

  3308.  */

  3309. var TextDocumentEdit;

  3310. (function (TextDocumentEdit) {

  3311.     /**

  3312.      * Creates a new `TextDocumentEdit`

  3313.      */

  3314.     function create(textDocument, edits) {

  3315.         return { textDocument: textDocument, edits: edits };

  3316.     }

  3317.     TextDocumentEdit.create = create;

  3318.     function is(value) {

  3319.         var candidate = value;

  3320.         return Is.defined(candidate)

  3321.             && VersionedTextDocumentIdentifier.is(candidate.textDocument)

  3322.             && Array.isArray(candidate.edits);

  3323.     }

  3324.     TextDocumentEdit.is = is;

  3325. })(TextDocumentEdit || (TextDocumentEdit = {}));

  3326. var CreateFile;

  3327. (function (CreateFile) {

  3328.     function create(uri, options) {

  3329.         var result = {

  3330.             kind: 'create',

  3331.             uri: uri

  3332.         };

  3333.         if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {

  3334.             result.options = options;

  3335.         }

  3336.         return result;

  3337.     }

  3338.     CreateFile.create = create;

  3339.     function is(value) {

  3340.         var candidate = value;

  3341.         return candidate && candidate.kind === 'create' && Is.string(candidate.uri) &&

  3342.             (candidate.options === void 0 ||

  3343.                 ((candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))));

  3344.     }

  3345.     CreateFile.is = is;

  3346. })(CreateFile || (CreateFile = {}));

  3347. var RenameFile;

  3348. (function (RenameFile) {

  3349.     function create(oldUri, newUri, options) {

  3350.         var result = {

  3351.             kind: 'rename',

  3352.             oldUri: oldUri,

  3353.             newUri: newUri

  3354.         };

  3355.         if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {

  3356.             result.options = options;

  3357.         }

  3358.         return result;

  3359.     }

  3360.     RenameFile.create = create;

  3361.     function is(value) {

  3362.         var candidate = value;

  3363.         return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) &&

  3364.             (candidate.options === void 0 ||

  3365.                 ((candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))));

  3366.     }

  3367.     RenameFile.is = is;

  3368. })(RenameFile || (RenameFile = {}));

  3369. var DeleteFile;

  3370. (function (DeleteFile) {

  3371.     function create(uri, options) {

  3372.         var result = {

  3373.             kind: 'delete',

  3374.             uri: uri

  3375.         };

  3376.         if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {

  3377.             result.options = options;

  3378.         }

  3379.         return result;

  3380.     }

  3381.     DeleteFile.create = create;

  3382.     function is(value) {

  3383.         var candidate = value;

  3384.         return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) &&

  3385.             (candidate.options === void 0 ||

  3386.                 ((candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))));

  3387.     }

  3388.     DeleteFile.is = is;

  3389. })(DeleteFile || (DeleteFile = {}));

  3390. var WorkspaceEdit;

  3391. (function (WorkspaceEdit) {

  3392.     function is(value) {

  3393.         var candidate = value;

  3394.         return candidate &&

  3395.             (candidate.changes !== void 0 || candidate.documentChanges !== void 0) &&

  3396.             (candidate.documentChanges === void 0 || candidate.documentChanges.every(function (change) {

  3397.                 if (Is.string(change.kind)) {

  3398.                     return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);

  3399.                 }

  3400.                 else {

  3401.                     return TextDocumentEdit.is(change);

  3402.                 }

  3403.             }));

  3404.     }

  3405.     WorkspaceEdit.is = is;

  3406. })(WorkspaceEdit || (WorkspaceEdit = {}));

  3407. var TextEditChangeImpl = /** @class */ (function () {

  3408.     function TextEditChangeImpl(edits) {

  3409.         this.edits = edits;

  3410.     }

  3411.     TextEditChangeImpl.prototype.insert = function (position, newText) {

  3412.         this.edits.push(TextEdit.insert(position, newText));

  3413.     };

  3414.     TextEditChangeImpl.prototype.replace = function (range, newText) {

  3415.         this.edits.push(TextEdit.replace(range, newText));

  3416.     };

  3417.     TextEditChangeImpl.prototype.delete = function (range) {

  3418.         this.edits.push(TextEdit.del(range));

  3419.     };

  3420.     TextEditChangeImpl.prototype.add = function (edit) {

  3421.         this.edits.push(edit);

  3422.     };

  3423.     TextEditChangeImpl.prototype.all = function () {

  3424.         return this.edits;

  3425.     };

  3426.     TextEditChangeImpl.prototype.clear = function () {

  3427.         this.edits.splice(0, this.edits.length);

  3428.     };

  3429.     return TextEditChangeImpl;

  3430. }());

  3431. /**

  3432.  * A workspace change helps constructing changes to a workspace.

  3433.  */

  3434. var WorkspaceChange = /** @class */ (function () {

  3435.     function WorkspaceChange(workspaceEdit) {

  3436.         var _this = this;

  3437.         this._textEditChanges = Object.create(null);

  3438.         if (workspaceEdit) {

  3439.             this._workspaceEdit = workspaceEdit;

  3440.             if (workspaceEdit.documentChanges) {

  3441.                 workspaceEdit.documentChanges.forEach(function (change) {

  3442.                     if (TextDocumentEdit.is(change)) {

  3443.                         var textEditChange = new TextEditChangeImpl(change.edits);

  3444.                         _this._textEditChanges[change.textDocument.uri] = textEditChange;

  3445.                     }

  3446.                 });

  3447.             }

  3448.             else if (workspaceEdit.changes) {

  3449.                 Object.keys(workspaceEdit.changes).forEach(function (key) {

  3450.                     var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);

  3451.                     _this._textEditChanges[key] = textEditChange;

  3452.                 });

  3453.             }

  3454.         }

  3455.     }

  3456.     Object.defineProperty(WorkspaceChange.prototype, "edit", {

  3457.         /**

  3458.          * Returns the underlying [WorkspaceEdit](#WorkspaceEdit) literal

  3459.          * use to be returned from a workspace edit operation like rename.

  3460.          */

  3461.         get: function () {

  3462.             return this._workspaceEdit;

  3463.         },

  3464.         enumerable: true,

  3465.         configurable: true

  3466.     });

  3467.     WorkspaceChange.prototype.getTextEditChange = function (key) {

  3468.         if (VersionedTextDocumentIdentifier.is(key)) {

  3469.             if (!this._workspaceEdit) {

  3470.                 this._workspaceEdit = {

  3471.                     documentChanges: []

  3472.                 };

  3473.             }

  3474.             if (!this._workspaceEdit.documentChanges) {

  3475.                 throw new Error('Workspace edit is not configured for document changes.');

  3476.             }

  3477.             var textDocument = key;

  3478.             var result = this._textEditChanges[textDocument.uri];

  3479.             if (!result) {

  3480.                 var edits = [];

  3481.                 var textDocumentEdit = {

  3482.                     textDocument: textDocument,

  3483.                     edits: edits

  3484.                 };

  3485.                 this._workspaceEdit.documentChanges.push(textDocumentEdit);

  3486.                 result = new TextEditChangeImpl(edits);

  3487.                 this._textEditChanges[textDocument.uri] = result;

  3488.             }

  3489.             return result;

  3490.         }

  3491.         else {

  3492.             if (!this._workspaceEdit) {

  3493.                 this._workspaceEdit = {

  3494.                     changes: Object.create(null)

  3495.                 };

  3496.             }

  3497.             if (!this._workspaceEdit.changes) {

  3498.                 throw new Error('Workspace edit is not configured for normal text edit changes.');

  3499.             }

  3500.             var result = this._textEditChanges[key];

  3501.             if (!result) {

  3502.                 var edits = [];

  3503.                 this._workspaceEdit.changes[key] = edits;

  3504.                 result = new TextEditChangeImpl(edits);

  3505.                 this._textEditChanges[key] = result;

  3506.             }

  3507.             return result;

  3508.         }

  3509.     };

  3510.     WorkspaceChange.prototype.createFile = function (uri, options) {

  3511.         this.checkDocumentChanges();

  3512.         this._workspaceEdit.documentChanges.push(CreateFile.create(uri, options));

  3513.     };

  3514.     WorkspaceChange.prototype.renameFile = function (oldUri, newUri, options) {

  3515.         this.checkDocumentChanges();

  3516.         this._workspaceEdit.documentChanges.push(RenameFile.create(oldUri, newUri, options));

  3517.     };

  3518.     WorkspaceChange.prototype.deleteFile = function (uri, options) {

  3519.         this.checkDocumentChanges();

  3520.         this._workspaceEdit.documentChanges.push(DeleteFile.create(uri, options));

  3521.     };

  3522.     WorkspaceChange.prototype.checkDocumentChanges = function () {

  3523.         if (!this._workspaceEdit || !this._workspaceEdit.documentChanges) {

  3524.             throw new Error('Workspace edit is not configured for document changes.');

  3525.         }

  3526.     };

  3527.     return WorkspaceChange;

  3528. }());

  3529. 

  3530. /**

  3531.  * The TextDocumentIdentifier namespace provides helper functions to work with

  3532.  * [TextDocumentIdentifier](#TextDocumentIdentifier) literals.

  3533.  */

  3534. var TextDocumentIdentifier;

  3535. (function (TextDocumentIdentifier) {

  3536.     /**

  3537.      * Creates a new TextDocumentIdentifier literal.

  3538.      * @param uri The document's uri.

  3539.      */

  3540.     function create(uri) {

  3541.         return { uri: uri };

  3542.     }

  3543.     TextDocumentIdentifier.create = create;

  3544.     /**

  3545.      * Checks whether the given literal conforms to the [TextDocumentIdentifier](#TextDocumentIdentifier) interface.

  3546.      */

  3547.     function is(value) {

  3548.         var candidate = value;

  3549.         return Is.defined(candidate) && Is.string(candidate.uri);

  3550.     }

  3551.     TextDocumentIdentifier.is = is;

  3552. })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));

  3553. /**

  3554.  * The VersionedTextDocumentIdentifier namespace provides helper functions to work with

  3555.  * [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) literals.

  3556.  */

  3557. var VersionedTextDocumentIdentifier;

  3558. (function (VersionedTextDocumentIdentifier) {

  3559.     /**

  3560.      * Creates a new VersionedTextDocumentIdentifier literal.

  3561.      * @param uri The document's uri.

  3562.      * @param uri The document's text.

  3563.      */

  3564.     function create(uri, version) {

  3565.         return { uri: uri, version: version };

  3566.     }

  3567.     VersionedTextDocumentIdentifier.create = create;

  3568.     /**

  3569.      * Checks whether the given literal conforms to the [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) interface.

  3570.      */

  3571.     function is(value) {

  3572.         var candidate = value;

  3573.         return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.number(candidate.version));

  3574.     }

  3575.     VersionedTextDocumentIdentifier.is = is;

  3576. })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));

  3577. /**

  3578.  * The TextDocumentItem namespace provides helper functions to work with

  3579.  * [TextDocumentItem](#TextDocumentItem) literals.

  3580.  */

  3581. var TextDocumentItem;

  3582. (function (TextDocumentItem) {

  3583.     /**

  3584.      * Creates a new TextDocumentItem literal.

  3585.      * @param uri The document's uri.

  3586.      * @param languageId The document's language identifier.

  3587.      * @param version The document's version number.

  3588.      * @param text The document's text.

  3589.      */

  3590.     function create(uri, languageId, version, text) {

  3591.         return { uri: uri, languageId: languageId, version: version, text: text };

  3592.     }

  3593.     TextDocumentItem.create = create;

  3594.     /**

  3595.      * Checks whether the given literal conforms to the [TextDocumentItem](#TextDocumentItem) interface.

  3596.      */

  3597.     function is(value) {

  3598.         var candidate = value;

  3599.         return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.number(candidate.version) && Is.string(candidate.text);

  3600.     }

  3601.     TextDocumentItem.is = is;

  3602. })(TextDocumentItem || (TextDocumentItem = {}));

  3603. /**

  3604.  * Describes the content type that a client supports in various

  3605.  * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.

  3606.  *

  3607.  * Please note that `MarkupKinds` must not start with a `$`. This kinds

  3608.  * are reserved for internal usage.

  3609.  */

  3610. var MarkupKind;

  3611. (function (MarkupKind) {

  3612.     /**

  3613.      * Plain text is supported as a content format

  3614.      */

  3615.     MarkupKind.PlainText = 'plaintext';

  3616.     /**

  3617.      * Markdown is supported as a content format

  3618.      */

  3619.     MarkupKind.Markdown = 'markdown';

  3620. })(MarkupKind || (MarkupKind = {}));

  3621. (function (MarkupKind) {

  3622.     /**

  3623.      * Checks whether the given value is a value of the [MarkupKind](#MarkupKind) type.

  3624.      */

  3625.     function is(value) {

  3626.         var candidate = value;

  3627.         return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;

  3628.     }

  3629.     MarkupKind.is = is;

  3630. })(MarkupKind || (MarkupKind = {}));

  3631. var MarkupContent;

  3632. (function (MarkupContent) {

  3633.     /**

  3634.      * Checks whether the given value conforms to the [MarkupContent](#MarkupContent) interface.

  3635.      */

  3636.     function is(value) {

  3637.         var candidate = value;

  3638.         return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);

  3639.     }

  3640.     MarkupContent.is = is;

  3641. })(MarkupContent || (MarkupContent = {}));

  3642. /**

  3643.  * The kind of a completion entry.

  3644.  */

  3645. var CompletionItemKind;

  3646. (function (CompletionItemKind) {

  3647.     CompletionItemKind.Text = 1;

  3648.     CompletionItemKind.Method = 2;

  3649.     CompletionItemKind.Function = 3;

  3650.     CompletionItemKind.Constructor = 4;

  3651.     CompletionItemKind.Field = 5;

  3652.     CompletionItemKind.Variable = 6;

  3653.     CompletionItemKind.Class = 7;

  3654.     CompletionItemKind.Interface = 8;

  3655.     CompletionItemKind.Module = 9;

  3656.     CompletionItemKind.Property = 10;

  3657.     CompletionItemKind.Unit = 11;

  3658.     CompletionItemKind.Value = 12;

  3659.     CompletionItemKind.Enum = 13;

  3660.     CompletionItemKind.Keyword = 14;

  3661.     CompletionItemKind.Snippet = 15;

  3662.     CompletionItemKind.Color = 16;

  3663.     CompletionItemKind.File = 17;

  3664.     CompletionItemKind.Reference = 18;

  3665.     CompletionItemKind.Folder = 19;

  3666.     CompletionItemKind.EnumMember = 20;

  3667.     CompletionItemKind.Constant = 21;

  3668.     CompletionItemKind.Struct = 22;

  3669.     CompletionItemKind.Event = 23;

  3670.     CompletionItemKind.Operator = 24;

  3671.     CompletionItemKind.TypeParameter = 25;

  3672. })(CompletionItemKind || (CompletionItemKind = {}));

  3673. /**

  3674.  * Defines whether the insert text in a completion item should be interpreted as

  3675.  * plain text or a snippet.

  3676.  */

  3677. var InsertTextFormat;

  3678. (function (InsertTextFormat) {

  3679.     /**

  3680.      * The primary text to be inserted is treated as a plain string.

  3681.      */

  3682.     InsertTextFormat.PlainText = 1;

  3683.     /**

  3684.      * The primary text to be inserted is treated as a snippet.

  3685.      *

  3686.      * A snippet can define tab stops and placeholders with `$1`, `$2`

  3687.      * and `${3:foo}`. `$0` defines the final tab stop, it defaults to

  3688.      * the end of the snippet. Placeholders with equal identifiers are linked,

  3689.      * that is typing in one will update others too.

  3690.      *

  3691.      * See also: https://github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md

  3692.      */

  3693.     InsertTextFormat.Snippet = 2;

  3694. })(InsertTextFormat || (InsertTextFormat = {}));

  3695. /**

  3696.  * The CompletionItem namespace provides functions to deal with

  3697.  * completion items.

  3698.  */

  3699. var CompletionItem;

  3700. (function (CompletionItem) {

  3701.     /**

  3702.      * Create a completion item and seed it with a label.

  3703.      * @param label The completion item's label

  3704.      */

  3705.     function create(label) {

  3706.         return { label: label };

  3707.     }

  3708.     CompletionItem.create = create;

  3709. })(CompletionItem || (CompletionItem = {}));

  3710. /**

  3711.  * The CompletionList namespace provides functions to deal with

  3712.  * completion lists.

  3713.  */

  3714. var CompletionList;

  3715. (function (CompletionList) {

  3716.     /**

  3717.      * Creates a new completion list.

  3718.      *

  3719.      * @param items The completion items.

  3720.      * @param isIncomplete The list is not complete.

  3721.      */

  3722.     function create(items, isIncomplete) {

  3723.         return { items: items ? items : [], isIncomplete: !!isIncomplete };

  3724.     }

  3725.     CompletionList.create = create;

  3726. })(CompletionList || (CompletionList = {}));

  3727. var MarkedString;

  3728. (function (MarkedString) {

  3729.     /**

  3730.      * Creates a marked string from plain text.

  3731.      *

  3732.      * @param plainText The plain text.

  3733.      */

  3734.     function fromPlainText(plainText) {

  3735.         return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&"); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash

  3736.     }

  3737.     MarkedString.fromPlainText = fromPlainText;

  3738.     /**

  3739.      * Checks whether the given value conforms to the [MarkedString](#MarkedString) type.

  3740.      */

  3741.     function is(value) {

  3742.         var candidate = value;

  3743.         return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value));

  3744.     }

  3745.     MarkedString.is = is;

  3746. })(MarkedString || (MarkedString = {}));

  3747. var Hover;

  3748. (function (Hover) {

  3749.     /**

  3750.      * Checks whether the given value conforms to the [Hover](#Hover) interface.

  3751.      */

  3752.     function is(value) {

  3753.         var candidate = value;

  3754.         return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) ||

  3755.             MarkedString.is(candidate.contents) ||

  3756.             Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range));

  3757.     }

  3758.     Hover.is = is;

  3759. })(Hover || (Hover = {}));

  3760. /**

  3761.  * The ParameterInformation namespace provides helper functions to work with

  3762.  * [ParameterInformation](#ParameterInformation) literals.

  3763.  */

  3764. var ParameterInformation;

  3765. (function (ParameterInformation) {

  3766.     /**

  3767.      * Creates a new parameter information literal.

  3768.      *

  3769.      * @param label A label string.

  3770.      * @param documentation A doc string.

  3771.      */

  3772.     function create(label, documentation) {

  3773.         return documentation ? { label: label, documentation: documentation } : { label: label };

  3774.     }

  3775.     ParameterInformation.create = create;

  3776.     ;

  3777. })(ParameterInformation || (ParameterInformation = {}));

  3778. /**

  3779.  * The SignatureInformation namespace provides helper functions to work with

  3780.  * [SignatureInformation](#SignatureInformation) literals.

  3781.  */

  3782. var SignatureInformation;

  3783. (function (SignatureInformation) {

  3784.     function create(label, documentation) {

  3785.         var parameters = [];

  3786.         for (var _i = 2; _i < arguments.length; _i++) {

  3787.             parameters[_i - 2] = arguments[_i];

  3788.         }

  3789.         var result = { label: label };

  3790.         if (Is.defined(documentation)) {

  3791.             result.documentation = documentation;

  3792.         }

  3793.         if (Is.defined(parameters)) {

  3794.             result.parameters = parameters;

  3795.         }

  3796.         else {

  3797.             result.parameters = [];

  3798.         }

  3799.         return result;

  3800.     }

  3801.     SignatureInformation.create = create;

  3802. })(SignatureInformation || (SignatureInformation = {}));

  3803. /**

  3804.  * A document highlight kind.

  3805.  */

  3806. var DocumentHighlightKind;

  3807. (function (DocumentHighlightKind) {

  3808.     /**

  3809.      * A textual occurrence.

  3810.      */

  3811.     DocumentHighlightKind.Text = 1;

  3812.     /**

  3813.      * Read-access of a symbol, like reading a variable.

  3814.      */

  3815.     DocumentHighlightKind.Read = 2;

  3816.     /**

  3817.      * Write-access of a symbol, like writing to a variable.

  3818.      */

  3819.     DocumentHighlightKind.Write = 3;

  3820. })(DocumentHighlightKind || (DocumentHighlightKind = {}));

  3821. /**

  3822.  * DocumentHighlight namespace to provide helper functions to work with

  3823.  * [DocumentHighlight](#DocumentHighlight) literals.

  3824.  */

  3825. var DocumentHighlight;

  3826. (function (DocumentHighlight) {

  3827.     /**

  3828.      * Create a DocumentHighlight object.

  3829.      * @param range The range the highlight applies to.

  3830.      */

  3831.     function create(range, kind) {

  3832.         var result = { range: range };

  3833.         if (Is.number(kind)) {

  3834.             result.kind = kind;

  3835.         }

  3836.         return result;

  3837.     }

  3838.     DocumentHighlight.create = create;

  3839. })(DocumentHighlight || (DocumentHighlight = {}));

  3840. /**

  3841.  * A symbol kind.

  3842.  */

  3843. var SymbolKind;

  3844. (function (SymbolKind) {

  3845.     SymbolKind.File = 1;

  3846.     SymbolKind.Module = 2;

  3847.     SymbolKind.Namespace = 3;

  3848.     SymbolKind.Package = 4;

  3849.     SymbolKind.Class = 5;

  3850.     SymbolKind.Method = 6;

  3851.     SymbolKind.Property = 7;

  3852.     SymbolKind.Field = 8;

  3853.     SymbolKind.Constructor = 9;

  3854.     SymbolKind.Enum = 10;

  3855.     SymbolKind.Interface = 11;

  3856.     SymbolKind.Function = 12;

  3857.     SymbolKind.Variable = 13;

  3858.     SymbolKind.Constant = 14;

  3859.     SymbolKind.String = 15;

  3860.     SymbolKind.Number = 16;

  3861.     SymbolKind.Boolean = 17;

  3862.     SymbolKind.Array = 18;

  3863.     SymbolKind.Object = 19;

  3864.     SymbolKind.Key = 20;

  3865.     SymbolKind.Null = 21;

  3866.     SymbolKind.EnumMember = 22;

  3867.     SymbolKind.Struct = 23;

  3868.     SymbolKind.Event = 24;

  3869.     SymbolKind.Operator = 25;

  3870.     SymbolKind.TypeParameter = 26;

  3871. })(SymbolKind || (SymbolKind = {}));

  3872. var SymbolInformation;

  3873. (function (SymbolInformation) {

  3874.     /**

  3875.      * Creates a new symbol information literal.

  3876.      *

  3877.      * @param name The name of the symbol.

  3878.      * @param kind The kind of the symbol.

  3879.      * @param range The range of the location of the symbol.

  3880.      * @param uri The resource of the location of symbol, defaults to the current document.

  3881.      * @param containerName The name of the symbol containing the symbol.

  3882.      */

  3883.     function create(name, kind, range, uri, containerName) {

  3884.         var result = {

  3885.             name: name,

  3886.             kind: kind,

  3887.             location: { uri: uri, range: range }

  3888.         };

  3889.         if (containerName) {

  3890.             result.containerName = containerName;

  3891.         }

  3892.         return result;

  3893.     }

  3894.     SymbolInformation.create = create;

  3895. })(SymbolInformation || (SymbolInformation = {}));

  3896. /**

  3897.  * Represents programming constructs like variables, classes, interfaces etc.

  3898.  * that appear in a document. Document symbols can be hierarchical and they

  3899.  * have two ranges: one that encloses its definition and one that points to

  3900.  * its most interesting range, e.g. the range of an identifier.

  3901.  */

  3902. var DocumentSymbol = /** @class */ (function () {

  3903.     function DocumentSymbol() {

  3904.     }

  3905.     return DocumentSymbol;

  3906. }());

  3907. 

  3908. (function (DocumentSymbol) {

  3909.     /**

  3910.      * Creates a new symbol information literal.

  3911.      *

  3912.      * @param name The name of the symbol.

  3913.      * @param detail The detail of the symbol.

  3914.      * @param kind The kind of the symbol.

  3915.      * @param range The range of the symbol.

  3916.      * @param selectionRange The selectionRange of the symbol.

  3917.      * @param children Children of the symbol.

  3918.      */

  3919.     function create(name, detail, kind, range, selectionRange, children) {

  3920.         var result = {

  3921.             name: name,

  3922.             detail: detail,

  3923.             kind: kind,

  3924.             range: range,

  3925.             selectionRange: selectionRange

  3926.         };

  3927.         if (children !== void 0) {

  3928.             result.children = children;

  3929.         }

  3930.         return result;

  3931.     }

  3932.     DocumentSymbol.create = create;

  3933.     /**

  3934.      * Checks whether the given literal conforms to the [DocumentSymbol](#DocumentSymbol) interface.

  3935.      */

  3936.     function is(value) {

  3937.         var candidate = value;

  3938.         return candidate &&

  3939.             Is.string(candidate.name) && Is.number(candidate.kind) &&

  3940.             Range.is(candidate.range) && Range.is(candidate.selectionRange) &&

  3941.             (candidate.detail === void 0 || Is.string(candidate.detail)) &&

  3942.             (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) &&

  3943.             (candidate.children === void 0 || Array.isArray(candidate.children));

  3944.     }

  3945.     DocumentSymbol.is = is;

  3946. })(DocumentSymbol || (DocumentSymbol = {}));

  3947. /**

  3948.  * A set of predefined code action kinds

  3949.  */

  3950. var CodeActionKind;

  3951. (function (CodeActionKind) {

  3952.     /**

  3953.      * Base kind for quickfix actions: 'quickfix'

  3954.      */

  3955.     CodeActionKind.QuickFix = 'quickfix';

  3956.     /**

  3957.      * Base kind for refactoring actions: 'refactor'

  3958.      */

  3959.     CodeActionKind.Refactor = 'refactor';

  3960.     /**

  3961.      * Base kind for refactoring extraction actions: 'refactor.extract'

  3962.      *

  3963.      * Example extract actions:

  3964.      *

  3965.      * - Extract method

  3966.      * - Extract function

  3967.      * - Extract variable

  3968.      * - Extract interface from class

  3969.      * - ...

  3970.      */

  3971.     CodeActionKind.RefactorExtract = 'refactor.extract';

  3972.     /**

  3973.      * Base kind for refactoring inline actions: 'refactor.inline'

  3974.      *

  3975.      * Example inline actions:

  3976.      *

  3977.      * - Inline function

  3978.      * - Inline variable

  3979.      * - Inline constant

  3980.      * - ...

  3981.      */

  3982.     CodeActionKind.RefactorInline = 'refactor.inline';

  3983.     /**

  3984.      * Base kind for refactoring rewrite actions: 'refactor.rewrite'

  3985.      *

  3986.      * Example rewrite actions:

  3987.      *

  3988.      * - Convert JavaScript function to class

  3989.      * - Add or remove parameter

  3990.      * - Encapsulate field

  3991.      * - Make method static

  3992.      * - Move method to base class

  3993.      * - ...

  3994.      */

  3995.     CodeActionKind.RefactorRewrite = 'refactor.rewrite';

  3996.     /**

  3997.      * Base kind for source actions: `source`

  3998.      *

  3999.      * Source code actions apply to the entire file.

  4000.      */

  4001.     CodeActionKind.Source = 'source';

  4002.     /**

  4003.      * Base kind for an organize imports source action: `source.organizeImports`

  4004.      */

  4005.     CodeActionKind.SourceOrganizeImports = 'source.organizeImports';

  4006. })(CodeActionKind || (CodeActionKind = {}));

  4007. /**

  4008.  * The CodeActionContext namespace provides helper functions to work with

  4009.  * [CodeActionContext](#CodeActionContext) literals.

  4010.  */

  4011. var CodeActionContext;

  4012. (function (CodeActionContext) {

  4013.     /**

  4014.      * Creates a new CodeActionContext literal.

  4015.      */

  4016.     function create(diagnostics, only) {

  4017.         var result = { diagnostics: diagnostics };

  4018.         if (only !== void 0 && only !== null) {

  4019.             result.only = only;

  4020.         }

  4021.         return result;

  4022.     }

  4023.     CodeActionContext.create = create;

  4024.     /**

  4025.      * Checks whether the given literal conforms to the [CodeActionContext](#CodeActionContext) interface.

  4026.      */

  4027.     function is(value) {

  4028.         var candidate = value;

  4029.         return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));

  4030.     }

  4031.     CodeActionContext.is = is;

  4032. })(CodeActionContext || (CodeActionContext = {}));

  4033. var CodeAction;

  4034. (function (CodeAction) {

  4035.     function create(title, commandOrEdit, kind) {

  4036.         var result = { title: title };

  4037.         if (Command.is(commandOrEdit)) {

  4038.             result.command = commandOrEdit;

  4039.         }

  4040.         else {

  4041.             result.edit = commandOrEdit;

  4042.         }

  4043.         if (kind !== void null) {

  4044.             result.kind = kind;

  4045.         }

  4046.         return result;

  4047.     }

  4048.     CodeAction.create = create;

  4049.     function is(value) {

  4050.         var candidate = value;

  4051.         return candidate && Is.string(candidate.title) &&

  4052.             (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&

  4053.             (candidate.kind === void 0 || Is.string(candidate.kind)) &&

  4054.             (candidate.edit !== void 0 || candidate.command !== void 0) &&

  4055.             (candidate.command === void 0 || Command.is(candidate.command)) &&

  4056.             (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit));

  4057.     }

  4058.     CodeAction.is = is;

  4059. })(CodeAction || (CodeAction = {}));

  4060. /**

  4061.  * The CodeLens namespace provides helper functions to work with

  4062.  * [CodeLens](#CodeLens) literals.

  4063.  */

  4064. var CodeLens;

  4065. (function (CodeLens) {

  4066.     /**

  4067.      * Creates a new CodeLens literal.

  4068.      */

  4069.     function create(range, data) {

  4070.         var result = { range: range };

  4071.         if (Is.defined(data))

  4072.             result.data = data;

  4073.         return result;

  4074.     }

  4075.     CodeLens.create = create;

  4076.     /**

  4077.      * Checks whether the given literal conforms to the [CodeLens](#CodeLens) interface.

  4078.      */

  4079.     function is(value) {

  4080.         var candidate = value;

  4081.         return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));

  4082.     }

  4083.     CodeLens.is = is;

  4084. })(CodeLens || (CodeLens = {}));

  4085. /**

  4086.  * The FormattingOptions namespace provides helper functions to work with

  4087.  * [FormattingOptions](#FormattingOptions) literals.

  4088.  */

  4089. var FormattingOptions;

  4090. (function (FormattingOptions) {

  4091.     /**

  4092.      * Creates a new FormattingOptions literal.

  4093.      */

  4094.     function create(tabSize, insertSpaces) {

  4095.         return { tabSize: tabSize, insertSpaces: insertSpaces };

  4096.     }

  4097.     FormattingOptions.create = create;

  4098.     /**

  4099.      * Checks whether the given literal conforms to the [FormattingOptions](#FormattingOptions) interface.

  4100.      */

  4101.     function is(value) {

  4102.         var candidate = value;

  4103.         return Is.defined(candidate) && Is.number(candidate.tabSize) && Is.boolean(candidate.insertSpaces);

  4104.     }

  4105.     FormattingOptions.is = is;

  4106. })(FormattingOptions || (FormattingOptions = {}));

  4107. /**

  4108.  * A document link is a range in a text document that links to an internal or external resource, like another

  4109.  * text document or a web site.

  4110.  */

  4111. var DocumentLink = /** @class */ (function () {

  4112.     function DocumentLink() {

  4113.     }

  4114.     return DocumentLink;

  4115. }());

  4116. 

  4117. /**

  4118.  * The DocumentLink namespace provides helper functions to work with

  4119.  * [DocumentLink](#DocumentLink) literals.

  4120.  */

  4121. (function (DocumentLink) {

  4122.     /**

  4123.      * Creates a new DocumentLink literal.

  4124.      */

  4125.     function create(range, target, data) {

  4126.         return { range: range, target: target, data: data };

  4127.     }

  4128.     DocumentLink.create = create;

  4129.     /**

  4130.      * Checks whether the given literal conforms to the [DocumentLink](#DocumentLink) interface.

  4131.      */

  4132.     function is(value) {

  4133.         var candidate = value;

  4134.         return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));

  4135.     }

  4136.     DocumentLink.is = is;

  4137. })(DocumentLink || (DocumentLink = {}));

  4138. var EOL = ['\n', '\r\n', '\r'];

  4139. var TextDocument;

  4140. (function (TextDocument) {

  4141.     /**

  4142.      * Creates a new ITextDocument literal from the given uri and content.

  4143.      * @param uri The document's uri.

  4144.      * @param languageId  The document's language Id.

  4145.      * @param content The document's content.

  4146.      */

  4147.     function create(uri, languageId, version, content) {

  4148.         return new FullTextDocument(uri, languageId, version, content);

  4149.     }

  4150.     TextDocument.create = create;

  4151.     /**

  4152.      * Checks whether the given literal conforms to the [ITextDocument](#ITextDocument) interface.

  4153.      */

  4154.     function is(value) {

  4155.         var candidate = value;

  4156.         return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.number(candidate.lineCount)

  4157.             && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;

  4158.     }

  4159.     TextDocument.is = is;

  4160.     function applyEdits(document, edits) {

  4161.         var text = document.getText();

  4162.         var sortedEdits = mergeSort(edits, function (a, b) {

  4163.             var diff = a.range.start.line - b.range.start.line;

  4164.             if (diff === 0) {

  4165.                 return a.range.start.character - b.range.start.character;

  4166.             }

  4167.             return diff;

  4168.         });

  4169.         var lastModifiedOffset = text.length;

  4170.         for (var i = sortedEdits.length - 1; i >= 0; i--) {

  4171.             var e = sortedEdits[i];

  4172.             var startOffset = document.offsetAt(e.range.start);

  4173.             var endOffset = document.offsetAt(e.range.end);

  4174.             if (endOffset <= lastModifiedOffset) {

  4175.                 text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);

  4176.             }

  4177.             else {

  4178.                 throw new Error('Overlapping edit');

  4179.             }

  4180.             lastModifiedOffset = startOffset;

  4181.         }

  4182.         return text;

  4183.     }

  4184.     TextDocument.applyEdits = applyEdits;

  4185.     function mergeSort(data, compare) {

  4186.         if (data.length <= 1) {

  4187.             // sorted

  4188.             return data;

  4189.         }

  4190.         var p = (data.length / 2) | 0;

  4191.         var left = data.slice(0, p);

  4192.         var right = data.slice(p);

  4193.         mergeSort(left, compare);

  4194.         mergeSort(right, compare);

  4195.         var leftIdx = 0;

  4196.         var rightIdx = 0;

  4197.         var i = 0;

  4198.         while (leftIdx < left.length && rightIdx < right.length) {

  4199.             var ret = compare(left[leftIdx], right[rightIdx]);

  4200.             if (ret <= 0) {

  4201.                 // smaller_equal -> take left to preserve order

  4202.                 data[i++] = left[leftIdx++];

  4203.             }

  4204.             else {

  4205.                 // greater -> take right

  4206.                 data[i++] = right[rightIdx++];

  4207.             }

  4208.         }

  4209.         while (leftIdx < left.length) {

  4210.             data[i++] = left[leftIdx++];

  4211.         }

  4212.         while (rightIdx < right.length) {

  4213.             data[i++] = right[rightIdx++];

  4214.         }

  4215.         return data;

  4216.     }

  4217. })(TextDocument || (TextDocument = {}));

  4218. /**

  4219.  * Represents reasons why a text document is saved.

  4220.  */

  4221. var TextDocumentSaveReason;

  4222. (function (TextDocumentSaveReason) {

  4223.     /**

  4224.      * Manually triggered, e.g. by the user pressing save, by starting debugging,

  4225.      * or by an API call.

  4226.      */

  4227.     TextDocumentSaveReason.Manual = 1;

  4228.     /**

  4229.      * Automatic after a delay.

  4230.      */

  4231.     TextDocumentSaveReason.AfterDelay = 2;

  4232.     /**

  4233.      * When the editor lost focus.

  4234.      */

  4235.     TextDocumentSaveReason.FocusOut = 3;

  4236. })(TextDocumentSaveReason || (TextDocumentSaveReason = {}));

  4237. var FullTextDocument = /** @class */ (function () {

  4238.     function FullTextDocument(uri, languageId, version, content) {

  4239.         this._uri = uri;

  4240.         this._languageId = languageId;

  4241.         this._version = version;

  4242.         this._content = content;

  4243.         this._lineOffsets = null;

  4244.     }

  4245.     Object.defineProperty(FullTextDocument.prototype, "uri", {

  4246.         get: function () {

  4247.             return this._uri;

  4248.         },

  4249.         enumerable: true,

  4250.         configurable: true

  4251.     });

  4252.     Object.defineProperty(FullTextDocument.prototype, "languageId", {

  4253.         get: function () {

  4254.             return this._languageId;

  4255.         },

  4256.         enumerable: true,

  4257.         configurable: true

  4258.     });

  4259.     Object.defineProperty(FullTextDocument.prototype, "version", {

  4260.         get: function () {

  4261.             return this._version;

  4262.         },

  4263.         enumerable: true,

  4264.         configurable: true

  4265.     });

  4266.     FullTextDocument.prototype.getText = function (range) {

  4267.         if (range) {

  4268.             var start = this.offsetAt(range.start);

  4269.             var end = this.offsetAt(range.end);

  4270.             return this._content.substring(start, end);

  4271.         }

  4272.         return this._content;

  4273.     };

  4274.     FullTextDocument.prototype.update = function (event, version) {

  4275.         this._content = event.text;

  4276.         this._version = version;

  4277.         this._lineOffsets = null;

  4278.     };

  4279.     FullTextDocument.prototype.getLineOffsets = function () {

  4280.         if (this._lineOffsets === null) {

  4281.             var lineOffsets = [];

  4282.             var text = this._content;

  4283.             var isLineStart = true;

  4284.             for (var i = 0; i < text.length; i++) {

  4285.                 if (isLineStart) {

  4286.                     lineOffsets.push(i);

  4287.                     isLineStart = false;

  4288.                 }

  4289.                 var ch = text.charAt(i);

  4290.                 isLineStart = (ch === '\r' || ch === '\n');

  4291.                 if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {

  4292.                     i++;

  4293.                 }

  4294.             }

  4295.             if (isLineStart && text.length > 0) {

  4296.                 lineOffsets.push(text.length);

  4297.             }

  4298.             this._lineOffsets = lineOffsets;

  4299.         }

  4300.         return this._lineOffsets;

  4301.     };

  4302.     FullTextDocument.prototype.positionAt = function (offset) {

  4303.         offset = Math.max(Math.min(offset, this._content.length), 0);

  4304.         var lineOffsets = this.getLineOffsets();

  4305.         var low = 0, high = lineOffsets.length;

  4306.         if (high === 0) {

  4307.             return Position.create(0, offset);

  4308.         }

  4309.         while (low < high) {

  4310.             var mid = Math.floor((low + high) / 2);

  4311.             if (lineOffsets[mid] > offset) {

  4312.                 high = mid;

  4313.             }

  4314.             else {

  4315.                 low = mid + 1;

  4316.             }

  4317.         }

  4318.         // low is the least x for which the line offset is larger than the current offset

  4319.         // or array.length if no line offset is larger than the current offset

  4320.         var line = low - 1;

  4321.         return Position.create(line, offset - lineOffsets[line]);

  4322.     };

  4323.     FullTextDocument.prototype.offsetAt = function (position) {

  4324.         var lineOffsets = this.getLineOffsets();

  4325.         if (position.line >= lineOffsets.length) {

  4326.             return this._content.length;

  4327.         }

  4328.         else if (position.line < 0) {

  4329.             return 0;

  4330.         }

  4331.         var lineOffset = lineOffsets[position.line];

  4332.         var nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;

  4333.         return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);

  4334.     };

  4335.     Object.defineProperty(FullTextDocument.prototype, "lineCount", {

  4336.         get: function () {

  4337.             return this.getLineOffsets().length;

  4338.         },

  4339.         enumerable: true,

  4340.         configurable: true

  4341.     });

  4342.     return FullTextDocument;

  4343. }());

  4344. var Is;

  4345. (function (Is) {

  4346.     var toString = Object.prototype.toString;

  4347.     function defined(value) {

  4348.         return typeof value !== 'undefined';

  4349.     }

  4350.     Is.defined = defined;

  4351.     function undefined(value) {

  4352.         return typeof value === 'undefined';

  4353.     }

  4354.     Is.undefined = undefined;

  4355.     function boolean(value) {

  4356.         return value === true || value === false;

  4357.     }

  4358.     Is.boolean = boolean;

  4359.     function string(value) {

  4360.         return toString.call(value) === '[object String]';

  4361.     }

  4362.     Is.string = string;

  4363.     function number(value) {

  4364.         return toString.call(value) === '[object Number]';

  4365.     }

  4366.     Is.number = number;

  4367.     function func(value) {

  4368.         return toString.call(value) === '[object Function]';

  4369.     }

  4370.     Is.func = func;

  4371.     function objectLiteral(value) {

  4372.         // Strictly speaking class instances pass this check as well. Since the LSP

  4373.         // doesn't use classes we ignore this for now. If we do we need to add something

  4374.         // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`

  4375.         return value !== null && typeof value === 'object';

  4376.     }

  4377.     Is.objectLiteral = objectLiteral;

  4378.     function typedArray(value, check) {

  4379.         return Array.isArray(value) && value.every(check);

  4380.     }

  4381.     Is.typedArray = typedArray;

  4382. })(Is || (Is = {}));

  4383. 

  4384. 

  4385. /***/ }),

  4386. /* 18 */

  4387. /***/ (function(module, exports, __webpack_require__) {

  4388. 

  4389. "use strict";

  4390. /* --------------------------------------------------------------------------------------------

  4391.  * Copyright (c) Microsoft Corporation. All rights reserved.

  4392.  * Licensed under the MIT License. See License.txt in the project root for license information.

  4393.  * ------------------------------------------------------------------------------------------ */

  4394. 

  4395. Object.defineProperty(exports, "__esModule", { value: true });

  4396. const Is = __webpack_require__(19);

  4397. const vscode_jsonrpc_1 = __webpack_require__(4);

  4398. const protocol_implementation_1 = __webpack_require__(20);

  4399. exports.ImplementationRequest = protocol_implementation_1.ImplementationRequest;

  4400. const protocol_typeDefinition_1 = __webpack_require__(21);

  4401. exports.TypeDefinitionRequest = protocol_typeDefinition_1.TypeDefinitionRequest;

  4402. const protocol_workspaceFolders_1 = __webpack_require__(22);

  4403. exports.WorkspaceFoldersRequest = protocol_workspaceFolders_1.WorkspaceFoldersRequest;

  4404. exports.DidChangeWorkspaceFoldersNotification = protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;

  4405. const protocol_configuration_1 = __webpack_require__(23);

  4406. exports.ConfigurationRequest = protocol_configuration_1.ConfigurationRequest;

  4407. const protocol_colorProvider_1 = __webpack_require__(24);

  4408. exports.DocumentColorRequest = protocol_colorProvider_1.DocumentColorRequest;

  4409. exports.ColorPresentationRequest = protocol_colorProvider_1.ColorPresentationRequest;

  4410. const protocol_foldingRange_1 = __webpack_require__(25);

  4411. exports.FoldingRangeRequest = protocol_foldingRange_1.FoldingRangeRequest;

  4412. const protocol_declaration_1 = __webpack_require__(26);

  4413. exports.DeclarationRequest = protocol_declaration_1.DeclarationRequest;

  4414. // @ts-ignore: to avoid inlining LocatioLink as dynamic import

  4415. let __noDynamicImport;

  4416. var DocumentFilter;

  4417. (function (DocumentFilter) {

  4418.     function is(value) {

  4419.         let candidate = value;

  4420.         return Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern);

  4421.     }

  4422.     DocumentFilter.is = is;

  4423. })(DocumentFilter = exports.DocumentFilter || (exports.DocumentFilter = {}));

  4424. /**

  4425.  * The `client/registerCapability` request is sent from the server to the client to register a new capability

  4426.  * handler on the client side.

  4427.  */

  4428. var RegistrationRequest;

  4429. (function (RegistrationRequest) {

  4430.     RegistrationRequest.type = new vscode_jsonrpc_1.RequestType('client/registerCapability');

  4431. })(RegistrationRequest = exports.RegistrationRequest || (exports.RegistrationRequest = {}));

  4432. /**

  4433.  * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability

  4434.  * handler on the client side.

  4435.  */

  4436. var UnregistrationRequest;

  4437. (function (UnregistrationRequest) {

  4438.     UnregistrationRequest.type = new vscode_jsonrpc_1.RequestType('client/unregisterCapability');

  4439. })(UnregistrationRequest = exports.UnregistrationRequest || (exports.UnregistrationRequest = {}));

  4440. var ResourceOperationKind;

  4441. (function (ResourceOperationKind) {

  4442.     /**

  4443.      * Supports creating new files and folders.

  4444.      */

  4445.     ResourceOperationKind.Create = 'create';

  4446.     /**

  4447.      * Supports renaming existing files and folders.

  4448.      */

  4449.     ResourceOperationKind.Rename = 'rename';

  4450.     /**

  4451.      * Supports deleting existing files and folders.

  4452.      */

  4453.     ResourceOperationKind.Delete = 'delete';

  4454. })(ResourceOperationKind = exports.ResourceOperationKind || (exports.ResourceOperationKind = {}));

  4455. var FailureHandlingKind;

  4456. (function (FailureHandlingKind) {

  4457.     /**

  4458.      * Applying the workspace change is simply aborted if one of the changes provided

  4459.      * fails. All operations executed before the failing operation stay executed.

  4460.      */

  4461.     FailureHandlingKind.Abort = 'abort';

  4462.     /**

  4463.      * All operations are executed transactional. That means they either all

  4464.      * succeed or no changes at all are applied to the workspace.

  4465.      */

  4466.     FailureHandlingKind.Transactional = 'transactional';

  4467.     /**

  4468.      * If the workspace edit contains only textual file changes they are executed transactional.

  4469.      * If resource changes (create, rename or delete file) are part of the change the failure

  4470.      * handling startegy is abort.

  4471.      */

  4472.     FailureHandlingKind.TextOnlyTransactional = 'textOnlyTransactional';

  4473.     /**

  4474.      * The client tries to undo the operations already executed. But there is no

  4475.      * guaruntee that this is succeeding.

  4476.      */

  4477.     FailureHandlingKind.Undo = 'undo';

  4478. })(FailureHandlingKind = exports.FailureHandlingKind || (exports.FailureHandlingKind = {}));

  4479. /**

  4480.  * Defines how the host (editor) should sync

  4481.  * document changes to the language server.

  4482.  */

  4483. var TextDocumentSyncKind;

  4484. (function (TextDocumentSyncKind) {

  4485.     /**

  4486.      * Documents should not be synced at all.

  4487.      */

  4488.     TextDocumentSyncKind.None = 0;

  4489.     /**

  4490.      * Documents are synced by always sending the full content

  4491.      * of the document.

  4492.      */

  4493.     TextDocumentSyncKind.Full = 1;

  4494.     /**

  4495.      * Documents are synced by sending the full content on open.

  4496.      * After that only incremental updates to the document are

  4497.      * send.

  4498.      */

  4499.     TextDocumentSyncKind.Incremental = 2;

  4500. })(TextDocumentSyncKind = exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {}));

  4501. /**

  4502.  * The initialize request is sent from the client to the server.

  4503.  * It is sent once as the request after starting up the server.

  4504.  * The requests parameter is of type [InitializeParams](#InitializeParams)

  4505.  * the response if of type [InitializeResult](#InitializeResult) of a Thenable that

  4506.  * resolves to such.

  4507.  */

  4508. var InitializeRequest;

  4509. (function (InitializeRequest) {

  4510.     InitializeRequest.type = new vscode_jsonrpc_1.RequestType('initialize');

  4511. })(InitializeRequest = exports.InitializeRequest || (exports.InitializeRequest = {}));

  4512. /**

  4513.  * Known error codes for an `InitializeError`;

  4514.  */

  4515. var InitializeError;

  4516. (function (InitializeError) {

  4517.     /**

  4518.      * If the protocol version provided by the client can't be handled by the server.

  4519.      * @deprecated This initialize error got replaced by client capabilities. There is

  4520.      * no version handshake in version 3.0x

  4521.      */

  4522.     InitializeError.unknownProtocolVersion = 1;

  4523. })(InitializeError = exports.InitializeError || (exports.InitializeError = {}));

  4524. /**

  4525.  * The intialized notification is sent from the client to the

  4526.  * server after the client is fully initialized and the server

  4527.  * is allowed to send requests from the server to the client.

  4528.  */

  4529. var InitializedNotification;

  4530. (function (InitializedNotification) {

  4531.     InitializedNotification.type = new vscode_jsonrpc_1.NotificationType('initialized');

  4532. })(InitializedNotification = exports.InitializedNotification || (exports.InitializedNotification = {}));

  4533. //---- Shutdown Method ----

  4534. /**

  4535.  * A shutdown request is sent from the client to the server.

  4536.  * It is sent once when the client decides to shutdown the

  4537.  * server. The only notification that is sent after a shutdown request

  4538.  * is the exit event.

  4539.  */

  4540. var ShutdownRequest;

  4541. (function (ShutdownRequest) {

  4542.     ShutdownRequest.type = new vscode_jsonrpc_1.RequestType0('shutdown');

  4543. })(ShutdownRequest = exports.ShutdownRequest || (exports.ShutdownRequest = {}));

  4544. //---- Exit Notification ----

  4545. /**

  4546.  * The exit event is sent from the client to the server to

  4547.  * ask the server to exit its process.

  4548.  */

  4549. var ExitNotification;

  4550. (function (ExitNotification) {

  4551.     ExitNotification.type = new vscode_jsonrpc_1.NotificationType0('exit');

  4552. })(ExitNotification = exports.ExitNotification || (exports.ExitNotification = {}));

  4553. //---- Configuration notification ----

  4554. /**

  4555.  * The configuration change notification is sent from the client to the server

  4556.  * when the client's configuration has changed. The notification contains

  4557.  * the changed configuration as defined by the language client.

  4558.  */

  4559. var DidChangeConfigurationNotification;

  4560. (function (DidChangeConfigurationNotification) {

  4561.     DidChangeConfigurationNotification.type = new vscode_jsonrpc_1.NotificationType('workspace/didChangeConfiguration');

  4562. })(DidChangeConfigurationNotification = exports.DidChangeConfigurationNotification || (exports.DidChangeConfigurationNotification = {}));

  4563. //---- Message show and log notifications ----

  4564. /**

  4565.  * The message type

  4566.  */

  4567. var MessageType;

  4568. (function (MessageType) {

  4569.     /**

  4570.      * An error message.

  4571.      */

  4572.     MessageType.Error = 1;

  4573.     /**

  4574.      * A warning message.

  4575.      */

  4576.     MessageType.Warning = 2;

  4577.     /**

  4578.      * An information message.

  4579.      */

  4580.     MessageType.Info = 3;

  4581.     /**

  4582.      * A log message.

  4583.      */

  4584.     MessageType.Log = 4;

  4585. })(MessageType = exports.MessageType || (exports.MessageType = {}));

  4586. /**

  4587.  * The show message notification is sent from a server to a client to ask

  4588.  * the client to display a particular message in the user interface.

  4589.  */

  4590. var ShowMessageNotification;

  4591. (function (ShowMessageNotification) {

  4592.     ShowMessageNotification.type = new vscode_jsonrpc_1.NotificationType('window/showMessage');

  4593. })(ShowMessageNotification = exports.ShowMessageNotification || (exports.ShowMessageNotification = {}));

  4594. /**

  4595.  * The show message request is sent from the server to the client to show a message

  4596.  * and a set of options actions to the user.

  4597.  */

  4598. var ShowMessageRequest;

  4599. (function (ShowMessageRequest) {

  4600.     ShowMessageRequest.type = new vscode_jsonrpc_1.RequestType('window/showMessageRequest');

  4601. })(ShowMessageRequest = exports.ShowMessageRequest || (exports.ShowMessageRequest = {}));

  4602. /**

  4603.  * The log message notification is sent from the server to the client to ask

  4604.  * the client to log a particular message.

  4605.  */

  4606. var LogMessageNotification;

  4607. (function (LogMessageNotification) {

  4608.     LogMessageNotification.type = new vscode_jsonrpc_1.NotificationType('window/logMessage');

  4609. })(LogMessageNotification = exports.LogMessageNotification || (exports.LogMessageNotification = {}));

  4610. //---- Telemetry notification

  4611. /**

  4612.  * The telemetry event notification is sent from the server to the client to ask

  4613.  * the client to log telemetry data.

  4614.  */

  4615. var TelemetryEventNotification;

  4616. (function (TelemetryEventNotification) {

  4617.     TelemetryEventNotification.type = new vscode_jsonrpc_1.NotificationType('telemetry/event');

  4618. })(TelemetryEventNotification = exports.TelemetryEventNotification || (exports.TelemetryEventNotification = {}));

  4619. /**

  4620.  * The document open notification is sent from the client to the server to signal

  4621.  * newly opened text documents. The document's truth is now managed by the client

  4622.  * and the server must not try to read the document's truth using the document's

  4623.  * uri. Open in this sense means it is managed by the client. It doesn't necessarily

  4624.  * mean that its content is presented in an editor. An open notification must not

  4625.  * be sent more than once without a corresponding close notification send before.

  4626.  * This means open and close notification must be balanced and the max open count

  4627.  * is one.

  4628.  */

  4629. var DidOpenTextDocumentNotification;

  4630. (function (DidOpenTextDocumentNotification) {

  4631.     DidOpenTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/didOpen');

  4632. })(DidOpenTextDocumentNotification = exports.DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = {}));

  4633. /**

  4634.  * The document change notification is sent from the client to the server to signal

  4635.  * changes to a text document.

  4636.  */

  4637. var DidChangeTextDocumentNotification;

  4638. (function (DidChangeTextDocumentNotification) {

  4639.     DidChangeTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/didChange');

  4640. })(DidChangeTextDocumentNotification = exports.DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = {}));

  4641. /**

  4642.  * The document close notification is sent from the client to the server when

  4643.  * the document got closed in the client. The document's truth now exists where

  4644.  * the document's uri points to (e.g. if the document's uri is a file uri the

  4645.  * truth now exists on disk). As with the open notification the close notification

  4646.  * is about managing the document's content. Receiving a close notification

  4647.  * doesn't mean that the document was open in an editor before. A close

  4648.  * notification requires a previous open notification to be sent.

  4649.  */

  4650. var DidCloseTextDocumentNotification;

  4651. (function (DidCloseTextDocumentNotification) {

  4652.     DidCloseTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/didClose');

  4653. })(DidCloseTextDocumentNotification = exports.DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = {}));

  4654. /**

  4655.  * The document save notification is sent from the client to the server when

  4656.  * the document got saved in the client.

  4657.  */

  4658. var DidSaveTextDocumentNotification;

  4659. (function (DidSaveTextDocumentNotification) {

  4660.     DidSaveTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/didSave');

  4661. })(DidSaveTextDocumentNotification = exports.DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = {}));

  4662. /**

  4663.  * A document will save notification is sent from the client to the server before

  4664.  * the document is actually saved.

  4665.  */

  4666. var WillSaveTextDocumentNotification;

  4667. (function (WillSaveTextDocumentNotification) {

  4668.     WillSaveTextDocumentNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/willSave');

  4669. })(WillSaveTextDocumentNotification = exports.WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = {}));

  4670. /**

  4671.  * A document will save request is sent from the client to the server before

  4672.  * the document is actually saved. The request can return an array of TextEdits

  4673.  * which will be applied to the text document before it is saved. Please note that

  4674.  * clients might drop results if computing the text edits took too long or if a

  4675.  * server constantly fails on this request. This is done to keep the save fast and

  4676.  * reliable.

  4677.  */

  4678. var WillSaveTextDocumentWaitUntilRequest;

  4679. (function (WillSaveTextDocumentWaitUntilRequest) {

  4680.     WillSaveTextDocumentWaitUntilRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/willSaveWaitUntil');

  4681. })(WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = {}));

  4682. //---- File eventing ----

  4683. /**

  4684.  * The watched files notification is sent from the client to the server when

  4685.  * the client detects changes to file watched by the language client.

  4686.  */

  4687. var DidChangeWatchedFilesNotification;

  4688. (function (DidChangeWatchedFilesNotification) {

  4689.     DidChangeWatchedFilesNotification.type = new vscode_jsonrpc_1.NotificationType('workspace/didChangeWatchedFiles');

  4690. })(DidChangeWatchedFilesNotification = exports.DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = {}));

  4691. /**

  4692.  * The file event type

  4693.  */

  4694. var FileChangeType;

  4695. (function (FileChangeType) {

  4696.     /**

  4697.      * The file got created.

  4698.      */

  4699.     FileChangeType.Created = 1;

  4700.     /**

  4701.      * The file got changed.

  4702.      */

  4703.     FileChangeType.Changed = 2;

  4704.     /**

  4705.      * The file got deleted.

  4706.      */

  4707.     FileChangeType.Deleted = 3;

  4708. })(FileChangeType = exports.FileChangeType || (exports.FileChangeType = {}));

  4709. var WatchKind;

  4710. (function (WatchKind) {

  4711.     /**

  4712.      * Interested in create events.

  4713.      */

  4714.     WatchKind.Create = 1;

  4715.     /**

  4716.      * Interested in change events

  4717.      */

  4718.     WatchKind.Change = 2;

  4719.     /**

  4720.      * Interested in delete events

  4721.      */

  4722.     WatchKind.Delete = 4;

  4723. })(WatchKind = exports.WatchKind || (exports.WatchKind = {}));

  4724. //---- Diagnostic notification ----

  4725. /**

  4726.  * Diagnostics notification are sent from the server to the client to signal

  4727.  * results of validation runs.

  4728.  */

  4729. var PublishDiagnosticsNotification;

  4730. (function (PublishDiagnosticsNotification) {

  4731.     PublishDiagnosticsNotification.type = new vscode_jsonrpc_1.NotificationType('textDocument/publishDiagnostics');

  4732. })(PublishDiagnosticsNotification = exports.PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = {}));

  4733. /**

  4734.  * How a completion was triggered

  4735.  */

  4736. var CompletionTriggerKind;

  4737. (function (CompletionTriggerKind) {

  4738.     /**

  4739.      * Completion was triggered by typing an identifier (24x7 code

  4740.      * complete), manual invocation (e.g Ctrl+Space) or via API.

  4741.      */

  4742.     CompletionTriggerKind.Invoked = 1;

  4743.     /**

  4744.      * Completion was triggered by a trigger character specified by

  4745.      * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.

  4746.      */

  4747.     CompletionTriggerKind.TriggerCharacter = 2;

  4748.     /**

  4749.      * Completion was re-triggered as current completion list is incomplete

  4750.      */

  4751.     CompletionTriggerKind.TriggerForIncompleteCompletions = 3;

  4752. })(CompletionTriggerKind = exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {}));

  4753. /**

  4754.  * Request to request completion at a given text document position. The request's

  4755.  * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response

  4756.  * is of type [CompletionItem[]](#CompletionItem) or [CompletionList](#CompletionList)

  4757.  * or a Thenable that resolves to such.

  4758.  *

  4759.  * The request can delay the computation of the [`detail`](#CompletionItem.detail)

  4760.  * and [`documentation`](#CompletionItem.documentation) properties to the `completionItem/resolve`

  4761.  * request. However, properties that are needed for the initial sorting and filtering, like `sortText`,

  4762.  * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.

  4763.  */

  4764. var CompletionRequest;

  4765. (function (CompletionRequest) {

  4766.     CompletionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/completion');

  4767. })(CompletionRequest = exports.CompletionRequest || (exports.CompletionRequest = {}));

  4768. /**

  4769.  * Request to resolve additional information for a given completion item.The request's

  4770.  * parameter is of type [CompletionItem](#CompletionItem) the response

  4771.  * is of type [CompletionItem](#CompletionItem) or a Thenable that resolves to such.

  4772.  */

  4773. var CompletionResolveRequest;

  4774. (function (CompletionResolveRequest) {

  4775.     CompletionResolveRequest.type = new vscode_jsonrpc_1.RequestType('completionItem/resolve');

  4776. })(CompletionResolveRequest = exports.CompletionResolveRequest || (exports.CompletionResolveRequest = {}));

  4777. //---- Hover Support -------------------------------

  4778. /**

  4779.  * Request to request hover information at a given text document position. The request's

  4780.  * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response is of

  4781.  * type [Hover](#Hover) or a Thenable that resolves to such.

  4782.  */

  4783. var HoverRequest;

  4784. (function (HoverRequest) {

  4785.     HoverRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/hover');

  4786. })(HoverRequest = exports.HoverRequest || (exports.HoverRequest = {}));

  4787. var SignatureHelpRequest;

  4788. (function (SignatureHelpRequest) {

  4789.     SignatureHelpRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/signatureHelp');

  4790. })(SignatureHelpRequest = exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {}));

  4791. //---- Goto Definition -------------------------------------

  4792. /**

  4793.  * A request to resolve the definition location of a symbol at a given text

  4794.  * document position. The request's parameter is of type [TextDocumentPosition]

  4795.  * (#TextDocumentPosition) the response is of either type [Definition](#Definition)

  4796.  * or a typed array of [DefinitionLink](#DefinitionLink) or a Thenable that resolves

  4797.  * to such.

  4798.  */

  4799. var DefinitionRequest;

  4800. (function (DefinitionRequest) {

  4801.     DefinitionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/definition');

  4802. })(DefinitionRequest = exports.DefinitionRequest || (exports.DefinitionRequest = {}));

  4803. /**

  4804.  * A request to resolve project-wide references for the symbol denoted

  4805.  * by the given text document position. The request's parameter is of

  4806.  * type [ReferenceParams](#ReferenceParams) the response is of type

  4807.  * [Location[]](#Location) or a Thenable that resolves to such.

  4808.  */

  4809. var ReferencesRequest;

  4810. (function (ReferencesRequest) {

  4811.     ReferencesRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/references');

  4812. })(ReferencesRequest = exports.ReferencesRequest || (exports.ReferencesRequest = {}));

  4813. //---- Document Highlight ----------------------------------

  4814. /**

  4815.  * Request to resolve a [DocumentHighlight](#DocumentHighlight) for a given

  4816.  * text document position. The request's parameter is of type [TextDocumentPosition]

  4817.  * (#TextDocumentPosition) the request response is of type [DocumentHighlight[]]

  4818.  * (#DocumentHighlight) or a Thenable that resolves to such.

  4819.  */

  4820. var DocumentHighlightRequest;

  4821. (function (DocumentHighlightRequest) {

  4822.     DocumentHighlightRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/documentHighlight');

  4823. })(DocumentHighlightRequest = exports.DocumentHighlightRequest || (exports.DocumentHighlightRequest = {}));

  4824. //---- Document Symbol Provider ---------------------------

  4825. /**

  4826.  * A request to list all symbols found in a given text document. The request's

  4827.  * parameter is of type [TextDocumentIdentifier](#TextDocumentIdentifier) the

  4828.  * response is of type [SymbolInformation[]](#SymbolInformation) or a Thenable

  4829.  * that resolves to such.

  4830.  */

  4831. var DocumentSymbolRequest;

  4832. (function (DocumentSymbolRequest) {

  4833.     DocumentSymbolRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/documentSymbol');

  4834. })(DocumentSymbolRequest = exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {}));

  4835. //---- Workspace Symbol Provider ---------------------------

  4836. /**

  4837.  * A request to list project-wide symbols matching the query string given

  4838.  * by the [WorkspaceSymbolParams](#WorkspaceSymbolParams). The response is

  4839.  * of type [SymbolInformation[]](#SymbolInformation) or a Thenable that

  4840.  * resolves to such.

  4841.  */

  4842. var WorkspaceSymbolRequest;

  4843. (function (WorkspaceSymbolRequest) {

  4844.     WorkspaceSymbolRequest.type = new vscode_jsonrpc_1.RequestType('workspace/symbol');

  4845. })(WorkspaceSymbolRequest = exports.WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = {}));

  4846. /**

  4847.  * A request to provide commands for the given text document and range.

  4848.  */

  4849. var CodeActionRequest;

  4850. (function (CodeActionRequest) {

  4851.     CodeActionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/codeAction');

  4852. })(CodeActionRequest = exports.CodeActionRequest || (exports.CodeActionRequest = {}));

  4853. /**

  4854.  * A request to provide code lens for the given text document.

  4855.  */

  4856. var CodeLensRequest;

  4857. (function (CodeLensRequest) {

  4858.     CodeLensRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/codeLens');

  4859. })(CodeLensRequest = exports.CodeLensRequest || (exports.CodeLensRequest = {}));

  4860. /**

  4861.  * A request to resolve a command for a given code lens.

  4862.  */

  4863. var CodeLensResolveRequest;

  4864. (function (CodeLensResolveRequest) {

  4865.     CodeLensResolveRequest.type = new vscode_jsonrpc_1.RequestType('codeLens/resolve');

  4866. })(CodeLensResolveRequest = exports.CodeLensResolveRequest || (exports.CodeLensResolveRequest = {}));

  4867. /**

  4868.  * A request to to format a whole document.

  4869.  */

  4870. var DocumentFormattingRequest;

  4871. (function (DocumentFormattingRequest) {

  4872.     DocumentFormattingRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/formatting');

  4873. })(DocumentFormattingRequest = exports.DocumentFormattingRequest || (exports.DocumentFormattingRequest = {}));

  4874. /**

  4875.  * A request to to format a range in a document.

  4876.  */

  4877. var DocumentRangeFormattingRequest;

  4878. (function (DocumentRangeFormattingRequest) {

  4879.     DocumentRangeFormattingRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/rangeFormatting');

  4880. })(DocumentRangeFormattingRequest = exports.DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = {}));

  4881. /**

  4882.  * A request to format a document on type.

  4883.  */

  4884. var DocumentOnTypeFormattingRequest;

  4885. (function (DocumentOnTypeFormattingRequest) {

  4886.     DocumentOnTypeFormattingRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/onTypeFormatting');

  4887. })(DocumentOnTypeFormattingRequest = exports.DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = {}));

  4888. /**

  4889.  * A request to rename a symbol.

  4890.  */

  4891. var RenameRequest;

  4892. (function (RenameRequest) {

  4893.     RenameRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/rename');

  4894. })(RenameRequest = exports.RenameRequest || (exports.RenameRequest = {}));

  4895. /**

  4896.  * A request to test and perform the setup necessary for a rename.

  4897.  */

  4898. var PrepareRenameRequest;

  4899. (function (PrepareRenameRequest) {

  4900.     PrepareRenameRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/prepareRename');

  4901. })(PrepareRenameRequest = exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {}));

  4902. /**

  4903.  * A request to provide document links

  4904.  */

  4905. var DocumentLinkRequest;

  4906. (function (DocumentLinkRequest) {

  4907.     DocumentLinkRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/documentLink');

  4908. })(DocumentLinkRequest = exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {}));

  4909. /**

  4910.  * Request to resolve additional information for a given document link. The request's

  4911.  * parameter is of type [DocumentLink](#DocumentLink) the response

  4912.  * is of type [DocumentLink](#DocumentLink) or a Thenable that resolves to such.

  4913.  */

  4914. var DocumentLinkResolveRequest;

  4915. (function (DocumentLinkResolveRequest) {

  4916.     DocumentLinkResolveRequest.type = new vscode_jsonrpc_1.RequestType('documentLink/resolve');

  4917. })(DocumentLinkResolveRequest = exports.DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = {}));

  4918. /**

  4919.  * A request send from the client to the server to execute a command. The request might return

  4920.  * a workspace edit which the client will apply to the workspace.

  4921.  */

  4922. var ExecuteCommandRequest;

  4923. (function (ExecuteCommandRequest) {

  4924.     ExecuteCommandRequest.type = new vscode_jsonrpc_1.RequestType('workspace/executeCommand');

  4925. })(ExecuteCommandRequest = exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {}));

  4926. /**

  4927.  * A request sent from the server to the client to modified certain resources.

  4928.  */

  4929. var ApplyWorkspaceEditRequest;

  4930. (function (ApplyWorkspaceEditRequest) {

  4931.     ApplyWorkspaceEditRequest.type = new vscode_jsonrpc_1.RequestType('workspace/applyEdit');

  4932. })(ApplyWorkspaceEditRequest = exports.ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = {}));

  4933. 

  4934. 

  4935. /***/ }),

  4936. /* 19 */

  4937. /***/ (function(module, exports, __webpack_require__) {

  4938. 

  4939. "use strict";

  4940. /* --------------------------------------------------------------------------------------------

  4941.  * Copyright (c) Microsoft Corporation. All rights reserved.

  4942.  * Licensed under the MIT License. See License.txt in the project root for license information.

  4943.  * ------------------------------------------------------------------------------------------ */

  4944. 

  4945. Object.defineProperty(exports, "__esModule", { value: true });

  4946. function boolean(value) {

  4947.     return value === true || value === false;

  4948. }

  4949. exports.boolean = boolean;

  4950. function string(value) {

  4951.     return typeof value === 'string' || value instanceof String;

  4952. }

  4953. exports.string = string;

  4954. function number(value) {

  4955.     return typeof value === 'number' || value instanceof Number;

  4956. }

  4957. exports.number = number;

  4958. function error(value) {

  4959.     return value instanceof Error;

  4960. }

  4961. exports.error = error;

  4962. function func(value) {

  4963.     return typeof value === 'function';

  4964. }

  4965. exports.func = func;

  4966. function array(value) {

  4967.     return Array.isArray(value);

  4968. }

  4969. exports.array = array;

  4970. function stringArray(value) {

  4971.     return array(value) && value.every(elem => string(elem));

  4972. }

  4973. exports.stringArray = stringArray;

  4974. function typedArray(value, check) {

  4975.     return Array.isArray(value) && value.every(check);

  4976. }

  4977. exports.typedArray = typedArray;

  4978. function thenable(value) {

  4979.     return value && func(value.then);

  4980. }

  4981. exports.thenable = thenable;

  4982. 

  4983. 

  4984. /***/ }),

  4985. /* 20 */

  4986. /***/ (function(module, exports, __webpack_require__) {

  4987. 

  4988. "use strict";

  4989. /* --------------------------------------------------------------------------------------------

  4990.  * Copyright (c) Microsoft Corporation. All rights reserved.

  4991.  * Licensed under the MIT License. See License.txt in the project root for license information.

  4992.  * ------------------------------------------------------------------------------------------ */

  4993. 

  4994. Object.defineProperty(exports, "__esModule", { value: true });

  4995. const vscode_jsonrpc_1 = __webpack_require__(4);

  4996. // @ts-ignore: to avoid inlining LocatioLink as dynamic import

  4997. let __noDynamicImport;

  4998. /**

  4999.  * A request to resolve the implementation locations of a symbol at a given text

  5000.  * document position. The request's parameter is of type [TextDocumentPositioParams]

  5001.  * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a

  5002.  * Thenable that resolves to such.

  5003.  */

  5004. var ImplementationRequest;

  5005. (function (ImplementationRequest) {

  5006.     ImplementationRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/implementation');

  5007. })(ImplementationRequest = exports.ImplementationRequest || (exports.ImplementationRequest = {}));

  5008. 

  5009. 

  5010. /***/ }),

  5011. /* 21 */

  5012. /***/ (function(module, exports, __webpack_require__) {

  5013. 

  5014. "use strict";

  5015. /* --------------------------------------------------------------------------------------------

  5016.  * Copyright (c) Microsoft Corporation. All rights reserved.

  5017.  * Licensed under the MIT License. See License.txt in the project root for license information.

  5018.  * ------------------------------------------------------------------------------------------ */

  5019. 

  5020. Object.defineProperty(exports, "__esModule", { value: true });

  5021. const vscode_jsonrpc_1 = __webpack_require__(4);

  5022. // @ts-ignore: to avoid inlining LocatioLink as dynamic import

  5023. let __noDynamicImport;

  5024. /**

  5025.  * A request to resolve the type definition locations of a symbol at a given text

  5026.  * document position. The request's parameter is of type [TextDocumentPositioParams]

  5027.  * (#TextDocumentPositionParams) the response is of type [Definition](#Definition) or a

  5028.  * Thenable that resolves to such.

  5029.  */

  5030. var TypeDefinitionRequest;

  5031. (function (TypeDefinitionRequest) {

  5032.     TypeDefinitionRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/typeDefinition');

  5033. })(TypeDefinitionRequest = exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {}));

  5034. 

  5035. 

  5036. /***/ }),

  5037. /* 22 */

  5038. /***/ (function(module, exports, __webpack_require__) {

  5039. 

  5040. "use strict";

  5041. /* --------------------------------------------------------------------------------------------

  5042.  * Copyright (c) Microsoft Corporation. All rights reserved.

  5043.  * Licensed under the MIT License. See License.txt in the project root for license information.

  5044.  * ------------------------------------------------------------------------------------------ */

  5045. 

  5046. Object.defineProperty(exports, "__esModule", { value: true });

  5047. const vscode_jsonrpc_1 = __webpack_require__(4);

  5048. /**

  5049.  * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.

  5050.  */

  5051. var WorkspaceFoldersRequest;

  5052. (function (WorkspaceFoldersRequest) {

  5053.     WorkspaceFoldersRequest.type = new vscode_jsonrpc_1.RequestType0('workspace/workspaceFolders');

  5054. })(WorkspaceFoldersRequest = exports.WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = {}));

  5055. /**

  5056.  * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace

  5057.  * folder configuration changes.

  5058.  */

  5059. var DidChangeWorkspaceFoldersNotification;

  5060. (function (DidChangeWorkspaceFoldersNotification) {

  5061.     DidChangeWorkspaceFoldersNotification.type = new vscode_jsonrpc_1.NotificationType('workspace/didChangeWorkspaceFolders');

  5062. })(DidChangeWorkspaceFoldersNotification = exports.DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = {}));

  5063. 

  5064. 

  5065. /***/ }),

  5066. /* 23 */

  5067. /***/ (function(module, exports, __webpack_require__) {

  5068. 

  5069. "use strict";

  5070. /* --------------------------------------------------------------------------------------------

  5071.  * Copyright (c) Microsoft Corporation. All rights reserved.

  5072.  * Licensed under the MIT License. See License.txt in the project root for license information.

  5073.  * ------------------------------------------------------------------------------------------ */

  5074. 

  5075. Object.defineProperty(exports, "__esModule", { value: true });

  5076. const vscode_jsonrpc_1 = __webpack_require__(4);

  5077. /**

  5078.  * The 'workspace/configuration' request is sent from the server to the client to fetch a certain

  5079.  * configuration setting.

  5080.  *

  5081.  * This pull model replaces the old push model were the client signaled configuration change via an

  5082.  * event. If the server still needs to react to configuration changes (since the server caches the

  5083.  * result of `workspace/configuration` requests) the server should register for an empty configuration

  5084.  * change event and empty the cache if such an event is received.

  5085.  */

  5086. var ConfigurationRequest;

  5087. (function (ConfigurationRequest) {

  5088.     ConfigurationRequest.type = new vscode_jsonrpc_1.RequestType('workspace/configuration');

  5089. })(ConfigurationRequest = exports.ConfigurationRequest || (exports.ConfigurationRequest = {}));

  5090. 

  5091. 

  5092. /***/ }),

  5093. /* 24 */

  5094. /***/ (function(module, exports, __webpack_require__) {

  5095. 

  5096. "use strict";

  5097. /* --------------------------------------------------------------------------------------------

  5098.  * Copyright (c) Microsoft Corporation. All rights reserved.

  5099.  * Licensed under the MIT License. See License.txt in the project root for license information.

  5100.  * ------------------------------------------------------------------------------------------ */

  5101. 

  5102. Object.defineProperty(exports, "__esModule", { value: true });

  5103. const vscode_jsonrpc_1 = __webpack_require__(4);

  5104. /**

  5105.  * A request to list all color symbols found in a given text document. The request's

  5106.  * parameter is of type [DocumentColorParams](#DocumentColorParams) the

  5107.  * response is of type [ColorInformation[]](#ColorInformation) or a Thenable

  5108.  * that resolves to such.

  5109.  */

  5110. var DocumentColorRequest;

  5111. (function (DocumentColorRequest) {

  5112.     DocumentColorRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/documentColor');

  5113. })(DocumentColorRequest = exports.DocumentColorRequest || (exports.DocumentColorRequest = {}));

  5114. /**

  5115.  * A request to list all presentation for a color. The request's

  5116.  * parameter is of type [ColorPresentationParams](#ColorPresentationParams) the

  5117.  * response is of type [ColorInformation[]](#ColorInformation) or a Thenable

  5118.  * that resolves to such.

  5119.  */

  5120. var ColorPresentationRequest;

  5121. (function (ColorPresentationRequest) {

  5122.     ColorPresentationRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/colorPresentation');

  5123. })(ColorPresentationRequest = exports.ColorPresentationRequest || (exports.ColorPresentationRequest = {}));

  5124. 

  5125. 

  5126. /***/ }),

  5127. /* 25 */

  5128. /***/ (function(module, exports, __webpack_require__) {

  5129. 

  5130. "use strict";

  5131. 

  5132. /*---------------------------------------------------------------------------------------------

  5133.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  5134.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  5135.  *--------------------------------------------------------------------------------------------*/

  5136. Object.defineProperty(exports, "__esModule", { value: true });

  5137. const vscode_jsonrpc_1 = __webpack_require__(4);

  5138. /**

  5139.  * Enum of known range kinds

  5140.  */

  5141. var FoldingRangeKind;

  5142. (function (FoldingRangeKind) {

  5143.     /**

  5144.      * Folding range for a comment

  5145.      */

  5146.     FoldingRangeKind["Comment"] = "comment";

  5147.     /**

  5148.      * Folding range for a imports or includes

  5149.      */

  5150.     FoldingRangeKind["Imports"] = "imports";

  5151.     /**

  5152.      * Folding range for a region (e.g. `#region`)

  5153.      */

  5154.     FoldingRangeKind["Region"] = "region";

  5155. })(FoldingRangeKind = exports.FoldingRangeKind || (exports.FoldingRangeKind = {}));

  5156. /**

  5157.  * A request to provide folding ranges in a document. The request's

  5158.  * parameter is of type [FoldingRangeParams](#FoldingRangeParams), the

  5159.  * response is of type [FoldingRangeList](#FoldingRangeList) or a Thenable

  5160.  * that resolves to such.

  5161.  */

  5162. var FoldingRangeRequest;

  5163. (function (FoldingRangeRequest) {

  5164.     FoldingRangeRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/foldingRange');

  5165. })(FoldingRangeRequest = exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {}));

  5166. 

  5167. 

  5168. /***/ }),

  5169. /* 26 */

  5170. /***/ (function(module, exports, __webpack_require__) {

  5171. 

  5172. "use strict";

  5173. /* --------------------------------------------------------------------------------------------

  5174.  * Copyright (c) Microsoft Corporation. All rights reserved.

  5175.  * Licensed under the MIT License. See License.txt in the project root for license information.

  5176.  * ------------------------------------------------------------------------------------------ */

  5177. 

  5178. Object.defineProperty(exports, "__esModule", { value: true });

  5179. const vscode_jsonrpc_1 = __webpack_require__(4);

  5180. // @ts-ignore: to avoid inlining LocatioLink as dynamic import

  5181. let __noDynamicImport;

  5182. /**

  5183.  * A request to resolve the type definition locations of a symbol at a given text

  5184.  * document position. The request's parameter is of type [TextDocumentPositioParams]

  5185.  * (#TextDocumentPositionParams) the response is of type [Declaration](#Declaration)

  5186.  * or a typed array of [DeclarationLink](#DeclarationLink) or a Thenable that resolves

  5187.  * to such.

  5188.  */

  5189. var DeclarationRequest;

  5190. (function (DeclarationRequest) {

  5191.     DeclarationRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/declaration');

  5192. })(DeclarationRequest = exports.DeclarationRequest || (exports.DeclarationRequest = {}));

  5193. 

  5194. 

  5195. /***/ }),

  5196. /* 27 */

  5197. /***/ (function(module, exports, __webpack_require__) {

  5198. 

  5199. "use strict";

  5200. /* --------------------------------------------------------------------------------------------

  5201.  * Copyright (c) TypeFox and others. All rights reserved.

  5202.  * Licensed under the MIT License. See License.txt in the project root for license information.

  5203.  * ------------------------------------------------------------------------------------------ */

  5204. 

  5205. Object.defineProperty(exports, "__esModule", { value: true });

  5206. const vscode_jsonrpc_1 = __webpack_require__(4);

  5207. /**

  5208.  * The direction of a call hierarchy request.

  5209.  */

  5210. var CallHierarchyDirection;

  5211. (function (CallHierarchyDirection) {

  5212.     /**

  5213.      * The callers

  5214.      */

  5215.     CallHierarchyDirection.CallsFrom = 1;

  5216.     /**

  5217.      * The callees

  5218.      */

  5219.     CallHierarchyDirection.CallsTo = 2;

  5220. })(CallHierarchyDirection = exports.CallHierarchyDirection || (exports.CallHierarchyDirection = {}));

  5221. /**

  5222.  * Request to provide the call hierarchy at a given text document position.

  5223.  *

  5224.  * The request's parameter is of type [CallHierarchyParams](#CallHierarchyParams). The response

  5225.  * is of type [CallHierarchyCall[]](#CallHierarchyCall) or a Thenable that resolves to such.

  5226.  *

  5227.  * Evaluates the symbol defined (or referenced) at the given position, and returns all incoming or outgoing calls to the symbol(s).

  5228.  */

  5229. var CallHierarchyRequest;

  5230. (function (CallHierarchyRequest) {

  5231.     CallHierarchyRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/callHierarchy');

  5232. })(CallHierarchyRequest = exports.CallHierarchyRequest || (exports.CallHierarchyRequest = {}));

  5233. 

  5234. 

  5235. /***/ }),

  5236. /* 28 */

  5237. /***/ (function(module, exports, __webpack_require__) {

  5238. 

  5239. "use strict";

  5240. /* --------------------------------------------------------------------------------------------

  5241.  * Copyright (c) Microsoft Corporation. All rights reserved.

  5242.  * Licensed under the MIT License. See License.txt in the project root for license information.

  5243.  * ------------------------------------------------------------------------------------------ */

  5244. 

  5245. Object.defineProperty(exports, "__esModule", { value: true });

  5246. const vscode_jsonrpc_1 = __webpack_require__(4);

  5247. /**

  5248.  * The `window/progress/start` notification is sent from the server to the client

  5249.  * to initiate a progress.

  5250.  */

  5251. var ProgressStartNotification;

  5252. (function (ProgressStartNotification) {

  5253.     ProgressStartNotification.type = new vscode_jsonrpc_1.NotificationType('window/progress/start');

  5254. })(ProgressStartNotification = exports.ProgressStartNotification || (exports.ProgressStartNotification = {}));

  5255. /**

  5256.  * The `window/progress/report` notification is sent from the server to the client

  5257.  * to initiate a progress.

  5258.  */

  5259. var ProgressReportNotification;

  5260. (function (ProgressReportNotification) {

  5261.     ProgressReportNotification.type = new vscode_jsonrpc_1.NotificationType('window/progress/report');

  5262. })(ProgressReportNotification = exports.ProgressReportNotification || (exports.ProgressReportNotification = {}));

  5263. /**

  5264.  * The `window/progress/done` notification is sent from the server to the client

  5265.  * to initiate a progress.

  5266.  */

  5267. var ProgressDoneNotification;

  5268. (function (ProgressDoneNotification) {

  5269.     ProgressDoneNotification.type = new vscode_jsonrpc_1.NotificationType('window/progress/done');

  5270. })(ProgressDoneNotification = exports.ProgressDoneNotification || (exports.ProgressDoneNotification = {}));

  5271. /**

  5272.  * The `window/progress/cancel` notification is sent client to the server to cancel a progress

  5273.  * initiated on the server side.

  5274.  */

  5275. var ProgressCancelNotification;

  5276. (function (ProgressCancelNotification) {

  5277.     ProgressCancelNotification.type = new vscode_jsonrpc_1.NotificationType('window/progress/cancel');

  5278. })(ProgressCancelNotification = exports.ProgressCancelNotification || (exports.ProgressCancelNotification = {}));

  5279. 

  5280. 

  5281. /***/ }),

  5282. /* 29 */

  5283. /***/ (function(module, exports, __webpack_require__) {

  5284. 

  5285. "use strict";

  5286. 

  5287. /*---------------------------------------------------------------------------------------------

  5288.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  5289.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  5290.  *--------------------------------------------------------------------------------------------*/

  5291. Object.defineProperty(exports, "__esModule", { value: true });

  5292. const vscode_jsonrpc_1 = __webpack_require__(4);

  5293. const vscode_languageserver_types_1 = __webpack_require__(17);

  5294. /**

  5295.  * The SelectionRange namespace provides helper function to work with

  5296.  * SelectionRange literals.

  5297.  */

  5298. var SelectionRange;

  5299. (function (SelectionRange) {

  5300.     /**

  5301.      * Creates a new SelectionRange

  5302.      * @param range the range.

  5303.      * @param parent an optional parent.

  5304.      */

  5305.     function create(range, parent) {

  5306.         return { range, parent };

  5307.     }

  5308.     SelectionRange.create = create;

  5309.     function is(value) {

  5310.         let candidate = value;

  5311.         return candidate !== undefined && vscode_languageserver_types_1.Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));

  5312.     }

  5313.     SelectionRange.is = is;

  5314. })(SelectionRange = exports.SelectionRange || (exports.SelectionRange = {}));

  5315. /**

  5316.  * A request to provide selection ranges in a document. The request's

  5317.  * parameter is of type [SelectionRangeParams](#SelectionRangeParams), the

  5318.  * response is of type [SelectionRange[]](#SelectionRange[]) or a Thenable

  5319.  * that resolves to such.

  5320.  */

  5321. var SelectionRangeRequest;

  5322. (function (SelectionRangeRequest) {

  5323.     SelectionRangeRequest.type = new vscode_jsonrpc_1.RequestType('textDocument/selectionRange');

  5324. })(SelectionRangeRequest = exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {}));

  5325. 

  5326. 

  5327. /***/ }),

  5328. /* 30 */

  5329. /***/ (function(module) {

  5330. 

  5331. module.exports = {"$schema":"http://json.schemastore.org/schema-catalog","version":1,"schemas":[{"name":".angular-cli.json","description":"Angular CLI configuration file","fileMatch":[".angular-cli.json","angular-cli.json"],"url":"https://raw.githubusercontent.com/angular/angular-cli/master/packages/angular/cli/lib/config/schema.json"},{"name":"Ansible","description":"Ansible task files","url":"http://json.schemastore.org/ansible-stable-2.5","fileMatch":["tasks/*.yml","tasks/*.yaml"],"versions":{"2.0":"http://json.schemastore.org/ansible-stable-2.0","2.1":"http://json.schemastore.org/ansible-stable-2.1","2.2":"http://json.schemastore.org/ansible-stable-2.2","2.3":"http://json.schemastore.org/ansible-stable-2.3","2.4":"http://json.schemastore.org/ansible-stable-2.4","2.5":"http://json.schemastore.org/ansible-stable-2.5","2.6":"http://json.schemastore.org/ansible-stable-2.6","2.7":"http://json.schemastore.org/ansible-stable-2.7"}},{"name":"apple-app-site-association","description":"Apple Universal Link, App Site Association","fileMatch":["apple-app-site-association"],"url":"http://json.schemastore.org/apple-app-site-association"},{"name":"appsscript.json","description":"Google Apps Script manifest file","fileMatch":["appsscript.json"],"url":"http://json.schemastore.org/appsscript"},{"name":"appsettings.json","description":"ASP.NET Core's configuration file","fileMatch":["appsettings.json","appsettings.*.json"],"url":"http://json.schemastore.org/appsettings"},{"name":"appveyor.yml","description":"AppVeyor CI configuration file","fileMatch":["appveyor.yml"],"url":"http://json.schemastore.org/appveyor"},{"name":"Avro Avsc","description":"Avro Schema Avsc file","fileMatch":[".avsc"],"url":"http://json.schemastore.org/avro-avsc"},{"name":"Azure IoT Edge deployment","description":"Azure IoT Edge deployment schema","url":"http://json.schemastore.org/azure-iot-edge-deployment-2.0","versions":{"1.0":"http://json.schemastore.org/azure-iot-edge-deployment-1.0","1.1":"http://json.schemastore.org/azure-iot-edge-deployment-2.0"}},{"name":"Azure IoT Edge deployment template","description":"Azure IoT Edge deployment template schema","fileMatch":["deployment.template.json","deployment.*.template.json"],"url":"http://json.schemastore.org/azure-iot-edge-deployment-template-2.0","versions":{"1.0":"http://json.schemastore.org/azure-iot-edge-deployment-template-1.0","1.1":"http://json.schemastore.org/azure-iot-edge-deployment-template-2.0"}},{"name":"Foxx Manifest","description":"ArangoDB Foxx service manifest file","fileMatch":["manifest.json"],"url":"http://json.schemastore.org/foxx-manifest"},{"name":".asmdef","description":"Unity 3D assembly definition file","fileMatch":["*.asmdef"],"url":"http://json.schemastore.org/asmdef"},{"name":"babelrc.json","description":"Babel configuration file","fileMatch":[".babelrc"],"url":"http://json.schemastore.org/babelrc"},{"name":".backportrc.json","description":"Backport configuration file","fileMatch":[".backportrc.json"],"url":"http://json.schemastore.org/backportrc"},{"name":"batect.yml","description":"batect configuration file","fileMatch":["batect.yml"],"url":"https://batect.charleskorn.com/configSchema.json"},{"name":".bootstraprc","description":"Webpack bootstrap-loader configuration file","fileMatch":[".bootstraprc"],"url":"http://json.schemastore.org/bootstraprc"},{"name":"bower.json","description":"Bower package description file","fileMatch":["bower.json",".bower.json"],"url":"http://json.schemastore.org/bower"},{"name":".bowerrc","description":"Bower configuration file","fileMatch":[".bowerrc"],"url":"http://json.schemastore.org/bowerrc"},{"name":"behat.yml","description":"Behat configuration file","fileMatch":["behat.yml","*.behat.yml"],"url":"http://json.schemastore.org/behat"},{"name":"bozr.suite.json","description":"Bozr test suite file","fileMatch":[".suite.json",".xsuite.json"],"url":"http://json.schemastore.org/bozr"},{"name":"Bukkit plugin.yml","description":"Schema for Minecraft Bukkit plugin description files","fileMatch":["plugin.yml"],"url":"http://json.schemastore.org/bukkit-plugin"},{"name":"Buildkite","description":"Schema for Buildkite pipeline.yml files","fileMatch":["buildkite.yml","buildkite.yaml","buildkite.json","buildkite.*.yml","buildkite.*.yaml","buildkite.*.json",".buildkite/pipeline.yml",".buildkite/pipeline.yaml",".buildkite/pipeline.json",".buildkite/pipeline.*.yml",".buildkite/pipeline.*.yaml",".buildkite/pipeline.*.json"],"url":"https://raw.githubusercontent.com/buildkite/pipeline-schema/master/schema.json"},{"name":".build.yml","description":"Sourcehut Build Manifest","fileMatch":[".build.yml"],"url":"http://json.schemastore.org/sourcehut-build"},{"name":"bundleconfig.json","description":"Schema for bundleconfig.json files","fileMatch":["bundleconfig.json"],"url":"http://json.schemastore.org/bundleconfig"},{"name":"BungeeCord plugin.yml","description":"Schema for BungeeCord plugin description files","fileMatch":["plugin.yml","bungee.yml"],"url":"http://json.schemastore.org/bungee-plugin"},{"name":"Carafe","description":"Schema for Carafe compatible JavaScript Bundles","url":"https://carafe.fm/schema/draft-01/bundle.schema.json","versions":{"draft-01":"https://carafe.fm/schema/draft-01/bundle.schema.json"}},{"name":"circleciconfig.json","description":"Schema for CircleCI 2.0 config files","fileMatch":[".circleci/config.yml"],"url":"http://json.schemastore.org/circleciconfig"},{"name":".cirrus.yml","description":"Cirrus CI configuration files","fileMatch":[".cirrus.yml"],"url":"http://json.schemastore.org/cirrus"},{"name":".clasp.json","description":"Google Apps Script CLI project file","fileMatch":[".clasp.json"],"url":"http://json.schemastore.org/clasp"},{"name":"compilerconfig.json","description":"Schema for compilerconfig.json files","fileMatch":["compilerconfig.json"],"url":"http://json.schemastore.org/compilerconfig"},{"name":"commands.json","description":"Config file for Command Task Runner","fileMatch":["commands.json"],"url":"http://json.schemastore.org/commands"},{"name":"Chrome Extension","description":"Google Chrome extension manifest file","url":"http://json.schemastore.org/chrome-manifest"},{"name":"chutzpah.json","description":"Chutzpah configuration file","fileMatch":["chutzpah.json"],"url":"http://json.schemastore.org/chutzpah"},{"name":"contentmanifest.json","description":"Visual Studio manifest injection file","fileMatch":["contentmanifest.json"],"url":"http://json.schemastore.org/vsix-manifestinjection"},{"name":"cloudbuild.json","description":"Google Cloud Build configuration file","fileMatch":["cloudbuild.json","cloudbuild.yaml","cloudbuild.yml","*.cloudbuild.json"],"url":"http://json.schemastore.org/cloudbuild"},{"name":"AWS CloudFormation","description":"AWS CloudFormation provides a common language for you to describe and provision all the infrastructure resources in your cloud environment.","fileMatch":["*.cf.json","*.cf.yml","*.cf.yaml","cloudformation.json","cloudformation.yml","cloudformation.yaml"],"url":"https://raw.githubusercontent.com/awslabs/goformation/master/schema/cloudformation.schema.json"},{"name":"AWS CloudFormation Serverless Application Model (SAM)","description":"The AWS Serverless Application Model (AWS SAM, previously known as Project Flourish) extends AWS CloudFormation to provide a simplified way of defining the Amazon API Gateway APIs, AWS Lambda functions, and Amazon DynamoDB tables needed by your serverless application.","fileMatch":["*.sam.json","*.sam.yml","*.sam.yaml","sam.json","sam.yml","sam.yaml"],"url":"https://raw.githubusercontent.com/awslabs/goformation/master/schema/sam.schema.json"},{"name":"coffeelint.json","description":"CoffeeLint configuration file","fileMatch":["coffeelint.json"],"url":"http://json.schemastore.org/coffeelint"},{"name":"composer.json","description":"PHP Composer configuration file","fileMatch":["composer.json"],"url":"http://json.schemastore.org/composer"},{"name":"component.json","description":"Web component file","fileMatch":["component.json"],"url":"http://json.schemastore.org/component"},{"name":"config.json","description":"ASP.NET project config file","fileMatch":["config.json"],"url":"http://json.schemastore.org/config"},{"name":"contribute.json","description":"A JSON schema for open-source project contribution data by Mozilla","fileMatch":["contribute.json"],"url":"http://json.schemastore.org/contribute"},{"name":"cypress.json","description":"Cypress.io test runner configuration file","fileMatch":["cypress.json"],"url":"https://raw.githubusercontent.com/cypress-io/cypress/develop/cli/schema/cypress.schema.json"},{"name":".creatomic","description":"A config for Atomic Design 4 React generator","fileMatch":[".creatomic"],"url":"http://json.schemastore.org/creatomic"},{"name":".csscomb.json","description":"A JSON schema CSS Comb's configuration file","fileMatch":[".csscomb.json"],"url":"http://json.schemastore.org/csscomb"},{"name":".csslintrc","description":"A JSON schema CSS Lint's configuration file","fileMatch":[".csslintrc"],"url":"http://json.schemastore.org/csslintrc"},{"name":"datalogic-scan2deploy-android","description":"Datalogic Scan2Deploy Android file","fileMatch":[".dla.json"],"url":"http://json.schemastore.org/datalogic-scan2deploy-android"},{"name":"datalogic-scan2deploy-ce","description":"Datalogic Scan2Deploy CE file","fileMatch":[".dlc.json"],"url":"http://json.schemastore.org/datalogic-scan2deploy-ce"},{"name":"debugsettings.json","description":"A JSON schema for the ASP.NET DebugSettings.json files","fileMatch":["debugsettings.json"],"url":"http://json.schemastore.org/debugsettings"},{"name":"docfx.json","description":"A JSON schema for DocFx configuraton files","fileMatch":["docfx.json"],"url":"http://json.schemastore.org/docfx","versions":{"2.8.0":"http://json.schemastore.org/docfx-2.8.0"}},{"name":"Dolittle Artifacts","description":"A JSON schema for a Dolittle bounded context's artifacts","fileMatch":[".dolittle/artifacts.json"],"url":"https://raw.githubusercontent.com/dolittle/DotNET.SDK/master/Schemas/Artifacts.Configuration/artifacts.json"},{"name":"Dolittle Bounded Context Configuration","description":"A JSON schema for Dolittle application's bounded context configuration","fileMatch":["bounded-context.json"],"url":"https://raw.githubusercontent.com/dolittle/Runtime/master/Schemas/Applications.Configuration/bounded-context.json"},{"name":"Dolittle Event Horizons Configuration","description":"A JSON schema for a Dolittle bounded context's event horizon configurations","fileMatch":[".dolittle/event-horizons.json"],"url":"https://raw.githubusercontent.com/dolittle/Runtime/master/Schemas/Events/event-horizons.json"},{"name":"Dolittle Resources Configuration","description":"A JSON schema for a Dolittle bounded context's resource configurations","fileMatch":[".dolittle/resources.json"],"url":"https://raw.githubusercontent.com/dolittle/DotNET.Fundamentals/master/Schemas/ResourceTypes.Configuration/resources.json"},{"name":"Dolittle Server Configuration","description":"A JSON schema for a Dolittle bounded context's event horizon's interaction server configuration","fileMatch":[".dolittle/server.json"],"url":"https://raw.githubusercontent.com/dolittle/Runtime/master/Schemas/Server/server.json"},{"name":"Dolittle Tenants Configuration","description":"A JSON schema for a Dolittle bounded context's tenant configuration","fileMatch":[".dolittle/tenants.json"],"url":"https://raw.githubusercontent.com/dolittle/Runtime/master/Schemas/Tenancy/tenants.json"},{"name":"Dolittle Tenant Map Configuration","description":"A JSON schema for a Dolittle bounded context's tenant mapping configurations","fileMatch":[".dolittle/tenant-map.json"],"url":"https://raw.githubusercontent.com/dolittle/DotNET.Fundamentals/master/Schemas/Tenancy.Configuration/tenant-map.json"},{"name":"Dolittle Topology","description":"A JSON schema for a Dolittle bounded context's topology","fileMatch":[".dolittle/topology.json"],"url":"https://raw.githubusercontent.com/dolittle/DotNET.SDK/master/Schemas/Applications.Configuration/topology.json"},{"name":"dotnetcli.host.json","description":"JSON schema for .NET CLI template host files","fileMatch":["dotnetcli.host.json"],"url":"http://json.schemastore.org/dotnetcli.host"},{"name":"Drush site aliases","description":"JSON Schema for Drush 9 site aliases file","fileMatch":["sites/*.site.yml"],"url":"http://json.schemastore.org/drush.site.yml"},{"name":"dss-2.0.0.json","description":"Digital Signature Service Core Protocols, Elements, and Bindings Version 2.0","url":"http://json.schemastore.org/dss-2.0.0.json"},{"name":"epr-manifest.json","description":"Entry Point Regulation manifest file","fileMatch":["epr-manifest.json"],"url":"http://json.schemastore.org/epr-manifest"},{"name":"electron-builder configuration file.","description":"JSON schema for electron-build configuration file.","fileMatch":["electron-builder.json"],"url":"http://json.schemastore.org/electron-builder"},{"name":".eslintrc","description":"JSON schema for ESLint configuration files","fileMatch":[".eslintrc",".eslintrc.json",".eslintrc.yml",".eslintrc.yaml"],"url":"http://json.schemastore.org/eslintrc"},{"name":"function.json","description":"JSON schema for Azure Functions function.json files","fileMatch":["function.json"],"url":"http://json.schemastore.org/function"},{"name":"geojson.json","description":"GeoJSON format for representing geographic data.","url":"http://json.schemastore.org/geojson"},{"name":"gitlab-ci","description":"JSON schema for configuring Gitlab CI","fileMatch":[".gitlab-ci.yml"],"url":"http://json.schemastore.org/gitlab-ci"},{"name":"global.json","description":"ASP.NET global configuration file","fileMatch":["global.json"],"url":"http://json.schemastore.org/global"},{"name":"Grunt copy task","description":"Grunt copy task configuration file","fileMatch":["copy.json"],"url":"http://json.schemastore.org/grunt-copy-task"},{"name":"Grunt clean task","description":"Grunt clean task configuration file","fileMatch":["clean.json"],"url":"http://json.schemastore.org/grunt-clean-task"},{"name":"Grunt cssmin task","description":"Grunt cssmin task configuration file","fileMatch":["cssmin.json"],"url":"http://json.schemastore.org/grunt-cssmin-task"},{"name":"Grunt JSHint task","description":"Grunt JSHint task configuration file","fileMatch":["jshint.json"],"url":"http://json.schemastore.org/grunt-jshint-task"},{"name":"Grunt Watch task","description":"Grunt Watch task configuration file","fileMatch":["watch.json"],"url":"http://json.schemastore.org/grunt-watch-task"},{"name":"Grunt base task","description":"Schema for standard Grunt tasks","fileMatch":["grunt/*.json","*-tasks.json"],"url":"http://json.schemastore.org/grunt-task"},{"name":"haxelib.json","description":"Haxelib manifest","fileMatch":["haxelib.json"],"url":"http://json.schemastore.org/haxelib"},{"name":"host.json","description":"JSON schema for Azure Functions host.json files","fileMatch":["host.json"],"url":"http://json.schemastore.org/host"},{"name":"host-meta.json","description":"Schema for host-meta JDR files","fileMatch":["host-meta.json"],"url":"http://json.schemastore.org/host-meta"},{"name":".htmlhintrc","description":"HTML Hint configuration file","fileMatch":[".htmlhintrc"],"url":"http://json.schemastore.org/htmlhint"},{"name":"imageoptimizer.json","description":"Schema for imageoptimizer.json files","fileMatch":["imageoptimizer.json"],"url":"http://json.schemastore.org/imageoptimizer"},{"name":"Jenkins X Pipelines","description":"Jenkins X Pipeline YAML configuration files","fileMatch":["jenkins-x*.yml"],"url":"https://jenkins-x.io/schemas/jx-schema.json"},{"name":".jsbeautifyrc","description":"js-beautify configuration file","fileMatch":[".jsbeautifyrc"],"url":"http://json.schemastore.org/jsbeautifyrc"},{"name":".jsbeautifyrc-nested","description":"js-beautify configuration file allowing nested `js`, `css`, and `html` attributes","fileMatch":[".jsbeautifyrc"],"url":"http://json.schemastore.org/jsbeautifyrc-nested"},{"name":".jscsrc","description":"JSCS configuration file","fileMatch":[".jscsrc","jscsrc.json"],"url":"http://json.schemastore.org/jscsrc"},{"name":".jshintrc","description":"JSHint configuration file","fileMatch":[".jshintrc"],"url":"http://json.schemastore.org/jshintrc"},{"name":".jsinspectrc","description":"JSInspect configuration file","fileMatch":[".jsinspectrc"],"url":"http://json.schemastore.org/jsinspectrc"},{"name":"JSON-API","description":"JSON API document","fileMatch":["*.schema.json"],"url":"http://jsonapi.org/schema"},{"name":"JSON Document Transform","description":"JSON Document Transofrm","url":"http://json.schemastore.org/jdt"},{"name":"JSON Feed","description":"JSON schema for the JSON Feed format","fileMatch":["feed.json"],"url":"http://json.schemastore.org/feed"},{"name":"*.jsonld","description":"JSON Linked Data files","fileMatch":["*.jsonld"],"url":"http://json.schemastore.org/jsonld"},{"name":"JSONPatch","description":"JSONPatch files","fileMatch":["*.patch"],"url":"http://json.schemastore.org/json-patch"},{"name":"jsconfig.json","description":"JavaScript project configuration file","fileMatch":["jsconfig.json"],"url":"http://json.schemastore.org/jsconfig"},{"name":"kustomization.yaml","description":"Kubernetes native configuration management","fileMatch":["kustomization.yaml","kustomization.yml"],"url":"http://json.schemastore.org/kustomization"},{"name":"launchsettings.json","description":"A JSON schema for the ASP.NET LaunchSettings.json files","fileMatch":["launchsettings.json"],"url":"http://json.schemastore.org/launchsettings"},{"name":"lerna.json","description":"A JSON schema for lerna.json files","fileMatch":["lerna.json"],"url":"http://json.schemastore.org/lerna"},{"name":"libman.json","description":"JSON schema for client-side library config files","fileMatch":["libman.json"],"url":"http://json.schemastore.org/libman"},{"name":"lsdlschema.json","description":"JSON schema for Linguistic Schema Definition Language files","fileMatch":["*.lsdl.yaml","*.lsdl.json"],"url":"http://json.schemastore.org/lsdlschema"},{"name":"Microsoft Band Web Tile","description":"Microsoft Band Web Tile manifest file","url":"http://json.schemastore.org/band-manifest"},{"name":"mimetypes.json","description":"JSON Schema for mime type collections","fileMatch":["mimetypes.json"],"url":"http://json.schemastore.org/mimetypes"},{"name":".modernizrrc","description":"Webpack modernizr-loader configuration file","fileMatch":[".modernizrrc"],"url":"http://json.schemastore.org/modernizrrc"},{"name":"mycode.json","description":"JSON schema for mycode.js files","fileMatch":["mycode.json"],"url":"http://json.schemastore.org/mycode"},{"name":"news in JSON","description":"A JSON Schema for ninjs by the IPTC. News and publishing information. See http://dev.iptc.org/ninjs","fileMatch":["ninjs.json"],"url":"http://json.schemastore.org/ninjs"},{"name":"nodemon.json","description":"JSON schema for nodemon.json configuration files.","url":"http://json.schemastore.org/nodemon","fileMatch":["nodemon.json"]},{"name":".npmpackagejsonlintrc","description":"Configuration file for npm-package-json-lint","fileMatch":[".npmpackagejsonlintrc","npmpackagejsonlintrc.json",".npmpackagejsonlintrc.json"],"url":"http://json.schemastore.org/npmpackagejsonlintrc"},{"name":"nuget-project.json","description":"JSON schema for NuGet project.json files.","url":"http://json.schemastore.org/nuget-project","versions":{"3.3.0":"http://json.schemastore.org/nuget-project-3.3.0"}},{"name":"nswag.json","description":"JSON schema for nswag configuration","url":"http://json.schemastore.org/nswag","fileMatch":["nswag.json"]},{"name":"ocelot.json","description":"JSON schema for the Ocelot Api Gateway.","fileMatch":["ocelot.json"],"url":"http://json.schemastore.org/ocelot"},{"name":"omnisharp.json","description":"Omnisharp Configuration file","fileMatch":["omnisharp.json"],"url":"http://json.schemastore.org/omnisharp"},{"name":"openapi.json","description":"A JSON schema for Open API documentation files","fileMatch":["openapi.json","openapi.yml","openapi.yaml"],"url":"https://raw.githubusercontent.com/kogosoftwarellc/open-api/master/packages/openapi-schema-validator/resources/openapi-3.0.json"},{"name":"openfin.json","description":"OpenFin application configuration file","url":"http://json.schemastore.org/openfin"},{"name":"package.json","description":"NPM configuration file","fileMatch":["package.json"],"url":"http://json.schemastore.org/package"},{"name":"package.manifest","description":"Umbraco package configuration file","fileMatch":["package.manifest"],"url":"http://json.schemastore.org/package.manifest","versions":{"8.0.0":"http://json.schemastore.org/package.manifest-8.0.0","7.0.0":"http://json.schemastore.org/package.manifest-7.0.0"}},{"name":"pattern.json","description":"Patternplate pattern manifest file","fileMatch":["pattern.json"],"url":"http://json.schemastore.org/pattern"},{"name":"PocketMine plugin.yml","description":"PocketMine plugin manifest file","fileMatch":["plugin.yml"],"url":"http://json.schemastore.org/pocketmine-plugin"},{"name":".phraseapp.yml","description":"PhraseApp configuration file","fileMatch":[".phraseapp.yml"],"url":"http://json.schemastore.org/phraseapp"},{"name":"prettierrc.json","description":".prettierrc configuration file","fileMatch":[".prettierrc",".prettierrc.json"],"url":"http://json.schemastore.org/prettierrc","versions":{"1.8.2":"http://json.schemastore.org/prettierrc-1.8.2"}},{"name":"prisma.yml","description":"prisma.yml service definition file","fileMatch":["prisma.yml"],"url":"http://json.schemastore.org/prisma"},{"name":"project.json","description":"ASP.NET vNext project configuration file","fileMatch":["project.json"],"url":"http://json.schemastore.org/project","versions":{"1.0.0-beta3":"http://json.schemastore.org/project-1.0.0-beta3","1.0.0-beta4":"http://json.schemastore.org/project-1.0.0-beta4","1.0.0-beta5":"http://json.schemastore.org/project-1.0.0-beta5","1.0.0-beta6":"http://json.schemastore.org/project-1.0.0-beta6","1.0.0-beta8":"http://json.schemastore.org/project-1.0.0-beta8","1.0.0-rc1":"http://json.schemastore.org/project-1.0.0-rc1","1.0.0-rc1-update1":"http://json.schemastore.org/project-1.0.0-rc1","1.0.0-rc2":"http://json.schemastore.org/project-1.0.0-rc2"}},{"name":"project-1.0.0-beta3.json","description":"ASP.NET vNext project configuration file","url":"http://json.schemastore.org/project-1.0.0-beta3"},{"name":"project-1.0.0-beta4.json","description":"ASP.NET vNext project configuration file","url":"http://json.schemastore.org/project-1.0.0-beta4"},{"name":"project-1.0.0-beta5.json","description":"ASP.NET vNext project configuration file","url":"http://json.schemastore.org/project-1.0.0-beta5"},{"name":"project-1.0.0-beta6.json","description":"ASP.NET vNext project configuration file","url":"http://json.schemastore.org/project-1.0.0-beta6"},{"name":"project-1.0.0-beta8.json","description":"ASP.NET vNext project configuration file","url":"http://json.schemastore.org/project-1.0.0-beta8"},{"name":"project-1.0.0-rc1.json","description":"ASP.NET vNext project configuration file","url":"http://json.schemastore.org/project-1.0.0-rc1"},{"name":"project-1.0.0-rc2.json","description":".NET Core project configuration file","url":"http://json.schemastore.org/project-1.0.0-rc2"},{"name":"proxies.json","description":"JSON schema for Azure Function Proxies proxies.json files","fileMatch":["proxies.json"],"url":"http://json.schemastore.org/proxies"},{"name":"pyrseas-0.8.json","description":"Pyrseas database schema versioning for Postgres databases, v0.8","fileMatch":["pyrseas-0.8.json"],"url":"http://json.schemastore.org/pyrseas-0.8"},{"name":"*.resjson","description":"Windows App localization file","fileMatch":["*.resjson"],"url":"http://json.schemastore.org/resjson"},{"name":"JSON Resume","description":"A JSON format to describe resumes","fileMatch":["resume.json"],"url":"http://json.schemastore.org/resume"},{"name":"Renovate","description":"Renovate config file (https://renovatebot.com/)","fileMatch":["renovate.json"],"url":"http://json.schemastore.org/renovate"},{"name":"sarif-1.0.0.json","description":"Static Analysis Results Interchange Format (SARIF) version 1","url":"http://json.schemastore.org/sarif-1.0.0.json"},{"name":"sarif-2.0.0.json","description":"Static Analysis Results Interchange Format (SARIF) version 2","url":"http://json.schemastore.org/sarif-2.0.0.json"},{"name":"2.0.0-csd.2.beta.2018-10-10","description":"Static Analysis Results Format (SARIF) Version 2.0.0-csd.2.beta-2018-10-10","url":"http://json.schemastore.org/2.0.0-csd.2.beta.2018-10-10.json"},{"name":"sarif-2.1.0-rtm.2","description":"Static Analysis Results Format (SARIF), Version 2.1.0-rtm.2","url":"http://json.schemastore.org/sarif-2.1.0-rtm.2.json"},{"name":"sarif-external-property-file-2.1.0-rtm.2","description":"Static Analysis Results Format (SARIF) External Property File Format, Version 2.1.0-rtm.2","url":"http://json.schemastore.org/sarif-external-property-file-2.1.0-rtm.2.json"},{"name":"sarif-2.1.0-rtm.3","description":"Static Analysis Results Format (SARIF), Version 2.1.0-rtm.3","url":"http://json.schemastore.org/sarif-2.1.0-rtm.3.json"},{"name":"sarif-external-property-file-2.1.0-rtm.3","description":"Static Analysis Results Format (SARIF) External Property File Format, Version 2.1.0-rtm.3","url":"http://json.schemastore.org/sarif-external-property-file-2.1.0-rtm.3.json"},{"name":"Schema Catalog","description":"JSON Schema catalog files compatible with SchemaStore.org","url":"http://json.schemastore.org/schema-catalog"},{"name":"schema.org - Action","description":"JSON Schema for Action as defined by schema.org","url":"http://json.schemastore.org/schema-org-action"},{"name":"schema.org - ContactPoint","description":"JSON Schema for ContactPoint as defined by schema.org","url":"http://json.schemastore.org/schema-org-contact-point"},{"name":"schema.org - Place","description":"JSON Schema for Place as defined by schema.org","url":"http://json.schemastore.org/schema-org-place"},{"name":"schema.org - Thing","description":"JSON Schema for Thing as defined by schema.org","url":"http://json.schemastore.org/schema-org-thing"},{"name":"settings.job","description":"Azure Webjob settings file","fileMatch":["settings.job"],"url":"http://json.schemastore.org/settings.job"},{"name":"skyuxconfig.json","description":"SKY UX CLI configuration file","fileMatch":["skyuxconfig.json","skyuxconfig.*.json"],"url":"https://raw.githubusercontent.com/blackbaud/skyux-builder/master/skyuxconfig-schema.json"},{"name":"snapcraft","description":"snapcraft project  (https://snapcraft.io)","fileMatch":[".snapcraft.yaml","snapcraft.yaml"],"url":"https://raw.githubusercontent.com/snapcore/snapcraft/master/schema/snapcraft.json"},{"name":"Solidarity","description":"CLI config for enforcing environment settings","fileMatch":[".solidarity",".solidarity.json"],"url":"http://json.schemastore.org/solidaritySchema"},{"name":"Source Maps v3","description":"Source Map files version 3","fileMatch":["*.map"],"url":"http://json.schemastore.org/sourcemap-v3"},{"name":".sprite files","description":"Schema for image sprite generation files","fileMatch":["*.sprite"],"url":"http://json.schemastore.org/sprite"},{"name":"StyleCop Analyzers Configuration","description":"Configuration file for StyleCop Analyzers","fileMatch":["stylecop.json"],"url":"https://raw.githubusercontent.com/DotNetAnalyzers/StyleCopAnalyzers/master/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json"},{"name":".stylelintrc","description":"Configuration file for stylelint","fileMatch":[".stylelintrc","stylelintrc.json",".stylelintrc.json"],"url":"http://json.schemastore.org/stylelintrc"},{"name":"Swagger API 2.0","description":"Swagger API 2.0 schema","fileMatch":["swagger.json"],"url":"http://json.schemastore.org/swagger-2.0"},{"name":"template.json","description":"JSON schema .NET template files","fileMatch":[".template.config/template.json"],"url":"http://json.schemastore.org/template"},{"name":"templatsources.json","description":"SideWaffle template source schema","fileMatch":["templatesources.json"],"url":"http://json.schemastore.org/templatesources"},{"name":"tmLanguage","description":"Language grammar description files in Textmate and compatible editors","fileMatch":["*.tmLanguage.json"],"url":"https://raw.githubusercontent.com/Septh/tmlanguage/master/tmLanguage.schema.json"},{"name":".travis.yml","description":"Travis CI configuration file","fileMatch":[".travis.yml"],"url":"http://json.schemastore.org/travis"},{"name":"tsconfig.json","description":"TypeScript compiler configuration file","fileMatch":["tsconfig.json"],"url":"http://json.schemastore.org/tsconfig"},{"name":"tsd.json","description":"JSON schema for DefinatelyTyped description manager (TSD)","fileMatch":["tsd.json"],"url":"http://json.schemastore.org/tsd"},{"name":"tsdrc.json","description":"TypeScript Definition manager (tsd) global settings file","fileMatch":[".tsdrc"],"url":"http://json.schemastore.org/tsdrc"},{"name":"ts-force-config.json","description":"Generated Typescript classes for Salesforce","fileMatch":["ts-force-config.json"],"url":"http://json.schemastore.org/ts-force-config"},{"name":"tslint.json","description":"TypeScript Lint configuration file","fileMatch":["tslint.json","tslint.yaml","tslint.yml"],"url":"http://json.schemastore.org/tslint"},{"name":"typewiz.json","description":"Typewiz configuration file","fileMatch":["typewiz.json"],"url":"http://json.schemastore.org/typewiz"},{"name":"typings.json","description":"Typings TypeScript definitions manager definition file","fileMatch":["typings.json"],"url":"http://json.schemastore.org/typings"},{"name":"typingsrc.json","description":"Typings TypeScript definitions manager configuration file","fileMatch":[".typingsrc"],"url":"http://json.schemastore.org/typingsrc"},{"name":"up.json","description":"Up configuration file","fileMatch":["up.json"],"url":"http://json.schemastore.org/up.json"},{"name":"ui5-manifest","description":"UI5/OPENUI5 descriptor file","fileMatch":[".manifest"],"url":"http://json.schemastore.org/ui5-manifest"},{"name":"vega.json","description":"Vega visualization specification file","fileMatch":["*.vg","*.vg.json"],"url":"http://json.schemastore.org/vega"},{"name":"vega-lite.json","description":"Vega-Lite visualization specification file","fileMatch":["*.vl","*.vl.json"],"url":"http://json.schemastore.org/vega-lite"},{"name":"version.json","description":"A project version descriptor file used by Nerdbank.GitVersioning","fileMatch":["version.json"],"url":"https://raw.githubusercontent.com/AArnott/Nerdbank.GitVersioning/master/src/NerdBank.GitVersioning/version.schema.json"},{"name":"vsls.json","description":"Visual Studio Live Share configuration file","fileMatch":[".vsls.json"],"url":"http://json.schemastore.org/vsls"},{"name":"vs-2017.3.host.json","description":"JSON schema for Visual Studio template host file","fileMatch":["vs-2017.3.host.json"],"url":"http://json.schemastore.org/vs-2017.3.host"},{"name":"vs-nesting.json","description":"JSON schema for Visual Studio's file nesting feature","fileMatch":["*.filenesting.json",".filenesting.json"],"url":"http://json.schemastore.org/vs-nesting"},{"name":".vsconfig","description":"JSON schema for Visual Studio component configuration files","fileMatch":["*.vsconfig"],"url":"http://json.schemastore.org/vsconfig"},{"name":".vsext","description":"JSON schema for Visual Studio extension pack manifests","fileMatch":["*.vsext"],"url":"http://json.schemastore.org/vsext"},{"name":"VSIX CLI publishing","description":"JSON schema for Visual Studio extension publishing","fileMatch":["vs-publish.json"],"url":"http://json.schemastore.org/vsix-publish"},{"name":"WebExtensions","description":"JSON schema for WebExtension manifest files","fileMatch":["manifest.json"],"url":"http://json.schemastore.org/webextension"},{"name":"Web Manifest","description":"Web Application manifest file","fileMatch":["manifest.json","*.webmanifest"],"url":"http://json.schemastore.org/web-manifest"},{"name":"webjobs-list.json","description":"Azure Webjob list file","fileMatch":["webjobs-list.json"],"url":"http://json.schemastore.org/webjobs-list"},{"name":"webjobpublishsettings.json","description":"Azure Webjobs publish settings file","fileMatch":["webjobpublishsettings.json"],"url":"http://json.schemastore.org/webjob-publish-settings"},{"name":"JSON-stat 2.0","description":"JSON-stat 2.0 Schema","url":"https://json-stat.org/format/schema/2.0/"},{"name":"KSP-CKAN 1.26","description":"Metadata spec v1.26 for KSP-CKAN","fileMatch":["*.ckan"],"url":"http://json.schemastore.org/ksp-ckan"},{"name":"JSON Schema Draft 4","description":"Meta-validation schema for JSON Schema Draft 4","url":"http://json-schema.org/draft-04/schema"},{"name":"xunit.runner.json","description":"xUnit.net runner configuration file","fileMatch":["xunit.runner.json"],"url":"http://json.schemastore.org/xunit.runner.schema"},{"name":".cryproj engine-5.2","description":"A JSON schema for CRYENGINE projects (.cryproj files)","fileMatch":["*.cryproj"],"url":"http://json.schemastore.org/cryproj.52.schema"},{"name":".cryproj engine-5.3","description":"A JSON schema for CRYENGINE projects (.cryproj files)","fileMatch":["*.cryproj"],"url":"http://json.schemastore.org/cryproj.53.schema"},{"name":".cryproj engine-5.4","description":"A JSON schema for CRYENGINE projects (.cryproj files)","fileMatch":["*.cryproj"],"url":"http://json.schemastore.org/cryproj.54.schema"},{"name":".cryproj engine-5.5","description":"A JSON schema for CRYENGINE projects (.cryproj files)","fileMatch":["*.cryproj"],"url":"http://json.schemastore.org/cryproj.55.schema"},{"name":".cryproj engine-dev","description":"A JSON schema for CRYENGINE projects (.cryproj files)","fileMatch":["*.cryproj"],"url":"http://json.schemastore.org/cryproj.dev.schema"},{"name":".cryproj (generic)","description":"A JSON schema for CRYENGINE projects (.cryproj files)","fileMatch":["*.cryproj"],"url":"http://json.schemastore.org/cryproj"},{"name":"typedoc.json","description":"A JSON schema for the Typedoc configuration file","fileMatch":["typedoc.json"],"url":"http://json.schemastore.org/typedoc"},{"name":"huskyrc","description":"Husky can prevent bad `git commit`, `git push` and more 🐶 woof!","fileMatch":[".huskyrc",".huskyrc.json"],"url":"http://json.schemastore.org/huskyrc"},{"name":".lintstagedrc","description":"JSON schema for lint-staged config","fileMatch":[".lintstagedrc",".lintstagedrc.json"],"url":"http://json.schemastore.org/lintstagedrc.schema"},{"name":"mta","description":"A JSON schema for MTA projects (mta.yaml files)","fileMatch":["mta.yaml","mta.yml"],"url":"http://json.schemastore.org/mta-3.1"},{"name":"mtad.yaml","description":"A JSON schema for MTA deployment descriptors v3.3","fileMatch":["mtad.yaml","mtad.yml"],"url":"http://json.schemastore.org/mtad"},{"name":".mtaext","description":"A JSON schema for MTA extension descriptors v3.3","fileMatch":["*.mtaext"],"url":"http://json.schemastore.org/mtaext"}]};

  5332. 

  5333. /***/ }),

  5334. /* 31 */

  5335. /***/ (function(module, exports, __webpack_require__) {

  5336. 

  5337. "use strict";

  5338. /*---------------------------------------------------------------------------------------------

  5339.  *  Copyright (c) Microsoft Corporation. All rights reserved.

  5340.  *  Licensed under the MIT License. See License.txt in the project root for license information.

  5341.  *--------------------------------------------------------------------------------------------*/

  5342. 

  5343. Object.defineProperty(exports, "__esModule", { value: true });

  5344. /**

  5345.  * Return a hash value for an object.

  5346.  */

  5347. function hash(obj, hashVal = 0) {

  5348.     switch (typeof obj) {

  5349.         case 'object':

  5350.             if (obj === null) {

  5351.                 return numberHash(349, hashVal);

  5352.             }

  5353.             else if (Array.isArray(obj)) {

  5354.                 return arrayHash(obj, hashVal);

  5355.             }

  5356.             return objectHash(obj, hashVal);

  5357.         case 'string':

  5358.             return stringHash(obj, hashVal);

  5359.         case 'boolean':

  5360.             return booleanHash(obj, hashVal);

  5361.         case 'number':

  5362.             return numberHash(obj, hashVal);

  5363.         case 'undefined':

  5364.             return numberHash(obj, 937);

  5365.         default:

  5366.             return numberHash(obj, 617);

  5367.     }

  5368. }

  5369. exports.hash = hash;

  5370. function numberHash(val, initialHashVal) {

  5371.     return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32

  5372. }

  5373. function booleanHash(b, initialHashVal) {

  5374.     return numberHash(b ? 433 : 863, initialHashVal);

  5375. }

  5376. function stringHash(s, hashVal) {

  5377.     hashVal = numberHash(149417, hashVal);

  5378.     for (let i = 0, length = s.length; i < length; i++) {

  5379.         hashVal = numberHash(s.charCodeAt(i), hashVal);

  5380.     }

  5381.     return hashVal;

  5382. }

  5383. function arrayHash(arr, initialHashVal) {

  5384.     initialHashVal = numberHash(104579, initialHashVal);

  5385.     return arr.reduce((hashVal, item) => hash(item, hashVal), initialHashVal);

  5386. }

  5387. function objectHash(obj, initialHashVal) {

  5388.     initialHashVal = numberHash(181387, initialHashVal);

  5389.     return Object.keys(obj).sort().reduce((hashVal, key) => {

  5390.         hashVal = stringHash(key, hashVal);

  5391.         return hash(obj[key], hashVal);

  5392.     }, initialHashVal);

  5393. }

  5394. 

  5395. 

  5396. /***/ }),

  5397. /* 32 */

  5398. /***/ (function(module, exports) {

  5399. 

  5400. module.exports = require("coc.nvim");

  5401. 

  5402. /***/ })

  5403. /******/ ])));