Browse Source

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

Alex Dima 4 years ago
parent
commit
28d4512f33

+ 1 - 1
README.md

@@ -9,7 +9,7 @@ JSON language plugin for the Monaco Editor. It provides the following features w
 * Syntax highlighting
 * Syntax highlighting
 * Color decorators for all properties matching a schema containing `format: "color-hex"'` (non-standard schema extension)
 * 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.
 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)
 Internally the JSON plugin uses the [vscode-json-languageservice](https://github.com/Microsoft/vscode-json-languageservice)

+ 4 - 14
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.
  *  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 {
 	export interface DiagnosticsOptions {
 		/**
 		/**
 		 * If set, the validator will be enabled and perform syntax validation as well as schema based validation.
 		 * 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;
 		readonly enableSchemaRequest?: boolean;
 	}
 	}
-
 	export interface ModeConfiguration {
 	export interface ModeConfiguration {
 		/**
 		/**
 		 * Defines whether the built-in documentFormattingEdit provider is enabled.
 		 * Defines whether the built-in documentFormattingEdit provider is enabled.
 		 */
 		 */
 		readonly documentFormattingEdits?: boolean;
 		readonly documentFormattingEdits?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
 		 * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
 		 */
 		 */
 		readonly documentRangeFormattingEdits?: boolean;
 		readonly documentRangeFormattingEdits?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in completionItemProvider is enabled.
 		 * Defines whether the built-in completionItemProvider is enabled.
 		 */
 		 */
 		readonly completionItems?: boolean;
 		readonly completionItems?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in hoverProvider is enabled.
 		 * Defines whether the built-in hoverProvider is enabled.
 		 */
 		 */
 		readonly hovers?: boolean;
 		readonly hovers?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in documentSymbolProvider is enabled.
 		 * Defines whether the built-in documentSymbolProvider is enabled.
 		 */
 		 */
 		readonly documentSymbols?: boolean;
 		readonly documentSymbols?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in tokens provider is enabled.
 		 * Defines whether the built-in tokens provider is enabled.
 		 */
 		 */
 		readonly tokens?: boolean;
 		readonly tokens?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in color provider is enabled.
 		 * Defines whether the built-in color provider is enabled.
 		 */
 		 */
 		readonly colors?: boolean;
 		readonly colors?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in foldingRange provider is enabled.
 		 * Defines whether the built-in foldingRange provider is enabled.
 		 */
 		 */
 		readonly foldingRanges?: boolean;
 		readonly foldingRanges?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in diagnostic provider is enabled.
 		 * Defines whether the built-in diagnostic provider is enabled.
 		 */
 		 */
 		readonly diagnostics?: boolean;
 		readonly diagnostics?: boolean;
-
 		/**
 		/**
 		 * Defines whether the built-in selection range provider is enabled.
 		 * Defines whether the built-in selection range provider is enabled.
 		 */
 		 */
 		readonly selectionRanges?: boolean;
 		readonly selectionRanges?: boolean;
-
 	}
 	}
-
 	export interface LanguageServiceDefaults {
 	export interface LanguageServiceDefaults {
+		readonly languageId: string;
 		readonly onDidChange: IEvent<LanguageServiceDefaults>;
 		readonly onDidChange: IEvent<LanguageServiceDefaults>;
 		readonly diagnosticsOptions: DiagnosticsOptions;
 		readonly diagnosticsOptions: DiagnosticsOptions;
 		readonly modeConfiguration: ModeConfiguration;
 		readonly modeConfiguration: ModeConfiguration;
 		setDiagnosticsOptions(options: DiagnosticsOptions): void;
 		setDiagnosticsOptions(options: DiagnosticsOptions): void;
 		setModeConfiguration(modeConfiguration: ModeConfiguration): void;
 		setModeConfiguration(modeConfiguration: ModeConfiguration): void;
 	}
 	}
+	export const jsonDefaults: LanguageServiceDefaults;
 
 
-	export var jsonDefaults: LanguageServiceDefaults;
 }
 }

+ 27 - 27
package-lock.json

@@ -17,9 +17,9 @@
       "dev": true
       "dev": true
     },
     },
     "jsonc-parser": {
     "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
       "dev": true
     },
     },
     "monaco-editor-core": {
     "monaco-editor-core": {
@@ -35,9 +35,9 @@
       "dev": true
       "dev": true
     },
     },
     "monaco-plugin-helpers": {
     "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,
       "dev": true,
       "requires": {
       "requires": {
         "typescript": "^2.7.2"
         "typescript": "^2.7.2"
@@ -64,9 +64,9 @@
       "dev": true
       "dev": true
     },
     },
     "source-map-support": {
     "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,
       "dev": true,
       "requires": {
       "requires": {
         "buffer-from": "^1.0.0",
         "buffer-from": "^1.0.0",
@@ -74,9 +74,9 @@
       }
       }
     },
     },
     "terser": {
     "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,
       "dev": true,
       "requires": {
       "requires": {
         "commander": "^2.20.0",
         "commander": "^2.20.0",
@@ -85,9 +85,9 @@
       }
       }
     },
     },
     "typescript": {
     "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
       "dev": true
     },
     },
     "vscode-json-languageservice": {
     "vscode-json-languageservice": {
@@ -104,27 +104,27 @@
       }
       }
     },
     },
     "vscode-languageserver-textdocument": {
     "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
       "dev": true
     },
     },
     "vscode-languageserver-types": {
     "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
       "dev": true
     },
     },
     "vscode-nls": {
     "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
       "dev": true
     },
     },
     "vscode-uri": {
     "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
       "dev": true
     }
     }
   }
   }

+ 7 - 5
package.json

@@ -3,9 +3,9 @@
   "version": "2.9.0",
   "version": "2.9.0",
   "description": "JSON plugin for the Monaco Editor",
   "description": "JSON plugin for the Monaco Editor",
   "scripts": {
   "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",
     "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-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"
     "install-service-local": "npm install ../vscode-json-languageservice -f -D && npm install ../vscode-languageserver-node/types -f -D"
   },
   },
@@ -18,14 +18,16 @@
   "bugs": {
   "bugs": {
     "url": "https://github.com/Microsoft/monaco-json/issues"
     "url": "https://github.com/Microsoft/monaco-json/issues"
   },
   },
+  "module": "./release/esm/monaco.contribution.js",
+  "typings": "./release/esm/monaco.contribution.d.ts",
   "devDependencies": {
   "devDependencies": {
     "jsonc-parser": "^2.2.0",
     "jsonc-parser": "^2.2.0",
     "monaco-editor-core": "0.20.0",
     "monaco-editor-core": "0.20.0",
     "monaco-languages": "1.10.0",
     "monaco-languages": "1.10.0",
-    "monaco-plugin-helpers": "^1.0.2",
+    "monaco-plugin-helpers": "^1.0.3",
     "requirejs": "^2.3.6",
     "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"
     "vscode-json-languageservice": "3.4.11"
   }
   }
 }
 }

+ 3 - 3
scripts/bundle.js

@@ -24,14 +24,14 @@ bundleOne('monaco.contribution');
 bundleOne('jsonMode');
 bundleOne('jsonMode');
 bundleOne('jsonWorker');
 bundleOne('jsonWorker');
 
 
-function bundleOne(moduleId, exclude) {
+function bundleOne(moduleId) {
 	requirejs.optimize({
 	requirejs.optimize({
 		baseUrl: 'out/amd/',
 		baseUrl: 'out/amd/',
 		name: 'vs/language/json/' + moduleId,
 		name: 'vs/language/json/' + moduleId,
 		out: 'release/dev/' + moduleId + '.js',
 		out: 'release/dev/' + moduleId + '.js',
-		exclude: exclude,
 		paths: {
 		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',
 		optimize: 'none',
 		packages: [{
 		packages: [{

+ 37 - 0
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'));

+ 12 - 0
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;
+});

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

@@ -2,4 +2,5 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *  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';

+ 0 - 1
src/json.worker.ts

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

+ 15 - 18
src/jsonMode.ts

@@ -2,18 +2,15 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
 
 import { WorkerManager } from './workerManager';
 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 * as languageFeatures from './languageFeatures';
 import { createTokenizationSupport } from './tokenization';
 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 disposables: IDisposable[] = [];
 	const providers: IDisposable[] = [];
 	const providers: IDisposable[] = [];
@@ -32,40 +29,40 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
 		disposeAll(providers);
 		disposeAll(providers);
 
 
 		if (modeConfiguration.documentFormattingEdits) {
 		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) {
 		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) {
 		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) {
 		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) {
 		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) {
 		if (modeConfiguration.tokens) {
-			providers.push(monaco.languages.setTokensProvider(languageId, createTokenizationSupport(true)));
+			providers.push(languages.setTokensProvider(languageId, createTokenizationSupport(true)));
 		}
 		}
 		if (modeConfiguration.colors) {
 		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) {
 		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) {
 		if (modeConfiguration.diagnostics) {
 			providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults));
 			providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults));
 		}
 		}
 		if (modeConfiguration.selectionRanges) {
 		if (modeConfiguration.selectionRanges) {
-			providers.push(monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker)));
+			providers.push(languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker)));
 		}
 		}
 	}
 	}
 
 
 	registerProviders();
 	registerProviders();
 
 
-	disposables.push(monaco.languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration));
+	disposables.push(languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration));
 
 
 	let modeConfiguration = defaults.modeConfiguration;
 	let modeConfiguration = defaults.modeConfiguration;
 	defaults.onDidChange((newDefaults) => {
 	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,
 	wordPattern: /(-?\d*\.\d\w*)|([^\[\{\]\}\:\"\,\s]+)/g,
 
 
 	comments: {
 	comments: {

+ 16 - 44
src/jsonWorker.ts

@@ -2,61 +2,33 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *  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 * as jsonService from 'vscode-json-languageservice';
+import type { worker } from './fillers/monaco-editor-core'
 
 
 let defaultSchemaRequestService;
 let defaultSchemaRequestService;
 if (typeof fetch !== 'undefined') {
 if (typeof fetch !== 'undefined') {
 	defaultSchemaRequestService = function (url) { return fetch(url).then(response => response.text()) };
 	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 {
 export class JSONWorker {
 
 
-	private _ctx: IWorkerContext;
+	private _ctx: worker.IWorkerContext;
 	private _languageService: jsonService.LanguageService;
 	private _languageService: jsonService.LanguageService;
 	private _languageSettings: jsonService.LanguageSettings;
 	private _languageSettings: jsonService.LanguageSettings;
 	private _languageId: string;
 	private _languageId: string;
 
 
-	constructor(ctx: IWorkerContext, createData: ICreateData) {
+	constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
 		this._ctx = ctx;
 		this._ctx = ctx;
 		this._languageSettings = createData.languageSettings;
 		this._languageSettings = createData.languageSettings;
 		this._languageId = createData.languageId;
 		this._languageId = createData.languageId;
 		this._languageService = jsonService.getLanguageService({
 		this._languageService = jsonService.getLanguageService({
-			schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService,
-			promiseConstructor: PromiseAdapter
+			schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService
 		});
 		});
 		this._languageService.configure(this._languageSettings);
 		this._languageService.configure(this._languageSettings);
 	}
 	}
 
 
-	doValidation(uri: string): Thenable<jsonService.Diagnostic[]> {
+	async doValidation(uri: string): Promise<jsonService.Diagnostic[]> {
 		let document = this._getTextDocument(uri);
 		let document = this._getTextDocument(uri);
 		if (document) {
 		if (document) {
 			let jsonDocument = this._languageService.parseJSONDocument(document);
 			let jsonDocument = this._languageService.parseJSONDocument(document);
@@ -64,51 +36,51 @@ export class JSONWorker {
 		}
 		}
 		return Promise.resolve([]);
 		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 document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		return this._languageService.doComplete(document, position, jsonDocument);
 		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);
 		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 document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		return this._languageService.doHover(document, position, jsonDocument);
 		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 document = this._getTextDocument(uri);
 		let textEdits = this._languageService.format(document, range, options);
 		let textEdits = this._languageService.format(document, range, options);
 		return Promise.resolve(textEdits);
 		return Promise.resolve(textEdits);
 	}
 	}
-	resetSchema(uri: string): Thenable<boolean> {
+	async resetSchema(uri: string): Promise<boolean> {
 		return Promise.resolve(this._languageService.resetSchema(uri));
 		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 document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let symbols = this._languageService.findDocumentSymbols(document, jsonDocument);
 		let symbols = this._languageService.findDocumentSymbols(document, jsonDocument);
 		return Promise.resolve(symbols);
 		return Promise.resolve(symbols);
 	}
 	}
-	findDocumentColors(uri: string): Thenable<jsonService.ColorInformation[]> {
+	async findDocumentColors(uri: string): Promise<jsonService.ColorInformation[]> {
 		let document = this._getTextDocument(uri);
 		let document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let colorSymbols = this._languageService.findDocumentColors(document, jsonDocument);
 		let colorSymbols = this._languageService.findDocumentColors(document, jsonDocument);
 		return Promise.resolve(colorSymbols);
 		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 document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let colorPresentations = this._languageService.getColorPresentations(document, jsonDocument, color, range);
 		let colorPresentations = this._languageService.getColorPresentations(document, jsonDocument, color, range);
 		return Promise.resolve(colorPresentations);
 		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 document = this._getTextDocument(uri);
 		let ranges = this._languageService.getFoldingRanges(document, context);
 		let ranges = this._languageService.getFoldingRanges(document, context);
 		return Promise.resolve(ranges);
 		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 document = this._getTextDocument(uri);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let jsonDocument = this._languageService.parseJSONDocument(document);
 		let ranges = this._languageService.getSelectionRanges(document, positions, jsonDocument);
 		let ranges = this._languageService.getSelectionRanges(document, positions, jsonDocument);
@@ -131,6 +103,6 @@ export interface ICreateData {
 	enableSchemaRequest: boolean;
 	enableSchemaRequest: boolean;
 }
 }
 
 
-export function create(ctx: IWorkerContext, createData: ICreateData): JSONWorker {
+export function create(ctx: worker.IWorkerContext, createData: ICreateData): JSONWorker {
 	return new JSONWorker(ctx, createData);
 	return new JSONWorker(ctx, createData);
 }
 }

+ 62 - 71
src/languageFeatures.ts

@@ -2,24 +2,15 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *  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 * 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 {
 export interface WorkerAccessor {
-	(...more: Uri[]): Thenable<JSONWorker>
+	(...more: Uri[]): Promise<JSONWorker>
 }
 }
 
 
 // --- diagnostics --- ---
 // --- diagnostics --- ---
@@ -29,8 +20,8 @@ export class DiagnosticsAdapter {
 	private _disposables: IDisposable[] = [];
 	private _disposables: IDisposable[] = [];
 	private _listener: { [uri: string]: IDisposable } = Object.create(null);
 	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();
 			let modeId = model.getModeId();
 			if (modeId !== this._languageId) {
 			if (modeId !== this._languageId) {
 				return;
 				return;
@@ -45,8 +36,8 @@ export class DiagnosticsAdapter {
 			this._doValidate(model.uri, modeId);
 			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 uriStr = model.uri.toString();
 			let listener = this._listener[uriStr];
 			let listener = this._listener[uriStr];
 			if (listener) {
 			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);
 			onModelRemoved(model);
 			this._resetSchema(model.uri);
 			this._resetSchema(model.uri);
 		}));
 		}));
-		this._disposables.push(monaco.editor.onDidChangeModelLanguage(event => {
+		this._disposables.push(editor.onDidChangeModelLanguage(event => {
 			onModelRemoved(event.model);
 			onModelRemoved(event.model);
 			onModelAdd(event.model);
 			onModelAdd(event.model);
 			this._resetSchema(event.model.uri);
 			this._resetSchema(event.model.uri);
 		}));
 		}));
 
 
 		this._disposables.push(defaults.onDidChange(_ => {
 		this._disposables.push(defaults.onDidChange(_ => {
-			monaco.editor.getModels().forEach(model => {
+			editor.getModels().forEach(model => {
 				if (model.getModeId() === this._languageId) {
 				if (model.getModeId() === this._languageId) {
 					onModelRemoved(model);
 					onModelRemoved(model);
 					onModelAdd(model);
 					onModelAdd(model);
@@ -77,14 +68,14 @@ export class DiagnosticsAdapter {
 
 
 		this._disposables.push({
 		this._disposables.push({
 			dispose: () => {
 			dispose: () => {
-				monaco.editor.getModels().forEach(onModelRemoved);
+				editor.getModels().forEach(onModelRemoved);
 				for (let key in this._listener) {
 				for (let key in this._listener) {
 					this._listener[key].dispose();
 					this._listener[key].dispose();
 				}
 				}
 			}
 			}
 		});
 		});
 
 
-		monaco.editor.getModels().forEach(onModelAdd);
+		editor.getModels().forEach(onModelAdd);
 	}
 	}
 
 
 	public dispose(): void {
 	public dispose(): void {
@@ -102,9 +93,9 @@ export class DiagnosticsAdapter {
 		this._worker(resource).then(worker => {
 		this._worker(resource).then(worker => {
 			return worker.doValidation(resource.toString()).then(diagnostics => {
 			return worker.doValidation(resource.toString()).then(diagnostics => {
 				const markers = diagnostics.map(d => toDiagnostics(resource, d));
 				const markers = diagnostics.map(d => toDiagnostics(resource, d));
-				let model = monaco.editor.getModel(resource);
+				let model = editor.getModel(resource);
 				if (model && model.getModeId() === languageId) {
 				if (model && model.getModeId() === languageId) {
-					monaco.editor.setModelMarkers(model, languageId, markers);
+					editor.setModelMarkers(model, languageId, markers);
 				}
 				}
 			});
 			});
 		}).then(undefined, err => {
 		}).then(undefined, err => {
@@ -114,18 +105,18 @@ export class DiagnosticsAdapter {
 }
 }
 
 
 
 
-function toSeverity(lsSeverity: number): monaco.MarkerSeverity {
+function toSeverity(lsSeverity: number): MarkerSeverity {
 	switch (lsSeverity) {
 	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:
 		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;
 	let code = typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
 
 
 	return {
 	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);
 	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) {
 	switch (kind) {
 		case jsonService.CompletionItemKind.Text: return mItemKind.Text;
 		case jsonService.CompletionItemKind.Text: return mItemKind.Text;
@@ -188,8 +179,8 @@ function toCompletionItemKind(kind: number): monaco.languages.CompletionItemKind
 	return mItemKind.Property;
 	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) {
 	switch (kind) {
 		case mItemKind.Text: return jsonService.CompletionItemKind.Text;
 		case mItemKind.Text: return jsonService.CompletionItemKind.Text;
@@ -214,7 +205,7 @@ function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): json
 	return jsonService.CompletionItemKind.Property;
 	return jsonService.CompletionItemKind.Property;
 }
 }
 
 
-function toTextEdit(textEdit: jsonService.TextEdit): monaco.editor.ISingleEditOperation {
+function toTextEdit(textEdit: jsonService.TextEdit): editor.ISingleEditOperation {
 	if (!textEdit) {
 	if (!textEdit) {
 		return void 0;
 		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) {
 	constructor(private _worker: WorkerAccessor) {
 	}
 	}
@@ -233,7 +224,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 		return [' ', ':'];
 		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;
 		const resource = model.uri;
 
 
 		return this._worker(resource).then(worker => {
 		return this._worker(resource).then(worker => {
@@ -245,8 +236,8 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 			const wordInfo = model.getWordUntilPosition(position);
 			const wordInfo = model.getWordUntilPosition(position);
 			const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
 			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,
 					label: entry.label,
 					insertText: entry.insertText || entry.label,
 					insertText: entry.insertText || entry.label,
 					sortText: entry.sortText,
 					sortText: entry.sortText,
@@ -264,7 +255,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 					item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit)
 					item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit)
 				}
 				}
 				if (entry.insertTextFormat === jsonService.InsertTextFormat.Snippet) {
 				if (entry.insertTextFormat === jsonService.InsertTextFormat.Snippet) {
-					item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+					item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
 				}
 				}
 				return item;
 				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';
 	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') {
 	if (typeof entry === 'string') {
 		return {
 		return {
 			value: entry
 			value: entry
@@ -301,7 +292,7 @@ function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedS
 	return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' };
 	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) {
 	if (!contents) {
 		return void 0;
 		return void 0;
 	}
 	}
@@ -314,12 +305,12 @@ function toMarkedStringArray(contents: jsonService.MarkupContent | jsonService.M
 
 
 // --- hover ------
 // --- hover ------
 
 
-export class HoverAdapter implements monaco.languages.HoverProvider {
+export class HoverAdapter implements languages.HoverProvider {
 
 
 	constructor(private _worker: WorkerAccessor) {
 	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;
 		let resource = model.uri;
 
 
 		return this._worker(resource).then(worker => {
 		return this._worker(resource).then(worker => {
@@ -328,7 +319,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
 			if (!info) {
 			if (!info) {
 				return;
 				return;
 			}
 			}
-			return <monaco.languages.Hover>{
+			return <languages.Hover>{
 				range: toRange(info.range),
 				range: toRange(info.range),
 				contents: toMarkedStringArray(info.contents)
 				contents: toMarkedStringArray(info.contents)
 			};
 			};
@@ -338,7 +329,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
 
 
 // --- definition ------
 // --- definition ------
 
 
-function toLocation(location: jsonService.Location): monaco.languages.Location {
+function toLocation(location: jsonService.Location): languages.Location {
 	return {
 	return {
 		uri: Uri.parse(location.uri),
 		uri: Uri.parse(location.uri),
 		range: toRange(location.range)
 		range: toRange(location.range)
@@ -348,8 +339,8 @@ function toLocation(location: jsonService.Location): monaco.languages.Location {
 
 
 // --- document symbols ------
 // --- 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) {
 	switch (kind) {
 		case jsonService.SymbolKind.File: return mKind.Array;
 		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) {
 	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;
 		const resource = model.uri;
 
 
 		return this._worker(resource).then(worker => worker.findDocumentSymbols(resource.toString())).then(items => {
 		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 {
 	return {
 		tabSize: options.tabSize,
 		tabSize: options.tabSize,
 		insertSpaces: options.insertSpaces
 		insertSpaces: options.insertSpaces
 	};
 	};
 }
 }
 
 
-export class DocumentFormattingEditProvider implements monaco.languages.DocumentFormattingEditProvider {
+export class DocumentFormattingEditProvider implements languages.DocumentFormattingEditProvider {
 
 
 	constructor(private _worker: WorkerAccessor) {
 	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;
 		const resource = model.uri;
 
 
 		return this._worker(resource).then(worker => {
 		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) {
 	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;
 		const resource = model.uri;
 
 
 		return this._worker(resource).then(worker => {
 		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) {
 	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;
 		const resource = model.uri;
 
 
 		return this._worker(resource).then(worker => worker.findDocumentColors(resource.toString())).then(infos => {
 		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;
 		const resource = model.uri;
 
 
 		return this._worker(resource).then(worker => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))).then(presentations => {
 		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;
 			}
 			}
 			return presentations.map(presentation => {
 			return presentations.map(presentation => {
-				let item: monaco.languages.IColorPresentation = {
+				let item: languages.IColorPresentation = {
 					label: presentation.label,
 					label: presentation.label,
 				};
 				};
 				if (presentation.textEdit) {
 				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) {
 	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;
 		const resource = model.uri;
 
 
 		return this._worker(resource).then(worker => worker.getFoldingRanges(resource.toString(), context)).then(ranges => {
 		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;
 			}
 			}
 			return ranges.map(range => {
 			return ranges.map(range => {
-				let result: monaco.languages.FoldingRange = {
+				let result: languages.FoldingRange = {
 					start: range.startLine + 1,
 					start: range.startLine + 1,
 					end: range.endLine + 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) {
 	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;
 	return void 0;
 }
 }
 
 
-export class SelectionRangeAdapter implements monaco.languages.SelectionRangeProvider {
+export class SelectionRangeAdapter implements languages.SelectionRangeProvider {
 
 
 	constructor(private _worker: WorkerAccessor) {
 	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;
 		const resource = model.uri;
 
 
 		return this._worker(resource).then(worker => worker.getSelectionRanges(resource.toString(), positions.map(fromPosition))).then(selectionRanges => {
 		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;
 			}
 			}
 			return selectionRanges.map(selectionRange => {
 			return selectionRanges.map(selectionRange => {
-				const result: monaco.languages.SelectionRange[] = [];
+				const result: languages.SelectionRange[] = [];
 				while (selectionRange) {
 				while (selectionRange) {
 					result.push({ range: toRange(selectionRange.range) });
 					result.push({ range: toRange(selectionRange.range) });
 					selectionRange = selectionRange.parent;
 					selectionRange = selectionRange.parent;

+ 112 - 26
src/monaco.contribution.ts

@@ -2,29 +2,120 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
 
 import * as mode from './jsonMode';
 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 ---------
 // --- 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;
 	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._languageId = languageId;
 		this.setDiagnosticsOptions(diagnosticsOptions);
 		this.setDiagnosticsOptions(diagnosticsOptions);
 		this.setModeConfiguration(modeConfiguration);
 		this.setModeConfiguration(modeConfiguration);
 	}
 	}
 
 
-	get onDidChange(): IEvent<monaco.languages.json.LanguageServiceDefaults> {
+	get onDidChange(): IEvent<LanguageServiceDefaults> {
 		return this._onDidChange.event;
 		return this._onDidChange.event;
 	}
 	}
 
 
@@ -32,33 +123,33 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.json.Langua
 		return this._languageId;
 		return this._languageId;
 	}
 	}
 
 
-	get modeConfiguration(): monaco.languages.json.ModeConfiguration {
+	get modeConfiguration(): ModeConfiguration {
 		return this._modeConfiguration;
 		return this._modeConfiguration;
 	}
 	}
 
 
-	get diagnosticsOptions(): monaco.languages.json.DiagnosticsOptions {
+	get diagnosticsOptions(): DiagnosticsOptions {
 		return this._diagnosticsOptions;
 		return this._diagnosticsOptions;
 	}
 	}
 
 
-	setDiagnosticsOptions(options: monaco.languages.json.DiagnosticsOptions): void {
+	setDiagnosticsOptions(options: DiagnosticsOptions): void {
 		this._diagnosticsOptions = options || Object.create(null);
 		this._diagnosticsOptions = options || Object.create(null);
 		this._onDidChange.fire(this);
 		this._onDidChange.fire(this);
 	}
 	}
 
 
-	setModeConfiguration(modeConfiguration: monaco.languages.json.ModeConfiguration): void {
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void {
 		this._modeConfiguration = modeConfiguration || Object.create(null);
 		this._modeConfiguration = modeConfiguration || Object.create(null);
 		this._onDidChange.fire(this);
 		this._onDidChange.fire(this);
 	};
 	};
 }
 }
 
 
-const diagnosticDefault: Required<monaco.languages.json.DiagnosticsOptions> = {
+const diagnosticDefault: Required<DiagnosticsOptions> = {
 	validate: true,
 	validate: true,
 	allowComments: true,
 	allowComments: true,
 	schemas: [],
 	schemas: [],
 	enableSchemaRequest: false
 	enableSchemaRequest: false
 };
 };
 
 
-const modeConfigurationDefault: Required<monaco.languages.json.ModeConfiguration> = {
+const modeConfigurationDefault: Required<ModeConfiguration> = {
 	documentFormattingEdits: true,
 	documentFormattingEdits: true,
 	documentRangeFormattingEdits: true,
 	documentRangeFormattingEdits: true,
 	completionItems: true,
 	completionItems: true,
@@ -71,15 +162,10 @@ const modeConfigurationDefault: Required<monaco.languages.json.ModeConfiguration
 	selectionRanges: true
 	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 ---
 // --- Registration to monaco editor ---
 
 
@@ -87,13 +173,13 @@ function getMode(): Promise<typeof mode> {
 	return import('./jsonMode');
 	return import('./jsonMode');
 }
 }
 
 
-monaco.languages.register({
+languages.register({
 	id: 'json',
 	id: 'json',
 	extensions: ['.json', '.bowerrc', '.jshintrc', '.jscsrc', '.eslintrc', '.babelrc', '.har'],
 	extensions: ['.json', '.bowerrc', '.jshintrc', '.jscsrc', '.eslintrc', '.babelrc', '.har'],
 	aliases: ['JSON', 'json'],
 	aliases: ['JSON', 'json'],
 	mimetypes: ['application/json'],
 	mimetypes: ['application/json'],
 });
 });
 
 
-monaco.languages.onLanguage('json', () => {
+languages.onLanguage('json', () => {
 	getMode().then(mode => mode.setupMode(jsonDefaults));
 	getMode().then(mode => mode.setupMode(jsonDefaults));
 });
 });

+ 12 - 12
src/tokenization.ts

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

+ 2 - 1
src/tsconfig.esm.json

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

+ 2 - 1
src/tsconfig.json

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

+ 7 - 10
src/workerManager.ts

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