Use the global `monaco` only in the AMD case (see https://github.com/microsoft/monaco-editor/issues/1974)

README.md

@@ -9,7 +9,7 @@ JSON language plugin for the Monaco Editor. It provides the following features w
 * Syntax highlighting
 * Color decorators for all properties matching a schema containing `format: "color-hex"'` (non-standard schema extension)
 
-Schemas can be provided by configuration. See [here](https://github.com/Microsoft/monaco-json/blob/master/src/monaco.d.ts)
+Schemas can be provided by configuration. See [here](https://github.com/Microsoft/monaco-json/blob/master/monaco.d.ts)
 for the API that the JSON plugin offers to configure the JSON language support.
 
 Internally the JSON plugin uses the [vscode-json-languageservice](https://github.com/Microsoft/vscode-json-languageservice)

src/monaco.d.ts → monaco.d.ts

@@ -3,7 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-declare module monaco.languages.json {
+declare namespace monaco.languages.json {
+
 	export interface DiagnosticsOptions {
 		/**
 		 * If set, the validator will be enabled and perform syntax validation as well as schema based validation.
@@ -35,67 +36,56 @@ declare module monaco.languages.json {
 		 */
 		readonly enableSchemaRequest?: boolean;
 	}
-
 	export interface ModeConfiguration {
 		/**
 		 * Defines whether the built-in documentFormattingEdit provider is enabled.
 		 */
 		readonly documentFormattingEdits?: boolean;
-
 		/**
 		 * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
 		 */
 		readonly documentRangeFormattingEdits?: boolean;
-
 		/**
 		 * Defines whether the built-in completionItemProvider is enabled.
 		 */
 		readonly completionItems?: boolean;
-
 		/**
 		 * Defines whether the built-in hoverProvider is enabled.
 		 */
 		readonly hovers?: boolean;
-
 		/**
 		 * Defines whether the built-in documentSymbolProvider is enabled.
 		 */
 		readonly documentSymbols?: boolean;
-
 		/**
 		 * Defines whether the built-in tokens provider is enabled.
 		 */
 		readonly tokens?: boolean;
-
 		/**
 		 * Defines whether the built-in color provider is enabled.
 		 */
 		readonly colors?: boolean;
-
 		/**
 		 * Defines whether the built-in foldingRange provider is enabled.
 		 */
 		readonly foldingRanges?: boolean;
-
 		/**
 		 * Defines whether the built-in diagnostic provider is enabled.
 		 */
 		readonly diagnostics?: boolean;
-
 		/**
 		 * Defines whether the built-in selection range provider is enabled.
 		 */
 		readonly selectionRanges?: boolean;
-
 	}
-
 	export interface LanguageServiceDefaults {
+		readonly languageId: string;
 		readonly onDidChange: IEvent<LanguageServiceDefaults>;
 		readonly diagnosticsOptions: DiagnosticsOptions;
 		readonly modeConfiguration: ModeConfiguration;
 		setDiagnosticsOptions(options: DiagnosticsOptions): void;
 		setModeConfiguration(modeConfiguration: ModeConfiguration): void;
 	}
+	export const jsonDefaults: LanguageServiceDefaults;
 
-	export var jsonDefaults: LanguageServiceDefaults;
 }

package-lock.json

@@ -17,9 +17,9 @@
       "dev": true
     },
     "jsonc-parser": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.2.0.tgz",
-      "integrity": "sha512-4fLQxW1j/5fWj6p78vAlAafoCKtuBm6ghv+Ij5W2DrDx0qE+ZdEl2c6Ko1mgJNF5ftX1iEWQQ4Ap7+3GlhjkOA==",
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.3.0.tgz",
+      "integrity": "sha512-b0EBt8SWFNnixVdvoR2ZtEGa9ZqLhbJnOjezn+WP+8kspFm+PFYDN8Z4Bc7pRlDjvuVcADSUkroIuTWWn/YiIA==",
       "dev": true
     },
     "monaco-editor-core": {
@@ -35,9 +35,9 @@
       "dev": true
     },
     "monaco-plugin-helpers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/monaco-plugin-helpers/-/monaco-plugin-helpers-1.0.2.tgz",
-      "integrity": "sha512-7kUx8dtd5qVNVgUARBRhnM8oftPglYwlINfigC4yGUiuzqtIN22u1tly8umiOCIPR0eFiBLjt6aN23oZh2QJgg==",
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/monaco-plugin-helpers/-/monaco-plugin-helpers-1.0.3.tgz",
+      "integrity": "sha512-6AYI3ONAy8ki74qG2JqtFrLdiJHQlgeO5l4Rwr0OMyIpGXhc94y5rZuFxOtgGkxgSrZfHSwOt/MulUNZ/mOQOw==",
       "dev": true,
       "requires": {
         "typescript": "^2.7.2"
@@ -64,9 +64,9 @@
       "dev": true
     },
     "source-map-support": {
-      "version": "0.5.16",
-      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.16.tgz",
-      "integrity": "sha512-efyLRJDr68D9hBBNIPWFjhpFzURh+KJykQwvMyW5UiZzYwoF6l4YMMDIJJEyFWxWCqfyxLzz6tSfUFR+kXXsVQ==",
+      "version": "0.5.19",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz",
+      "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==",
       "dev": true,
       "requires": {
         "buffer-from": "^1.0.0",
@@ -74,9 +74,9 @@
       }
     },
     "terser": {
-      "version": "4.6.3",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-4.6.3.tgz",
-      "integrity": "sha512-Lw+ieAXmY69d09IIc/yqeBqXpEQIpDGZqT34ui1QWXIUpR2RjbqEkT8X7Lgex19hslSqcWM5iMN2kM11eMsESQ==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.3.0.tgz",
+      "integrity": "sha512-XTT3D3AwxC54KywJijmY2mxZ8nJiEjBHVYzq8l9OaYuRFWeQNBwvipuzzYEP4e+/AVcd1hqG/CqgsdIRyT45Fg==",
       "dev": true,
       "requires": {
         "commander": "^2.20.0",
@@ -85,9 +85,9 @@
       }
     },
     "typescript": {
-      "version": "3.7.5",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.5.tgz",
-      "integrity": "sha512-/P5lkRXkWHNAbcJIiHPfRoKqyd7bsyCma1hZNUGfn20qm64T6ZBlrzprymeu918H+mB/0rIg2gGK/BXkhhYgBw==",
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.0.2.tgz",
+      "integrity": "sha512-e4ERvRV2wb+rRZ/IQeb3jm2VxBsirQLpQhdxplZ2MEzGvDkkMmPglecnNDfSUBivMjP93vRbngYYDQqQ/78bcQ==",
       "dev": true
     },
     "vscode-json-languageservice": {
@@ -104,27 +104,27 @@
       }
     },
     "vscode-languageserver-textdocument": {
-      "version": "1.0.0-next.5",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.0-next.5.tgz",
-      "integrity": "sha512-1jp/zAidN/bF/sqPimhBX1orH5G4rzRw63k75TesukJDuxm8yW79ECStWbDSy41BHGOwSGN4M69QFvhancSr5A==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.1.tgz",
+      "integrity": "sha512-UIcJDjX7IFkck7cSkNNyzIz5FyvpQfY7sdzVy+wkKN/BLaD4DQ0ppXQrKePomCxTS7RrolK1I0pey0bG9eh8dA==",
       "dev": true
     },
     "vscode-languageserver-types": {
-      "version": "3.15.0-next.9",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.0-next.9.tgz",
-      "integrity": "sha512-Rl/8qJ6932nrHCdPn+9y0x08uLVQaSLRG+U4JzhyKpWU4eJbVaDRoAcz1Llj7CErJGbPr6kdBvShPy5fRfR+Uw==",
+      "version": "3.15.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.1.tgz",
+      "integrity": "sha512-+a9MPUQrNGRrGU630OGbYVQ+11iOIovjCkqxajPa9w57Sd5ruK8WQNsslzpa0x/QJqC8kRc2DUxWjIFwoNm4ZQ==",
       "dev": true
     },
     "vscode-nls": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.1.tgz",
-      "integrity": "sha512-4R+2UoUUU/LdnMnFjePxfLqNhBS8lrAFyX7pjb2ud/lqDkrUavFUTcG7wR0HBZFakae0Q6KLBFjMS6W93F403A==",
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.2.tgz",
+      "integrity": "sha512-7bOHxPsfyuCqmP+hZXscLhiHwe7CSuFE4hyhbs22xPIhQ4jv99FcR4eBzfYYVLP356HNFpdvz63FFb/xw6T4Iw==",
       "dev": true
     },
     "vscode-uri": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-2.1.1.tgz",
-      "integrity": "sha512-eY9jmGoEnVf8VE8xr5znSah7Qt1P/xsCdErz+g8HYZtJ7bZqKH5E3d+6oVNm1AC/c6IHUDokbmVXKOi4qPAC9A==",
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-2.1.2.tgz",
+      "integrity": "sha512-8TEXQxlldWAuIODdukIb+TR5s+9Ds40eSJrw+1iDDA9IFORPjMELarNQE3myz5XIkWWpdprmJjm1/SxMlWOC8A==",
       "dev": true
     }
   }

package.json

@@ -3,9 +3,9 @@
   "version": "2.9.0",
   "description": "JSON plugin for the Monaco Editor",
   "scripts": {
-    "compile": "mrmdir ./out && tsc -p ./src/tsconfig.json && tsc -p ./src/tsconfig.esm.json",
+    "compile": "mrmdir ./out && tsc -p ./src/tsconfig.json && tsc -p ./src/tsconfig.esm.json && node ./scripts/dts",
     "watch": "tsc -p ./src --watch",
-    "prepublishOnly": "mrmdir ./release && npm run compile && node ./scripts/release.js && node ./scripts/bundle && mcopy ./src/monaco.d.ts ./release/monaco.d.ts",
+    "prepublishOnly": "mrmdir ./release && npm run compile && node ./scripts/release.js && node ./scripts/bundle && mcopy ./monaco.d.ts ./release/monaco.d.ts && mcopy ./out/esm/monaco.contribution.d.ts ./release/esm/monaco.contribution.d.ts && mcopy ./out/esm/fillers/monaco-editor-core.d.ts ./release/esm/fillers/monaco-editor-core.d.ts",
     "install-service-next": "npm install vscode-json-languageservice@next -f -D && npm install vscode-languageserver-types@next -f -D",
     "install-service-local": "npm install ../vscode-json-languageservice -f -D && npm install ../vscode-languageserver-node/types -f -D"
   },
@@ -18,14 +18,16 @@
   "bugs": {
     "url": "https://github.com/Microsoft/monaco-json/issues"
   },
+  "module": "./release/esm/monaco.contribution.js",
+  "typings": "./release/esm/monaco.contribution.d.ts",
   "devDependencies": {
     "jsonc-parser": "^2.2.0",
     "monaco-editor-core": "0.20.0",
     "monaco-languages": "1.10.0",
-    "monaco-plugin-helpers": "^1.0.2",
+    "monaco-plugin-helpers": "^1.0.3",
     "requirejs": "^2.3.6",
-    "typescript": "3.7.5",
-    "terser": "^4.6.3",
+    "typescript": "4.0.2",
+    "terser": "^5.3.0",
     "vscode-json-languageservice": "3.4.11"
   }
 }

scripts/bundle.js

@@ -24,14 +24,14 @@ bundleOne('monaco.contribution');
 bundleOne('jsonMode');
 bundleOne('jsonWorker');
 
-function bundleOne(moduleId, exclude) {
+function bundleOne(moduleId) {
 	requirejs.optimize({
 		baseUrl: 'out/amd/',
 		name: 'vs/language/json/' + moduleId,
 		out: 'release/dev/' + moduleId + '.js',
-		exclude: exclude,
 		paths: {
-			'vs/language/json': REPO_ROOT + '/out/amd'
+			'vs/language/json': REPO_ROOT + '/out/amd',
+			'vs/language/json/fillers/monaco-editor-core': REPO_ROOT + '/out/amd/fillers/monaco-editor-core-amd',
 		},
 		optimize: 'none',
 		packages: [{

scripts/dts.js

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const path = require('path');
+const fs = require('fs');
+
+const REPO_ROOT = path.join(__dirname, '../');
+const SRC_PATH = path.join(REPO_ROOT, 'out/amd/monaco.contribution.d.ts');
+const DST_PATH = path.join(REPO_ROOT, 'monaco.d.ts');
+
+const lines = fs.readFileSync(SRC_PATH).toString().split(/\r\n|\r|\n/);
+let result = [
+	`/*---------------------------------------------------------------------------------------------`,
+	` *  Copyright (c) Microsoft Corporation. All rights reserved.`,
+	` *  Licensed under the MIT License. See License.txt in the project root for license information.`,
+	` *--------------------------------------------------------------------------------------------*/`,
+	``,
+	`declare namespace monaco.languages.json {`,
+	``
+];
+for (let line of lines) {
+	if (/^import/.test(line)) {
+		continue;
+	}
+	line = line.replace(/    /g, '\t');
+	line = line.replace(/export declare/g, 'export');
+	if (line.length > 0) {
+		line = `\t${line}`;
+	}
+	result.push(line);
+}
+result.push(`}`);
+result.push(``);
+
+fs.writeFileSync(DST_PATH, result.join('\n'));

src/fillers/monaco-editor-core-amd.ts

@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// Resolves with the global monaco API
+
+declare var define;
+
+define([], function() {
+    return (<any>self).monaco;
+});

src/typings/refs.d.ts → src/fillers/monaco-editor-core.ts

@@ -2,4 +2,5 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-/// <reference path='../../node_modules/monaco-editor-core/monaco.d.ts'/>
+
+export * from 'monaco-editor-core';

src/json.worker.ts

@@ -2,7 +2,6 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
 import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
 import { JSONWorker } from './jsonWorker';

src/jsonMode.ts

@@ -2,18 +2,15 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
 import { WorkerManager } from './workerManager';
-import { JSONWorker } from './jsonWorker';
-import { LanguageServiceDefaultsImpl } from './monaco.contribution';
+import type { JSONWorker } from './jsonWorker';
+import { LanguageServiceDefaults } from './monaco.contribution';
 import * as languageFeatures from './languageFeatures';
 import { createTokenizationSupport } from './tokenization';
+import { Uri, IDisposable, languages } from './fillers/monaco-editor-core'
 
-import Uri = monaco.Uri;
-import IDisposable = monaco.IDisposable;
-
-export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
+export function setupMode(defaults: LanguageServiceDefaults): IDisposable {
 
 	const disposables: IDisposable[] = [];
 	const providers: IDisposable[] = [];
@@ -32,40 +29,40 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
 		disposeAll(providers);
 
 		if (modeConfiguration.documentFormattingEdits) {
-			providers.push(monaco.languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker)));
+			providers.push(languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker)));
 		}
 		if (modeConfiguration.documentRangeFormattingEdits) {
-			providers.push(monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker)));
+			providers.push(languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker)));
 		}
 		if (modeConfiguration.completionItems) {
-			providers.push(monaco.languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker)));
+			providers.push(languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker)));
 		}
 		if (modeConfiguration.hovers) {
-			providers.push(monaco.languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker)));
+			providers.push(languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker)));
 		}
 		if (modeConfiguration.documentSymbols) {
-			providers.push(monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker)));
+			providers.push(languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker)));
 		}
 		if (modeConfiguration.tokens) {
-			providers.push(monaco.languages.setTokensProvider(languageId, createTokenizationSupport(true)));
+			providers.push(languages.setTokensProvider(languageId, createTokenizationSupport(true)));
 		}
 		if (modeConfiguration.colors) {
-			providers.push(monaco.languages.registerColorProvider(languageId, new languageFeatures.DocumentColorAdapter(worker)));
+			providers.push(languages.registerColorProvider(languageId, new languageFeatures.DocumentColorAdapter(worker)));
 		}
 		if (modeConfiguration.foldingRanges) {
-			providers.push(monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker)));
+			providers.push(languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker)));
 		}
 		if (modeConfiguration.diagnostics) {
 			providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults));
 		}
 		if (modeConfiguration.selectionRanges) {
-			providers.push(monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker)));
+			providers.push(languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker)));
 		}
 	}
 
 	registerProviders();
 
-	disposables.push(monaco.languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration));
+	disposables.push(languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration));
 
 	let modeConfiguration = defaults.modeConfiguration;
 	defaults.onDidChange((newDefaults) => {
@@ -90,7 +87,7 @@ function disposeAll(disposables: IDisposable[]) {
 	}
 }
 
-const richEditConfiguration: monaco.languages.LanguageConfiguration = {
+const richEditConfiguration: languages.LanguageConfiguration = {
 	wordPattern: /(-?\d*\.\d\w*)|([^\[\{\]\}\:\"\,\s]+)/g,
 
 	comments: {

src/jsonWorker.ts

@@ -2,61 +2,33 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
-
-import Thenable = monaco.Thenable;
-import IWorkerContext = monaco.worker.IWorkerContext;
 
 import * as jsonService from 'vscode-json-languageservice';
+import type { worker } from './fillers/monaco-editor-core'
 
 let defaultSchemaRequestService;
 if (typeof fetch !== 'undefined') {
 	defaultSchemaRequestService = function (url) { return fetch(url).then(response => response.text()) };
 }
 
-class PromiseAdapter<T> implements jsonService.Thenable<T> {
-	private wrapped: Promise<T>;
-
-	constructor(executor: (resolve: (value?: T | jsonService.Thenable<T>) => void, reject: (reason?: any) => void) => void) {
-		this.wrapped = new Promise<T>(executor);
-	}
-	public then<TResult>(onfulfilled?: (value: T) => TResult | jsonService.Thenable<TResult>, onrejected?: (reason: any) => void): jsonService.Thenable<TResult> {
-		let thenable: jsonService.Thenable<T> = this.wrapped;
-		return thenable.then(onfulfilled, onrejected);
-	}
-	public getWrapped(): monaco.Thenable<T> {
-		return this.wrapped;
-	}
-	public static resolve<T>(v: T | Thenable<T>): jsonService.Thenable<T> {
-		return <monaco.Thenable<T>>Promise.resolve(v);
-	}
-	public static reject<T>(v: T): jsonService.Thenable<T> {
-		return Promise.reject(<any>v);
-	}
-	public static all<T>(values: jsonService.Thenable<T>[]): jsonService.Thenable<T[]> {
-		return Promise.all(values);
-	}
-}
-
 export class JSONWorker {
 
-	private _ctx: IWorkerContext;
+	private _ctx: worker.IWorkerContext;
 	private _languageService: jsonService.LanguageService;
 	private _languageSettings: jsonService.LanguageSettings;
 	private _languageId: string;
 
-	constructor(ctx: IWorkerContext, createData: ICreateData) {
+	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
 		this._ctx = ctx;
 		this._languageSettings = createData.languageSettings;
 		this._languageId = createData.languageId;
 		this._languageService = jsonService.getLanguageService({
-			schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService,
-			promiseConstructor: PromiseAdapter
+			schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService
 		});
 		this._languageService.configure(this._languageSettings);
 	}
 
-	doValidation(uri: string): Thenable<jsonService.Diagnostic[]> {
+	async doValidation(uri: string): Promise<jsonService.Diagnostic[]> {
 		let document = this._getTextDocument(uri);
 		if (document) {
 			let jsonDocument = this._languageService.parseJSONDocument(document);
@@ -64,51 +36,51 @@ export class JSONWorker {
 		}
 		return Promise.resolve([]);
 	}
-	doComplete(uri: string, position: jsonService.Position): Thenable<jsonService.CompletionList> {
+	async doComplete(uri: string, position: jsonService.Position): Promise<jsonService.CompletionList> {
 		let document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		return this._languageService.doComplete(document, position, jsonDocument);
 	}
-	doResolve(item: jsonService.CompletionItem): Thenable<jsonService.CompletionItem> {
+	async doResolve(item: jsonService.CompletionItem): Promise<jsonService.CompletionItem> {
 		return this._languageService.doResolve(item);
 	}
-	doHover(uri: string, position: jsonService.Position): Thenable<jsonService.Hover> {
+	async doHover(uri: string, position: jsonService.Position): Promise<jsonService.Hover> {
 		let document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		return this._languageService.doHover(document, position, jsonDocument);
 	}
-	format(uri: string, range: jsonService.Range, options: jsonService.FormattingOptions): Thenable<jsonService.TextEdit[]> {
+	async format(uri: string, range: jsonService.Range, options: jsonService.FormattingOptions): Promise<jsonService.TextEdit[]> {
 		let document = this._getTextDocument(uri);
 		let textEdits = this._languageService.format(document, range, options);
 		return Promise.resolve(textEdits);
 	}
-	resetSchema(uri: string): Thenable<boolean> {
+	async resetSchema(uri: string): Promise<boolean> {
 		return Promise.resolve(this._languageService.resetSchema(uri));
 	}
-	findDocumentSymbols(uri: string): Thenable<jsonService.SymbolInformation[]> {
+	async findDocumentSymbols(uri: string): Promise<jsonService.SymbolInformation[]> {
 		let document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let symbols = this._languageService.findDocumentSymbols(document, jsonDocument);
 		return Promise.resolve(symbols);
 	}
-	findDocumentColors(uri: string): Thenable<jsonService.ColorInformation[]> {
+	async findDocumentColors(uri: string): Promise<jsonService.ColorInformation[]> {
 		let document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let colorSymbols = this._languageService.findDocumentColors(document, jsonDocument);
 		return Promise.resolve(colorSymbols);
 	}
-	getColorPresentations(uri: string, color: jsonService.Color, range: jsonService.Range): Thenable<jsonService.ColorPresentation[]> {
+	async getColorPresentations(uri: string, color: jsonService.Color, range: jsonService.Range): Promise<jsonService.ColorPresentation[]> {
 		let document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let colorPresentations = this._languageService.getColorPresentations(document, jsonDocument, color, range);
 		return Promise.resolve(colorPresentations);
 	}
-	getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Thenable<jsonService.FoldingRange[]> {
+	async getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Promise<jsonService.FoldingRange[]> {
 		let document = this._getTextDocument(uri);
 		let ranges = this._languageService.getFoldingRanges(document, context);
 		return Promise.resolve(ranges);
 	}
-	getSelectionRanges(uri: string, positions: jsonService.Position[]): Thenable<jsonService.SelectionRange[]> {
+	async getSelectionRanges(uri: string, positions: jsonService.Position[]): Promise<jsonService.SelectionRange[]> {
 		let document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let ranges = this._languageService.getSelectionRanges(document, positions, jsonDocument);
@@ -131,6 +103,6 @@ export interface ICreateData {
 	enableSchemaRequest: boolean;
 }
 
-export function create(ctx: IWorkerContext, createData: ICreateData): JSONWorker {
+export function create(ctx: worker.IWorkerContext, createData: ICreateData): JSONWorker {
 	return new JSONWorker(ctx, createData);
 }

src/languageFeatures.ts

@@ -2,24 +2,15 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
-
-import { LanguageServiceDefaultsImpl } from './monaco.contribution';
-import { JSONWorker } from './jsonWorker';
 
+import { LanguageServiceDefaults } from './monaco.contribution';
+import type { JSONWorker } from './jsonWorker';
+import { Uri, Position, Range, IRange, CancellationToken, IDisposable, editor, languages, MarkerSeverity, IMarkdownString } from './fillers/monaco-editor-core'
 import * as jsonService from 'vscode-json-languageservice';
 
-import Uri = monaco.Uri;
-import Position = monaco.Position;
-import Range = monaco.Range;
-import IRange = monaco.IRange;
-import Thenable = monaco.Thenable;
-import CancellationToken = monaco.CancellationToken;
-import IDisposable = monaco.IDisposable;
-
 
 export interface WorkerAccessor {
-	(...more: Uri[]): Thenable<JSONWorker>
+	(...more: Uri[]): Promise<JSONWorker>
 }
 
 // --- diagnostics --- ---
@@ -29,8 +20,8 @@ export class DiagnosticsAdapter {
 	private _disposables: IDisposable[] = [];
 	private _listener: { [uri: string]: IDisposable } = Object.create(null);
 
-	constructor(private _languageId: string, private _worker: WorkerAccessor, defaults: LanguageServiceDefaultsImpl) {
-		const onModelAdd = (model: monaco.editor.IModel): void => {
+	constructor(private _languageId: string, private _worker: WorkerAccessor, defaults: LanguageServiceDefaults) {
+		const onModelAdd = (model: editor.IModel): void => {
 			let modeId = model.getModeId();
 			if (modeId !== this._languageId) {
 				return;
@@ -45,8 +36,8 @@ export class DiagnosticsAdapter {
 			this._doValidate(model.uri, modeId);
 		};
 
-		const onModelRemoved = (model: monaco.editor.IModel): void => {
-			monaco.editor.setModelMarkers(model, this._languageId, []);
+		const onModelRemoved = (model: editor.IModel): void => {
+			editor.setModelMarkers(model, this._languageId, []);
 			let uriStr = model.uri.toString();
 			let listener = this._listener[uriStr];
 			if (listener) {
@@ -55,19 +46,19 @@ export class DiagnosticsAdapter {
 			}
 		};
 
-		this._disposables.push(monaco.editor.onDidCreateModel(onModelAdd));
-		this._disposables.push(monaco.editor.onWillDisposeModel(model => {
+		this._disposables.push(editor.onDidCreateModel(onModelAdd));
+		this._disposables.push(editor.onWillDisposeModel(model => {
 			onModelRemoved(model);
 			this._resetSchema(model.uri);
 		}));
-		this._disposables.push(monaco.editor.onDidChangeModelLanguage(event => {
+		this._disposables.push(editor.onDidChangeModelLanguage(event => {
 			onModelRemoved(event.model);
 			onModelAdd(event.model);
 			this._resetSchema(event.model.uri);
 		}));
 
 		this._disposables.push(defaults.onDidChange(_ => {
-			monaco.editor.getModels().forEach(model => {
+			editor.getModels().forEach(model => {
 				if (model.getModeId() === this._languageId) {
 					onModelRemoved(model);
 					onModelAdd(model);
@@ -77,14 +68,14 @@ export class DiagnosticsAdapter {
 
 		this._disposables.push({
 			dispose: () => {
-				monaco.editor.getModels().forEach(onModelRemoved);
+				editor.getModels().forEach(onModelRemoved);
 				for (let key in this._listener) {
 					this._listener[key].dispose();
 				}
 			}
 		});
 
-		monaco.editor.getModels().forEach(onModelAdd);
+		editor.getModels().forEach(onModelAdd);
 	}
 
 	public dispose(): void {
@@ -102,9 +93,9 @@ export class DiagnosticsAdapter {
 		this._worker(resource).then(worker => {
 			return worker.doValidation(resource.toString()).then(diagnostics => {
 				const markers = diagnostics.map(d => toDiagnostics(resource, d));
-				let model = monaco.editor.getModel(resource);
+				let model = editor.getModel(resource);
 				if (model && model.getModeId() === languageId) {
-					monaco.editor.setModelMarkers(model, languageId, markers);
+					editor.setModelMarkers(model, languageId, markers);
 				}
 			});
 		}).then(undefined, err => {
@@ -114,18 +105,18 @@ export class DiagnosticsAdapter {
 }
 
 
-function toSeverity(lsSeverity: number): monaco.MarkerSeverity {
+function toSeverity(lsSeverity: number): MarkerSeverity {
 	switch (lsSeverity) {
-		case jsonService.DiagnosticSeverity.Error: return monaco.MarkerSeverity.Error;
-		case jsonService.DiagnosticSeverity.Warning: return monaco.MarkerSeverity.Warning;
-		case jsonService.DiagnosticSeverity.Information: return monaco.MarkerSeverity.Info;
-		case jsonService.DiagnosticSeverity.Hint: return monaco.MarkerSeverity.Hint;
+		case jsonService.DiagnosticSeverity.Error: return MarkerSeverity.Error;
+		case jsonService.DiagnosticSeverity.Warning: return MarkerSeverity.Warning;
+		case jsonService.DiagnosticSeverity.Information: return MarkerSeverity.Info;
+		case jsonService.DiagnosticSeverity.Hint: return MarkerSeverity.Hint;
 		default:
-			return monaco.MarkerSeverity.Info;
+			return MarkerSeverity.Info;
 	}
 }
 
-function toDiagnostics(resource: Uri, diag: jsonService.Diagnostic): monaco.editor.IMarkerData {
+function toDiagnostics(resource: Uri, diag: jsonService.Diagnostic): editor.IMarkerData {
 	let code = typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
 
 	return {
@@ -162,8 +153,8 @@ function toRange(range: jsonService.Range): Range {
 	return new Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
 }
 
-function toCompletionItemKind(kind: number): monaco.languages.CompletionItemKind {
-	let mItemKind = monaco.languages.CompletionItemKind;
+function toCompletionItemKind(kind: number): languages.CompletionItemKind {
+	let mItemKind = languages.CompletionItemKind;
 
 	switch (kind) {
 		case jsonService.CompletionItemKind.Text: return mItemKind.Text;
@@ -188,8 +179,8 @@ function toCompletionItemKind(kind: number): monaco.languages.CompletionItemKind
 	return mItemKind.Property;
 }
 
-function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): jsonService.CompletionItemKind {
-	let mItemKind = monaco.languages.CompletionItemKind;
+function fromCompletionItemKind(kind: languages.CompletionItemKind): jsonService.CompletionItemKind {
+	let mItemKind = languages.CompletionItemKind;
 
 	switch (kind) {
 		case mItemKind.Text: return jsonService.CompletionItemKind.Text;
@@ -214,7 +205,7 @@ function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): json
 	return jsonService.CompletionItemKind.Property;
 }
 
-function toTextEdit(textEdit: jsonService.TextEdit): monaco.editor.ISingleEditOperation {
+function toTextEdit(textEdit: jsonService.TextEdit): editor.ISingleEditOperation {
 	if (!textEdit) {
 		return void 0;
 	}
@@ -224,7 +215,7 @@ function toTextEdit(textEdit: jsonService.TextEdit): monaco.editor.ISingleEditOp
 	}
 }
 
-export class CompletionAdapter implements monaco.languages.CompletionItemProvider {
+export class CompletionAdapter implements languages.CompletionItemProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
@@ -233,7 +224,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 		return [' ', ':'];
 	}
 
-	provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.CompletionContext, token: CancellationToken): Thenable<monaco.languages.CompletionList> {
+	provideCompletionItems(model: editor.IReadOnlyModel, position: Position, context: languages.CompletionContext, token: CancellationToken): Promise<languages.CompletionList> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -245,8 +236,8 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 			const wordInfo = model.getWordUntilPosition(position);
 			const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
 
-			let items: monaco.languages.CompletionItem[] = info.items.map(entry => {
-				let item: monaco.languages.CompletionItem = {
+			let items: languages.CompletionItem[] = info.items.map(entry => {
+				let item: languages.CompletionItem = {
 					label: entry.label,
 					insertText: entry.insertText || entry.label,
 					sortText: entry.sortText,
@@ -264,7 +255,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 					item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit)
 				}
 				if (entry.insertTextFormat === jsonService.InsertTextFormat.Snippet) {
-					item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+					item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
 				}
 				return item;
 			});
@@ -281,7 +272,7 @@ function isMarkupContent(thing: any): thing is jsonService.MarkupContent {
 	return thing && typeof thing === 'object' && typeof (<jsonService.MarkupContent>thing).kind === 'string';
 }
 
-function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedString): monaco.IMarkdownString {
+function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedString): IMarkdownString {
 	if (typeof entry === 'string') {
 		return {
 			value: entry
@@ -301,7 +292,7 @@ function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedS
 	return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' };
 }
 
-function toMarkedStringArray(contents: jsonService.MarkupContent | jsonService.MarkedString | jsonService.MarkedString[]): monaco.IMarkdownString[] {
+function toMarkedStringArray(contents: jsonService.MarkupContent | jsonService.MarkedString | jsonService.MarkedString[]): IMarkdownString[] {
 	if (!contents) {
 		return void 0;
 	}
@@ -314,12 +305,12 @@ function toMarkedStringArray(contents: jsonService.MarkupContent | jsonService.M
 
 // --- hover ------
 
-export class HoverAdapter implements monaco.languages.HoverProvider {
+export class HoverAdapter implements languages.HoverProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	provideHover(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Thenable<monaco.languages.Hover> {
+	provideHover(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<languages.Hover> {
 		let resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -328,7 +319,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
 			if (!info) {
 				return;
 			}
-			return <monaco.languages.Hover>{
+			return <languages.Hover>{
 				range: toRange(info.range),
 				contents: toMarkedStringArray(info.contents)
 			};
@@ -338,7 +329,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
 
 // --- definition ------
 
-function toLocation(location: jsonService.Location): monaco.languages.Location {
+function toLocation(location: jsonService.Location): languages.Location {
 	return {
 		uri: Uri.parse(location.uri),
 		range: toRange(location.range)
@@ -348,8 +339,8 @@ function toLocation(location: jsonService.Location): monaco.languages.Location {
 
 // --- document symbols ------
 
-function toSymbolKind(kind: jsonService.SymbolKind): monaco.languages.SymbolKind {
-	let mKind = monaco.languages.SymbolKind;
+function toSymbolKind(kind: jsonService.SymbolKind): languages.SymbolKind {
+	let mKind = languages.SymbolKind;
 
 	switch (kind) {
 		case jsonService.SymbolKind.File: return mKind.Array;
@@ -375,12 +366,12 @@ function toSymbolKind(kind: jsonService.SymbolKind): monaco.languages.SymbolKind
 }
 
 
-export class DocumentSymbolAdapter implements monaco.languages.DocumentSymbolProvider {
+export class DocumentSymbolAdapter implements languages.DocumentSymbolProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	public provideDocumentSymbols(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Thenable<monaco.languages.DocumentSymbol[]> {
+	public provideDocumentSymbols(model: editor.IReadOnlyModel, token: CancellationToken): Promise<languages.DocumentSymbol[]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => worker.findDocumentSymbols(resource.toString())).then(items => {
@@ -401,19 +392,19 @@ export class DocumentSymbolAdapter implements monaco.languages.DocumentSymbolPro
 }
 
 
-function fromFormattingOptions(options: monaco.languages.FormattingOptions): jsonService.FormattingOptions {
+function fromFormattingOptions(options: languages.FormattingOptions): jsonService.FormattingOptions {
 	return {
 		tabSize: options.tabSize,
 		insertSpaces: options.insertSpaces
 	};
 }
 
-export class DocumentFormattingEditProvider implements monaco.languages.DocumentFormattingEditProvider {
+export class DocumentFormattingEditProvider implements languages.DocumentFormattingEditProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	public provideDocumentFormattingEdits(model: monaco.editor.IReadOnlyModel, options: monaco.languages.FormattingOptions, token: CancellationToken): Thenable<monaco.editor.ISingleEditOperation[]> {
+	public provideDocumentFormattingEdits(model: editor.IReadOnlyModel, options: languages.FormattingOptions, token: CancellationToken): Promise<editor.ISingleEditOperation[]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -427,12 +418,12 @@ export class DocumentFormattingEditProvider implements monaco.languages.Document
 	}
 }
 
-export class DocumentRangeFormattingEditProvider implements monaco.languages.DocumentRangeFormattingEditProvider {
+export class DocumentRangeFormattingEditProvider implements languages.DocumentRangeFormattingEditProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	public provideDocumentRangeFormattingEdits(model: monaco.editor.IReadOnlyModel, range: Range, options: monaco.languages.FormattingOptions, token: CancellationToken): Thenable<monaco.editor.ISingleEditOperation[]> {
+	public provideDocumentRangeFormattingEdits(model: editor.IReadOnlyModel, range: Range, options: languages.FormattingOptions, token: CancellationToken): Promise<editor.ISingleEditOperation[]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -446,12 +437,12 @@ export class DocumentRangeFormattingEditProvider implements monaco.languages.Doc
 	}
 }
 
-export class DocumentColorAdapter implements monaco.languages.DocumentColorProvider {
+export class DocumentColorAdapter implements languages.DocumentColorProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	public provideDocumentColors(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Thenable<monaco.languages.IColorInformation[]> {
+	public provideDocumentColors(model: editor.IReadOnlyModel, token: CancellationToken): Promise<languages.IColorInformation[]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => worker.findDocumentColors(resource.toString())).then(infos => {
@@ -465,7 +456,7 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi
 		});
 	}
 
-	public provideColorPresentations(model: monaco.editor.IReadOnlyModel, info: monaco.languages.IColorInformation, token: CancellationToken): Thenable<monaco.languages.IColorPresentation[]> {
+	public provideColorPresentations(model: editor.IReadOnlyModel, info: languages.IColorInformation, token: CancellationToken): Promise<languages.IColorPresentation[]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))).then(presentations => {
@@ -473,7 +464,7 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi
 				return;
 			}
 			return presentations.map(presentation => {
-				let item: monaco.languages.IColorPresentation = {
+				let item: languages.IColorPresentation = {
 					label: presentation.label,
 				};
 				if (presentation.textEdit) {
@@ -488,12 +479,12 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi
 	}
 }
 
-export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvider {
+export class FoldingRangeAdapter implements languages.FoldingRangeProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	public provideFoldingRanges(model: monaco.editor.IReadOnlyModel, context: monaco.languages.FoldingContext, token: CancellationToken): Thenable<monaco.languages.FoldingRange[]> {
+	public provideFoldingRanges(model: editor.IReadOnlyModel, context: languages.FoldingContext, token: CancellationToken): Promise<languages.FoldingRange[]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => worker.getFoldingRanges(resource.toString(), context)).then(ranges => {
@@ -501,7 +492,7 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide
 				return;
 			}
 			return ranges.map(range => {
-				let result: monaco.languages.FoldingRange = {
+				let result: languages.FoldingRange = {
 					start: range.startLine + 1,
 					end: range.endLine + 1
 				};
@@ -515,21 +506,21 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide
 
 }
 
-function toFoldingRangeKind(kind: jsonService.FoldingRangeKind): monaco.languages.FoldingRangeKind {
+function toFoldingRangeKind(kind: jsonService.FoldingRangeKind): languages.FoldingRangeKind {
 	switch (kind) {
-		case jsonService.FoldingRangeKind.Comment: return monaco.languages.FoldingRangeKind.Comment;
-		case jsonService.FoldingRangeKind.Imports: return monaco.languages.FoldingRangeKind.Imports;
-		case jsonService.FoldingRangeKind.Region: return monaco.languages.FoldingRangeKind.Region;
+		case jsonService.FoldingRangeKind.Comment: return languages.FoldingRangeKind.Comment;
+		case jsonService.FoldingRangeKind.Imports: return languages.FoldingRangeKind.Imports;
+		case jsonService.FoldingRangeKind.Region: return languages.FoldingRangeKind.Region;
 	}
 	return void 0;
 }
 
-export class SelectionRangeAdapter implements monaco.languages.SelectionRangeProvider {
+export class SelectionRangeAdapter implements languages.SelectionRangeProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	public provideSelectionRanges(model: monaco.editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Thenable<monaco.languages.SelectionRange[][]> {
+	public provideSelectionRanges(model: editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Promise<languages.SelectionRange[][]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => worker.getSelectionRanges(resource.toString(), positions.map(fromPosition))).then(selectionRanges => {
@@ -537,7 +528,7 @@ export class SelectionRangeAdapter implements monaco.languages.SelectionRangePro
 				return;
 			}
 			return selectionRanges.map(selectionRange => {
-				const result: monaco.languages.SelectionRange[] = [];
+				const result: languages.SelectionRange[] = [];
 				while (selectionRange) {
 					result.push({ range: toRange(selectionRange.range) });
 					selectionRange = selectionRange.parent;

src/monaco.contribution.ts

@@ -2,29 +2,120 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
 import * as mode from './jsonMode';
-
-import Emitter = monaco.Emitter;
-import IEvent = monaco.IEvent;
+import { Emitter, IEvent, languages } from './fillers/monaco-editor-core'
 
 // --- JSON configuration and defaults ---------
 
-export class LanguageServiceDefaultsImpl implements monaco.languages.json.LanguageServiceDefaults {
+export interface DiagnosticsOptions {
+	/**
+	 * If set, the validator will be enabled and perform syntax validation as well as schema based validation.
+	 */
+	readonly validate?: boolean;
+	/**
+	 * If set, comments are tolerated. If set to false, syntax errors will be emitted for comments.
+	 */
+	readonly allowComments?: boolean;
+	/**
+	 * A list of known schemas and/or associations of schemas to file names.
+	 */
+	readonly schemas?: {
+		/**
+		 * The URI of the schema, which is also the identifier of the schema.
+		 */
+		readonly uri: string;
+		/**
+		 * A list of file names that are associated to the schema. The '*' wildcard can be used. For example '*.schema.json', 'package.json'
+		 */
+		readonly fileMatch?: string[];
+		/**
+		 * The schema for the given URI.
+		 */
+		readonly schema?: any;
+	}[];
+	/**
+	 *  If set, the schema service would load schema content on-demand with 'fetch' if available
+	 */
+	readonly enableSchemaRequest?: boolean;
+}
+
+export interface ModeConfiguration {
+	/**
+	 * Defines whether the built-in documentFormattingEdit provider is enabled.
+	 */
+	readonly documentFormattingEdits?: boolean;
+
+	/**
+	 * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
+	 */
+	readonly documentRangeFormattingEdits?: boolean;
+
+	/**
+	 * Defines whether the built-in completionItemProvider is enabled.
+	 */
+	readonly completionItems?: boolean;
+
+	/**
+	 * Defines whether the built-in hoverProvider is enabled.
+	 */
+	readonly hovers?: boolean;
+
+	/**
+	 * Defines whether the built-in documentSymbolProvider is enabled.
+	 */
+	readonly documentSymbols?: boolean;
+
+	/**
+	 * Defines whether the built-in tokens provider is enabled.
+	 */
+	readonly tokens?: boolean;
+
+	/**
+	 * Defines whether the built-in color provider is enabled.
+	 */
+	readonly colors?: boolean;
+
+	/**
+	 * Defines whether the built-in foldingRange provider is enabled.
+	 */
+	readonly foldingRanges?: boolean;
+
+	/**
+	 * Defines whether the built-in diagnostic provider is enabled.
+	 */
+	readonly diagnostics?: boolean;
+
+	/**
+	 * Defines whether the built-in selection range provider is enabled.
+	 */
+	readonly selectionRanges?: boolean;
+
+}
+
+export interface LanguageServiceDefaults {
+	readonly languageId: string;
+	readonly onDidChange: IEvent<LanguageServiceDefaults>;
+	readonly diagnosticsOptions: DiagnosticsOptions;
+	readonly modeConfiguration: ModeConfiguration;
+	setDiagnosticsOptions(options: DiagnosticsOptions): void;
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+}
+
+class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
 
-	private _onDidChange = new Emitter<monaco.languages.json.LanguageServiceDefaults>();
-	private _diagnosticsOptions: monaco.languages.json.DiagnosticsOptions;
-	private _modeConfiguration: monaco.languages.json.ModeConfiguration;
+	private _onDidChange = new Emitter<LanguageServiceDefaults>();
+	private _diagnosticsOptions: DiagnosticsOptions;
+	private _modeConfiguration: ModeConfiguration;
 	private _languageId: string;
 
-	constructor(languageId: string, diagnosticsOptions: monaco.languages.json.DiagnosticsOptions, modeConfiguration: monaco.languages.json.ModeConfiguration) {
+	constructor(languageId: string, diagnosticsOptions: DiagnosticsOptions, modeConfiguration: ModeConfiguration) {
 		this._languageId = languageId;
 		this.setDiagnosticsOptions(diagnosticsOptions);
 		this.setModeConfiguration(modeConfiguration);
 	}
 
-	get onDidChange(): IEvent<monaco.languages.json.LanguageServiceDefaults> {
+	get onDidChange(): IEvent<LanguageServiceDefaults> {
 		return this._onDidChange.event;
 	}
 
@@ -32,33 +123,33 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.json.Langua
 		return this._languageId;
 	}
 
-	get modeConfiguration(): monaco.languages.json.ModeConfiguration {
+	get modeConfiguration(): ModeConfiguration {
 		return this._modeConfiguration;
 	}
 
-	get diagnosticsOptions(): monaco.languages.json.DiagnosticsOptions {
+	get diagnosticsOptions(): DiagnosticsOptions {
 		return this._diagnosticsOptions;
 	}
 
-	setDiagnosticsOptions(options: monaco.languages.json.DiagnosticsOptions): void {
+	setDiagnosticsOptions(options: DiagnosticsOptions): void {
 		this._diagnosticsOptions = options || Object.create(null);
 		this._onDidChange.fire(this);
 	}
 
-	setModeConfiguration(modeConfiguration: monaco.languages.json.ModeConfiguration): void {
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void {
 		this._modeConfiguration = modeConfiguration || Object.create(null);
 		this._onDidChange.fire(this);
 	};
 }
 
-const diagnosticDefault: Required<monaco.languages.json.DiagnosticsOptions> = {
+const diagnosticDefault: Required<DiagnosticsOptions> = {
 	validate: true,
 	allowComments: true,
 	schemas: [],
 	enableSchemaRequest: false
 };
 
-const modeConfigurationDefault: Required<monaco.languages.json.ModeConfiguration> = {
+const modeConfigurationDefault: Required<ModeConfiguration> = {
 	documentFormattingEdits: true,
 	documentRangeFormattingEdits: true,
 	completionItems: true,
@@ -71,15 +162,10 @@ const modeConfigurationDefault: Required<monaco.languages.json.ModeConfiguration
 	selectionRanges: true
 }
 
-const jsonDefaults = new LanguageServiceDefaultsImpl('json', diagnosticDefault, modeConfigurationDefault);
+export const jsonDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl('json', diagnosticDefault, modeConfigurationDefault);
 
-// Export API
-function createAPI(): typeof monaco.languages.json {
-	return {
-		jsonDefaults: jsonDefaults
-	}
-}
-monaco.languages.json = createAPI();
+// export to the global based API
+(<any>languages).json = { jsonDefaults };
 
 // --- Registration to monaco editor ---
 
@@ -87,13 +173,13 @@ function getMode(): Promise<typeof mode> {
 	return import('./jsonMode');
 }
 
-monaco.languages.register({
+languages.register({
 	id: 'json',
 	extensions: ['.json', '.bowerrc', '.jshintrc', '.jscsrc', '.eslintrc', '.babelrc', '.har'],
 	aliases: ['JSON', 'json'],
 	mimetypes: ['application/json'],
 });
 
-monaco.languages.onLanguage('json', () => {
+languages.onLanguage('json', () => {
 	getMode().then(mode => mode.setupMode(jsonDefaults));
 });

src/tokenization.ts

@@ -2,11 +2,11 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
 import * as json from 'jsonc-parser';
+import { languages } from './fillers/monaco-editor-core'
 
-export function createTokenizationSupport(supportComments: boolean): monaco.languages.TokensProvider {
+export function createTokenizationSupport(supportComments: boolean): languages.TokensProvider {
     return {
         getInitialState: () => new JSONState(null, null, false),
         tokenize: (line, state, offsetDelta?, stopAtOffset?) => tokenize(supportComments, line, <JSONState>state, offsetDelta, stopAtOffset)
@@ -25,14 +25,14 @@ export const TOKEN_PROPERTY_NAME = 'string.key.json';
 export const TOKEN_COMMENT_BLOCK = 'comment.block.json';
 export const TOKEN_COMMENT_LINE = 'comment.line.json';
 
-class JSONState implements monaco.languages.IState {
+class JSONState implements languages.IState {
 
-    private _state: monaco.languages.IState;
+    private _state: languages.IState;
 
     public scanError: json.ScanError;
     public lastWasColon: boolean;
 
-    constructor(state: monaco.languages.IState, scanError: json.ScanError, lastWasColon: boolean) {
+    constructor(state: languages.IState, scanError: json.ScanError, lastWasColon: boolean) {
         this._state = state;
         this.scanError = scanError;
         this.lastWasColon = lastWasColon;
@@ -42,7 +42,7 @@ class JSONState implements monaco.languages.IState {
         return new JSONState(this._state, this.scanError, this.lastWasColon);
     }
 
-    public equals(other: monaco.languages.IState): boolean {
+    public equals(other: languages.IState): boolean {
         if (other === this) {
             return true;
         }
@@ -53,16 +53,16 @@ class JSONState implements monaco.languages.IState {
             this.lastWasColon === (<JSONState>other).lastWasColon;
     }
 
-    public getStateData(): monaco.languages.IState {
+    public getStateData(): languages.IState {
         return this._state;
     }
 
-    public setStateData(state: monaco.languages.IState): void {
+    public setStateData(state: languages.IState): void {
         this._state = state;
     }
 }
 
-function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta: number = 0, stopAtOffset?: number): monaco.languages.ILineTokens {
+function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta: number = 0, stopAtOffset?: number): languages.ILineTokens {
 
     // handle multiline strings and block comments
     var numberOfInsertedCharacters = 0,
@@ -81,11 +81,11 @@ function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta
 
     var scanner = json.createScanner(line),
         kind: json.SyntaxKind,
-        ret: monaco.languages.ILineTokens,
+        ret: languages.ILineTokens,
         lastWasColon = state.lastWasColon;
 
     ret = {
-        tokens: <monaco.languages.IToken[]>[],
+        tokens: <languages.IToken[]>[],
         endState: state.clone()
     };
 
@@ -177,4 +177,4 @@ function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta
     }
 
     return ret;
-}
+}

src/tsconfig.esm.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "declaration": true,
     "module": "esnext",
     "moduleResolution": "node",
     "outDir": "../out/esm",
@@ -12,4 +13,4 @@
       "es2015.iterable"
     ]
   }
-}
+}

src/tsconfig.json

@@ -3,6 +3,7 @@
     "module": "amd",
     "moduleResolution": "node",
     "outDir": "../out/amd",
+    "declaration": true,
     "target": "es5",
     "lib": [
       "dom",
@@ -12,4 +13,4 @@
       "es2015.iterable"
     ]
   }
-}
+}

src/workerManager.ts

@@ -2,27 +2,24 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
-import { LanguageServiceDefaultsImpl } from './monaco.contribution';
-import { JSONWorker } from './jsonWorker';
-
-import IDisposable = monaco.IDisposable;
-import Uri = monaco.Uri;
+import { LanguageServiceDefaults } from './monaco.contribution';
+import type { JSONWorker } from './jsonWorker';
+import { IDisposable, Uri, editor } from './fillers/monaco-editor-core'
 
 const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min
 
 export class WorkerManager {
 
-	private _defaults: LanguageServiceDefaultsImpl;
+	private _defaults: LanguageServiceDefaults;
 	private _idleCheckInterval: number;
 	private _lastUsedTime: number;
 	private _configChangeListener: IDisposable;
 
-	private _worker: monaco.editor.MonacoWebWorker<JSONWorker>;
+	private _worker: editor.MonacoWebWorker<JSONWorker>;
 	private _client: Promise<JSONWorker>;
 
-	constructor(defaults: LanguageServiceDefaultsImpl) {
+	constructor(defaults: LanguageServiceDefaults) {
 		this._defaults = defaults;
 		this._worker = null;
 		this._idleCheckInterval = setInterval(() => this._checkIfIdle(), 30 * 1000);
@@ -58,7 +55,7 @@ export class WorkerManager {
 		this._lastUsedTime = Date.now();
 
 		if (!this._client) {
-			this._worker = monaco.editor.createWebWorker<JSONWorker>({
+			this._worker = editor.createWebWorker<JSONWorker>({
 
 				// module that exports the create() method and returns a `JSONWorker` instance
 				moduleId: 'vs/language/json/jsonWorker',