[json] run serverless

extensions/css-language-features/client/src/node/cssClientMain.ts

@@ -12,12 +12,9 @@ import { TextDecoder } from 'util';
 // this method is called when vs code is activated
 export function activate(context: ExtensionContext) {
 
-	const clientMain = extensions.getExtension('vscode.css-language-features')?.packageJSON?.main;
-	const serverMain = clientMain?.replace('client', 'server').replace('cssClientMain', 'cssServerMain');
-	if (!serverMain) {
-		throw new Error('Unable to compute CSS server module path. Client: ' + clientMain);
-	}
+	const clientMain = extensions.getExtension('vscode.css-language-features')?.packageJSON?.main || '';
 
+	const serverMain = `./server/${clientMain.indexOf('/dist/') !== -1 ? 'dist' : 'out'}/node/cssServerMain`;
 	const serverModule = context.asAbsolutePath(serverMain);
 
 	// The debug options for the server

extensions/css-language-features/server/src/cssServer.ts

@@ -5,7 +5,7 @@
 
 import {
 	Connection, TextDocuments, InitializeParams, InitializeResult, ServerCapabilities, ConfigurationRequest, WorkspaceFolder, TextDocumentSyncKind, NotificationType
-} from 'vscode-languageserver/lib/common/api';
+} from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import { getCSSLanguageService, getSCSSLanguageService, getLESSLanguageService, LanguageSettings, LanguageService, Stylesheet, TextDocument, Position } from 'vscode-css-languageservice';
 import { getLanguageModelCache } from './languageModelCache';

extensions/json-language-features/.vscodeignore

@@ -12,7 +12,10 @@ server/bin/**
 server/build/**
 server/yarn.lock
 server/.npmignore
+polyfills/**
 yarn.lock
 CONTRIBUTING.md
 server/extension.webpack.config.js
-extension.webpack.config.js
\ No newline at end of file
+extension.webpack.config.js
+server/extension-browser.webpack.config.js
+extension-browser.webpack.config.js

extensions/json-language-features/client/src/browser/jsonClientMain.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ExtensionContext } from 'vscode';
+import { LanguageClientOptions } from 'vscode-languageclient';
+import { startClient, LanguageClientConstructor } from '../jsonClient';
+import { LanguageClient } from 'vscode-languageclient/browser';
+import { RequestService } from '../requests';
+
+declare const Worker: {
+	new(stringUrl: string): any;
+};
+
+declare function fetch(uri: string, options: any): any;
+
+// this method is called when vs code is activated
+export function activate(context: ExtensionContext) {
+	const serverMain = context.asAbsolutePath('server/dist/browser/jsonServerMain.js');
+	try {
+		const worker = new Worker(serverMain);
+		const newLanguageClient: LanguageClientConstructor = (id: string, name: string, clientOptions: LanguageClientOptions) => {
+			return new LanguageClient(id, name, clientOptions, worker);
+		};
+
+		const http: RequestService = {
+			getContent(uri: string) {
+				return fetch(uri, { mode: 'cors' })
+					.then(function (response: any) {
+						return response.text();
+					});
+			}
+		};
+		startClient(context, newLanguageClient, { http });
+
+	} catch (e) {
+		console.log(e);
+	}
+}

extensions/json-language-features/client/src/jsonMain.ts → extensions/json-language-features/client/src/jsonClient.ts

@@ -2,11 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-
-import * as path from 'path';
-import * as fs from 'fs';
 import * as nls from 'vscode-nls';
-import { xhr, XHRResponse, getErrorStatusDescription } from 'request-light';
 
 const localize = nls.loadMessageBundle();
 
@@ -16,13 +12,13 @@ import {
 	ProviderResult, TextEdit, Range, Position, Disposable, CompletionItem, CompletionList, CompletionContext, Hover, MarkdownString,
 } from 'vscode';
 import {
-	LanguageClient, LanguageClientOptions, RequestType, ServerOptions, TransportKind, NotificationType,
+	LanguageClientOptions, RequestType, NotificationType,
 	DidChangeConfigurationNotification, HandleDiagnosticsSignature, ResponseError, DocumentRangeFormattingParams,
-	DocumentRangeFormattingRequest, ProvideCompletionItemsSignature, ProvideHoverSignature
+	DocumentRangeFormattingRequest, ProvideCompletionItemsSignature, ProvideHoverSignature, CommonLanguageClient
 } from 'vscode-languageclient';
-import TelemetryReporter from 'vscode-extension-telemetry';
 
 import { hash } from './utils/hash';
+import { RequestService, joinPath } from './requests';
 
 namespace VSCodeContentRequest {
 	export const type: RequestType<string, string, any, any> = new RequestType('vscode/content');
@@ -53,13 +49,6 @@ namespace ResultLimitReachedNotification {
 	export const type: NotificationType<string, any> = new NotificationType('json/resultLimitReached');
 }
 
-interface IPackageInfo {
-	name: string;
-	version: string;
-	aiKey: string;
-	main: string;
-}
-
 interface Settings {
 	json?: {
 		schemas?: JSONSchemaSettings[];
@@ -84,29 +73,27 @@ namespace SettingIds {
 	export const maxItemsComputed = 'json.maxItemsComputed';
 }
 
-let telemetryReporter: TelemetryReporter | undefined;
-
-export function activate(context: ExtensionContext) {
+export interface TelemetryReporter {
+	sendTelemetryEvent(eventName: string, properties?: {
+		[key: string]: string;
+	}, measurements?: {
+		[key: string]: number;
+	}): void;
+}
 
-	const toDispose = context.subscriptions;
+export type LanguageClientConstructor = (name: string, description: string, clientOptions: LanguageClientOptions) => CommonLanguageClient;
 
-	let rangeFormatting: Disposable | undefined = undefined;
+export interface Runtime {
+	http: RequestService;
+	telemetry?: TelemetryReporter
+}
 
-	let clientPackageJSON = getPackageInfo(context);
-	telemetryReporter = new TelemetryReporter(clientPackageJSON.name, clientPackageJSON.version, clientPackageJSON.aiKey);
+export function startClient(context: ExtensionContext, newLanguageClient: LanguageClientConstructor, runtime: Runtime) {
 
-	const serverMain = `./server/${clientPackageJSON.main.indexOf('/dist/') !== -1 ? 'dist' : 'out'}/jsonServerMain`;
-	const serverModule = context.asAbsolutePath(serverMain);
+	const toDispose = context.subscriptions;
 
-	// The debug options for the server
-	const debugOptions = { execArgv: ['--nolazy', '--inspect=' + (9000 + Math.round(Math.random() * 10000))] };
+	let rangeFormatting: Disposable | undefined = undefined;
 
-	// If the extension is launch in debug mode the debug server options are use
-	// Otherwise the run options are used
-	const serverOptions: ServerOptions = {
-		run: { module: serverModule, transport: TransportKind.ipc },
-		debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions }
-	};
 
 	const documentSelector = ['json', 'jsonc'];
 
@@ -203,7 +190,7 @@ export function activate(context: ExtensionContext) {
 	};
 
 	// Create the language client and start the client.
-	const client = new LanguageClient('json', localize('jsonserver.name', 'JSON Language Server'), serverOptions, clientOptions);
+	const client = newLanguageClient('json', localize('jsonserver.name', 'JSON Language Server'), clientOptions);
 	client.registerProposedFeatures();
 
 	const disposable = client.start();
@@ -225,24 +212,15 @@ export function activate(context: ExtensionContext) {
 					return Promise.reject(new ResponseError(2, error.toString()));
 				});
 			} else if (schemaDownloadEnabled) {
-				if (telemetryReporter && uri.authority === 'schema.management.azure.com') {
+				if (runtime.telemetry && uri.authority === 'schema.management.azure.com') {
 					/* __GDPR__
 						"json.schema" : {
 							"schemaURL" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
 						}
 					 */
-					telemetryReporter.sendTelemetryEvent('json.schema', { schemaURL: uriPath });
+					runtime.telemetry.sendTelemetryEvent('json.schema', { schemaURL: uriPath });
 				}
-				const headers = { 'Accept-Encoding': 'gzip, deflate' };
-				return xhr({ url: uriPath, followRedirects: 5, headers }).then(response => {
-					return response.responseText;
-				}, (error: XHRResponse) => {
-					let extraInfo = error.responseText || error.toString();
-					if (extraInfo.length > 256) {
-						extraInfo = `${extraInfo.substr(0, 256)}...`;
-					}
-					return Promise.reject(new ResponseError(error.status, getErrorStatusDescription(error.status) + '\n' + extraInfo));
-				});
+				return runtime.http.getContent(uriPath);
 			} else {
 				return Promise.reject(new ResponseError(1, localize('schemaDownloadDisabled', 'Downloading schemas is disabled through setting \'{0}\'', SettingIds.enableSchemaDownload)));
 			}
@@ -340,7 +318,7 @@ export function activate(context: ExtensionContext) {
 						return client.sendRequest(DocumentRangeFormattingRequest.type, params, token).then(
 							client.protocol2CodeConverter.asTextEdits,
 							(error) => {
-								client.logFailedRequest(DocumentRangeFormattingRequest.type, error);
+								client.handleFailedRequest(DocumentRangeFormattingRequest.type, error, []);
 								return Promise.resolve([]);
 							}
 						);
@@ -375,12 +353,6 @@ export function activate(context: ExtensionContext) {
 
 }
 
-
-
-export function deactivate(): Promise<any> {
-	return telemetryReporter ? telemetryReporter.dispose() : Promise.resolve(null);
-}
-
 function getSchemaAssociations(_context: ExtensionContext): ISchemaAssociation[] {
 	const associations: ISchemaAssociation[] = [];
 	extensions.all.forEach(extension => {
@@ -393,9 +365,10 @@ function getSchemaAssociations(_context: ExtensionContext): ISchemaAssociation[]
 					if (typeof fileMatch === 'string') {
 						fileMatch = [fileMatch];
 					}
-					if (Array.isArray(fileMatch) && url) {
-						if (url[0] === '.' && url[1] === '/') {
-							url = Uri.file(path.join(extension.extensionPath, url)).toString();
+					if (Array.isArray(fileMatch) && typeof url === 'string') {
+						let uri: string = url;
+						if (uri[0] === '.' && uri[1] === '/') {
+							uri = joinPath(extension.extensionUri, uri).toString();
 						}
 						fileMatch = fileMatch.map(fm => {
 							if (fm[0] === '%') {
@@ -407,7 +380,7 @@ function getSchemaAssociations(_context: ExtensionContext): ISchemaAssociation[]
 							}
 							return fm;
 						});
-						associations.push({ fileMatch, uri: url });
+						associations.push({ fileMatch, uri });
 					}
 				});
 			}
@@ -509,28 +482,18 @@ function getSettings(): Settings {
 	return settings;
 }
 
-function getSchemaId(schema: JSONSchemaSettings, folderUri?: Uri) {
+function getSchemaId(schema: JSONSchemaSettings, folderUri?: Uri): string | undefined {
 	let url = schema.url;
 	if (!url) {
 		if (schema.schema) {
 			url = schema.schema.id || `vscode://schemas/custom/${encodeURIComponent(hash(schema.schema).toString(16))}`;
 		}
 	} else if (folderUri && (url[0] === '.' || url[0] === '/')) {
-		url = folderUri.with({ path: path.posix.join(folderUri.path, url) }).toString();
+		url = joinPath(folderUri, url).toString();
 	}
 	return url;
 }
 
-function getPackageInfo(context: ExtensionContext): IPackageInfo {
-	const location = context.asAbsolutePath('./package.json');
-	try {
-		return JSON.parse(fs.readFileSync(location).toString());
-	} catch (e) {
-		console.log(`Problems reading ${location}: ${e}`);
-		return { name: '', version: '', aiKey: '', main: '' };
-	}
-}
-
 function isThenable<T>(obj: ProviderResult<T>): obj is Thenable<T> {
 	return obj && (<any>obj)['then'];
 }

extensions/json-language-features/client/src/node/jsonClientMain.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ExtensionContext } from 'vscode';
+import { startClient, LanguageClientConstructor } from '../jsonClient';
+import { ServerOptions, TransportKind, LanguageClientOptions, LanguageClient } from 'vscode-languageclient/node';
+
+import * as fs from 'fs';
+import { xhr, XHRResponse, getErrorStatusDescription } from 'request-light';
+
+import TelemetryReporter from 'vscode-extension-telemetry';
+import { RequestService } from '../requests';
+
+let telemetry: TelemetryReporter | undefined;
+
+// this method is called when vs code is activated
+export function activate(context: ExtensionContext) {
+
+	const clientPackageJSON = getPackageInfo(context);
+	telemetry = new TelemetryReporter(clientPackageJSON.name, clientPackageJSON.version, clientPackageJSON.aiKey);
+
+	const serverMain = `./server/${clientPackageJSON.main.indexOf('/dist/') !== -1 ? 'dist' : 'out'}/node/jsonServerMain`;
+	const serverModule = context.asAbsolutePath(serverMain);
+
+	// The debug options for the server
+	const debugOptions = { execArgv: ['--nolazy', '--inspect=6044'] };
+
+	// If the extension is launch in debug mode the debug server options are use
+	// Otherwise the run options are used
+	const serverOptions: ServerOptions = {
+		run: { module: serverModule, transport: TransportKind.ipc },
+		debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions }
+	};
+
+	const newLanguageClient: LanguageClientConstructor = (id: string, name: string, clientOptions: LanguageClientOptions) => {
+		return new LanguageClient(id, name, serverOptions, clientOptions);
+	};
+
+	startClient(context, newLanguageClient, { http: getHTTPRequestService(), telemetry });
+}
+
+export function deactivate(): Promise<any> {
+	return telemetry ? telemetry.dispose() : Promise.resolve(null);
+}
+
+interface IPackageInfo {
+	name: string;
+	version: string;
+	aiKey: string;
+	main: string;
+}
+
+function getPackageInfo(context: ExtensionContext): IPackageInfo {
+	const location = context.asAbsolutePath('./package.json');
+	try {
+		return JSON.parse(fs.readFileSync(location).toString());
+	} catch (e) {
+		console.log(`Problems reading ${location}: ${e}`);
+		return { name: '', version: '', aiKey: '', main: '' };
+	}
+}
+
+function getHTTPRequestService(): RequestService {
+	return {
+		getContent(uri: string, _encoding?: string) {
+			const headers = { 'Accept-Encoding': 'gzip, deflate' };
+			return xhr({ url: uri, followRedirects: 5, headers }).then(response => {
+				return response.responseText;
+			}, (error: XHRResponse) => {
+				return Promise.reject(error.responseText || getErrorStatusDescription(error.status) || error.toString());
+			});
+		}
+	};
+}

extensions/json-language-features/client/src/requests.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Uri } from 'vscode';
+
+export interface RequestService {
+	getContent(uri: string, encoding?: string): Thenable<string>;
+}
+
+export function getScheme(uri: string) {
+	return uri.substr(0, uri.indexOf(':'));
+}
+
+export function dirname(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
+}
+
+export function basename(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return uri.substr(lastIndexOfSlash + 1);
+}
+
+const Slash = '/'.charCodeAt(0);
+const Dot = '.'.charCodeAt(0);
+
+export function isAbsolutePath(path: string) {
+	return path.charCodeAt(0) === Slash;
+}
+
+export function resolvePath(uri: Uri, path: string): Uri {
+	if (isAbsolutePath(path)) {
+		return uri.with({ path: normalizePath(path.split('/')) });
+	}
+	return joinPath(uri, path);
+}
+
+export function normalizePath(parts: string[]): string {
+	const newParts: string[] = [];
+	for (const part of parts) {
+		if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
+			// ignore
+		} else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
+			newParts.pop();
+		} else {
+			newParts.push(part);
+		}
+	}
+	if (parts.length > 1 && parts[parts.length - 1].length === 0) {
+		newParts.push('');
+	}
+	let res = newParts.join('/');
+	if (parts[0].length === 0) {
+		res = '/' + res;
+	}
+	return res;
+}
+
+
+export function joinPath(uri: Uri, ...paths: string[]): Uri {
+	const parts = uri.path.split('/');
+	for (let path of paths) {
+		parts.push(...path.split('/'));
+	}
+	return uri.with({ path: normalizePath(parts) });
+}

extensions/json-language-features/extension-browser.webpack.config.js

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//@ts-check
+
+'use strict';
+
+const withDefaults = require('../shared.webpack.config');
+const path = require('path');
+
+const clientConfig = withDefaults({
+	target: 'webworker',
+	context: path.join(__dirname, 'client'),
+	entry: {
+		extension: './src/browser/jsonClientMain.ts'
+	},
+	output: {
+		filename: 'jsonClientMain.js',
+		path: path.join(__dirname, 'client', 'dist', 'browser')
+	},
+	performance: {
+		hints: false
+	},
+	resolve: {
+		alias: {
+			'vscode-nls': path.resolve(__dirname, 'polyfills/vscode-nls.js')
+		}
+	}
+});
+clientConfig.module.rules[0].use.shift(); // remove nls loader
+
+module.exports = clientConfig;

extensions/json-language-features/package.json

@@ -14,7 +14,8 @@
         "onLanguage:json",
         "onLanguage:jsonc"
     ],
-    "main": "./client/out/jsonMain",
+    "main": "./client/out/node/jsonClientMain",
+    "browser": "./client/dist/browser/jsonClientMain",
     "enableProposedApi": true,
     "scripts": {
         "compile": "gulp compile-extension:json-language-features-client compile-extension:json-language-features-server",
@@ -128,7 +129,7 @@
     "dependencies": {
         "request-light": "^0.3.0",
         "vscode-extension-telemetry": "0.1.1",
-        "vscode-languageclient": "^6.1.3",
+        "vscode-languageclient": "7.0.0-next.5",
         "vscode-nls": "^4.1.2"
     },
     "devDependencies": {

extensions/json-language-features/polyfills/vscode-nls.js

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+
+function format(message, args) {
+	let result;
+	// if (isPseudo) {
+	// 	// FF3B and FF3D is the Unicode zenkaku representation for [ and ]
+	// 	message = '\uFF3B' + message.replace(/[aouei]/g, '$&$&') + '\uFF3D';
+	// }
+	if (args.length === 0) {
+		result = message;
+	}
+	else {
+		result = message.replace(/\{(\d+)\}/g, function (match, rest) {
+			let index = rest[0];
+			let arg = args[index];
+			let replacement = match;
+			if (typeof arg === 'string') {
+				replacement = arg;
+			}
+			else if (typeof arg === 'number' || typeof arg === 'boolean' || arg === void 0 || arg === null) {
+				replacement = String(arg);
+			}
+			return replacement;
+		});
+	}
+	return result;
+}
+
+function localize(key, message) {
+	let args = [];
+	for (let _i = 2; _i < arguments.length; _i++) {
+		args[_i - 2] = arguments[_i];
+	}
+	return format(message, args);
+}
+
+function loadMessageBundle(file) {
+	return localize;
+}
+
+let MessageFormat;
+(function (MessageFormat) {
+	MessageFormat["file"] = "file";
+	MessageFormat["bundle"] = "bundle";
+	MessageFormat["both"] = "both";
+})(MessageFormat = exports.MessageFormat || (exports.MessageFormat = {}));
+let BundleFormat;
+(function (BundleFormat) {
+	// the nls.bundle format
+	BundleFormat["standalone"] = "standalone";
+	BundleFormat["languagePack"] = "languagePack";
+})(BundleFormat = exports.BundleFormat || (exports.BundleFormat = {}));
+
+exports.loadMessageBundle = loadMessageBundle;
+function config(opts) {
+	if (opts) {
+		if (isString(opts.locale)) {
+			options.locale = opts.locale.toLowerCase();
+			options.language = options.locale;
+			resolvedLanguage = undefined;
+			resolvedBundles = Object.create(null);
+		}
+		if (opts.messageFormat !== undefined) {
+			options.messageFormat = opts.messageFormat;
+		}
+		if (opts.bundleFormat === BundleFormat.standalone && options.languagePackSupport === true) {
+			options.languagePackSupport = false;
+		}
+	}
+	isPseudo = options.locale === 'pseudo';
+	return loadMessageBundle;
+}
+exports.config = config;

extensions/json-language-features/server/extension-browser.webpack.config.js

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//@ts-check
+
+'use strict';
+
+const withDefaults = require('../../shared.webpack.config');
+const path = require('path');
+
+const serverConfig = withDefaults({
+	target: 'webworker',
+	context: __dirname,
+	entry: {
+		extension: './src/browser/jsonServerMain.ts',
+	},
+	output: {
+		filename: 'jsonServerMain.js',
+		path: path.join(__dirname, 'dist', 'browser'),
+		libraryTarget: 'var'
+	},
+	performance: {
+		hints: false
+	},
+	resolve: {
+		alias: {
+			'vscode-nls': path.resolve(__dirname, '../polyfills/vscode-nls.js')
+		}
+	}
+});
+serverConfig.module.rules[0].use.shift(); // remove nls loader
+
+module.exports = serverConfig;

extensions/json-language-features/server/package.json

@@ -15,7 +15,7 @@
     "jsonc-parser": "^2.2.1",
     "request-light": "^0.3.0",
     "vscode-json-languageservice": "^3.7.0",
-    "vscode-languageserver": "^6.1.1",
+    "vscode-languageserver": "7.0.0-next.3",
     "vscode-uri": "^2.1.2"
   },
   "devDependencies": {

extensions/json-language-features/server/src/browser/jsonServerMain.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createConnection, BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageserver/browser';
+import { startServer } from '../jsonServer';
+
+declare let self: any;
+
+const messageReader = new BrowserMessageReader(self);
+const messageWriter = new BrowserMessageWriter(self);
+
+const connection = createConnection(messageReader, messageWriter);
+
+startServer(connection, {});

extensions/json-language-features/server/src/jsonServer.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import {
+	Connection,
+	TextDocuments, InitializeParams, InitializeResult, NotificationType, RequestType,
+	DocumentRangeFormattingRequest, Disposable, ServerCapabilities, TextDocumentSyncKind, TextEdit
+} from 'vscode-languageserver';
+
+import { formatError, runSafe, runSafeAsync } from './utils/runner';
+import { TextDocument, JSONDocument, JSONSchema, getLanguageService, DocumentLanguageSettings, SchemaConfiguration, ClientCapabilities, Diagnostic, Range, Position } from 'vscode-json-languageservice';
+import { getLanguageModelCache } from './languageModelCache';
+import { RequestService, basename, resolvePath } from './requests';
+
+interface ISchemaAssociations {
+	[pattern: string]: string[];
+}
+
+interface ISchemaAssociation {
+	fileMatch: string[];
+	uri: string;
+}
+
+namespace SchemaAssociationNotification {
+	export const type: NotificationType<ISchemaAssociations | ISchemaAssociation[], any> = new NotificationType('json/schemaAssociations');
+}
+
+namespace VSCodeContentRequest {
+	export const type: RequestType<string, string, any, any> = new RequestType('vscode/content');
+}
+
+namespace SchemaContentChangeNotification {
+	export const type: NotificationType<string, any> = new NotificationType('json/schemaContent');
+}
+
+namespace ResultLimitReachedNotification {
+	export const type: NotificationType<string, any> = new NotificationType('json/resultLimitReached');
+}
+
+namespace ForceValidateRequest {
+	export const type: RequestType<string, Diagnostic[], any, any> = new RequestType('json/validate');
+}
+
+
+const workspaceContext = {
+	resolveRelativePath: (relativePath: string, resource: string) => {
+		const base = resource.substr(0, resource.lastIndexOf('/') + 1);
+		return resolvePath(base, relativePath);
+	}
+};
+
+export interface RuntimeEnvironment {
+	file?: RequestService;
+	http?: RequestService
+	configureHttpRequests?(proxy: string, strictSSL: boolean): void;
+}
+
+export function startServer(connection: Connection, runtime: RuntimeEnvironment) {
+
+	function getSchemaRequestService(handledSchemas: string[] = ['https', 'http', 'file']) {
+		const builtInHandlers: { [protocol: string]: RequestService | undefined } = {};
+		for (let protocol of handledSchemas) {
+			if (protocol === 'file') {
+				builtInHandlers[protocol] = runtime.file;
+			} else if (protocol === 'http' || protocol === 'https') {
+				builtInHandlers[protocol] = runtime.http;
+			}
+		}
+		return (uri: string): Thenable<string> => {
+			const protocol = uri.substr(0, uri.indexOf(':'));
+
+			const builtInHandler = builtInHandlers[protocol];
+			if (builtInHandler) {
+				return builtInHandler.getContent(uri);
+			}
+			return connection.sendRequest(VSCodeContentRequest.type, uri).then(responseText => {
+				return responseText;
+			}, error => {
+				return Promise.reject(error.message);
+			});
+		};
+	}
+
+	// create the JSON language service
+	let languageService = getLanguageService({
+		workspaceContext,
+		contributions: [],
+		clientCapabilities: ClientCapabilities.LATEST
+	});
+
+	// Create a text document manager.
+	const documents = new TextDocuments(TextDocument);
+
+	// Make the text document manager listen on the connection
+	// for open, change and close text document events
+	documents.listen(connection);
+
+	let clientSnippetSupport = false;
+	let dynamicFormatterRegistration = false;
+	let hierarchicalDocumentSymbolSupport = false;
+
+	let foldingRangeLimitDefault = Number.MAX_VALUE;
+	let foldingRangeLimit = Number.MAX_VALUE;
+	let resultLimit = Number.MAX_VALUE;
+	let formatterMaxNumberOfEdits = Number.MAX_VALUE;
+
+	// After the server has started the client sends an initialize request. The server receives
+	// in the passed params the rootPath of the workspace plus the client capabilities.
+	connection.onInitialize((params: InitializeParams): InitializeResult => {
+
+		const handledProtocols = params.initializationOptions?.handledSchemaProtocols;
+
+		languageService = getLanguageService({
+			schemaRequestService: getSchemaRequestService(handledProtocols),
+			workspaceContext,
+			contributions: [],
+			clientCapabilities: params.capabilities
+		});
+
+		function getClientCapability<T>(name: string, def: T) {
+			const keys = name.split('.');
+			let c: any = params.capabilities;
+			for (let i = 0; c && i < keys.length; i++) {
+				if (!c.hasOwnProperty(keys[i])) {
+					return def;
+				}
+				c = c[keys[i]];
+			}
+			return c;
+		}
+
+		clientSnippetSupport = getClientCapability('textDocument.completion.completionItem.snippetSupport', false);
+		dynamicFormatterRegistration = getClientCapability('textDocument.rangeFormatting.dynamicRegistration', false) && (typeof params.initializationOptions?.provideFormatter !== 'boolean');
+		foldingRangeLimitDefault = getClientCapability('textDocument.foldingRange.rangeLimit', Number.MAX_VALUE);
+		hierarchicalDocumentSymbolSupport = getClientCapability('textDocument.documentSymbol.hierarchicalDocumentSymbolSupport', false);
+		formatterMaxNumberOfEdits = params.initializationOptions?.customCapabilities?.rangeFormatting?.editLimit || Number.MAX_VALUE;
+		const capabilities: ServerCapabilities = {
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			completionProvider: clientSnippetSupport ? {
+				resolveProvider: false, // turn off resolving as the current language service doesn't do anything on resolve. Also fixes #91747
+				triggerCharacters: ['"', ':']
+			} : undefined,
+			hoverProvider: true,
+			documentSymbolProvider: true,
+			documentRangeFormattingProvider: params.initializationOptions.provideFormatter === true,
+			colorProvider: {},
+			foldingRangeProvider: true,
+			selectionRangeProvider: true,
+			definitionProvider: true
+		};
+
+		return { capabilities };
+	});
+
+
+
+	// The settings interface describes the server relevant settings part
+	interface Settings {
+		json: {
+			schemas: JSONSchemaSettings[];
+			format: { enable: boolean; };
+			resultLimit?: number;
+		};
+		http: {
+			proxy: string;
+			proxyStrictSSL: boolean;
+		};
+	}
+
+	interface JSONSchemaSettings {
+		fileMatch?: string[];
+		url?: string;
+		schema?: JSONSchema;
+	}
+
+
+	const limitExceededWarnings = function () {
+		const pendingWarnings: { [uri: string]: { features: { [name: string]: string }; timeout?: NodeJS.Timeout; } } = {};
+
+		return {
+			cancel(uri: string) {
+				const warning = pendingWarnings[uri];
+				if (warning && warning.timeout) {
+					clearTimeout(warning.timeout);
+					delete pendingWarnings[uri];
+				}
+			},
+
+			onResultLimitExceeded(uri: string, resultLimit: number, name: string) {
+				return () => {
+					let warning = pendingWarnings[uri];
+					if (warning) {
+						if (!warning.timeout) {
+							// already shown
+							return;
+						}
+						warning.features[name] = name;
+						warning.timeout.refresh();
+					} else {
+						warning = { features: { [name]: name } };
+						warning.timeout = setTimeout(() => {
+							connection.sendNotification(ResultLimitReachedNotification.type, `${basename(uri)}: For performance reasons, ${Object.keys(warning.features).join(' and ')} have been limited to ${resultLimit} items.`);
+							warning.timeout = undefined;
+						}, 2000);
+						pendingWarnings[uri] = warning;
+					}
+				};
+			}
+		};
+	}();
+
+	let jsonConfigurationSettings: JSONSchemaSettings[] | undefined = undefined;
+	let schemaAssociations: ISchemaAssociations | ISchemaAssociation[] | undefined = undefined;
+	let formatterRegistration: Thenable<Disposable> | null = null;
+
+	// The settings have changed. Is send on server activation as well.
+	connection.onDidChangeConfiguration((change) => {
+		let settings = <Settings>change.settings;
+		if (runtime.configureHttpRequests) {
+			runtime.configureHttpRequests(settings.http && settings.http.proxy, settings.http && settings.http.proxyStrictSSL);
+		}
+		jsonConfigurationSettings = settings.json && settings.json.schemas;
+		updateConfiguration();
+
+		foldingRangeLimit = Math.trunc(Math.max(settings.json && settings.json.resultLimit || foldingRangeLimitDefault, 0));
+		resultLimit = Math.trunc(Math.max(settings.json && settings.json.resultLimit || Number.MAX_VALUE, 0));
+
+		// dynamically enable & disable the formatter
+		if (dynamicFormatterRegistration) {
+			const enableFormatter = settings && settings.json && settings.json.format && settings.json.format.enable;
+			if (enableFormatter) {
+				if (!formatterRegistration) {
+					formatterRegistration = connection.client.register(DocumentRangeFormattingRequest.type, { documentSelector: [{ language: 'json' }, { language: 'jsonc' }] });
+				}
+			} else if (formatterRegistration) {
+				formatterRegistration.then(r => r.dispose());
+				formatterRegistration = null;
+			}
+		}
+	});
+
+	// The jsonValidation extension configuration has changed
+	connection.onNotification(SchemaAssociationNotification.type, associations => {
+		schemaAssociations = associations;
+		updateConfiguration();
+	});
+
+	// A schema has changed
+	connection.onNotification(SchemaContentChangeNotification.type, uri => {
+		languageService.resetSchema(uri);
+	});
+
+	// Retry schema validation on all open documents
+	connection.onRequest(ForceValidateRequest.type, uri => {
+		return new Promise<Diagnostic[]>(resolve => {
+			const document = documents.get(uri);
+			if (document) {
+				updateConfiguration();
+				validateTextDocument(document, diagnostics => {
+					resolve(diagnostics);
+				});
+			} else {
+				resolve([]);
+			}
+		});
+	});
+
+	function updateConfiguration() {
+		const languageSettings = {
+			validate: true,
+			allowComments: true,
+			schemas: new Array<SchemaConfiguration>()
+		};
+		if (schemaAssociations) {
+			if (Array.isArray(schemaAssociations)) {
+				Array.prototype.push.apply(languageSettings.schemas, schemaAssociations);
+			} else {
+				for (const pattern in schemaAssociations) {
+					const association = schemaAssociations[pattern];
+					if (Array.isArray(association)) {
+						association.forEach(uri => {
+							languageSettings.schemas.push({ uri, fileMatch: [pattern] });
+						});
+					}
+				}
+			}
+		}
+		if (jsonConfigurationSettings) {
+			jsonConfigurationSettings.forEach((schema, index) => {
+				let uri = schema.url;
+				if (!uri && schema.schema) {
+					uri = schema.schema.id || `vscode://schemas/custom/${index}`;
+				}
+				if (uri) {
+					languageSettings.schemas.push({ uri, fileMatch: schema.fileMatch, schema: schema.schema });
+				}
+			});
+		}
+		languageService.configure(languageSettings);
+
+		// Revalidate any open text documents
+		documents.all().forEach(triggerValidation);
+	}
+
+	// The content of a text document has changed. This event is emitted
+	// when the text document first opened or when its content has changed.
+	documents.onDidChangeContent((change) => {
+		limitExceededWarnings.cancel(change.document.uri);
+		triggerValidation(change.document);
+	});
+
+	// a document has closed: clear all diagnostics
+	documents.onDidClose(event => {
+		limitExceededWarnings.cancel(event.document.uri);
+		cleanPendingValidation(event.document);
+		connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+	});
+
+	const pendingValidationRequests: { [uri: string]: NodeJS.Timer; } = {};
+	const validationDelayMs = 300;
+
+	function cleanPendingValidation(textDocument: TextDocument): void {
+		const request = pendingValidationRequests[textDocument.uri];
+		if (request) {
+			clearTimeout(request);
+			delete pendingValidationRequests[textDocument.uri];
+		}
+	}
+
+	function triggerValidation(textDocument: TextDocument): void {
+		cleanPendingValidation(textDocument);
+		pendingValidationRequests[textDocument.uri] = setTimeout(() => {
+			delete pendingValidationRequests[textDocument.uri];
+			validateTextDocument(textDocument);
+		}, validationDelayMs);
+	}
+
+	function validateTextDocument(textDocument: TextDocument, callback?: (diagnostics: Diagnostic[]) => void): void {
+		const respond = (diagnostics: Diagnostic[]) => {
+			connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+			if (callback) {
+				callback(diagnostics);
+			}
+		};
+		if (textDocument.getText().length === 0) {
+			respond([]); // ignore empty documents
+			return;
+		}
+		const jsonDocument = getJSONDocument(textDocument);
+		const version = textDocument.version;
+
+		const documentSettings: DocumentLanguageSettings = textDocument.languageId === 'jsonc' ? { comments: 'ignore', trailingCommas: 'warning' } : { comments: 'error', trailingCommas: 'error' };
+		languageService.doValidation(textDocument, jsonDocument, documentSettings).then(diagnostics => {
+			setImmediate(() => {
+				const currDocument = documents.get(textDocument.uri);
+				if (currDocument && currDocument.version === version) {
+					respond(diagnostics); // Send the computed diagnostics to VSCode.
+				}
+			});
+		}, error => {
+			connection.console.error(formatError(`Error while validating ${textDocument.uri}`, error));
+		});
+	}
+
+	connection.onDidChangeWatchedFiles((change) => {
+		// Monitored files have changed in VSCode
+		let hasChanges = false;
+		change.changes.forEach(c => {
+			if (languageService.resetSchema(c.uri)) {
+				hasChanges = true;
+			}
+		});
+		if (hasChanges) {
+			documents.all().forEach(triggerValidation);
+		}
+	});
+
+	const jsonDocuments = getLanguageModelCache<JSONDocument>(10, 60, document => languageService.parseJSONDocument(document));
+	documents.onDidClose(e => {
+		jsonDocuments.onDocumentRemoved(e.document);
+	});
+	connection.onShutdown(() => {
+		jsonDocuments.dispose();
+	});
+
+	function getJSONDocument(document: TextDocument): JSONDocument {
+		return jsonDocuments.get(document);
+	}
+
+	connection.onCompletion((textDocumentPosition, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(textDocumentPosition.textDocument.uri);
+			if (document) {
+				const jsonDocument = getJSONDocument(document);
+				return languageService.doComplete(document, textDocumentPosition.position, jsonDocument);
+			}
+			return null;
+		}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
+	});
+
+	connection.onHover((textDocumentPositionParams, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(textDocumentPositionParams.textDocument.uri);
+			if (document) {
+				const jsonDocument = getJSONDocument(document);
+				return languageService.doHover(document, textDocumentPositionParams.position, jsonDocument);
+			}
+			return null;
+		}, null, `Error while computing hover for ${textDocumentPositionParams.textDocument.uri}`, token);
+	});
+
+	connection.onDocumentSymbol((documentSymbolParams, token) => {
+		return runSafe(() => {
+			const document = documents.get(documentSymbolParams.textDocument.uri);
+			if (document) {
+				const jsonDocument = getJSONDocument(document);
+				const onResultLimitExceeded = limitExceededWarnings.onResultLimitExceeded(document.uri, resultLimit, 'document symbols');
+				if (hierarchicalDocumentSymbolSupport) {
+					return languageService.findDocumentSymbols2(document, jsonDocument, { resultLimit, onResultLimitExceeded });
+				} else {
+					return languageService.findDocumentSymbols(document, jsonDocument, { resultLimit, onResultLimitExceeded });
+				}
+			}
+			return [];
+		}, [], `Error while computing document symbols for ${documentSymbolParams.textDocument.uri}`, token);
+	});
+
+	connection.onDocumentRangeFormatting((formatParams, token) => {
+		return runSafe(() => {
+			const document = documents.get(formatParams.textDocument.uri);
+			if (document) {
+				const edits = languageService.format(document, formatParams.range, formatParams.options);
+				if (edits.length > formatterMaxNumberOfEdits) {
+					const newText = TextDocument.applyEdits(document, edits);
+					return [TextEdit.replace(Range.create(Position.create(0, 0), document.positionAt(document.getText().length)), newText)];
+				}
+				return edits;
+			}
+			return [];
+		}, [], `Error while formatting range for ${formatParams.textDocument.uri}`, token);
+	});
+
+	connection.onDocumentColor((params, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(params.textDocument.uri);
+			if (document) {
+				const onResultLimitExceeded = limitExceededWarnings.onResultLimitExceeded(document.uri, resultLimit, 'document colors');
+				const jsonDocument = getJSONDocument(document);
+				return languageService.findDocumentColors(document, jsonDocument, { resultLimit, onResultLimitExceeded });
+			}
+			return [];
+		}, [], `Error while computing document colors for ${params.textDocument.uri}`, token);
+	});
+
+	connection.onColorPresentation((params, token) => {
+		return runSafe(() => {
+			const document = documents.get(params.textDocument.uri);
+			if (document) {
+				const jsonDocument = getJSONDocument(document);
+				return languageService.getColorPresentations(document, jsonDocument, params.color, params.range);
+			}
+			return [];
+		}, [], `Error while computing color presentations for ${params.textDocument.uri}`, token);
+	});
+
+	connection.onFoldingRanges((params, token) => {
+		return runSafe(() => {
+			const document = documents.get(params.textDocument.uri);
+			if (document) {
+				const onRangeLimitExceeded = limitExceededWarnings.onResultLimitExceeded(document.uri, foldingRangeLimit, 'folding ranges');
+				return languageService.getFoldingRanges(document, { rangeLimit: foldingRangeLimit, onRangeLimitExceeded });
+			}
+			return null;
+		}, null, `Error while computing folding ranges for ${params.textDocument.uri}`, token);
+	});
+
+
+	connection.onSelectionRanges((params, token) => {
+		return runSafe(() => {
+			const document = documents.get(params.textDocument.uri);
+			if (document) {
+				const jsonDocument = getJSONDocument(document);
+				return languageService.getSelectionRanges(document, params.positions, jsonDocument);
+			}
+			return [];
+		}, [], `Error while computing selection ranges for ${params.textDocument.uri}`, token);
+	});
+
+	connection.onDefinition((params, token) => {
+		return runSafeAsync(async () => {
+			const document = documents.get(params.textDocument.uri);
+			if (document) {
+				const jsonDocument = getJSONDocument(document);
+				return languageService.findDefinition(document, params.position, jsonDocument);
+			}
+			return [];
+		}, [], `Error while computing definitions for ${params.textDocument.uri}`, token);
+	});
+
+	// Listen on the connection
+	connection.listen();
+}

extensions/json-language-features/server/src/jsonServerMain.ts

-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import {
-	createConnection, IConnection,
-	TextDocuments, InitializeParams, InitializeResult, NotificationType, RequestType,
-	DocumentRangeFormattingRequest, Disposable, ServerCapabilities, TextDocumentSyncKind, TextEdit
-} from 'vscode-languageserver';
-
-import { xhr, XHRResponse, configure as configureHttpRequests, getErrorStatusDescription } from 'request-light';
-import * as fs from 'fs';
-import { URI } from 'vscode-uri';
-import * as URL from 'url';
-import { posix } from 'path';
-import { setTimeout, clearTimeout } from 'timers';
-import { formatError, runSafe, runSafeAsync } from './utils/runner';
-import { TextDocument, JSONDocument, JSONSchema, getLanguageService, DocumentLanguageSettings, SchemaConfiguration, ClientCapabilities, SchemaRequestService, Diagnostic, Range, Position } from 'vscode-json-languageservice';
-import { getLanguageModelCache } from './languageModelCache';
-
-interface ISchemaAssociations {
-	[pattern: string]: string[];
-}
-
-interface ISchemaAssociation {
-	fileMatch: string[];
-	uri: string;
-}
-
-namespace SchemaAssociationNotification {
-	export const type: NotificationType<ISchemaAssociations | ISchemaAssociation[], any> = new NotificationType('json/schemaAssociations');
-}
-
-namespace VSCodeContentRequest {
-	export const type: RequestType<string, string, any, any> = new RequestType('vscode/content');
-}
-
-namespace SchemaContentChangeNotification {
-	export const type: NotificationType<string, any> = new NotificationType('json/schemaContent');
-}
-
-namespace ResultLimitReachedNotification {
-	export const type: NotificationType<string, any> = new NotificationType('json/resultLimitReached');
-}
-
-namespace ForceValidateRequest {
-	export const type: RequestType<string, Diagnostic[], any, any> = new RequestType('json/validate');
-}
-
-// Create a connection for the server
-const connection: IConnection = createConnection();
-
-process.on('unhandledRejection', (e: any) => {
-	console.error(formatError(`Unhandled exception`, e));
-});
-process.on('uncaughtException', (e: any) => {
-	console.error(formatError(`Unhandled exception`, e));
-});
-
-
-console.log = connection.console.log.bind(connection.console);
-console.error = connection.console.error.bind(connection.console);
-
-const workspaceContext = {
-	resolveRelativePath: (relativePath: string, resource: string) => {
-		return URL.resolve(resource, relativePath);
-	}
-};
-
-const fileRequestService: SchemaRequestService = (uri: string) => {
-	const fsPath = URI.parse(uri).fsPath;
-	return new Promise<string>((c, e) => {
-		fs.readFile(fsPath, 'UTF-8', (err, result) => {
-			err ? e(err.message || err.toString()) : c(result.toString());
-		});
-	});
-};
-
-const httpRequestService: SchemaRequestService = (uri: string) => {
-	const headers = { 'Accept-Encoding': 'gzip, deflate' };
-	return xhr({ url: uri, followRedirects: 5, headers }).then(response => {
-		return response.responseText;
-	}, (error: XHRResponse) => {
-		return Promise.reject(error.responseText || getErrorStatusDescription(error.status) || error.toString());
-	});
-};
-
-function getSchemaRequestService(handledSchemas: string[] = ['https', 'http', 'file']) {
-	const builtInHandlers: { [protocol: string]: SchemaRequestService } = {};
-	for (let protocol of handledSchemas) {
-		if (protocol === 'file') {
-			builtInHandlers[protocol] = fileRequestService;
-		} else if (protocol === 'http' || protocol === 'https') {
-			builtInHandlers[protocol] = httpRequestService;
-		}
-	}
-	return (uri: string): Thenable<string> => {
-		const protocol = uri.substr(0, uri.indexOf(':'));
-
-		const builtInHandler = builtInHandlers[protocol];
-		if (builtInHandler) {
-			return builtInHandler(uri);
-		}
-		return connection.sendRequest(VSCodeContentRequest.type, uri).then(responseText => {
-			return responseText;
-		}, error => {
-			return Promise.reject(error.message);
-		});
-	};
-}
-
-// create the JSON language service
-let languageService = getLanguageService({
-	workspaceContext,
-	contributions: [],
-	clientCapabilities: ClientCapabilities.LATEST
-});
-
-// Create a text document manager.
-const documents = new TextDocuments(TextDocument);
-
-// Make the text document manager listen on the connection
-// for open, change and close text document events
-documents.listen(connection);
-
-let clientSnippetSupport = false;
-let dynamicFormatterRegistration = false;
-let hierarchicalDocumentSymbolSupport = false;
-
-let foldingRangeLimitDefault = Number.MAX_VALUE;
-let foldingRangeLimit = Number.MAX_VALUE;
-let resultLimit = Number.MAX_VALUE;
-let formatterMaxNumberOfEdits = Number.MAX_VALUE;
-
-// After the server has started the client sends an initialize request. The server receives
-// in the passed params the rootPath of the workspace plus the client capabilities.
-connection.onInitialize((params: InitializeParams): InitializeResult => {
-
-	const handledProtocols = params.initializationOptions?.handledSchemaProtocols;
-
-	languageService = getLanguageService({
-		schemaRequestService: getSchemaRequestService(handledProtocols),
-		workspaceContext,
-		contributions: [],
-		clientCapabilities: params.capabilities
-	});
-
-	function getClientCapability<T>(name: string, def: T) {
-		const keys = name.split('.');
-		let c: any = params.capabilities;
-		for (let i = 0; c && i < keys.length; i++) {
-			if (!c.hasOwnProperty(keys[i])) {
-				return def;
-			}
-			c = c[keys[i]];
-		}
-		return c;
-	}
-
-	clientSnippetSupport = getClientCapability('textDocument.completion.completionItem.snippetSupport', false);
-	dynamicFormatterRegistration = getClientCapability('textDocument.rangeFormatting.dynamicRegistration', false) && (typeof params.initializationOptions?.provideFormatter !== 'boolean');
-	foldingRangeLimitDefault = getClientCapability('textDocument.foldingRange.rangeLimit', Number.MAX_VALUE);
-	hierarchicalDocumentSymbolSupport = getClientCapability('textDocument.documentSymbol.hierarchicalDocumentSymbolSupport', false);
-	formatterMaxNumberOfEdits = params.initializationOptions?.customCapabilities?.rangeFormatting?.editLimit || Number.MAX_VALUE;
-	const capabilities: ServerCapabilities = {
-		textDocumentSync: TextDocumentSyncKind.Incremental,
-		completionProvider: clientSnippetSupport ? {
-			resolveProvider: false, // turn off resolving as the current language service doesn't do anything on resolve. Also fixes #91747
-			triggerCharacters: ['"', ':']
-		} : undefined,
-		hoverProvider: true,
-		documentSymbolProvider: true,
-		documentRangeFormattingProvider: params.initializationOptions.provideFormatter === true,
-		colorProvider: {},
-		foldingRangeProvider: true,
-		selectionRangeProvider: true,
-		definitionProvider: true
-	};
-
-	return { capabilities };
-});
-
-
-
-// The settings interface describes the server relevant settings part
-interface Settings {
-	json: {
-		schemas: JSONSchemaSettings[];
-		format: { enable: boolean; };
-		resultLimit?: number;
-	};
-	http: {
-		proxy: string;
-		proxyStrictSSL: boolean;
-	};
-}
-
-interface JSONSchemaSettings {
-	fileMatch?: string[];
-	url?: string;
-	schema?: JSONSchema;
-}
-
-namespace LimitExceededWarnings {
-	const pendingWarnings: { [uri: string]: { features: { [name: string]: string }; timeout?: NodeJS.Timeout; } } = {};
-
-	export function cancel(uri: string) {
-		const warning = pendingWarnings[uri];
-		if (warning && warning.timeout) {
-			clearTimeout(warning.timeout);
-			delete pendingWarnings[uri];
-		}
-	}
-
-	export function onResultLimitExceeded(uri: string, resultLimit: number, name: string) {
-		return () => {
-			let warning = pendingWarnings[uri];
-			if (warning) {
-				if (!warning.timeout) {
-					// already shown
-					return;
-				}
-				warning.features[name] = name;
-				warning.timeout.refresh();
-			} else {
-				warning = { features: { [name]: name } };
-				warning.timeout = setTimeout(() => {
-					connection.sendNotification(ResultLimitReachedNotification.type, `${posix.basename(uri)}: For performance reasons, ${Object.keys(warning.features).join(' and ')} have been limited to ${resultLimit} items.`);
-					warning.timeout = undefined;
-				}, 2000);
-				pendingWarnings[uri] = warning;
-			}
-		};
-	}
-}
-
-let jsonConfigurationSettings: JSONSchemaSettings[] | undefined = undefined;
-let schemaAssociations: ISchemaAssociations | ISchemaAssociation[] | undefined = undefined;
-let formatterRegistration: Thenable<Disposable> | null = null;
-
-// The settings have changed. Is send on server activation as well.
-connection.onDidChangeConfiguration((change) => {
-	let settings = <Settings>change.settings;
-	configureHttpRequests(settings.http && settings.http.proxy, settings.http && settings.http.proxyStrictSSL);
-
-	jsonConfigurationSettings = settings.json && settings.json.schemas;
-	updateConfiguration();
-
-	foldingRangeLimit = Math.trunc(Math.max(settings.json && settings.json.resultLimit || foldingRangeLimitDefault, 0));
-	resultLimit = Math.trunc(Math.max(settings.json && settings.json.resultLimit || Number.MAX_VALUE, 0));
-
-	// dynamically enable & disable the formatter
-	if (dynamicFormatterRegistration) {
-		const enableFormatter = settings && settings.json && settings.json.format && settings.json.format.enable;
-		if (enableFormatter) {
-			if (!formatterRegistration) {
-				formatterRegistration = connection.client.register(DocumentRangeFormattingRequest.type, { documentSelector: [{ language: 'json' }, { language: 'jsonc' }] });
-			}
-		} else if (formatterRegistration) {
-			formatterRegistration.then(r => r.dispose());
-			formatterRegistration = null;
-		}
-	}
-});
-
-// The jsonValidation extension configuration has changed
-connection.onNotification(SchemaAssociationNotification.type, associations => {
-	schemaAssociations = associations;
-	updateConfiguration();
-});
-
-// A schema has changed
-connection.onNotification(SchemaContentChangeNotification.type, uri => {
-	languageService.resetSchema(uri);
-});
-
-// Retry schema validation on all open documents
-connection.onRequest(ForceValidateRequest.type, uri => {
-	return new Promise<Diagnostic[]>(resolve => {
-		const document = documents.get(uri);
-		if (document) {
-			updateConfiguration();
-			validateTextDocument(document, diagnostics => {
-				resolve(diagnostics);
-			});
-		} else {
-			resolve([]);
-		}
-	});
-});
-
-function updateConfiguration() {
-	const languageSettings = {
-		validate: true,
-		allowComments: true,
-		schemas: new Array<SchemaConfiguration>()
-	};
-	if (schemaAssociations) {
-		if (Array.isArray(schemaAssociations)) {
-			Array.prototype.push.apply(languageSettings.schemas, schemaAssociations);
-		} else {
-			for (const pattern in schemaAssociations) {
-				const association = schemaAssociations[pattern];
-				if (Array.isArray(association)) {
-					association.forEach(uri => {
-						languageSettings.schemas.push({ uri, fileMatch: [pattern] });
-					});
-				}
-			}
-		}
-	}
-	if (jsonConfigurationSettings) {
-		jsonConfigurationSettings.forEach((schema, index) => {
-			let uri = schema.url;
-			if (!uri && schema.schema) {
-				uri = schema.schema.id || `vscode://schemas/custom/${index}`;
-			}
-			if (uri) {
-				languageSettings.schemas.push({ uri, fileMatch: schema.fileMatch, schema: schema.schema });
-			}
-		});
-	}
-	languageService.configure(languageSettings);
-
-	// Revalidate any open text documents
-	documents.all().forEach(triggerValidation);
-}
-
-// The content of a text document has changed. This event is emitted
-// when the text document first opened or when its content has changed.
-documents.onDidChangeContent((change) => {
-	LimitExceededWarnings.cancel(change.document.uri);
-	triggerValidation(change.document);
-});
-
-// a document has closed: clear all diagnostics
-documents.onDidClose(event => {
-	LimitExceededWarnings.cancel(event.document.uri);
-	cleanPendingValidation(event.document);
-	connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
-});
-
-const pendingValidationRequests: { [uri: string]: NodeJS.Timer; } = {};
-const validationDelayMs = 300;
-
-function cleanPendingValidation(textDocument: TextDocument): void {
-	const request = pendingValidationRequests[textDocument.uri];
-	if (request) {
-		clearTimeout(request);
-		delete pendingValidationRequests[textDocument.uri];
-	}
-}
-
-function triggerValidation(textDocument: TextDocument): void {
-	cleanPendingValidation(textDocument);
-	pendingValidationRequests[textDocument.uri] = setTimeout(() => {
-		delete pendingValidationRequests[textDocument.uri];
-		validateTextDocument(textDocument);
-	}, validationDelayMs);
-}
-
-function validateTextDocument(textDocument: TextDocument, callback?: (diagnostics: Diagnostic[]) => void): void {
-	const respond = (diagnostics: Diagnostic[]) => {
-		connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
-		if (callback) {
-			callback(diagnostics);
-		}
-	};
-	if (textDocument.getText().length === 0) {
-		respond([]); // ignore empty documents
-		return;
-	}
-	const jsonDocument = getJSONDocument(textDocument);
-	const version = textDocument.version;
-
-	const documentSettings: DocumentLanguageSettings = textDocument.languageId === 'jsonc' ? { comments: 'ignore', trailingCommas: 'warning' } : { comments: 'error', trailingCommas: 'error' };
-	languageService.doValidation(textDocument, jsonDocument, documentSettings).then(diagnostics => {
-		setImmediate(() => {
-			const currDocument = documents.get(textDocument.uri);
-			if (currDocument && currDocument.version === version) {
-				respond(diagnostics); // Send the computed diagnostics to VSCode.
-			}
-		});
-	}, error => {
-		connection.console.error(formatError(`Error while validating ${textDocument.uri}`, error));
-	});
-}
-
-connection.onDidChangeWatchedFiles((change) => {
-	// Monitored files have changed in VSCode
-	let hasChanges = false;
-	change.changes.forEach(c => {
-		if (languageService.resetSchema(c.uri)) {
-			hasChanges = true;
-		}
-	});
-	if (hasChanges) {
-		documents.all().forEach(triggerValidation);
-	}
-});
-
-const jsonDocuments = getLanguageModelCache<JSONDocument>(10, 60, document => languageService.parseJSONDocument(document));
-documents.onDidClose(e => {
-	jsonDocuments.onDocumentRemoved(e.document);
-});
-connection.onShutdown(() => {
-	jsonDocuments.dispose();
-});
-
-function getJSONDocument(document: TextDocument): JSONDocument {
-	return jsonDocuments.get(document);
-}
-
-connection.onCompletion((textDocumentPosition, token) => {
-	return runSafeAsync(async () => {
-		const document = documents.get(textDocumentPosition.textDocument.uri);
-		if (document) {
-			const jsonDocument = getJSONDocument(document);
-			return languageService.doComplete(document, textDocumentPosition.position, jsonDocument);
-		}
-		return null;
-	}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
-});
-
-connection.onCompletionResolve((completionItem, token) => {
-	return runSafeAsync(() => {
-		return languageService.doResolve(completionItem);
-	}, completionItem, `Error while resolving completion proposal`, token);
-});
-
-connection.onHover((textDocumentPositionParams, token) => {
-	return runSafeAsync(async () => {
-		const document = documents.get(textDocumentPositionParams.textDocument.uri);
-		if (document) {
-			const jsonDocument = getJSONDocument(document);
-			return languageService.doHover(document, textDocumentPositionParams.position, jsonDocument);
-		}
-		return null;
-	}, null, `Error while computing hover for ${textDocumentPositionParams.textDocument.uri}`, token);
-});
-
-connection.onDocumentSymbol((documentSymbolParams, token) => {
-	return runSafe(() => {
-		const document = documents.get(documentSymbolParams.textDocument.uri);
-		if (document) {
-			const jsonDocument = getJSONDocument(document);
-			const onResultLimitExceeded = LimitExceededWarnings.onResultLimitExceeded(document.uri, resultLimit, 'document symbols');
-			if (hierarchicalDocumentSymbolSupport) {
-				return languageService.findDocumentSymbols2(document, jsonDocument, { resultLimit, onResultLimitExceeded });
-			} else {
-				return languageService.findDocumentSymbols(document, jsonDocument, { resultLimit, onResultLimitExceeded });
-			}
-		}
-		return [];
-	}, [], `Error while computing document symbols for ${documentSymbolParams.textDocument.uri}`, token);
-});
-
-connection.onDocumentRangeFormatting((formatParams, token) => {
-	return runSafe(() => {
-		const document = documents.get(formatParams.textDocument.uri);
-		if (document) {
-			const edits = languageService.format(document, formatParams.range, formatParams.options);
-			if (edits.length > formatterMaxNumberOfEdits) {
-				const newText = TextDocument.applyEdits(document, edits);
-				return [TextEdit.replace(Range.create(Position.create(0, 0), document.positionAt(document.getText().length)), newText)];
-			}
-			return edits;
-		}
-		return [];
-	}, [], `Error while formatting range for ${formatParams.textDocument.uri}`, token);
-});
-
-connection.onDocumentColor((params, token) => {
-	return runSafeAsync(async () => {
-		const document = documents.get(params.textDocument.uri);
-		if (document) {
-			const onResultLimitExceeded = LimitExceededWarnings.onResultLimitExceeded(document.uri, resultLimit, 'document colors');
-			const jsonDocument = getJSONDocument(document);
-			return languageService.findDocumentColors(document, jsonDocument, { resultLimit, onResultLimitExceeded });
-		}
-		return [];
-	}, [], `Error while computing document colors for ${params.textDocument.uri}`, token);
-});
-
-connection.onColorPresentation((params, token) => {
-	return runSafe(() => {
-		const document = documents.get(params.textDocument.uri);
-		if (document) {
-			const jsonDocument = getJSONDocument(document);
-			return languageService.getColorPresentations(document, jsonDocument, params.color, params.range);
-		}
-		return [];
-	}, [], `Error while computing color presentations for ${params.textDocument.uri}`, token);
-});
-
-connection.onFoldingRanges((params, token) => {
-	return runSafe(() => {
-		const document = documents.get(params.textDocument.uri);
-		if (document) {
-			const onRangeLimitExceeded = LimitExceededWarnings.onResultLimitExceeded(document.uri, foldingRangeLimit, 'folding ranges');
-			return languageService.getFoldingRanges(document, { rangeLimit: foldingRangeLimit, onRangeLimitExceeded });
-		}
-		return null;
-	}, null, `Error while computing folding ranges for ${params.textDocument.uri}`, token);
-});
-
-
-connection.onSelectionRanges((params, token) => {
-	return runSafe(() => {
-		const document = documents.get(params.textDocument.uri);
-		if (document) {
-			const jsonDocument = getJSONDocument(document);
-			return languageService.getSelectionRanges(document, params.positions, jsonDocument);
-		}
-		return [];
-	}, [], `Error while computing selection ranges for ${params.textDocument.uri}`, token);
-});
-
-connection.onDefinition((params, token) => {
-	return runSafeAsync(async () => {
-		const document = documents.get(params.textDocument.uri);
-		if (document) {
-			const jsonDocument = getJSONDocument(document);
-			return languageService.findDefinition(document, params.position, jsonDocument);
-		}
-		return [];
-	}, [], `Error while computing definitions for ${params.textDocument.uri}`, token);
-});
-
-// Listen on the connection
-connection.listen();

extensions/json-language-features/server/src/node/jsonServerMain.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createConnection, Connection } from 'vscode-languageserver/node';
+import { formatError } from '../utils/runner';
+import { startServer } from '../jsonServer';
+import { RequestService } from '../requests';
+
+import { xhr, XHRResponse, configure as configureHttpRequests, getErrorStatusDescription } from 'request-light';
+import { URI as Uri } from 'vscode-uri';
+import * as fs from 'fs';
+
+// Create a connection for the server.
+const connection: Connection = createConnection();
+
+console.log = connection.console.log.bind(connection.console);
+console.error = connection.console.error.bind(connection.console);
+
+process.on('unhandledRejection', (e: any) => {
+	connection.console.error(formatError(`Unhandled exception`, e));
+});
+
+function getHTTPRequestService(): RequestService {
+	return {
+		getContent(uri: string, _encoding?: string) {
+			const headers = { 'Accept-Encoding': 'gzip, deflate' };
+			return xhr({ url: uri, followRedirects: 5, headers }).then(response => {
+				return response.responseText;
+			}, (error: XHRResponse) => {
+				return Promise.reject(error.responseText || getErrorStatusDescription(error.status) || error.toString());
+			});
+		}
+	};
+}
+
+function getFileRequestService(): RequestService {
+	return {
+		getContent(location: string, encoding?: string) {
+			return new Promise((c, e) => {
+				const uri = Uri.parse(location);
+				fs.readFile(uri.fsPath, encoding, (err, buf) => {
+					if (err) {
+						return e(err);
+					}
+					c(buf.toString());
+				});
+			});
+		}
+	};
+}
+
+
+startServer(connection, { file: getFileRequestService(), http: getHTTPRequestService(), configureHttpRequests });

extensions/json-language-features/server/src/requests.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vscode-uri';
+
+export interface RequestService {
+	getContent(uri: string, encoding?: string): Promise<string>;
+}
+
+export function getScheme(uri: string) {
+	return uri.substr(0, uri.indexOf(':'));
+}
+
+export function dirname(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
+}
+
+export function basename(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return uri.substr(lastIndexOfSlash + 1);
+}
+
+
+const Slash = '/'.charCodeAt(0);
+const Dot = '.'.charCodeAt(0);
+
+export function extname(uri: string) {
+	for (let i = uri.length - 1; i >= 0; i--) {
+		const ch = uri.charCodeAt(i);
+		if (ch === Dot) {
+			if (i > 0 && uri.charCodeAt(i - 1) !== Slash) {
+				return uri.substr(i);
+			} else {
+				break;
+			}
+		} else if (ch === Slash) {
+			break;
+		}
+	}
+	return '';
+}
+
+export function isAbsolutePath(path: string) {
+	return path.charCodeAt(0) === Slash;
+}
+
+export function resolvePath(uriString: string, path: string): string {
+	if (isAbsolutePath(path)) {
+		const uri = URI.parse(uriString);
+		const parts = path.split('/');
+		return uri.with({ path: normalizePath(parts) }).toString();
+	}
+	return joinPath(uriString, path);
+}
+
+export function normalizePath(parts: string[]): string {
+	const newParts: string[] = [];
+	for (const part of parts) {
+		if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
+			// ignore
+		} else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
+			newParts.pop();
+		} else {
+			newParts.push(part);
+		}
+	}
+	if (parts.length > 1 && parts[parts.length - 1].length === 0) {
+		newParts.push('');
+	}
+	let res = newParts.join('/');
+	if (parts[0].length === 0) {
+		res = '/' + res;
+	}
+	return res;
+}
+
+export function joinPath(uriString: string, ...paths: string[]): string {
+	const uri = URI.parse(uriString);
+	const parts = uri.path.split('/');
+	for (let path of paths) {
+		parts.push(...path.split('/'));
+	}
+	return uri.with({ path: normalizePath(parts) }).toString();
+}

extensions/json-language-features/server/yarn.lock

@@ -91,35 +91,40 @@ vscode-json-languageservice@^3.7.0:
     vscode-nls "^4.1.2"
     vscode-uri "^2.1.2"
 
-vscode-jsonrpc@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-5.0.1.tgz#9bab9c330d89f43fc8c1e8702b5c36e058a01794"
-  integrity sha512-JvONPptw3GAQGXlVV2utDcHx0BiY34FupW/kI6mZ5x06ER5DdPG/tXWMVHjTNULF5uKPOUUD0SaXg5QaubJL0A==
-
-vscode-languageserver-protocol@^3.15.3:
-  version "3.15.3"
-  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.15.3.tgz#3fa9a0702d742cf7883cb6182a6212fcd0a1d8bb"
-  integrity sha512-zrMuwHOAQRhjDSnflWdJG+O2ztMWss8GqUUB8dXLR/FPenwkiBNkMIJJYfSN6sgskvsF0rHAoBowNQfbyZnnvw==
+vscode-jsonrpc@6.0.0-next.2:
+  version "6.0.0-next.2"
+  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-6.0.0-next.2.tgz#3d73f86d812304cb91b9fb1efee40ec60b09ed7f"
+  integrity sha512-dKQXRYNUY6BHALQJBJlyZyv9oWlYpbJ2vVoQNNVNPLAYQ3hzNp4zy+iSo7zGx1BPXByArJQDWTKLQh8dz3dnNw==
+
+vscode-languageserver-protocol@3.16.0-next.4:
+  version "3.16.0-next.4"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.16.0-next.4.tgz#8f8b1b831d4dfd9b26aa1ba3d2a32c427a91c99f"
+  integrity sha512-6GmPUp2MhJy2H1CTWp2B40Pa9BeC9glrXWmQWVG6A/0V9UbcAjVC9m56znm2GL32iyLDIprTBe8gBvvvcjbpaQ==
   dependencies:
-    vscode-jsonrpc "^5.0.1"
-    vscode-languageserver-types "3.15.1"
+    vscode-jsonrpc "6.0.0-next.2"
+    vscode-languageserver-types "3.16.0-next.2"
 
 vscode-languageserver-textdocument@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.1.tgz#178168e87efad6171b372add1dea34f53e5d330f"
   integrity sha512-UIcJDjX7IFkck7cSkNNyzIz5FyvpQfY7sdzVy+wkKN/BLaD4DQ0ppXQrKePomCxTS7RrolK1I0pey0bG9eh8dA==
 
-vscode-languageserver-types@3.15.1, vscode-languageserver-types@^3.15.1:
+vscode-languageserver-types@3.16.0-next.2:
+  version "3.16.0-next.2"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.16.0-next.2.tgz#940bd15c992295a65eae8ab6b8568a1e8daa3083"
+  integrity sha512-QjXB7CKIfFzKbiCJC4OWC8xUncLsxo19FzGVp/ADFvvi87PlmBSCAtZI5xwGjF5qE0xkLf0jjKUn3DzmpDP52Q==
+
+vscode-languageserver-types@^3.15.1:
   version "3.15.1"
   resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.15.1.tgz#17be71d78d2f6236d414f0001ce1ef4d23e6b6de"
   integrity sha512-+a9MPUQrNGRrGU630OGbYVQ+11iOIovjCkqxajPa9w57Sd5ruK8WQNsslzpa0x/QJqC8kRc2DUxWjIFwoNm4ZQ==
 
-vscode-languageserver@^6.1.1:
-  version "6.1.1"
-  resolved "https://registry.yarnpkg.com/vscode-languageserver/-/vscode-languageserver-6.1.1.tgz#d76afc68172c27d4327ee74332b468fbc740d762"
-  integrity sha512-DueEpkUAkD5XTR4MLYNr6bQIp/UFR0/IPApgXU3YfCBCB08u2sm9hRCs6DxYZELkk++STPjpcjksR2H8qI3cDQ==
+vscode-languageserver@7.0.0-next.3:
+  version "7.0.0-next.3"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver/-/vscode-languageserver-7.0.0-next.3.tgz#3833bd09259a4a085baeba90783f1e4d06d81095"
+  integrity sha512-qSt8eb546iFuoFIN+9MPl4Avru6Iz2/JP0UmS/3djf40ICa31Np/yJ7anX2j0Az5rCzb0fak8oeKwDioGeVOYg==
   dependencies:
-    vscode-languageserver-protocol "^3.15.3"
+    vscode-languageserver-protocol "3.16.0-next.4"
 
 vscode-nls@^4.1.1:
   version "4.1.1"

extensions/json-language-features/yarn.lock

@@ -120,31 +120,31 @@ vscode-extension-telemetry@0.1.1:
   dependencies:
     applicationinsights "1.0.8"
 
-vscode-jsonrpc@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-5.0.1.tgz#9bab9c330d89f43fc8c1e8702b5c36e058a01794"
-  integrity sha512-JvONPptw3GAQGXlVV2utDcHx0BiY34FupW/kI6mZ5x06ER5DdPG/tXWMVHjTNULF5uKPOUUD0SaXg5QaubJL0A==
-
-vscode-languageclient@^6.1.3:
-  version "6.1.3"
-  resolved "https://registry.yarnpkg.com/vscode-languageclient/-/vscode-languageclient-6.1.3.tgz#c979c5bb5855714a0307e998c18ca827c1b3953a"
-  integrity sha512-YciJxk08iU5LmWu7j5dUt9/1OLjokKET6rME3cI4BRpiF6HZlusm2ZwPt0MYJ0lV5y43sZsQHhyon2xBg4ZJVA==
+vscode-jsonrpc@6.0.0-next.2:
+  version "6.0.0-next.2"
+  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-6.0.0-next.2.tgz#3d73f86d812304cb91b9fb1efee40ec60b09ed7f"
+  integrity sha512-dKQXRYNUY6BHALQJBJlyZyv9oWlYpbJ2vVoQNNVNPLAYQ3hzNp4zy+iSo7zGx1BPXByArJQDWTKLQh8dz3dnNw==
+
+vscode-languageclient@7.0.0-next.5:
+  version "7.0.0-next.5"
+  resolved "https://registry.yarnpkg.com/vscode-languageclient/-/vscode-languageclient-7.0.0-next.5.tgz#7ae84c598dff360bd2bc64322b74e10e5d0b9cd6"
+  integrity sha512-ec+fJg+JiNBIdbeKbzssSuORUaVdtLValtiYdNEUCUjpYE+Y6xXPtXwiZOlS/0OB9pC/RLCMxsj16UwWncQhYQ==
   dependencies:
     semver "^6.3.0"
-    vscode-languageserver-protocol "^3.15.3"
+    vscode-languageserver-protocol "3.16.0-next.4"
 
-vscode-languageserver-protocol@^3.15.3:
-  version "3.15.3"
-  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.15.3.tgz#3fa9a0702d742cf7883cb6182a6212fcd0a1d8bb"
-  integrity sha512-zrMuwHOAQRhjDSnflWdJG+O2ztMWss8GqUUB8dXLR/FPenwkiBNkMIJJYfSN6sgskvsF0rHAoBowNQfbyZnnvw==
+vscode-languageserver-protocol@3.16.0-next.4:
+  version "3.16.0-next.4"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.16.0-next.4.tgz#8f8b1b831d4dfd9b26aa1ba3d2a32c427a91c99f"
+  integrity sha512-6GmPUp2MhJy2H1CTWp2B40Pa9BeC9glrXWmQWVG6A/0V9UbcAjVC9m56znm2GL32iyLDIprTBe8gBvvvcjbpaQ==
   dependencies:
-    vscode-jsonrpc "^5.0.1"
-    vscode-languageserver-types "3.15.1"
+    vscode-jsonrpc "6.0.0-next.2"
+    vscode-languageserver-types "3.16.0-next.2"
 
-vscode-languageserver-types@3.15.1:
-  version "3.15.1"
-  resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.15.1.tgz#17be71d78d2f6236d414f0001ce1ef4d23e6b6de"
-  integrity sha512-+a9MPUQrNGRrGU630OGbYVQ+11iOIovjCkqxajPa9w57Sd5ruK8WQNsslzpa0x/QJqC8kRc2DUxWjIFwoNm4ZQ==
+vscode-languageserver-types@3.16.0-next.2:
+  version "3.16.0-next.2"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.16.0-next.2.tgz#940bd15c992295a65eae8ab6b8568a1e8daa3083"
+  integrity sha512-QjXB7CKIfFzKbiCJC4OWC8xUncLsxo19FzGVp/ADFvvi87PlmBSCAtZI5xwGjF5qE0xkLf0jjKUn3DzmpDP52Q==
 
 vscode-nls@^4.1.1:
   version "4.1.1"