Use the global `monaco` only in the AMD case (see microsoft/monaco-editor#1974)

monaco.d.ts

@@ -2,98 +2,88 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-declare module monaco.languages.css {
+
+/// <reference path="node_modules/monaco-editor-core/monaco.d.ts" />
+
+declare namespace monaco.languages.css {
 	export interface DiagnosticsOptions {
 		readonly validate?: boolean;
 		readonly lint?: {
-			readonly compatibleVendorPrefixes?: 'ignore' | 'warning' | 'error',
-			readonly vendorPrefix?: 'ignore' | 'warning' | 'error',
-			readonly duplicateProperties?: 'ignore' | 'warning' | 'error',
-			readonly emptyRules?: 'ignore' | 'warning' | 'error',
-			readonly importStatement?: 'ignore' | 'warning' | 'error',
-			readonly boxModel?: 'ignore' | 'warning' | 'error',
-			readonly universalSelector?: 'ignore' | 'warning' | 'error',
-			readonly zeroUnits?: 'ignore' | 'warning' | 'error',
-			readonly fontFaceProperties?: 'ignore' | 'warning' | 'error',
-			readonly hexColorLength?: 'ignore' | 'warning' | 'error',
-			readonly argumentsInColorFunction?: 'ignore' | 'warning' | 'error',
-			readonly unknownProperties?: 'ignore' | 'warning' | 'error',
-			readonly ieHack?: 'ignore' | 'warning' | 'error',
-			readonly unknownVendorSpecificProperties?: 'ignore' | 'warning' | 'error',
-			readonly propertyIgnoredDueToDisplay?: 'ignore' | 'warning' | 'error',
-			readonly important?: 'ignore' | 'warning' | 'error',
-			readonly float?: 'ignore' | 'warning' | 'error',
-			readonly idSelector?: 'ignore' | 'warning' | 'error'
-		}
+			readonly compatibleVendorPrefixes?: 'ignore' | 'warning' | 'error';
+			readonly vendorPrefix?: 'ignore' | 'warning' | 'error';
+			readonly duplicateProperties?: 'ignore' | 'warning' | 'error';
+			readonly emptyRules?: 'ignore' | 'warning' | 'error';
+			readonly importStatement?: 'ignore' | 'warning' | 'error';
+			readonly boxModel?: 'ignore' | 'warning' | 'error';
+			readonly universalSelector?: 'ignore' | 'warning' | 'error';
+			readonly zeroUnits?: 'ignore' | 'warning' | 'error';
+			readonly fontFaceProperties?: 'ignore' | 'warning' | 'error';
+			readonly hexColorLength?: 'ignore' | 'warning' | 'error';
+			readonly argumentsInColorFunction?: 'ignore' | 'warning' | 'error';
+			readonly unknownProperties?: 'ignore' | 'warning' | 'error';
+			readonly ieHack?: 'ignore' | 'warning' | 'error';
+			readonly unknownVendorSpecificProperties?: 'ignore' | 'warning' | 'error';
+			readonly propertyIgnoredDueToDisplay?: 'ignore' | 'warning' | 'error';
+			readonly important?: 'ignore' | 'warning' | 'error';
+			readonly float?: 'ignore' | 'warning' | 'error';
+			readonly idSelector?: 'ignore' | 'warning' | 'error';
+		};
 	}
-
 	export interface ModeConfiguration {
 		/**
 		 * 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 definitions provider is enabled.
 		 */
 		readonly definitions?: boolean;
-
 		/**
 		 * Defines whether the built-in references provider is enabled.
 		 */
 		readonly references?: boolean;
-
 		/**
 		 * Defines whether the built-in references provider is enabled.
 		 */
 		readonly documentHighlights?: boolean;
-
 		/**
 		 * Defines whether the built-in rename provider is enabled.
 		 */
 		readonly rename?: 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 var cssDefaults: LanguageServiceDefaults;
-	export var lessDefaults: LanguageServiceDefaults;
-	export var scssDefaults: LanguageServiceDefaults;
-}
+	export const cssDefaults: LanguageServiceDefaults;
+	export const scssDefaults: LanguageServiceDefaults;
+	export const lessDefaults: LanguageServiceDefaults;
+}

package-lock.json

@@ -29,9 +29,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"
@@ -58,9 +58,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",
@@ -68,9 +68,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",
@@ -79,9 +79,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-css-languageservice": {

package.json

@@ -3,9 +3,9 @@
   "version": "2.7.0",
   "description": "CSS, LESS and SCSS 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-css-languageservice@next -f -D && npm install vscode-languageserver-types@next -f -D",
     "install-service-local": "npm install ../vscode-css-languageservice -f -D && npm install ../vscode-languageserver-node/types -f -D"
   },
@@ -18,13 +18,15 @@
   "bugs": {
     "url": "https://github.com/Microsoft/monaco-css/issues"
   },
+  "module": "./release/esm/monaco.contribution.js",
+  "typings": "./release/esm/monaco.contribution.d.ts",
   "devDependencies": {
     "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-css-languageservice": "4.0.3-next.25",
     "vscode-languageserver-types": "3.15.0-next.9",
     "vscode-languageserver-textdocument": "^1.0.0-next.5"

scripts/bundle.js

@@ -21,7 +21,7 @@ const BUNDLED_FILE_HEADER = [
 ].join('\n');
 
 bundleOne('monaco.contribution');
-bundleOne('cssMode');
+bundleOne('cssMode', ['vs/language/css/monaco.contribution']);
 bundleOne('cssWorker');
 
 function bundleOne(moduleId, exclude) {
@@ -31,7 +31,9 @@ function bundleOne(moduleId, exclude) {
 		out: 'release/dev/' + moduleId + '.js',
 		exclude: exclude,
 		paths: {
-			'vs/language/css': REPO_ROOT + '/out/amd'
+			'vs/language/css': REPO_ROOT + '/out/amd',
+			'vs/language/css/fillers/monaco-editor-core':
+					REPO_ROOT + '/out/amd/fillers/monaco-editor-core-amd'
 		},
 		optimize: 'none',
 		packages: [{
@@ -55,18 +57,18 @@ function bundleOne(moduleId, exclude) {
 			location: path.join(REPO_ROOT, '/out/amd/fillers'),
 			main: 'vscode-nls'
 		}]
-	}, function (buildResponse) {
+	}, async function (buildResponse) {
 		const devFilePath = path.join(REPO_ROOT, 'release/dev/' + moduleId + '.js');
 		const minFilePath = path.join(REPO_ROOT, 'release/min/' + moduleId + '.js');
 		const fileContents = fs.readFileSync(devFilePath).toString();
 		console.log();
 		console.log(`Minifying ${devFilePath}...`);
-		const result = Terser.minify(fileContents, {
+		const result = await Terser.minify(fileContents, {
 			output: {
 				comments: 'some'
 			}
 		});
-		console.log(`Done.`);
+		console.log(`Done minifying ${devFilePath}.`);
 		try { fs.mkdirSync(path.join(REPO_ROOT, 'release/min')) } catch (err) { }
 		fs.writeFileSync(minFilePath, BUNDLED_FILE_HEADER + result.code);
 	})

scripts/dts.js

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  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.`,
+	` *--------------------------------------------------------------------------------------------*/`,
+	``,
+	`/// <reference path="node_modules/monaco-editor-core/monaco.d.ts" />`,
+	``,
+	`declare namespace monaco.languages.css {`
+];
+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/css.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 { CSSWorker } from './cssWorker';

src/cssMode.ts

@@ -2,17 +2,14 @@
  *  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 { CSSWorker } from './cssWorker';
-import { LanguageServiceDefaultsImpl } from './monaco.contribution';
+import type { CSSWorker } from './cssWorker';
+import { LanguageServiceDefaults } from './monaco.contribution';
 import * as languageFeatures from './languageFeatures';
+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[] = [];
@@ -31,37 +28,37 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
 		disposeAll(providers);
 
 		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.documentHighlights) {
-			providers.push(monaco.languages.registerDocumentHighlightProvider(languageId, new languageFeatures.DocumentHighlightAdapter(worker)));
+			providers.push(languages.registerDocumentHighlightProvider(languageId, new languageFeatures.DocumentHighlightAdapter(worker)));
 		}
 		if (modeConfiguration.definitions) {
-			providers.push(monaco.languages.registerDefinitionProvider(languageId, new languageFeatures.DefinitionAdapter(worker)));
+			providers.push(languages.registerDefinitionProvider(languageId, new languageFeatures.DefinitionAdapter(worker)));
 		}
 		if (modeConfiguration.references) {
-			providers.push(monaco.languages.registerReferenceProvider(languageId, new languageFeatures.ReferenceAdapter(worker)));
+			providers.push(languages.registerReferenceProvider(languageId, new languageFeatures.ReferenceAdapter(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.rename) {
-			providers.push(monaco.languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker)));
+			providers.push(languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker)));
 		}
 		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)));
 		}
 	}
 

src/cssWorker.ts

@@ -2,22 +2,20 @@
  *  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 IWorkerContext = monaco.worker.IWorkerContext;
 
+import type { worker } from './fillers/monaco-editor-core';
 import * as cssService from 'vscode-css-languageservice';
 
 export class CSSWorker {
 
 	// --- model sync -----------------------
 
-	private _ctx: IWorkerContext;
+	private _ctx: worker.IWorkerContext;
 	private _languageService: cssService.LanguageService;
 	private _languageSettings: cssService.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;
@@ -135,6 +133,6 @@ export interface ICreateData {
 	languageSettings: cssService.LanguageSettings;
 }
 
-export function create(ctx: IWorkerContext, createData: ICreateData): CSSWorker {
+export function create(ctx: worker.IWorkerContext, createData: ICreateData): CSSWorker {
 	return new CSSWorker(ctx, createData);
 }

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/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/languageFeatures.ts

@@ -2,20 +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 { LanguageServiceDefaultsImpl } from './monaco.contribution';
-import { CSSWorker } from './cssWorker';
 
+import { LanguageServiceDefaults } from './monaco.contribution';
+import type { CSSWorker } from './cssWorker';
 import * as cssService from 'vscode-css-languageservice';
-
-import Uri = monaco.Uri;
-import Position = monaco.Position;
-import IRange = monaco.IRange;
-import Range = monaco.Range;
-import CancellationToken = monaco.CancellationToken;
-import IDisposable = monaco.IDisposable;
-
+import { languages, editor, IMarkdownString, Uri, Position, IRange, Range, CancellationToken, IDisposable, MarkerSeverity } from './fillers/monaco-editor-core';
 
 export interface WorkerAccessor {
 	(first: Uri, ...more: Uri[]): Promise<CSSWorker>
@@ -28,8 +19,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;
@@ -44,8 +35,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];
@@ -55,15 +46,15 @@ export class DiagnosticsAdapter {
 			}
 		};
 
-		this._disposables.push(monaco.editor.onDidCreateModel(onModelAdd));
-		this._disposables.push(monaco.editor.onWillDisposeModel(onModelRemoved));
-		this._disposables.push(monaco.editor.onDidChangeModelLanguage(event => {
+		this._disposables.push(editor.onDidCreateModel(onModelAdd));
+		this._disposables.push(editor.onWillDisposeModel(onModelRemoved));
+		this._disposables.push(editor.onDidChangeModelLanguage(event => {
 			onModelRemoved(event.model);
 			onModelAdd(event.model);
 		}));
 
 		defaults.onDidChange(_ => {
-			monaco.editor.getModels().forEach(model => {
+			editor.getModels().forEach(model => {
 				if (model.getModeId() === this._languageId) {
 					onModelRemoved(model);
 					onModelAdd(model);
@@ -79,7 +70,7 @@ export class DiagnosticsAdapter {
 			}
 		});
 
-		monaco.editor.getModels().forEach(onModelAdd);
+		editor.getModels().forEach(onModelAdd);
 	}
 
 	public dispose(): void {
@@ -92,9 +83,9 @@ export class DiagnosticsAdapter {
 			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.getModeId() === languageId) {
-				monaco.editor.setModelMarkers(model, languageId, markers);
+				editor.setModelMarkers(model, languageId, markers);
 			}
 		}).then(undefined, err => {
 			console.error(err);
@@ -103,18 +94,18 @@ export class DiagnosticsAdapter {
 }
 
 
-function toSeverity(lsSeverity: number): monaco.MarkerSeverity {
+function toSeverity(lsSeverity: number): MarkerSeverity {
 	switch (lsSeverity) {
-		case cssService.DiagnosticSeverity.Error: return monaco.MarkerSeverity.Error;
-		case cssService.DiagnosticSeverity.Warning: return monaco.MarkerSeverity.Warning;
-		case cssService.DiagnosticSeverity.Information: return monaco.MarkerSeverity.Info;
-		case cssService.DiagnosticSeverity.Hint: return monaco.MarkerSeverity.Hint;
+		case cssService.DiagnosticSeverity.Error: return MarkerSeverity.Error;
+		case cssService.DiagnosticSeverity.Warning: return MarkerSeverity.Warning;
+		case cssService.DiagnosticSeverity.Information: return MarkerSeverity.Info;
+		case cssService.DiagnosticSeverity.Hint: return MarkerSeverity.Hint;
 		default:
-			return monaco.MarkerSeverity.Info;
+			return MarkerSeverity.Info;
 	}
 }
 
-function toDiagnostics(resource: Uri, diag: cssService.Diagnostic): monaco.editor.IMarkerData {
+function toDiagnostics(resource: Uri, diag: cssService.Diagnostic): editor.IMarkerData {
 	let code = typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
 
 	return {
@@ -149,11 +140,11 @@ function toRange(range: cssService.Range): Range {
 	if (!range) {
 		return void 0;
 	}
-	return new monaco.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) {
 		case cssService.CompletionItemKind.Text: return mItemKind.Text;
@@ -178,7 +169,7 @@ function toCompletionItemKind(kind: number): monaco.languages.CompletionItemKind
 	return mItemKind.Property;
 }
 
-function toTextEdit(textEdit: cssService.TextEdit): monaco.editor.ISingleEditOperation {
+function toTextEdit(textEdit: cssService.TextEdit): editor.ISingleEditOperation {
 	if (!textEdit) {
 		return void 0;
 	}
@@ -188,7 +179,7 @@ function toTextEdit(textEdit: cssService.TextEdit): monaco.editor.ISingleEditOpe
 	}
 }
 
-export class CompletionAdapter implements monaco.languages.CompletionItemProvider {
+export class CompletionAdapter implements languages.CompletionItemProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
@@ -197,7 +188,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 		return [' ', ':'];
 	}
 
-	provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.CompletionContext, token: CancellationToken): Promise<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 => {
@@ -209,8 +200,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,
@@ -228,7 +219,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 					item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit)
 				}
 				if (entry.insertTextFormat === cssService.InsertTextFormat.Snippet) {
-					item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+					item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
 				}
 				return item;
 			});
@@ -246,7 +237,7 @@ function isMarkupContent(thing: any): thing is cssService.MarkupContent {
 	return thing && typeof thing === 'object' && typeof (<cssService.MarkupContent>thing).kind === 'string';
 }
 
-function toMarkdownString(entry: cssService.MarkupContent | cssService.MarkedString): monaco.IMarkdownString {
+function toMarkdownString(entry: cssService.MarkupContent | cssService.MarkedString): IMarkdownString {
 	if (typeof entry === 'string') {
 		return {
 			value: entry
@@ -266,7 +257,7 @@ function toMarkdownString(entry: cssService.MarkupContent | cssService.MarkedStr
 	return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' };
 }
 
-function toMarkedStringArray(contents: cssService.MarkupContent | cssService.MarkedString | cssService.MarkedString[]): monaco.IMarkdownString[] {
+function toMarkedStringArray(contents: cssService.MarkupContent | cssService.MarkedString | cssService.MarkedString[]): IMarkdownString[] {
 	if (!contents) {
 		return void 0;
 	}
@@ -279,12 +270,12 @@ function toMarkedStringArray(contents: cssService.MarkupContent | cssService.Mar
 
 // --- 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): Promise<monaco.languages.Hover> {
+	provideHover(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<languages.Hover> {
 		let resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -293,7 +284,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)
 			};
@@ -303,22 +294,22 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
 
 // --- document highlights ------
 
-function toDocumentHighlightKind(kind: number): monaco.languages.DocumentHighlightKind {
+function toDocumentHighlightKind(kind: number): languages.DocumentHighlightKind {
 	switch (kind) {
-		case cssService.DocumentHighlightKind.Read: return monaco.languages.DocumentHighlightKind.Read;
-		case cssService.DocumentHighlightKind.Write: return monaco.languages.DocumentHighlightKind.Write;
-		case cssService.DocumentHighlightKind.Text: return monaco.languages.DocumentHighlightKind.Text;
+		case cssService.DocumentHighlightKind.Read: return languages.DocumentHighlightKind.Read;
+		case cssService.DocumentHighlightKind.Write: return languages.DocumentHighlightKind.Write;
+		case cssService.DocumentHighlightKind.Text: return languages.DocumentHighlightKind.Text;
 	}
-	return monaco.languages.DocumentHighlightKind.Text;
+	return languages.DocumentHighlightKind.Text;
 }
 
 
-export class DocumentHighlightAdapter implements monaco.languages.DocumentHighlightProvider {
+export class DocumentHighlightAdapter implements languages.DocumentHighlightProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	public provideDocumentHighlights(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<monaco.languages.DocumentHighlight[]> {
+	public provideDocumentHighlights(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<languages.DocumentHighlight[]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -328,7 +319,7 @@ export class DocumentHighlightAdapter implements monaco.languages.DocumentHighli
 				return;
 			}
 			return entries.map(entry => {
-				return <monaco.languages.DocumentHighlight>{
+				return <languages.DocumentHighlight>{
 					range: toRange(entry.range),
 					kind: toDocumentHighlightKind(entry.kind)
 				};
@@ -339,7 +330,7 @@ export class DocumentHighlightAdapter implements monaco.languages.DocumentHighli
 
 // --- definition ------
 
-function toLocation(location: cssService.Location): monaco.languages.Location {
+function toLocation(location: cssService.Location): languages.Location {
 	return {
 		uri: Uri.parse(location.uri),
 		range: toRange(location.range)
@@ -351,7 +342,7 @@ export class DefinitionAdapter {
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	public provideDefinition(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<monaco.languages.Definition> {
+	public provideDefinition(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<languages.Definition> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -367,12 +358,12 @@ export class DefinitionAdapter {
 
 // --- references ------
 
-export class ReferenceAdapter implements monaco.languages.ReferenceProvider {
+export class ReferenceAdapter implements languages.ReferenceProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	provideReferences(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.ReferenceContext, token: CancellationToken): Promise<monaco.languages.Location[]> {
+	provideReferences(model: editor.IReadOnlyModel, position: Position, context: languages.ReferenceContext, token: CancellationToken): Promise<languages.Location[]> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -388,14 +379,14 @@ export class ReferenceAdapter implements monaco.languages.ReferenceProvider {
 
 // --- rename ------
 
-function toWorkspaceEdit(edit: cssService.WorkspaceEdit): monaco.languages.WorkspaceEdit {
+function toWorkspaceEdit(edit: cssService.WorkspaceEdit): languages.WorkspaceEdit {
 	if (!edit || !edit.changes) {
 		return void 0;
 	}
-	let resourceEdits: monaco.languages.WorkspaceTextEdit[] = [];
+	let resourceEdits: languages.WorkspaceTextEdit[] = [];
 	for (let uri in edit.changes) {
 		const _uri = Uri.parse(uri);
-		// let edits: monaco.languages.TextEdit[] = [];
+		// let edits: languages.TextEdit[] = [];
 		for (let e of edit.changes[uri]) {
 			resourceEdits.push({
 				resource: _uri,
@@ -412,12 +403,12 @@ function toWorkspaceEdit(edit: cssService.WorkspaceEdit): monaco.languages.Works
 }
 
 
-export class RenameAdapter implements monaco.languages.RenameProvider {
+export class RenameAdapter implements languages.RenameProvider {
 
 	constructor(private _worker: WorkerAccessor) {
 	}
 
-	provideRenameEdits(model: monaco.editor.IReadOnlyModel, position: Position, newName: string, token: CancellationToken): Promise<monaco.languages.WorkspaceEdit> {
+	provideRenameEdits(model: editor.IReadOnlyModel, position: Position, newName: string, token: CancellationToken): Promise<languages.WorkspaceEdit> {
 		const resource = model.uri;
 
 		return this._worker(resource).then(worker => {
@@ -430,8 +421,8 @@ export class RenameAdapter implements monaco.languages.RenameProvider {
 
 // --- document symbols ------
 
-function toSymbolKind(kind: cssService.SymbolKind): monaco.languages.SymbolKind {
-	let mKind = monaco.languages.SymbolKind;
+function toSymbolKind(kind: cssService.SymbolKind): languages.SymbolKind {
+	let mKind = languages.SymbolKind;
 
 	switch (kind) {
 		case cssService.SymbolKind.File: return mKind.Array;
@@ -457,12 +448,12 @@ function toSymbolKind(kind: cssService.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): Promise<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 => {
@@ -482,12 +473,12 @@ export class DocumentSymbolAdapter implements monaco.languages.DocumentSymbolPro
 	}
 }
 
-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): Promise<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 => {
@@ -501,7 +492,7 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi
 		});
 	}
 
-	public provideColorPresentations(model: monaco.editor.IReadOnlyModel, info: monaco.languages.IColorInformation, token: CancellationToken): Promise<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 => {
@@ -509,7 +500,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) {
@@ -524,12 +515,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): Promise<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 => {
@@ -537,7 +528,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
 				};
@@ -551,20 +542,20 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide
 
 }
 
-function toFoldingRangeKind(kind: cssService.FoldingRangeKind): monaco.languages.FoldingRangeKind {
+function toFoldingRangeKind(kind: cssService.FoldingRangeKind): languages.FoldingRangeKind {
 	switch (kind) {
-		case cssService.FoldingRangeKind.Comment: return monaco.languages.FoldingRangeKind.Comment;
-		case cssService.FoldingRangeKind.Imports: return monaco.languages.FoldingRangeKind.Imports;
-		case cssService.FoldingRangeKind.Region: return monaco.languages.FoldingRangeKind.Region;
+		case cssService.FoldingRangeKind.Comment: return languages.FoldingRangeKind.Comment;
+		case cssService.FoldingRangeKind.Imports: return languages.FoldingRangeKind.Imports;
+		case cssService.FoldingRangeKind.Region: return languages.FoldingRangeKind.Region;
 	}
 }
 
-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): Promise<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 => {
@@ -572,7 +563,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,66 +2,35 @@
  *  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 './cssMode';
-
-import Emitter = monaco.Emitter;
-import IEvent = monaco.IEvent;
-
-// --- CSS configuration and defaults ---------
-
-export class LanguageServiceDefaultsImpl implements monaco.languages.css.LanguageServiceDefaults {
-
-	private _onDidChange = new Emitter<monaco.languages.css.LanguageServiceDefaults>();
-	private _diagnosticsOptions: monaco.languages.css.DiagnosticsOptions;
-	private _modeConfiguration: monaco.languages.css.ModeConfiguration;
-	private _languageId: string;
-
-	constructor(languageId: string, diagnosticsOptions: monaco.languages.css.DiagnosticsOptions, modeConfiguration: monaco.languages.css.ModeConfiguration) {
-		this._languageId = languageId;
-		this.setDiagnosticsOptions(diagnosticsOptions);
-		this.setModeConfiguration(modeConfiguration);
-	}
-
-	get onDidChange(): IEvent<monaco.languages.css.LanguageServiceDefaults> {
-		return this._onDidChange.event;
-	}
-
-	get languageId(): string {
-		return this._languageId;
-	}
-
-	get modeConfiguration(): monaco.languages.css.ModeConfiguration {
-		return this._modeConfiguration;
-	}
-
-	get diagnosticsOptions(): monaco.languages.css.DiagnosticsOptions {
-		return this._diagnosticsOptions;
-	}
-
-	setDiagnosticsOptions(options: monaco.languages.css.DiagnosticsOptions): void {
-		this._diagnosticsOptions = options || Object.create(null);
-		this._onDidChange.fire(this);
+import { languages, Emitter, IEvent } from './fillers/monaco-editor-core';
+
+export interface DiagnosticsOptions {
+	readonly validate?: boolean;
+	readonly lint?: {
+		readonly compatibleVendorPrefixes?: 'ignore' | 'warning' | 'error',
+		readonly vendorPrefix?: 'ignore' | 'warning' | 'error',
+		readonly duplicateProperties?: 'ignore' | 'warning' | 'error',
+		readonly emptyRules?: 'ignore' | 'warning' | 'error',
+		readonly importStatement?: 'ignore' | 'warning' | 'error',
+		readonly boxModel?: 'ignore' | 'warning' | 'error',
+		readonly universalSelector?: 'ignore' | 'warning' | 'error',
+		readonly zeroUnits?: 'ignore' | 'warning' | 'error',
+		readonly fontFaceProperties?: 'ignore' | 'warning' | 'error',
+		readonly hexColorLength?: 'ignore' | 'warning' | 'error',
+		readonly argumentsInColorFunction?: 'ignore' | 'warning' | 'error',
+		readonly unknownProperties?: 'ignore' | 'warning' | 'error',
+		readonly ieHack?: 'ignore' | 'warning' | 'error',
+		readonly unknownVendorSpecificProperties?: 'ignore' | 'warning' | 'error',
+		readonly propertyIgnoredDueToDisplay?: 'ignore' | 'warning' | 'error',
+		readonly important?: 'ignore' | 'warning' | 'error',
+		readonly float?: 'ignore' | 'warning' | 'error',
+		readonly idSelector?: 'ignore' | 'warning' | 'error'
 	}
-
-	setModeConfiguration(modeConfiguration: monaco.languages.css.ModeConfiguration): void {
-		this._modeConfiguration = modeConfiguration || Object.create(null);
-		this._onDidChange.fire(this);
-	};
 }
 
 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.
 	 */
@@ -78,9 +47,24 @@ export interface ModeConfiguration {
 	readonly documentSymbols?: boolean;
 
 	/**
-	 * Defines whether the built-in tokens provider is enabled.
+	 * Defines whether the built-in definitions provider is enabled.
 	 */
-	readonly tokens?: boolean;
+	readonly definitions?: boolean;
+
+	/**
+	 * Defines whether the built-in references provider is enabled.
+	 */
+	readonly references?: boolean;
+
+	/**
+	 * Defines whether the built-in references provider is enabled.
+	 */
+	readonly documentHighlights?: boolean;
+
+	/**
+	 * Defines whether the built-in rename provider is enabled.
+	 */
+	readonly rename?: boolean;
 
 	/**
 	 * Defines whether the built-in color provider is enabled.
@@ -104,7 +88,58 @@ export interface ModeConfiguration {
 
 }
 
-const diagnosticDefault: Required<monaco.languages.css.DiagnosticsOptions> = {
+export interface LanguageServiceDefaults {
+	readonly languageId: string;
+	readonly onDidChange: IEvent<LanguageServiceDefaults>;
+	readonly diagnosticsOptions: DiagnosticsOptions;
+	readonly modeConfiguration: ModeConfiguration;
+	setDiagnosticsOptions(options: DiagnosticsOptions): void;
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+}
+
+// --- CSS configuration and defaults ---------
+
+class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
+
+	private _onDidChange = new Emitter<LanguageServiceDefaults>();
+	private _diagnosticsOptions: DiagnosticsOptions;
+	private _modeConfiguration: ModeConfiguration;
+	private _languageId: string;
+
+	constructor(languageId: string, diagnosticsOptions: DiagnosticsOptions, modeConfiguration: ModeConfiguration) {
+		this._languageId = languageId;
+		this.setDiagnosticsOptions(diagnosticsOptions);
+		this.setModeConfiguration(modeConfiguration);
+	}
+
+	get onDidChange(): IEvent<LanguageServiceDefaults> {
+		return this._onDidChange.event;
+	}
+
+	get languageId(): string {
+		return this._languageId;
+	}
+
+	get modeConfiguration(): ModeConfiguration {
+		return this._modeConfiguration;
+	}
+
+	get diagnosticsOptions(): DiagnosticsOptions {
+		return this._diagnosticsOptions;
+	}
+
+	setDiagnosticsOptions(options: DiagnosticsOptions): void {
+		this._diagnosticsOptions = options || Object.create(null);
+		this._onDidChange.fire(this);
+	}
+
+	setModeConfiguration(modeConfiguration: ModeConfiguration): void {
+		this._modeConfiguration = modeConfiguration || Object.create(null);
+		this._onDidChange.fire(this);
+	};
+}
+
+const diagnosticDefault: Required<DiagnosticsOptions> = {
 	validate: true,
 	lint: {
 		compatibleVendorPrefixes: 'ignore',
@@ -128,7 +163,7 @@ const diagnosticDefault: Required<monaco.languages.css.DiagnosticsOptions> = {
 	}
 }
 
-const modeConfigurationDefault: Required<monaco.languages.css.ModeConfiguration> = {
+const modeConfigurationDefault: Required<ModeConfiguration> = {
 	completionItems: true,
 	hovers: true,
 	documentSymbols: true,
@@ -142,20 +177,12 @@ const modeConfigurationDefault: Required<monaco.languages.css.ModeConfiguration>
 	selectionRanges: true
 }
 
-const cssDefaults = new LanguageServiceDefaultsImpl('css', diagnosticDefault, modeConfigurationDefault);
-const scssDefaults = new LanguageServiceDefaultsImpl('scss', diagnosticDefault, modeConfigurationDefault);
-const lessDefaults = new LanguageServiceDefaultsImpl('less', diagnosticDefault, modeConfigurationDefault);
-
+export const cssDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl('css', diagnosticDefault, modeConfigurationDefault);
+export const scssDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl('scss', diagnosticDefault, modeConfigurationDefault);
+export const lessDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl('less', diagnosticDefault, modeConfigurationDefault);
 
-// Export API
-function createAPI(): typeof monaco.languages.css {
-	return {
-		cssDefaults: cssDefaults,
-		lessDefaults: lessDefaults,
-		scssDefaults: scssDefaults
-	}
-}
-monaco.languages.css = createAPI();
+// export to the global based API
+(<any>languages).json = { cssDefaults, lessDefaults, scssDefaults };
 
 // --- Registration to monaco editor ---
 
@@ -163,14 +190,14 @@ function getMode(): Promise<typeof mode> {
 	return import('./cssMode');
 }
 
-monaco.languages.onLanguage('less', () => {
+languages.onLanguage('less', () => {
 	getMode().then(mode => mode.setupMode(lessDefaults));
 });
 
-monaco.languages.onLanguage('scss', () => {
+languages.onLanguage('scss', () => {
 	getMode().then(mode => mode.setupMode(scssDefaults));
 });
 
-monaco.languages.onLanguage('css', () => {
+languages.onLanguage('css', () => {
 	getMode().then(mode => mode.setupMode(cssDefaults));
 });

src/tsconfig.esm.json

@@ -3,6 +3,7 @@
     "module": "esnext",
     "moduleResolution": "node",
     "outDir": "../out/esm",
+    "declaration": true,
     "target": "es5",
     "lib": [
       "dom",
@@ -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 { CSSWorker } from './cssWorker';
-
-import IDisposable = monaco.IDisposable;
-import Uri = monaco.Uri;
+import { LanguageServiceDefaults } from './monaco.contribution';
+import type { CSSWorker } from './cssWorker';
+import { editor, IDisposable, Uri } 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<CSSWorker>;
+	private _worker: editor.MonacoWebWorker<CSSWorker>;
 	private _client: Promise<CSSWorker>;
 
-	constructor(defaults: LanguageServiceDefaultsImpl) {
+	constructor(defaults: LanguageServiceDefaults) {
 		this._defaults = defaults;
 		this._worker = null;
 		this._idleCheckInterval = window.setInterval(() => this._checkIfIdle(), 30 * 1000);
@@ -58,7 +55,7 @@ export class WorkerManager {
 		this._lastUsedTime = Date.now();
 
 		if (!this._client) {
-			this._worker = monaco.editor.createWebWorker<CSSWorker>({
+			this._worker = editor.createWebWorker<CSSWorker>({
 
 				// module that exports the create() method and returns a `CSSWorker` instance
 				moduleId: 'vs/language/css/cssWorker',