Merge VS Code 1.23.1 (#1520)

2026-02-13 19:48:37 -05:00 · 2018-06-05 11:24:51 -07:00
parent e3baf5c443
commit 0c58f09e59
3651 changed files with 74249 additions and 48599 deletions
--- a/extensions/json-language-features/.vscode/launch.json
+++ b/extensions/json-language-features/.vscode/launch.json
@@ -0,0 +1,38 @@
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"name": "Launch Extension",
+			"type": "extensionHost",
+			"request": "launch",
+			"runtimeExecutable": "${execPath}",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}"
+			],
+			"stopOnEntry": false,
+			"sourceMaps": true,
+			"outFiles": ["${workspaceFolder}/client/out"],
+			"preLaunchTask": "npm"
+		},
+		{
+			"name": "Launch Tests",
+			"type": "extensionHost",
+			"request": "launch",
+			"runtimeExecutable": "${execPath}",
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--extensionTestsPath=${workspaceFolder}/client/out/test" ],
+			"stopOnEntry": false,
+			"sourceMaps": true,
+			"outFiles": ["${workspaceFolder}/client/out/test"],
+			"preLaunchTask": "npm"
+		},
+		{
+			"name": "Attach Language Server",
+			"type": "node",
+			"request": "attach",
+			"port": 6004,
+			"sourceMaps": true,
+			"outFiles": ["${workspaceFolder}/server/out"]
+		}
+
+	]
+}
--- a/extensions/json-language-features/.vscode/tasks.json
+++ b/extensions/json-language-features/.vscode/tasks.json
@@ -0,0 +1,30 @@
+// Available variables which can be used inside of strings.
+// ${workspaceFolder}: the root folder of the team
+// ${file}: the current opened file
+// ${fileBasename}: the current opened file's basename
+// ${fileDirname}: the current opened file's dirname
+// ${fileExtname}: the current opened file's extension
+// ${cwd}: the current working directory of the spawned process
+
+// A task runner that calls a custom npm script that compiles the extension.
+{
+	"version": "0.1.0",
+
+	// we want to run npm
+	"command": "npm",
+
+	// the command is a shell script
+	"isShellCommand": true,
+
+	// show the output window only if unrecognized errors occur.
+	"showOutput": "silent",
+
+	// we run the custom script "compile" as defined in package.json
+	"args": ["run", "compile"],
+
+	// The tsc compiler is started in watching mode
+	"isWatching": true,
+
+	// use the standard tsc in watch mode problem matcher to find compile problems in the output.
+	"problemMatcher": "$tsc-watch"
+}
--- a/extensions/json-language-features/.vscodeignore
+++ b/extensions/json-language-features/.vscodeignore
@@ -0,0 +1,7 @@
+test/**
+client/tsconfig.json
+client/src/**
+server/bin
+server/tsconfig.json
+server/src/**
+server/node_modules/@types/**
--- a/extensions/json-language-features/client/src/jsonMain.ts
+++ b/extensions/json-language-features/client/src/jsonMain.ts
@@ -0,0 +1,311 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as path from 'path';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import { workspace, languages, ExtensionContext, extensions, Uri, LanguageConfiguration, TextDocument, FoldingRangeKind, FoldingRange, Disposable, FoldingContext } from 'vscode';
+import { LanguageClient, LanguageClientOptions, RequestType, ServerOptions, TransportKind, NotificationType, DidChangeConfigurationNotification, CancellationToken } from 'vscode-languageclient';
+import TelemetryReporter from 'vscode-extension-telemetry';
+
+import { FoldingRangeRequest, FoldingRangeRequestParam, FoldingRangeClientCapabilities, FoldingRangeKind as LSFoldingRangeKind } from 'vscode-languageserver-protocol-foldingprovider';
+
+import { hash } from './utils/hash';
+
+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');
+}
+
+export interface ISchemaAssociations {
+	[pattern: string]: string[];
+}
+
+namespace SchemaAssociationNotification {
+	export const type: NotificationType<ISchemaAssociations, any> = new NotificationType('json/schemaAssociations');
+}
+
+interface IPackageInfo {
+	name: string;
+	version: string;
+	aiKey: string;
+}
+
+interface Settings {
+	json?: {
+		schemas?: JSONSchemaSettings[];
+		format?: { enable: boolean; };
+	};
+	http?: {
+		proxy?: string;
+		proxyStrictSSL?: boolean;
+	};
+}
+
+interface JSONSchemaSettings {
+	fileMatch?: string[];
+	url?: string;
+	schema?: any;
+}
+
+let telemetryReporter: TelemetryReporter | undefined;
+
+export function activate(context: ExtensionContext) {
+
+	let toDispose = context.subscriptions;
+
+	let packageInfo = getPackageInfo(context);
+	telemetryReporter = packageInfo && new TelemetryReporter(packageInfo.name, packageInfo.version, packageInfo.aiKey);
+
+	// The server is implemented in node
+	let serverModule = context.asAbsolutePath(path.join('server', 'out', 'jsonServerMain.js'));
+	// The debug options for the server
+	let debugOptions = { execArgv: ['--nolazy', '--inspect=' + (9000 + Math.round(Math.random() * 10000))] };
+
+	// If the extension is launch in debug mode the debug server options are use
+	// Otherwise the run options are used
+	let serverOptions: ServerOptions = {
+		run: { module: serverModule, transport: TransportKind.ipc },
+		debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions }
+	};
+
+	let documentSelector = ['json', 'jsonc'];
+
+	// Options to control the language client
+	let clientOptions: LanguageClientOptions = {
+		// Register the server for json documents
+		documentSelector,
+		synchronize: {
+			// Synchronize the setting section 'json' to the server
+			configurationSection: ['json', 'http'],
+			fileEvents: workspace.createFileSystemWatcher('**/*.json')
+		},
+		middleware: {
+			workspace: {
+				didChangeConfiguration: () => client.sendNotification(DidChangeConfigurationNotification.type, { settings: getSettings() })
+			}
+		}
+	};
+
+	// Create the language client and start the client.
+	let client = new LanguageClient('json', localize('jsonserver.name', 'JSON Language Server'), serverOptions, clientOptions);
+	client.registerProposedFeatures();
+	client.registerFeature({
+		fillClientCapabilities(capabilities: FoldingRangeClientCapabilities): void {
+			let textDocumentCap = capabilities.textDocument;
+			if (!textDocumentCap) {
+				textDocumentCap = capabilities.textDocument = {};
+			}
+			textDocumentCap.foldingRange = {
+				dynamicRegistration: false,
+				rangeLimit: 5000,
+				lineFoldingOnly: true
+			};
+		},
+		initialize(capabilities, documentSelector): void {
+		}
+	});
+
+	let disposable = client.start();
+	toDispose.push(disposable);
+	client.onReady().then(() => {
+		disposable = client.onTelemetry(e => {
+			if (telemetryReporter) {
+				telemetryReporter.sendTelemetryEvent(e.key, e.data);
+			}
+		});
+
+		// handle content request
+		client.onRequest(VSCodeContentRequest.type, (uriPath: string) => {
+			let uri = Uri.parse(uriPath);
+			return workspace.openTextDocument(uri).then(doc => {
+				return doc.getText();
+			}, error => {
+				return Promise.reject(error);
+			});
+		});
+
+		let handleContentChange = (uri: Uri) => {
+			if (uri.scheme === 'vscode' && uri.authority === 'schemas') {
+				client.sendNotification(SchemaContentChangeNotification.type, uri.toString());
+			}
+		};
+		toDispose.push(workspace.onDidChangeTextDocument(e => handleContentChange(e.document.uri)));
+		toDispose.push(workspace.onDidCloseTextDocument(d => handleContentChange(d.uri)));
+
+		client.sendNotification(SchemaAssociationNotification.type, getSchemaAssociation(context));
+
+		toDispose.push(initFoldingProvider());
+	});
+
+	let languageConfiguration: LanguageConfiguration = {
+		wordPattern: /("(?:[^\\\"]*(?:\\.)?)*"?)|[^\s{}\[\],:]+/,
+		indentationRules: {
+			increaseIndentPattern: /^.*(\{[^}]*|\[[^\]]*)$/,
+			decreaseIndentPattern: /^\s*[}\]],?\s*$/
+		}
+	};
+	languages.setLanguageConfiguration('json', languageConfiguration);
+	languages.setLanguageConfiguration('jsonc', languageConfiguration);
+
+	function initFoldingProvider(): Disposable {
+		function getKind(kind: string | undefined): FoldingRangeKind | undefined {
+			if (kind) {
+				switch (kind) {
+					case LSFoldingRangeKind.Comment:
+						return FoldingRangeKind.Comment;
+					case LSFoldingRangeKind.Imports:
+						return FoldingRangeKind.Imports;
+					case LSFoldingRangeKind.Region:
+						return FoldingRangeKind.Region;
+				}
+			}
+			return void 0;
+		}
+		return languages.registerFoldingRangeProvider(documentSelector, {
+			provideFoldingRanges(document: TextDocument, context: FoldingContext, token: CancellationToken) {
+				const param: FoldingRangeRequestParam = {
+					textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
+				};
+				return client.sendRequest(FoldingRangeRequest.type, param, token).then(ranges => {
+					if (Array.isArray(ranges)) {
+						return ranges.map(r => new FoldingRange(r.startLine, r.endLine, getKind(r.kind)));
+					}
+					return null;
+				}, error => {
+					client.logFailedRequest(FoldingRangeRequest.type, error);
+					return null;
+				});
+			}
+		});
+	}
+}
+
+export function deactivate(): Promise<any> {
+	return telemetryReporter ? telemetryReporter.dispose() : Promise.resolve(null);
+}
+
+function getSchemaAssociation(context: ExtensionContext): ISchemaAssociations {
+	let associations: ISchemaAssociations = {};
+	extensions.all.forEach(extension => {
+		let packageJSON = extension.packageJSON;
+		if (packageJSON && packageJSON.contributes && packageJSON.contributes.jsonValidation) {
+			let jsonValidation = packageJSON.contributes.jsonValidation;
+			if (Array.isArray(jsonValidation)) {
+				jsonValidation.forEach(jv => {
+					let { fileMatch, url } = jv;
+					if (fileMatch && url) {
+						if (url[0] === '.' && url[1] === '/') {
+							url = Uri.file(path.join(extension.extensionPath, url)).toString();
+						}
+						if (fileMatch[0] === '%') {
+							fileMatch = fileMatch.replace(/%APP_SETTINGS_HOME%/, '/User');
+							fileMatch = fileMatch.replace(/%APP_WORKSPACES_HOME%/, '/Workspaces');
+						} else if (fileMatch.charAt(0) !== '/' && !fileMatch.match(/\w+:\/\//)) {
+							fileMatch = '/' + fileMatch;
+						}
+						let association = associations[fileMatch];
+						if (!association) {
+							association = [];
+							associations[fileMatch] = association;
+						}
+						association.push(url);
+					}
+				});
+			}
+		}
+	});
+	return associations;
+}
+
+function getSettings(): Settings {
+	let httpSettings = workspace.getConfiguration('http');
+
+	let settings: Settings = {
+		http: {
+			proxy: httpSettings.get('proxy'),
+			proxyStrictSSL: httpSettings.get('proxyStrictSSL')
+		},
+		json: {
+			format: workspace.getConfiguration('json').get('format'),
+			schemas: [],
+		}
+	};
+	let schemaSettingsById: { [schemaId: string]: JSONSchemaSettings } = Object.create(null);
+	let collectSchemaSettings = (schemaSettings: JSONSchemaSettings[], rootPath?: string, fileMatchPrefix?: string) => {
+		for (let setting of schemaSettings) {
+			let url = getSchemaId(setting, rootPath);
+			if (!url) {
+				continue;
+			}
+			let schemaSetting = schemaSettingsById[url];
+			if (!schemaSetting) {
+				schemaSetting = schemaSettingsById[url] = { url, fileMatch: [] };
+				settings.json!.schemas!.push(schemaSetting);
+			}
+			let fileMatches = setting.fileMatch;
+			if (Array.isArray(fileMatches)) {
+				if (fileMatchPrefix) {
+					fileMatches = fileMatches.map(m => fileMatchPrefix + m);
+				}
+				schemaSetting.fileMatch!.push(...fileMatches);
+			}
+			if (setting.schema) {
+				schemaSetting.schema = setting.schema;
+			}
+		}
+	};
+
+	// merge global and folder settings. Qualify all file matches with the folder path.
+	let globalSettings = workspace.getConfiguration('json', null).get<JSONSchemaSettings[]>('schemas');
+	if (Array.isArray(globalSettings)) {
+		collectSchemaSettings(globalSettings, workspace.rootPath);
+	}
+	let folders = workspace.workspaceFolders;
+	if (folders) {
+		for (let folder of folders) {
+			let folderUri = folder.uri;
+			let schemaConfigInfo = workspace.getConfiguration('json', folderUri).inspect<JSONSchemaSettings[]>('schemas');
+			let folderSchemas = schemaConfigInfo!.workspaceFolderValue;
+			if (Array.isArray(folderSchemas)) {
+				let folderPath = folderUri.toString();
+				if (folderPath[folderPath.length - 1] !== '/') {
+					folderPath = folderPath + '/';
+				}
+				collectSchemaSettings(folderSchemas, folderUri.fsPath, folderPath + '*');
+			}
+		}
+	}
+	return settings;
+}
+
+function getSchemaId(schema: JSONSchemaSettings, rootPath?: string) {
+	let url = schema.url;
+	if (!url) {
+		if (schema.schema) {
+			url = schema.schema.id || `vscode://schemas/custom/${encodeURIComponent(hash(schema.schema).toString(16))}`;
+		}
+	} else if (rootPath && (url[0] === '.' || url[0] === '/')) {
+		url = Uri.file(path.normalize(path.join(rootPath, url))).toString();
+	}
+	return url;
+}
+
+function getPackageInfo(context: ExtensionContext): IPackageInfo | undefined {
+	let extensionPackage = require(context.asAbsolutePath('./package.json'));
+	if (extensionPackage) {
+		return {
+			name: extensionPackage.name,
+			version: extensionPackage.version,
+			aiKey: extensionPackage.aiKey
+		};
+	}
+	return void 0;
+}
--- a/extensions/json-language-features/client/src/typings/ref.d.ts
+++ b/extensions/json-language-features/client/src/typings/ref.d.ts
@@ -0,0 +1,7 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path='../../../../../src/vs/vscode.d.ts'/>
+/// <reference path='../../../../../src/vs/vscode.proposed.d.ts'/>
--- a/extensions/json-language-features/client/src/utils/hash.ts
+++ b/extensions/json-language-features/client/src/utils/hash.ts
@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+/**
+ * Return a hash value for an object.
+ */
+export function hash(obj: any, hashVal = 0): number {
+	switch (typeof obj) {
+		case 'object':
+			if (obj === null) {
+				return numberHash(349, hashVal);
+			} else if (Array.isArray(obj)) {
+				return arrayHash(obj, hashVal);
+			}
+			return objectHash(obj, hashVal);
+		case 'string':
+			return stringHash(obj, hashVal);
+		case 'boolean':
+			return booleanHash(obj, hashVal);
+		case 'number':
+			return numberHash(obj, hashVal);
+		case 'undefined':
+			return numberHash(obj, 937);
+		default:
+			return numberHash(obj, 617);
+	}
+}
+
+function numberHash(val: number, initialHashVal: number): number {
+	return (((initialHashVal << 5) - initialHashVal) + val) | 0;  // hashVal * 31 + ch, keep as int32
+}
+
+function booleanHash(b: boolean, initialHashVal: number): number {
+	return numberHash(b ? 433 : 863, initialHashVal);
+}
+
+function stringHash(s: string, hashVal: number) {
+	hashVal = numberHash(149417, hashVal);
+	for (let i = 0, length = s.length; i < length; i++) {
+		hashVal = numberHash(s.charCodeAt(i), hashVal);
+	}
+	return hashVal;
+}
+
+function arrayHash(arr: any[], initialHashVal: number): number {
+	initialHashVal = numberHash(104579, initialHashVal);
+	return arr.reduce((hashVal, item) => hash(item, hashVal), initialHashVal);
+}
+
+function objectHash(obj: any, initialHashVal: number): number {
+	initialHashVal = numberHash(181387, initialHashVal);
+	return Object.keys(obj).sort().reduce((hashVal, key) => {
+		hashVal = stringHash(key, hashVal);
+		return hash(obj[key], hashVal);
+	}, initialHashVal);
+}
--- a/extensions/json-language-features/client/tsconfig.json
+++ b/extensions/json-language-features/client/tsconfig.json
@@ -0,0 +1,10 @@
+{
+	"compilerOptions": {
+		"target": "es6",
+		"module": "commonjs",
+		"outDir": "./out",
+		"noUnusedLocals": true,
+		"lib": [ "es2016" ],
+		"strict": true
+	}
+}
--- a/extensions/json-language-features/icons/json.png
+++ b/extensions/json-language-features/icons/json.png
--- a/extensions/json-language-features/package.json
+++ b/extensions/json-language-features/package.json
@@ -0,0 +1,111 @@
+{
+  "name": "json-language-features",
+  "displayName": "%displayName%",
+  "description": "%description%",
+  "version": "1.0.0",
+  "publisher": "vscode",
+  "aiKey": "AIF-d9b70cd4-b9f9-4d70-929b-a071c400b217",
+  "engines": {
+    "vscode": "0.10.x"
+  },
+  "icon": "icons/json.png",
+  "activationEvents": [
+    "onLanguage:json",
+    "onLanguage:jsonc"
+  ],
+  "enableProposedApi": true,
+  "main": "./client/out/jsonMain",
+  "scripts": {
+    "compile": "gulp compile-extension:json-language-features-client && gulp compile-extension:json-language-features-server",
+    "postinstall": "cd server && yarn install",
+    "install-client-next": "yarn add vscode-languageclient@next"
+  },
+  "categories": [
+    "Programming Languages"
+  ],
+  "contributes": {
+    "configuration": {
+      "id": "json",
+      "order": 20,
+      "type": "object",
+      "title": "JSON",
+      "properties": {
+        "json.schemas": {
+          "type": "array",
+          "scope": "resource",
+          "description": "%json.schemas.desc%",
+          "items": {
+            "type": "object",
+            "default": {
+              "fileMatch": [
+                "/myfile"
+              ],
+              "url": "schemaURL"
+            },
+            "properties": {
+              "url": {
+                "type": "string",
+                "default": "/user.schema.json",
+                "description": "%json.schemas.url.desc%"
+              },
+              "fileMatch": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "default": "MyFile.json",
+                  "description": "%json.schemas.fileMatch.item.desc%"
+                },
+                "minItems": 1,
+                "description": "%json.schemas.fileMatch.desc%"
+              },
+              "schema": {
+                "$ref": "http://json-schema.org/draft-04/schema#",
+                "description": "%json.schemas.schema.desc%"
+              }
+            }
+          }
+        },
+        "json.format.enable": {
+          "type": "boolean",
+          "scope": "window",
+          "default": true,
+          "description": "%json.format.enable.desc%"
+        },
+        "json.trace.server": {
+          "type": "string",
+          "scope": "window",
+          "enum": [
+            "off",
+            "messages",
+            "verbose"
+          ],
+          "default": "off",
+          "description": "%json.tracing.desc%"
+        },
+        "json.colorDecorators.enable": {
+          "type": "boolean",
+          "scope": "window",
+          "default": true,
+          "description": "%json.colorDecorators.enable.desc%",
+          "deprecationMessage": "%json.colorDecorators.enable.deprecationMessage%"
+        }
+      }
+    },
+    "configurationDefaults": {
+      "[json]": {
+        "editor.quickSuggestions": {
+          "strings": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "vscode-extension-telemetry": "0.0.17",
+    "vscode-languageclient": "^4.0.0",
+    "vscode-languageserver-protocol-foldingprovider": "^2.0.0-next.2",
+    "vscode-nls": "^3.2.2"
+  },
+  "devDependencies": {
+    "@types/node": "7.0.43"
+  }
+}
--- a/extensions/json-language-features/package.nls.json
+++ b/extensions/json-language-features/package.nls.json
@@ -0,0 +1,13 @@
+{
+	"displayName": "JSON Language Features",
+	"description": "Provides rich language support for JSON files.",
+	"json.schemas.desc": "Associate schemas to JSON files in the current project",
+	"json.schemas.url.desc": "A URL to a schema or a relative path to a schema in the current directory",
+	"json.schemas.fileMatch.desc": "An array of file patterns to match against when resolving JSON files to schemas.",
+	"json.schemas.fileMatch.item.desc": "A file pattern that can contain '*' to match against when resolving JSON files to schemas.",
+	"json.schemas.schema.desc": "The schema definition for the given URL. The schema only needs to be provided to avoid accesses to the schema URL.",
+	"json.format.enable.desc": "Enable/disable default JSON formatter (requires restart)",
+	"json.tracing.desc": "Traces the communication between VS Code and the JSON language server.",
+	"json.colorDecorators.enable.desc": "Enables or disables color decorators",
+	"json.colorDecorators.enable.deprecationMessage": "The setting `json.colorDecorators.enable` has been deprecated in favor of `editor.colorDecorators`."
+}
--- a/extensions/json-language-features/server/.npmignore
+++ b/extensions/json-language-features/server/.npmignore
@@ -0,0 +1,7 @@
+.vscode/
+out/test/
+out/**/*.js.map
+src/
+test/
+tsconfig.json
+.gitignore
--- a/extensions/json-language-features/server/.vscode/launch.json
+++ b/extensions/json-language-features/server/.vscode/launch.json
@@ -0,0 +1,34 @@
+{
+	"version": "0.1.0",
+	// List of configurations. Add new configurations or edit existing ones.
+	"configurations": [
+		{
+			"name": "Attach",
+			"type": "node",
+			"request": "attach",
+			"port": 6004,
+			"sourceMaps": true,
+			"outFiles": ["${workspaceFolder}/out/**/*js"],
+			"preLaunchTask": "npm: compile"
+		},
+		{
+			"name": "Unit Tests",
+			"type": "node",
+			"request": "launch",
+			"program": "${workspaceFolder}/../../../node_modules/mocha/bin/_mocha",
+			"stopOnEntry": false,
+			"args": [
+				"--timeout",
+				"999999",
+				"--colors"
+			],
+			"cwd": "${workspaceFolder}",
+			"runtimeExecutable": null,
+			"runtimeArgs": [],
+			"env": {},
+			"sourceMaps": true,
+			"outFiles": ["${workspaceFolder}/out/**/*js"],
+			"preLaunchTask": "npm: compile"
+		}
+	]
+}
--- a/extensions/json-language-features/server/.vscode/tasks.json
+++ b/extensions/json-language-features/server/.vscode/tasks.json
@@ -0,0 +1,20 @@
+// See https://go.microsoft.com/fwlink/?LinkId=733558
+// for the documentation about the tasks.json format
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"type": "npm",
+			"script": "compile",
+			"problemMatcher": "$tsc-watch",
+			"isBackground": true,
+			"presentation": {
+				"reveal": "never"
+			},
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			}
+		}
+	]
+}
--- a/extensions/json-language-features/server/README.md
+++ b/extensions/json-language-features/server/README.md
@@ -0,0 +1,173 @@
+# VSCode JSON Language Server
+
+[![NPM Version](https://img.shields.io/npm/v/vscode-json-languageserver.svg)](https://npmjs.org/package/vscode-json-languageserver)
+[![NPM Downloads](https://img.shields.io/npm/dm/vscode-json-languageserver.svg)](https://npmjs.org/package/vscode-json-languageserver)
+[![NPM Version](https://img.shields.io/npm/l/vscode-json-languageserver.svg)](https://npmjs.org/package/vscode-json-languageserver)
+
+The JSON Language server provides language-specific smarts for editing, validating and understanding JSON documents. It runs as a separate executable and implements the [language server protocol](https://microsoft.github.io/language-server-protocol/overview) to be connected by any code editor or IDE.
+
+## Capabilities
+
+### Server capabilities
+
+The JSON language server supports requests on documents of language id `json` and `jsonc`.
+- `json` documents are parsed and validated following the [JSON specification](https://tools.ietf.org/html/rfc7159).
+- `jsonc` documents additionally accept single line (`//`) and multi-line comments (`/* ... */`) and accepts trailing commas. JSONC is a VSCode specific file format, intended for VSCode configuration files, without any aspirations to define a new common file format.
+
+The server implements the following capabilities of the language server protocol:
+
+- [Code completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion) for JSON properties and values based on the document's [JSON schema](http://json-schema.org/) or based on existing properties and values used at other places in the document. JSON schemas are configured through the server configuration options.
+- [Hover](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover) for values based on descriptions in the document's [JSON schema](http://json-schema.org/).
+- [Document Symbols](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol) for quick navigation to properties in the document.
+- [Document Colors](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentColor) for showing color decorators on values representing colors and [Color Presentation](https://microsoft.github.io/language-server-protocol/specification#textDocument_colorPresentation) for color presentation information to support color pickers. The location of colors is defined by the document's [JSON schema](http://json-schema.org/). All values marked with `"format": "color-hex"` (VSCode specific, non-standard JSON Schema extension) are considered color values. The supported color formats are `#rgb[a]` and `#rrggbb[aa]`.
+- [Code Formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_rangeFormatting) supporting ranges and formatting the whole document.
+- [Diagnostics (Validation)](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics) are pushed for all open documents
+   - syntax errors
+   - structural validation based on the document's [JSON schema](http://json-schema.org/).
+
+In order to load JSON schemas, the JSON server uses NodeJS `http` and `fs` modules. For all other features, the JSON server only relies on the documents and settings provided by the client through the LSP.
+
+### Client requirements:
+
+The JSON language server expects the client to only send requests and notifications for documents of language id `json` and `jsonc`.
+
+The JSON language server has the following dependencies on the client's capabilities:
+
+- Code completion requires that the client capability has *snippetSupport*. If not supported by the client, the server will not offer the completion capability.
+- Formatting support requires the client to support *dynamicRegistration* for *rangeFormatting*. If not supported by the client, the server will not offer the format capability.
+
+## Configuration
+
+### Settings
+
+Clients may send a `workspace/didChangeConfiguration` notification to notify the server of settings changes.
+The server supports the following settings:
+
+- http
+   - `proxy`: The URL of the proxy server to use when fetching schema. When undefined or empty, no proxy is used.
+   - `proxyStrictSSL`: Whether the proxy server certificate should be verified against the list of supplied CAs.
+
+- json
+  - `format`
+    - `enable`: Whether the server should register the formatting support. This option is only applicable if the client supports *dynamicRegistration* for *rangeFormatting*
+    - `schema`: Configures association of file names to schema URL or schemas and/or associations of schema URL to schema content.
+	  - `fileMatch`: an array or file names or paths (separated by `/`). `*` can be used as a wildcard.
+	  - `url`: The URL of the schema, optional when also a schema is provided.
+	  - `schema`: The schema content.
+
+```json
+	{
+        "http": {
+            "proxy": "",
+            "proxyStrictSSL": true
+        },
+        "json": {
+            "format": {
+                "enable": true
+            },
+            "schemas": [
+                {
+                    "fileMatch": [
+                        "foo.json",
+                        "*.superfoo.json"
+                    ],
+                    "url": "http://json.schemastore.org/foo",
+                    "schema": {
+                    	"type": "array"
+                    }
+                }
+            ]
+        }
+    }
+```
+
+### Schema configuration and custom schema content delivery
+
+[JSON schemas](http://json-schema.org/) are essential for code assist, hovers, color decorators to work and are required for structural validation.
+
+To find the schema for a given JSON document, the server uses the following mechanisms:
+- JSON documents can define the schema URL using a `$schema` property
+- The settings define a schema association based on the documents URL. Settings can either associate a schema URL to a file or path pattern, and they can directly provide a schema.
+- Additionally, schema associations can also be provided by a custom 'schemaAssociations' configuration call.
+
+Schemas are identified by URLs. To load the content of a schema, the JSON language server tries to load from that URL or path. The following URL schemas are supported:
+- `http`, `https`: Loaded using NodeJS's HTTP support. Proxies can be configured through the settings.
+- `file`: Loaded using NodeJS's `fs` support.
+- `vscode`: Loaded by an LSP call to the client.
+
+#### Schema associations notification
+
+In addition to the settings, schemas associations can also be provided through a notification from the client to the server. This notification is a JSON language server specific, non-standardized, extension to the LSP.
+
+Notification:
+- method: 'json/schemaAssociations'
+- params: `ISchemaAssociations` defined as follows
+
+```ts
+interface ISchemaAssociations {
+	[pattern: string]: string[];
+}
+```
+  - keys: a file names or file path (separated by `/`). `*` can be used as a wildcard.
+  - values: An array of schema URLs
+
+#### Schema content request
+
+The schema content for schema URLs that start with `vscode://` will be requested from the client through an LSP request. This request is a JSON language server specific, non-standardized, extension to the LSP.
+
+Request:
+- method: 'vscode/content'
+- params: `string` - The schema URL to request. The server will only ask for URLs that start with `vscode://`
+- response: `string` - The content of the schema with the given URL
+
+#### Schema content change notification
+
+When the client is aware that a schema content has changed, it will notify the server through a notification. This notification is a JSON language server specific, non-standardized, extension to the LSP.
+The server will, as a response, clear the schema content from the cache and reload the schema content when required again.
+
+Notification:
+- method: 'json/schemaContent'
+- params: `string` the URL of the schema that has changed.
+
+## Try
+
+The JSON language server is shipped with [Visual Studio Code](https://code.visualstudio.com/) as part of the built-in VSCode extension `json-language-features`. The server is started when the first JSON file is opened. The [VSCode JSON documentation](https://code.visualstudio.com/docs/languages/json) for detailed information on the user experience and has more information on how to configure the language support.
+
+## Integrate
+
+If you plan to integrate the JSON language server into an editor and IDE, check out [this page](https://microsoft.github.io/language-server-protocol/implementors/tools/) if there's already an LSP client integration available.
+
+You can also launch the language server as a command and connect to it.
+For that, install the `json-language-server` npm module:
+
+`npm install -g json-language-server`
+
+Start the language server with the `json-language-server` command. Use a command line argument to specify the prefered communication channel:
+
+```
+json-language-server --node-ipc
+json-language-server --stdio
+json-language-server --socket=<port>
+```
+
+To connect to the server from NodeJS, see Remy Suen's great write-up on [how to communicate with the server](https://github.com/rcjsuen/dockerfile-language-server-nodejs#communicating-with-the-server) through the available communication channels.
+
+## Participate
+
+The source code of the JSON language server can be found [VSCode repository](https://github.com/Microsoft/vscode) at [extensions/json-language-features/server](https://github.com/Microsoft/vscode/tree/master/extensions/json-language-features/server).
+File issues and pull requests in the [VSCode GitHub Issues](https://github.com/Microsoft/vscode/issues). See the document [How to Contribute](https://github.com/Microsoft/vscode/wiki/How-to-Contribute) on how to build and run from source.
+
+Most of the functionality of the server is located in libraries:
+- [jsonc-parser](https://github.com/Microsoft/node-jsonc-parser) contains the JSON parser and scanner.
+- [vscode-json-languageservice](https://github.com/Microsoft/vscode-json-languageservice) contains the implementation of all features as a re-usable library.
+- [vscode-languageserver-node](https://github.com/Microsoft/vscode-languageserver-node) contains the implementation of language server for NodeJS.
+
+Help on any of these projects is very welcome.
+
+Please see also our [Code of Conduct](CODE_OF_CONDUCT.md).
+
+## License
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the [MIT](LICENSE.txt) License.
--- a/extensions/json-language-features/server/bin/vscode-json-languageserver
+++ b/extensions/json-language-features/server/bin/vscode-json-languageserver
@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+require("../out/jsonServerMain");
--- a/extensions/json-language-features/server/package.json
+++ b/extensions/json-language-features/server/package.json
@@ -0,0 +1,38 @@
+{
+  "name": "vscode-json-languageserver",
+  "description": "JSON language server",
+  "version": "1.0.1",
+  "author": "Microsoft Corporation",
+  "license": "MIT",
+  "engines": {
+    "node": "*"
+  },
+  "bin": {
+    "vscode-json-languageserver": "./bin/vscode-json-languageserver"
+  },
+  "dependencies": {
+    "jsonc-parser": "^2.0.0-next.1",
+    "request-light": "^0.2.2",
+    "vscode-json-languageservice": "^3.1.2-next.2",
+    "vscode-languageserver": "^4.0.0",
+    "vscode-languageserver-protocol-foldingprovider": "^2.0.0-next.2",
+    "vscode-nls": "^3.2.2",
+    "vscode-uri": "^1.0.3"
+  },
+  "devDependencies": {
+    "@types/mocha": "2.2.33",
+    "@types/node": "7.0.43"
+  },
+  "scripts": {
+    "prepublishOnly": "npm run clean && npm run test",
+    "preversion": "npm test",
+    "compile": "gulp compile-extension:json-language-features-server",
+    "watch": "gulp watch-extension:json-language-features-server",
+    "clean": "../../../node_modules/.bin/rimraf out",
+    "install-service-next": "yarn add vscode-json-languageservice@next",
+    "install-service-local": "yarn link vscode-json-languageservice",
+    "install-server-next": "yarn add vscode-languageserver@next",
+    "install-server-local": "yarn link vscode-languageserver-server",
+    "version": "git commit -m \"JSON Language Server $npm_package_version\" package.json"
+  }
+}
--- a/extensions/json-language-features/server/src/jsonServerMain.ts
+++ b/extensions/json-language-features/server/src/jsonServerMain.ts
@@ -0,0 +1,384 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import {
+	createConnection, IConnection,
+	TextDocuments, TextDocument, InitializeParams, InitializeResult, NotificationType, RequestType,
+	DocumentRangeFormattingRequest, Disposable, ServerCapabilities
+} 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 { startsWith } from './utils/strings';
+import { formatError, runSafe, runSafeAsync } from './utils/runner';
+import { JSONDocument, JSONSchema, getLanguageService, DocumentLanguageSettings, SchemaConfiguration } from 'vscode-json-languageservice';
+import { getLanguageModelCache } from './languageModelCache';
+
+import { FoldingRangeRequest, FoldingRangeServerCapabilities } from 'vscode-languageserver-protocol-foldingprovider';
+
+interface ISchemaAssociations {
+	[pattern: string]: string[];
+}
+
+namespace SchemaAssociationNotification {
+	export const type: NotificationType<ISchemaAssociations, 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');
+}
+
+// Create a connection for the server
+let 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);
+
+// Create a simple text document manager. The text document manager
+// supports full document sync only
+let documents: TextDocuments = new TextDocuments();
+// Make the text document manager listen on the connection
+// for open, change and close text document events
+documents.listen(connection);
+
+let clientSnippetSupport = false;
+let clientDynamicRegisterSupport = false;
+let foldingRangeLimit = 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 => {
+
+	function getClientCapability<T>(name: string, def: T) {
+		let 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);
+	clientDynamicRegisterSupport = getClientCapability('workspace.symbol.dynamicRegistration', false);
+	foldingRangeLimit = getClientCapability('textDocument.foldingRange.rangeLimit', Number.MAX_VALUE);
+	let capabilities: ServerCapabilities & FoldingRangeServerCapabilities = {
+		// Tell the client that the server works in FULL text document sync mode
+		textDocumentSync: documents.syncKind,
+		completionProvider: clientSnippetSupport ? { resolveProvider: true, triggerCharacters: ['"', ':'] } : void 0,
+		hoverProvider: true,
+		documentSymbolProvider: true,
+		documentRangeFormattingProvider: false,
+		colorProvider: true,
+		foldingRangeProvider: true
+	};
+
+	return { capabilities };
+});
+
+let workspaceContext = {
+	resolveRelativePath: (relativePath: string, resource: string) => {
+		return URL.resolve(resource, relativePath);
+	}
+};
+
+let schemaRequestService = (uri: string): Thenable<string> => {
+	if (startsWith(uri, 'file://')) {
+		let fsPath = URI.parse(uri).fsPath;
+		return new Promise<string>((c, e) => {
+			fs.readFile(fsPath, 'UTF-8', (err, result) => {
+				err ? e('') : c(result.toString());
+			});
+		});
+	} else if (startsWith(uri, 'vscode://')) {
+		return connection.sendRequest(VSCodeContentRequest.type, uri).then(responseText => {
+			return responseText;
+		}, error => {
+			return Promise.reject(error.message);
+		});
+	}
+	if (uri.indexOf('//schema.management.azure.com/') !== -1) {
+		/* __GDPR__
+			"json.schema" : {
+				"schemaURL" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		 */
+		connection.telemetry.logEvent({
+			key: 'json.schema',
+			value: {
+				schemaURL: uri
+			}
+		});
+	}
+	let 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());
+	});
+};
+
+// create the JSON language service
+let languageService = getLanguageService({
+	schemaRequestService,
+	workspaceContext,
+	contributions: []
+});
+
+// The settings interface describes the server relevant settings part
+interface Settings {
+	json: {
+		schemas: JSONSchemaSettings[];
+		format: { enable: boolean; };
+	};
+	http: {
+		proxy: string;
+		proxyStrictSSL: boolean;
+	};
+}
+
+interface JSONSchemaSettings {
+	fileMatch?: string[];
+	url?: string;
+	schema?: JSONSchema;
+}
+
+let jsonConfigurationSettings: JSONSchemaSettings[] | undefined = void 0;
+let schemaAssociations: ISchemaAssociations | undefined = void 0;
+let formatterRegistration: Thenable<Disposable> | null = null;
+
+// The settings have changed. Is send on server activation as well.
+connection.onDidChangeConfiguration((change) => {
+	var settings = <Settings>change.settings;
+	configureHttpRequests(settings.http && settings.http.proxy, settings.http && settings.http.proxyStrictSSL);
+
+	jsonConfigurationSettings = settings.json && settings.json.schemas;
+	updateConfiguration();
+
+	// dynamically enable & disable the formatter
+	if (clientDynamicRegisterSupport) {
+		let 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);
+});
+
+function updateConfiguration() {
+	let languageSettings = {
+		validate: true,
+		allowComments: true,
+		schemas: new Array<SchemaConfiguration>()
+	};
+	if (schemaAssociations) {
+		for (var pattern in schemaAssociations) {
+			let 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) => {
+	triggerValidation(change.document);
+});
+
+// a document has closed: clear all diagnostics
+documents.onDidClose(event => {
+	cleanPendingValidation(event.document);
+	connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+});
+
+let pendingValidationRequests: { [uri: string]: NodeJS.Timer; } = {};
+const validationDelayMs = 500;
+
+function cleanPendingValidation(textDocument: TextDocument): void {
+	let 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): void {
+	if (textDocument.getText().length === 0) {
+		// ignore empty documents
+		connection.sendDiagnostics({ uri: textDocument.uri, diagnostics: [] });
+		return;
+	}
+	let jsonDocument = getJSONDocument(textDocument);
+	let version = textDocument.version;
+
+	let documentSettings: DocumentLanguageSettings = textDocument.languageId === 'jsonc' ? { comments: 'ignore', trailingCommas: 'ignore' } : { comments: 'error', trailingCommas: 'error' };
+	languageService.doValidation(textDocument, jsonDocument, documentSettings).then(diagnostics => {
+		setTimeout(() => {
+			let currDocument = documents.get(textDocument.uri);
+			if (currDocument && currDocument.version === version) {
+				// Send the computed diagnostics to VSCode.
+				connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+			}
+		}, 100);
+	}, 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);
+	}
+});
+
+let 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(() => {
+		let document = documents.get(textDocumentPosition.textDocument.uri);
+		let jsonDocument = getJSONDocument(document);
+		return languageService.doComplete(document, textDocumentPosition.position, jsonDocument);
+	}, 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(() => {
+		let document = documents.get(textDocumentPositionParams.textDocument.uri);
+		let jsonDocument = getJSONDocument(document);
+		return languageService.doHover(document, textDocumentPositionParams.position, jsonDocument);
+	}, null, `Error while computing hover for ${textDocumentPositionParams.textDocument.uri}`, token);
+});
+
+connection.onDocumentSymbol((documentSymbolParams, token) => {
+	return runSafe(() => {
+		let document = documents.get(documentSymbolParams.textDocument.uri);
+		let jsonDocument = getJSONDocument(document);
+		return languageService.findDocumentSymbols(document, jsonDocument);
+	}, [], `Error while computing document symbols for ${documentSymbolParams.textDocument.uri}`, token);
+});
+
+connection.onDocumentRangeFormatting((formatParams, token) => {
+	return runSafe(() => {
+		let document = documents.get(formatParams.textDocument.uri);
+		return languageService.format(document, formatParams.range, formatParams.options);
+	}, [], `Error while formatting range for ${formatParams.textDocument.uri}`, token);
+});
+
+connection.onDocumentColor((params, token) => {
+	return runSafeAsync(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			let jsonDocument = getJSONDocument(document);
+			return languageService.findDocumentColors(document, jsonDocument);
+		}
+		return Promise.resolve([]);
+	}, [], `Error while computing document colors for ${params.textDocument.uri}`, token);
+});
+
+connection.onColorPresentation((params, token) => {
+	return runSafe(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			let jsonDocument = getJSONDocument(document);
+			return languageService.getColorPresentations(document, jsonDocument, params.color, params.range);
+		}
+		return [];
+	}, [], `Error while computing color presentations for ${params.textDocument.uri}`, token);
+});
+
+connection.onRequest(FoldingRangeRequest.type, (params, token) => {
+	return runSafe(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			return languageService.getFoldingRanges(document, { rangeLimit: foldingRangeLimit });
+		}
+		return null;
+	}, null, `Error while computing folding ranges for ${params.textDocument.uri}`, token);
+});
+
+// Listen on the connection
+connection.listen();
--- a/extensions/json-language-features/server/src/languageModelCache.ts
+++ b/extensions/json-language-features/server/src/languageModelCache.ts
@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { TextDocument } from 'vscode-languageserver';
+
+export interface LanguageModelCache<T> {
+	get(document: TextDocument): T;
+	onDocumentRemoved(document: TextDocument): void;
+	dispose(): void;
+}
+
+export function getLanguageModelCache<T>(maxEntries: number, cleanupIntervalTimeInSec: number, parse: (document: TextDocument) => T): LanguageModelCache<T> {
+	let languageModels: { [uri: string]: { version: number, languageId: string, cTime: number, languageModel: T } } = {};
+	let nModels = 0;
+
+	let cleanupInterval: NodeJS.Timer | undefined = void 0;
+	if (cleanupIntervalTimeInSec > 0) {
+		cleanupInterval = setInterval(() => {
+			let cutoffTime = Date.now() - cleanupIntervalTimeInSec * 1000;
+			let uris = Object.keys(languageModels);
+			for (let uri of uris) {
+				let languageModelInfo = languageModels[uri];
+				if (languageModelInfo.cTime < cutoffTime) {
+					delete languageModels[uri];
+					nModels--;
+				}
+			}
+		}, cleanupIntervalTimeInSec * 1000);
+	}
+
+	return {
+		get(document: TextDocument): T {
+			let version = document.version;
+			let languageId = document.languageId;
+			let languageModelInfo = languageModels[document.uri];
+			if (languageModelInfo && languageModelInfo.version === version && languageModelInfo.languageId === languageId) {
+				languageModelInfo.cTime = Date.now();
+				return languageModelInfo.languageModel;
+			}
+			let languageModel = parse(document);
+			languageModels[document.uri] = { languageModel, version, languageId, cTime: Date.now() };
+			if (!languageModelInfo) {
+				nModels++;
+			}
+
+			if (nModels === maxEntries) {
+				let oldestTime = Number.MAX_VALUE;
+				let oldestUri = null;
+				for (let uri in languageModels) {
+					let languageModelInfo = languageModels[uri];
+					if (languageModelInfo.cTime < oldestTime) {
+						oldestUri = uri;
+						oldestTime = languageModelInfo.cTime;
+					}
+				}
+				if (oldestUri) {
+					delete languageModels[oldestUri];
+					nModels--;
+				}
+			}
+			return languageModel;
+
+		},
+		onDocumentRemoved(document: TextDocument) {
+			let uri = document.uri;
+			if (languageModels[uri]) {
+				delete languageModels[uri];
+				nModels--;
+			}
+		},
+		dispose() {
+			if (typeof cleanupInterval !== 'undefined') {
+				clearInterval(cleanupInterval);
+				cleanupInterval = void 0;
+				languageModels = {};
+				nModels = 0;
+			}
+		}
+	};
+}
--- a/extensions/json-language-features/server/src/utils/runner.ts
+++ b/extensions/json-language-features/server/src/utils/runner.ts
@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { CancellationToken, ResponseError, ErrorCodes } from 'vscode-languageserver';
+
+export function formatError(message: string, err: any): string {
+	if (err instanceof Error) {
+		let error = <Error>err;
+		return `${message}: ${error.message}\n${error.stack}`;
+	} else if (typeof err === 'string') {
+		return `${message}: ${err}`;
+	} else if (err) {
+		return `${message}: ${err.toString()}`;
+	}
+	return message;
+}
+
+export function runSafeAsync<T>(func: () => Thenable<T>, errorVal: T, errorMessage: string, token: CancellationToken): Thenable<T | ResponseError<any>> {
+	return new Promise<T | ResponseError<any>>((resolve, reject) => {
+		setImmediate(() => {
+			if (token.isCancellationRequested) {
+				resolve(cancelValue());
+			}
+			return func().then(result => {
+				if (token.isCancellationRequested) {
+					resolve(cancelValue());
+					return;
+				} else {
+					resolve(result);
+				}
+			}, e => {
+				console.error(formatError(errorMessage, e));
+				resolve(errorVal);
+			});
+		});
+	});
+}
+
+export function runSafe<T, E>(func: () => T, errorVal: T, errorMessage: string, token: CancellationToken): Thenable<T | ResponseError<E>> {
+	return new Promise<T | ResponseError<E>>((resolve, reject) => {
+		setImmediate(() => {
+			if (token.isCancellationRequested) {
+				resolve(cancelValue());
+			} else {
+				try {
+					let result = func();
+					if (token.isCancellationRequested) {
+						resolve(cancelValue());
+						return;
+					} else {
+						resolve(result);
+					}
+
+				} catch (e) {
+					console.error(formatError(errorMessage, e));
+					resolve(errorVal);
+				}
+			}
+		});
+	});
+}
+
+function cancelValue<E>() {
+	console.log('cancelled');
+	return new ResponseError<E>(ErrorCodes.RequestCancelled, 'Request cancelled');
+}
--- a/extensions/json-language-features/server/src/utils/strings.ts
+++ b/extensions/json-language-features/server/src/utils/strings.ts
@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+export function startsWith(haystack: string, needle: string): boolean {
+	if (haystack.length < needle.length) {
+		return false;
+	}
+
+	for (let i = 0; i < needle.length; i++) {
+		if (haystack[i] !== needle[i]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * Determines if haystack ends with needle.
+ */
+export function endsWith(haystack: string, needle: string): boolean {
+	let diff = haystack.length - needle.length;
+	if (diff > 0) {
+		return haystack.lastIndexOf(needle) === diff;
+	} else if (diff === 0) {
+		return haystack === needle;
+	} else {
+		return false;
+	}
+}
+
+export function convertSimple2RegExpPattern(pattern: string): string {
+	return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
+}
--- a/extensions/json-language-features/server/test/mocha.opts
+++ b/extensions/json-language-features/server/test/mocha.opts
@@ -0,0 +1,3 @@
+--ui tdd
+--useColors true
+./out/test/**/*.test.js
--- a/extensions/json-language-features/server/tsconfig.json
+++ b/extensions/json-language-features/server/tsconfig.json
@@ -0,0 +1,17 @@
+{
+	"compilerOptions": {
+		"target": "es5",
+		"module": "commonjs",
+		"sourceMap": true,
+		"sourceRoot": "../src",
+		"outDir": "./out",
+		"noUnusedLocals": true,
+		"lib": [
+			"es5", "es2015.promise"
+		],
+		"strict": true
+	},
+	"include": [
+		"src/**/*"
+	]
+}
--- a/extensions/json-language-features/server/yarn.lock
+++ b/extensions/json-language-features/server/yarn.lock
@@ -0,0 +1,135 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@types/mocha@2.2.33":
+  version "2.2.33"
+  resolved "https://registry.yarnpkg.com/@types/mocha/-/mocha-2.2.33.tgz#d79a0061ec270379f4d9e225f4096fb436669def"
+
+"@types/node@7.0.43":
+  version "7.0.43"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-7.0.43.tgz#a187e08495a075f200ca946079c914e1a5fe962c"
+
+agent-base@4, agent-base@^4.1.0:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-4.1.2.tgz#80fa6cde440f4dcf9af2617cf246099b5d99f0c8"
+  dependencies:
+    es6-promisify "^5.0.0"
+
+debug@2:
+  version "2.6.9"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
+  dependencies:
+    ms "2.0.0"
+
+debug@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
+  dependencies:
+    ms "2.0.0"
+
+es6-promise@^4.0.3:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.1.1.tgz#8811e90915d9a0dba36274f0b242dbda78f9c92a"
+
+es6-promisify@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-5.0.0.tgz#5109d62f3e56ea967c4b63505aef08291c8a5203"
+  dependencies:
+    es6-promise "^4.0.3"
+
+http-proxy-agent@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-2.0.0.tgz#46482a2f0523a4d6082551709f469cb3e4a85ff4"
+  dependencies:
+    agent-base "4"
+    debug "2"
+
+https-proxy-agent@2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-2.1.1.tgz#a7ce4382a1ba8266ee848578778122d491260fd9"
+  dependencies:
+    agent-base "^4.1.0"
+    debug "^3.1.0"
+
+jsonc-parser@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-2.0.0.tgz#62ff087a7e753875febf3c55f1fc0cd737c36b5a"
+
+jsonc-parser@^2.0.0-next.1:
+  version "2.0.0-next.1"
+  resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-2.0.0-next.1.tgz#445a824f765a96abfbb286d759a9b1d226b18088"
+
+ms@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
+
+request-light@^0.2.2:
+  version "0.2.2"
+  resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.2.2.tgz#53e48af32ad1514e45221ea5ece5ce782720f712"
+  dependencies:
+    http-proxy-agent "2.0.0"
+    https-proxy-agent "2.1.1"
+    vscode-nls "^2.0.2"
+
+vscode-json-languageservice@^3.1.2-next.2:
+  version "3.1.2-next.2"
+  resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-3.1.2-next.2.tgz#da5346e5c22edbce739f29c110eb41732d41dc2d"
+  dependencies:
+    jsonc-parser "^2.0.0"
+    vscode-languageserver-types "^3.6.1"
+    vscode-nls "^3.2.1"
+    vscode-uri "^1.0.3"
+
+vscode-jsonrpc@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-3.6.0.tgz#848d56995d5168950d84feb5d9c237ae5c6a02d4"
+
+vscode-languageserver-protocol-foldingprovider@^2.0.0-next.2:
+  version "2.0.0-next.2"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol-foldingprovider/-/vscode-languageserver-protocol-foldingprovider-2.0.0-next.2.tgz#fbb9cfdf5b8c4ac451826ba6312f1f88379f35b0"
+  dependencies:
+    vscode-languageserver-protocol "^3.6.0"
+    vscode-languageserver-types "^3.6.0"
+
+vscode-languageserver-protocol@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.6.0.tgz#579642cdcccf74b0cd771c33daa3239acb40d040"
+  dependencies:
+    vscode-jsonrpc "^3.6.0"
+    vscode-languageserver-types "^3.6.0"
+
+vscode-languageserver-types@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.6.0.tgz#0bba63b0fa82a714394a4478f55a596ee4ed7d0a"
+
+vscode-languageserver-types@^3.6.1:
+  version "3.6.1"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.6.1.tgz#4bc06a48dff653495f12f94b8b1e228988a1748d"
+
+vscode-languageserver@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver/-/vscode-languageserver-4.0.0.tgz#8b792f0d6d10acfe363d02371ed4ce53d08af88a"
+  dependencies:
+    vscode-languageserver-protocol "^3.6.0"
+    vscode-uri "^1.0.1"
+
+vscode-nls@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/vscode-nls/-/vscode-nls-2.0.2.tgz#808522380844b8ad153499af5c3b03921aea02da"
+
+vscode-nls@^3.2.1:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/vscode-nls/-/vscode-nls-3.2.1.tgz#b1f3e04e8a94a715d5a7bcbc8339c51e6d74ca51"
+
+vscode-nls@^3.2.2:
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/vscode-nls/-/vscode-nls-3.2.2.tgz#3817eca5b985c2393de325197cf4e15eb2aa5350"
+
+vscode-uri@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-1.0.1.tgz#11a86befeac3c4aa3ec08623651a3c81a6d0bbc8"
+
+vscode-uri@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-1.0.3.tgz#631bdbf716dccab0e65291a8dc25c23232085a52"
--- a/extensions/json-language-features/yarn.lock
+++ b/extensions/json-language-features/yarn.lock
@@ -0,0 +1,71 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@types/node@7.0.43":
+  version "7.0.43"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-7.0.43.tgz#a187e08495a075f200ca946079c914e1a5fe962c"
+
+applicationinsights@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/applicationinsights/-/applicationinsights-1.0.1.tgz#53446b830fe8d5d619eee2a278b31d3d25030927"
+  dependencies:
+    diagnostic-channel "0.2.0"
+    diagnostic-channel-publishers "0.2.1"
+    zone.js "0.7.6"
+
+diagnostic-channel-publishers@0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/diagnostic-channel-publishers/-/diagnostic-channel-publishers-0.2.1.tgz#8e2d607a8b6d79fe880b548bc58cc6beb288c4f3"
+
+diagnostic-channel@0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/diagnostic-channel/-/diagnostic-channel-0.2.0.tgz#cc99af9612c23fb1fff13612c72f2cbfaa8d5a17"
+  dependencies:
+    semver "^5.3.0"
+
+semver@^5.3.0:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.5.0.tgz#dc4bbc7a6ca9d916dee5d43516f0092b58f7b8ab"
+
+vscode-extension-telemetry@0.0.17:
+  version "0.0.17"
+  resolved "https://registry.yarnpkg.com/vscode-extension-telemetry/-/vscode-extension-telemetry-0.0.17.tgz#15123e7edb34e7b9724b6056f54a869bbb922cb7"
+  dependencies:
+    applicationinsights "1.0.1"
+
+vscode-jsonrpc@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-3.6.0.tgz#848d56995d5168950d84feb5d9c237ae5c6a02d4"
+
+vscode-languageclient@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/vscode-languageclient/-/vscode-languageclient-4.0.0.tgz#635f5bfbcfa1385dae489b394857f1db8b459a7d"
+  dependencies:
+    vscode-languageserver-protocol "^3.6.0"
+
+vscode-languageserver-protocol-foldingprovider@^2.0.0-next.2:
+  version "2.0.0-next.2"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol-foldingprovider/-/vscode-languageserver-protocol-foldingprovider-2.0.0-next.2.tgz#fbb9cfdf5b8c4ac451826ba6312f1f88379f35b0"
+  dependencies:
+    vscode-languageserver-protocol "^3.6.0"
+    vscode-languageserver-types "^3.6.0"
+
+vscode-languageserver-protocol@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.6.0.tgz#579642cdcccf74b0cd771c33daa3239acb40d040"
+  dependencies:
+    vscode-jsonrpc "^3.6.0"
+    vscode-languageserver-types "^3.6.0"
+
+vscode-languageserver-types@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.6.0.tgz#0bba63b0fa82a714394a4478f55a596ee4ed7d0a"
+
+vscode-nls@^3.2.2:
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/vscode-nls/-/vscode-nls-3.2.2.tgz#3817eca5b985c2393de325197cf4e15eb2aa5350"
+
+zone.js@0.7.6:
+  version "0.7.6"
+  resolved "https://registry.yarnpkg.com/zone.js/-/zone.js-0.7.6.tgz#fbbc39d3e0261d0986f1ba06306eb3aeb0d22009"