Run prettier

README.md

@@ -1,11 +1,12 @@
 # Monaco HTML
 
 HTML language plugin for the Monaco Editor. It provides the following features when editing HTML files:
-* Code completion
-* Formatting
-* Document Highlights
-* Link detection
-* Syntax highlighting
+
+- Code completion
+- Formatting
+- Document Highlights
+- Link detection
+- Syntax highlighting
 
 Internally the HTML plugin uses the [vscode-html-languageservice](https://github.com/Microsoft/vscode-html-languageservice)
 node module, providing the implementation of the functionally listed above. The same module is also used
@@ -21,11 +22,12 @@ This npm module is bundled and distributed in the [monaco-editor](https://www.np
 
 ## Development
 
-* `git clone https://github.com/Microsoft/monaco-html`
-* `cd monaco-html`
-* `npm install .`
-* `npm run watch`
-* open `$/monaco-html/test/index.html` in your favorite browser.
+- `git clone https://github.com/Microsoft/monaco-html`
+- `cd monaco-html`
+- `npm install .`
+- `npm run watch`
+- open `$/monaco-html/test/index.html` in your favorite browser.
 
 ## License
+
 [MIT](https://github.com/Microsoft/monaco-html/blob/master/LICENSE.md)

package.json

@@ -32,5 +32,10 @@
 		"vscode-html-languageservice": "3.0.4-next.12",
 		"vscode-languageserver-types": "3.15.0-next.9",
 		"vscode-languageserver-textdocument": "^1.0.0-next.5"
+	},
+	"husky": {
+		"hooks": {
+			"pre-commit": "pretty-quick --staged"
+		}
 	}
 }

scripts/bundle.js

@@ -1,7 +1,7 @@
 const requirejs = require('requirejs');
 const path = require('path');
 const fs = require('fs');
-const terser = require("terser");
+const terser = require('terser');
 const helpers = require('monaco-plugin-helpers');
 
 const REPO_ROOT = path.resolve(__dirname, '..');
@@ -25,7 +25,8 @@ bundleOne('htmlMode');
 bundleOne('htmlWorker');
 
 function bundleOne(moduleId, exclude) {
-	requirejs.optimize({
+	requirejs.optimize(
+		{
 			baseUrl: 'out/amd/',
 			name: 'vs/language/html/' + moduleId,
 			out: 'release/dev/' + moduleId + '.js',
@@ -34,30 +35,52 @@ function bundleOne(moduleId, exclude) {
 				'vs/language/html': REPO_ROOT + '/out/amd'
 			},
 			optimize: 'none',
-		packages: [{
+			packages: [
+				{
 					name: 'vscode-html-languageservice',
-			location: path.join(REPO_ROOT, 'node_modules/vscode-html-languageservice/lib/umd'),
+					location: path.join(
+						REPO_ROOT,
+						'node_modules/vscode-html-languageservice/lib/umd'
+					),
 					main: 'htmlLanguageService'
-		}, {
+				},
+				{
 					name: 'vscode-languageserver-types',
-			location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-types/lib/umd'),
+					location: path.join(
+						REPO_ROOT,
+						'node_modules/vscode-languageserver-types/lib/umd'
+					),
 					main: 'main'
-		}, {
+				},
+				{
 					name: 'vscode-languageserver-textdocument',
-			location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-textdocument/lib/umd'),
+					location: path.join(
+						REPO_ROOT,
+						'node_modules/vscode-languageserver-textdocument/lib/umd'
+					),
 					main: 'main'
-		}, {
+				},
+				{
 					name: 'vscode-uri',
 					location: path.join(REPO_ROOT, 'node_modules/vscode-uri/lib/umd'),
 					main: 'index'
-		}, {
+				},
+				{
 					name: 'vscode-nls',
 					location: path.join(REPO_ROOT, '/out/amd/fillers'),
 					main: 'vscode-nls'
-		}]
-	}, function (buildResponse) {
-		const devFilePath = path.join(REPO_ROOT, 'release/dev/' + moduleId + '.js');
-		const minFilePath = path.join(REPO_ROOT, 'release/min/' + moduleId + '.js');
+				}
+			]
+		},
+		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}...`);
@@ -67,7 +90,10 @@ function bundleOne(moduleId, exclude) {
 				}
 			});
 			console.log(`Done.`);
-		try { fs.mkdirSync(path.join(REPO_ROOT, 'release/min')) } catch (err) { }
+			try {
+				fs.mkdirSync(path.join(REPO_ROOT, 'release/min'));
+			} catch (err) {}
 			fs.writeFileSync(minFilePath, BUNDLED_FILE_HEADER + result.code);
-	})
+		}
+	);
 }

scripts/release.js

@@ -12,19 +12,13 @@ helpers.packageESM({
 	repoRoot: REPO_ROOT,
 	esmSource: 'out/esm',
 	esmDestination: 'release/esm',
-	entryPoints: [
-		'monaco.contribution.js',
-		'htmlMode.js',
-		'html.worker.js'
-	],
+	entryPoints: ['monaco.contribution.js', 'htmlMode.js', 'html.worker.js'],
 	resolveAlias: {
-		'vscode-nls': path.join(REPO_ROOT, "out/esm/fillers/vscode-nls.js")
+		'vscode-nls': path.join(REPO_ROOT, 'out/esm/fillers/vscode-nls.js')
 	},
-	resolveSkip: [
-		'monaco-editor-core'
-	],
+	resolveSkip: ['monaco-editor-core'],
 	destinationFolderSimplification: {
-		'node_modules': '_deps',
+		node_modules: '_deps',
 		'vscode-languageserver-types/lib/esm': 'vscode-languageserver-types',
 		'vscode-uri/lib/esm': 'vscode-uri',
 		'vscode-html-languageservice/lib/esm': 'vscode-html-languageservice'

src/fillers/vscode-nls.ts

@@ -20,7 +20,7 @@ export interface LoadFunc {
 }
 
 function format(message: string, args: any[]): string {
-	let result:string;
+	let result: string;
 
 	if (args.length === 0) {
 		result = message;
@@ -33,7 +33,11 @@ function format(message: string, args: any[]): string {
 	return result;
 }
 
-function localize(key: string | LocalizeInfo, message: string, ...args: any[]): string {
+function localize(
+	key: string | LocalizeInfo,
+	message: string,
+	...args: any[]
+): string {
 	return format(message, args);
 }
 

src/html.worker.ts

@@ -10,6 +10,6 @@ import { HTMLWorker } from './htmlWorker';
 self.onmessage = () => {
 	// ignore the first message
 	worker.initialize((ctx, createData) => {
-		return new HTMLWorker(ctx, createData)
+		return new HTMLWorker(ctx, createData);
 	});
 };

src/htmlMode.ts

@@ -13,91 +13,172 @@ import Uri = monaco.Uri;
 import IDisposable = monaco.IDisposable;
 
 export function setupMode1(defaults: LanguageServiceDefaultsImpl): void {
-
 	const client = new WorkerManager(defaults);
 
-	const worker: languageFeatures.WorkerAccessor = (...uris: Uri[]): Promise<HTMLWorker> => {
+	const worker: languageFeatures.WorkerAccessor = (
+		...uris: Uri[]
+	): Promise<HTMLWorker> => {
 		return client.getLanguageServiceWorker(...uris);
 	};
 
 	let languageId = defaults.languageId;
 
 	// all modes
-	monaco.languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker));
-	monaco.languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker));
+	monaco.languages.registerCompletionItemProvider(
+		languageId,
+		new languageFeatures.CompletionAdapter(worker)
+	);
+	monaco.languages.registerHoverProvider(
+		languageId,
+		new languageFeatures.HoverAdapter(worker)
+	);
 
-	monaco.languages.registerDocumentHighlightProvider(languageId, new languageFeatures.DocumentHighlightAdapter(worker));
-	monaco.languages.registerLinkProvider(languageId, new languageFeatures.DocumentLinkAdapter(worker));
-	monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker));
-	monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker));
-	monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker));
-	monaco.languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker));
+	monaco.languages.registerDocumentHighlightProvider(
+		languageId,
+		new languageFeatures.DocumentHighlightAdapter(worker)
+	);
+	monaco.languages.registerLinkProvider(
+		languageId,
+		new languageFeatures.DocumentLinkAdapter(worker)
+	);
+	monaco.languages.registerFoldingRangeProvider(
+		languageId,
+		new languageFeatures.FoldingRangeAdapter(worker)
+	);
+	monaco.languages.registerDocumentSymbolProvider(
+		languageId,
+		new languageFeatures.DocumentSymbolAdapter(worker)
+	);
+	monaco.languages.registerSelectionRangeProvider(
+		languageId,
+		new languageFeatures.SelectionRangeAdapter(worker)
+	);
+	monaco.languages.registerRenameProvider(
+		languageId,
+		new languageFeatures.RenameAdapter(worker)
+	);
 
 	// only html
 	if (languageId === 'html') {
-		monaco.languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker));
-		monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker));
+		monaco.languages.registerDocumentFormattingEditProvider(
+			languageId,
+			new languageFeatures.DocumentFormattingEditProvider(worker)
+		);
+		monaco.languages.registerDocumentRangeFormattingEditProvider(
+			languageId,
+			new languageFeatures.DocumentRangeFormattingEditProvider(worker)
+		);
 		new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults);
 	}
-
 }
 
 export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
-
 	const disposables: IDisposable[] = [];
 	const providers: IDisposable[] = [];
 
 	const client = new WorkerManager(defaults);
 	disposables.push(client);
 
-	const worker: languageFeatures.WorkerAccessor = (...uris: Uri[]): Promise<HTMLWorker> => {
+	const worker: languageFeatures.WorkerAccessor = (
+		...uris: Uri[]
+	): Promise<HTMLWorker> => {
 		return client.getLanguageServiceWorker(...uris);
 	};
 
-
 	function registerProviders(): void {
 		const { languageId, modeConfiguration } = defaults;
 
 		disposeAll(providers);
 
 		if (modeConfiguration.completionItems) {
-			providers.push(monaco.languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker)));
+			providers.push(
+				monaco.languages.registerCompletionItemProvider(
+					languageId,
+					new languageFeatures.CompletionAdapter(worker)
+				)
+			);
 		}
 		if (modeConfiguration.hovers) {
-			providers.push(monaco.languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker)));
+			providers.push(
+				monaco.languages.registerHoverProvider(
+					languageId,
+					new languageFeatures.HoverAdapter(worker)
+				)
+			);
 		}
 		if (modeConfiguration.documentHighlights) {
-			providers.push(monaco.languages.registerDocumentHighlightProvider(languageId, new languageFeatures.DocumentHighlightAdapter(worker)));
+			providers.push(
+				monaco.languages.registerDocumentHighlightProvider(
+					languageId,
+					new languageFeatures.DocumentHighlightAdapter(worker)
+				)
+			);
 		}
 		if (modeConfiguration.links) {
-			providers.push(monaco.languages.registerLinkProvider(languageId, new languageFeatures.DocumentLinkAdapter(worker)));
+			providers.push(
+				monaco.languages.registerLinkProvider(
+					languageId,
+					new languageFeatures.DocumentLinkAdapter(worker)
+				)
+			);
 		}
 		if (modeConfiguration.documentSymbols) {
-			providers.push(monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker)));
+			providers.push(
+				monaco.languages.registerDocumentSymbolProvider(
+					languageId,
+					new languageFeatures.DocumentSymbolAdapter(worker)
+				)
+			);
 		}
 		if (modeConfiguration.rename) {
-			providers.push(monaco.languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker)));
+			providers.push(
+				monaco.languages.registerRenameProvider(
+					languageId,
+					new languageFeatures.RenameAdapter(worker)
+				)
+			);
 		}
 		if (modeConfiguration.foldingRanges) {
-			providers.push(monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker)));
+			providers.push(
+				monaco.languages.registerFoldingRangeProvider(
+					languageId,
+					new languageFeatures.FoldingRangeAdapter(worker)
+				)
+			);
 		}
 		if (modeConfiguration.selectionRanges) {
-			providers.push(monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker)));
+			providers.push(
+				monaco.languages.registerSelectionRangeProvider(
+					languageId,
+					new languageFeatures.SelectionRangeAdapter(worker)
+				)
+			);
 		}
 		if (modeConfiguration.documentFormattingEdits) {
-			providers.push(monaco.languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker)));
+			providers.push(
+				monaco.languages.registerDocumentFormattingEditProvider(
+					languageId,
+					new languageFeatures.DocumentFormattingEditProvider(worker)
+				)
+			);
 		}
 		if (modeConfiguration.documentRangeFormattingEdits) {
-			providers.push(monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker)));
+			providers.push(
+				monaco.languages.registerDocumentRangeFormattingEditProvider(
+					languageId,
+					new languageFeatures.DocumentRangeFormattingEditProvider(worker)
+				)
+			);
 		}
 		if (modeConfiguration.diagnostics) {
-			providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults));
+			providers.push(
+				new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults)
+			);
 		}
 	}
 
 	registerProviders();
 
-
 	disposables.push(asDisposable(providers));
 
 	return asDisposable(disposables);

src/htmlWorker.ts

@@ -9,7 +9,6 @@ import IWorkerContext = monaco.worker.IWorkerContext;
 import * as htmlService from 'vscode-html-languageservice';
 
 export class HTMLWorker {
-
 	private _ctx: IWorkerContext;
 	private _languageService: htmlService.LanguageService;
 	private _languageSettings: monaco.languages.html.Options;
@@ -26,26 +25,54 @@ export class HTMLWorker {
 		// not yet suported
 		return Promise.resolve([]);
 	}
-	async doComplete(uri: string, position: htmlService.Position): Promise<htmlService.CompletionList> {
+	async doComplete(
+		uri: string,
+		position: htmlService.Position
+	): Promise<htmlService.CompletionList> {
 		let document = this._getTextDocument(uri);
 		let htmlDocument = this._languageService.parseHTMLDocument(document);
-		return Promise.resolve(this._languageService.doComplete(document, position, htmlDocument, this._languageSettings && this._languageSettings.suggest));
+		return Promise.resolve(
+			this._languageService.doComplete(
+				document,
+				position,
+				htmlDocument,
+				this._languageSettings && this._languageSettings.suggest
+			)
+		);
 	}
-	async format(uri: string, range: htmlService.Range, options: htmlService.FormattingOptions): Promise<htmlService.TextEdit[]> {
+	async format(
+		uri: string,
+		range: htmlService.Range,
+		options: htmlService.FormattingOptions
+	): Promise<htmlService.TextEdit[]> {
 		let document = this._getTextDocument(uri);
-		let textEdits = this._languageService.format(document, range, this._languageSettings && this._languageSettings.format);
+		let textEdits = this._languageService.format(
+			document,
+			range,
+			this._languageSettings && this._languageSettings.format
+		);
 		return Promise.resolve(textEdits);
 	}
-	async doHover(uri: string, position: htmlService.Position): Promise<htmlService.Hover> {
+	async doHover(
+		uri: string,
+		position: htmlService.Position
+	): Promise<htmlService.Hover> {
 		let document = this._getTextDocument(uri);
 		let htmlDocument = this._languageService.parseHTMLDocument(document);
 		let hover = this._languageService.doHover(document, position, htmlDocument);
 		return Promise.resolve(hover);
 	}
-	async findDocumentHighlights(uri: string, position: htmlService.Position): Promise<htmlService.DocumentHighlight[]> {
+	async findDocumentHighlights(
+		uri: string,
+		position: htmlService.Position
+	): Promise<htmlService.DocumentHighlight[]> {
 		let document = this._getTextDocument(uri);
 		let htmlDocument = this._languageService.parseHTMLDocument(document);
-		let highlights = this._languageService.findDocumentHighlights(document, position, htmlDocument);
+		let highlights = this._languageService.findDocumentHighlights(
+			document,
+			position,
+			htmlDocument
+		);
 		return Promise.resolve(highlights);
 	}
 	async findDocumentLinks(uri: string): Promise<htmlService.DocumentLink[]> {
@@ -53,33 +80,58 @@ export class HTMLWorker {
 		let links = this._languageService.findDocumentLinks(document, null);
 		return Promise.resolve(links);
 	}
-	async findDocumentSymbols(uri: string): Promise<htmlService.SymbolInformation[]> {
+	async findDocumentSymbols(
+		uri: string
+	): Promise<htmlService.SymbolInformation[]> {
 		let document = this._getTextDocument(uri);
 		let htmlDocument = this._languageService.parseHTMLDocument(document);
-		let symbols = this._languageService.findDocumentSymbols(document, htmlDocument);
+		let symbols = this._languageService.findDocumentSymbols(
+			document,
+			htmlDocument
+		);
 		return Promise.resolve(symbols);
 	}
-	async getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Promise<htmlService.FoldingRange[]> {
+	async getFoldingRanges(
+		uri: string,
+		context?: { rangeLimit?: number }
+	): Promise<htmlService.FoldingRange[]> {
 		let document = this._getTextDocument(uri);
 		let ranges = this._languageService.getFoldingRanges(document, context);
 		return Promise.resolve(ranges);
 	}
-	async getSelectionRanges(uri: string, positions: htmlService.Position[]): Promise<htmlService.SelectionRange[]> {
+	async getSelectionRanges(
+		uri: string,
+		positions: htmlService.Position[]
+	): Promise<htmlService.SelectionRange[]> {
 		let document = this._getTextDocument(uri);
 		let ranges = this._languageService.getSelectionRanges(document, positions);
 		return Promise.resolve(ranges);
 	}
-	async doRename(uri: string, position: htmlService.Position, newName: string): Promise<htmlService.WorkspaceEdit> {
+	async doRename(
+		uri: string,
+		position: htmlService.Position,
+		newName: string
+	): Promise<htmlService.WorkspaceEdit> {
 		let document = this._getTextDocument(uri);
 		let htmlDocument = this._languageService.parseHTMLDocument(document);
-		let renames = this._languageService.doRename(document, position, newName, htmlDocument);
+		let renames = this._languageService.doRename(
+			document,
+			position,
+			newName,
+			htmlDocument
+		);
 		return Promise.resolve(renames);
 	}
 	private _getTextDocument(uri: string): htmlService.TextDocument {
 		let models = this._ctx.getMirrorModels();
 		for (let model of models) {
 			if (model.uri.toString() === uri) {
-				return htmlService.TextDocument.create(uri, this._languageId, model.version, model.getValue());
+				return htmlService.TextDocument.create(
+					uri,
+					this._languageId,
+					model.version,
+					model.getValue()
+				);
 			}
 		}
 		return null;
@@ -91,6 +143,9 @@ export interface ICreateData {
 	languageSettings: monaco.languages.html.Options;
 }
 
-export function create(ctx: IWorkerContext, createData: ICreateData): HTMLWorker {
+export function create(
+	ctx: IWorkerContext,
+	createData: ICreateData
+): HTMLWorker {
 	return new HTMLWorker(ctx, createData);
 }

src/languageFeatures.ts

@@ -15,19 +15,21 @@ import Range = monaco.Range;
 import CancellationToken = monaco.CancellationToken;
 import IDisposable = monaco.IDisposable;
 
-
 export interface WorkerAccessor {
-	(...more: Uri[]): Promise<HTMLWorker>
+	(...more: Uri[]): Promise<HTMLWorker>;
 }
 
 // --- diagnostics --- ---
 
 export class DiagnosticsAdapter {
-
 	private _disposables: IDisposable[] = [];
 	private _listener: { [uri: string]: IDisposable } = Object.create(null);
 
-	constructor(private _languageId: string, private _worker: WorkerAccessor, defaults: LanguageServiceDefaultsImpl) {
+	constructor(
+		private _languageId: string,
+		private _worker: WorkerAccessor,
+		defaults: LanguageServiceDefaultsImpl
+	) {
 		const onModelAdd = (model: monaco.editor.IModel): void => {
 			const modeId = model.getModeId();
 			if (modeId !== this._languageId) {
@@ -54,22 +56,28 @@ export class DiagnosticsAdapter {
 		};
 
 		this._disposables.push(monaco.editor.onDidCreateModel(onModelAdd));
-		this._disposables.push(monaco.editor.onWillDisposeModel(model => {
+		this._disposables.push(
+			monaco.editor.onWillDisposeModel((model) => {
 				onModelRemoved(model);
-		}));
-		this._disposables.push(monaco.editor.onDidChangeModelLanguage(event => {
+			})
+		);
+		this._disposables.push(
+			monaco.editor.onDidChangeModelLanguage((event) => {
 				onModelRemoved(event.model);
 				onModelAdd(event.model);
-		}));
+			})
+		);
 
-		this._disposables.push(defaults.onDidChange(_ => {
-			monaco.editor.getModels().forEach(model => {
+		this._disposables.push(
+			defaults.onDidChange((_) => {
+				monaco.editor.getModels().forEach((model) => {
 					if (model.getModeId() === this._languageId) {
 						onModelRemoved(model);
 						onModelAdd(model);
 					}
 				});
-		}));
+			})
+		);
 
 		this._disposables.push({
 			dispose: () => {
@@ -83,36 +91,49 @@ export class DiagnosticsAdapter {
 	}
 
 	public dispose(): void {
-		this._disposables.forEach(d => d && d.dispose());
+		this._disposables.forEach((d) => d && d.dispose());
 		this._disposables = [];
 	}
 
 	private _doValidate(resource: Uri, languageId: string): void {
-		this._worker(resource).then(worker => {
-			return worker.doValidation(resource.toString()).then(diagnostics => {
-				const markers = diagnostics.map(d => toDiagnostics(resource, d));
-				monaco.editor.setModelMarkers(monaco.editor.getModel(resource), languageId, markers);
+		this._worker(resource)
+			.then((worker) => {
+				return worker.doValidation(resource.toString()).then((diagnostics) => {
+					const markers = diagnostics.map((d) => toDiagnostics(resource, d));
+					monaco.editor.setModelMarkers(
+						monaco.editor.getModel(resource),
+						languageId,
+						markers
+					);
 				});
-		}).then(undefined, err => {
+			})
+			.then(undefined, (err) => {
 				console.error(err);
 			});
 	}
 }
 
-
 function toSeverity(lsSeverity: number): monaco.MarkerSeverity {
 	switch (lsSeverity) {
-		case htmlService.DiagnosticSeverity.Error: return monaco.MarkerSeverity.Error;
-		case htmlService.DiagnosticSeverity.Warning: return monaco.MarkerSeverity.Warning;
-		case htmlService.DiagnosticSeverity.Information: return monaco.MarkerSeverity.Info;
-		case htmlService.DiagnosticSeverity.Hint: return monaco.MarkerSeverity.Hint;
+		case htmlService.DiagnosticSeverity.Error:
+			return monaco.MarkerSeverity.Error;
+		case htmlService.DiagnosticSeverity.Warning:
+			return monaco.MarkerSeverity.Warning;
+		case htmlService.DiagnosticSeverity.Information:
+			return monaco.MarkerSeverity.Info;
+		case htmlService.DiagnosticSeverity.Hint:
+			return monaco.MarkerSeverity.Hint;
 		default:
 			return monaco.MarkerSeverity.Info;
 	}
 }
 
-function toDiagnostics(resource: Uri, diag: htmlService.Diagnostic): monaco.editor.IMarkerData {
-	const code = typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
+function toDiagnostics(
+	resource: Uri,
+	diag: htmlService.Diagnostic
+): monaco.editor.IMarkerData {
+	const code =
+		typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
 
 	return {
 		severity: toSeverity(diag.severity),
@@ -139,100 +160,162 @@ function fromRange(range: Range): htmlService.Range {
 	if (!range) {
 		return void 0;
 	}
-	return { start: fromPosition(range.getStartPosition()), end: fromPosition(range.getEndPosition()) };
+	return {
+		start: fromPosition(range.getStartPosition()),
+		end: fromPosition(range.getEndPosition())
+	};
 }
 
 function toRange(range: htmlService.Range): Range {
 	if (!range) {
 		return void 0;
 	}
-	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 {
+function toCompletionItemKind(
+	kind: number
+): monaco.languages.CompletionItemKind {
 	const mItemKind = monaco.languages.CompletionItemKind;
 
 	switch (kind) {
-		case htmlService.CompletionItemKind.Text: return mItemKind.Text;
-		case htmlService.CompletionItemKind.Method: return mItemKind.Method;
-		case htmlService.CompletionItemKind.Function: return mItemKind.Function;
-		case htmlService.CompletionItemKind.Constructor: return mItemKind.Constructor;
-		case htmlService.CompletionItemKind.Field: return mItemKind.Field;
-		case htmlService.CompletionItemKind.Variable: return mItemKind.Variable;
-		case htmlService.CompletionItemKind.Class: return mItemKind.Class;
-		case htmlService.CompletionItemKind.Interface: return mItemKind.Interface;
-		case htmlService.CompletionItemKind.Module: return mItemKind.Module;
-		case htmlService.CompletionItemKind.Property: return mItemKind.Property;
-		case htmlService.CompletionItemKind.Unit: return mItemKind.Unit;
-		case htmlService.CompletionItemKind.Value: return mItemKind.Value;
-		case htmlService.CompletionItemKind.Enum: return mItemKind.Enum;
-		case htmlService.CompletionItemKind.Keyword: return mItemKind.Keyword;
-		case htmlService.CompletionItemKind.Snippet: return mItemKind.Snippet;
-		case htmlService.CompletionItemKind.Color: return mItemKind.Color;
-		case htmlService.CompletionItemKind.File: return mItemKind.File;
-		case htmlService.CompletionItemKind.Reference: return mItemKind.Reference;
+		case htmlService.CompletionItemKind.Text:
+			return mItemKind.Text;
+		case htmlService.CompletionItemKind.Method:
+			return mItemKind.Method;
+		case htmlService.CompletionItemKind.Function:
+			return mItemKind.Function;
+		case htmlService.CompletionItemKind.Constructor:
+			return mItemKind.Constructor;
+		case htmlService.CompletionItemKind.Field:
+			return mItemKind.Field;
+		case htmlService.CompletionItemKind.Variable:
+			return mItemKind.Variable;
+		case htmlService.CompletionItemKind.Class:
+			return mItemKind.Class;
+		case htmlService.CompletionItemKind.Interface:
+			return mItemKind.Interface;
+		case htmlService.CompletionItemKind.Module:
+			return mItemKind.Module;
+		case htmlService.CompletionItemKind.Property:
+			return mItemKind.Property;
+		case htmlService.CompletionItemKind.Unit:
+			return mItemKind.Unit;
+		case htmlService.CompletionItemKind.Value:
+			return mItemKind.Value;
+		case htmlService.CompletionItemKind.Enum:
+			return mItemKind.Enum;
+		case htmlService.CompletionItemKind.Keyword:
+			return mItemKind.Keyword;
+		case htmlService.CompletionItemKind.Snippet:
+			return mItemKind.Snippet;
+		case htmlService.CompletionItemKind.Color:
+			return mItemKind.Color;
+		case htmlService.CompletionItemKind.File:
+			return mItemKind.File;
+		case htmlService.CompletionItemKind.Reference:
+			return mItemKind.Reference;
 	}
 	return mItemKind.Property;
 }
 
-function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): htmlService.CompletionItemKind {
+function fromCompletionItemKind(
+	kind: monaco.languages.CompletionItemKind
+): htmlService.CompletionItemKind {
 	const mItemKind = monaco.languages.CompletionItemKind;
 
 	switch (kind) {
-		case mItemKind.Text: return htmlService.CompletionItemKind.Text;
-		case mItemKind.Method: return htmlService.CompletionItemKind.Method;
-		case mItemKind.Function: return htmlService.CompletionItemKind.Function;
-		case mItemKind.Constructor: return htmlService.CompletionItemKind.Constructor;
-		case mItemKind.Field: return htmlService.CompletionItemKind.Field;
-		case mItemKind.Variable: return htmlService.CompletionItemKind.Variable;
-		case mItemKind.Class: return htmlService.CompletionItemKind.Class;
-		case mItemKind.Interface: return htmlService.CompletionItemKind.Interface;
-		case mItemKind.Module: return htmlService.CompletionItemKind.Module;
-		case mItemKind.Property: return htmlService.CompletionItemKind.Property;
-		case mItemKind.Unit: return htmlService.CompletionItemKind.Unit;
-		case mItemKind.Value: return htmlService.CompletionItemKind.Value;
-		case mItemKind.Enum: return htmlService.CompletionItemKind.Enum;
-		case mItemKind.Keyword: return htmlService.CompletionItemKind.Keyword;
-		case mItemKind.Snippet: return htmlService.CompletionItemKind.Snippet;
-		case mItemKind.Color: return htmlService.CompletionItemKind.Color;
-		case mItemKind.File: return htmlService.CompletionItemKind.File;
-		case mItemKind.Reference: return htmlService.CompletionItemKind.Reference;
+		case mItemKind.Text:
+			return htmlService.CompletionItemKind.Text;
+		case mItemKind.Method:
+			return htmlService.CompletionItemKind.Method;
+		case mItemKind.Function:
+			return htmlService.CompletionItemKind.Function;
+		case mItemKind.Constructor:
+			return htmlService.CompletionItemKind.Constructor;
+		case mItemKind.Field:
+			return htmlService.CompletionItemKind.Field;
+		case mItemKind.Variable:
+			return htmlService.CompletionItemKind.Variable;
+		case mItemKind.Class:
+			return htmlService.CompletionItemKind.Class;
+		case mItemKind.Interface:
+			return htmlService.CompletionItemKind.Interface;
+		case mItemKind.Module:
+			return htmlService.CompletionItemKind.Module;
+		case mItemKind.Property:
+			return htmlService.CompletionItemKind.Property;
+		case mItemKind.Unit:
+			return htmlService.CompletionItemKind.Unit;
+		case mItemKind.Value:
+			return htmlService.CompletionItemKind.Value;
+		case mItemKind.Enum:
+			return htmlService.CompletionItemKind.Enum;
+		case mItemKind.Keyword:
+			return htmlService.CompletionItemKind.Keyword;
+		case mItemKind.Snippet:
+			return htmlService.CompletionItemKind.Snippet;
+		case mItemKind.Color:
+			return htmlService.CompletionItemKind.Color;
+		case mItemKind.File:
+			return htmlService.CompletionItemKind.File;
+		case mItemKind.Reference:
+			return htmlService.CompletionItemKind.Reference;
 	}
 	return htmlService.CompletionItemKind.Property;
 }
 
-function toTextEdit(textEdit: htmlService.TextEdit): monaco.editor.ISingleEditOperation {
+function toTextEdit(
+	textEdit: htmlService.TextEdit
+): monaco.editor.ISingleEditOperation {
 	if (!textEdit) {
 		return void 0;
 	}
 	return {
 		range: toRange(textEdit.range),
 		text: textEdit.newText
-	}
+	};
 }
 
-export class CompletionAdapter implements monaco.languages.CompletionItemProvider {
-
-	constructor(private _worker: WorkerAccessor) {
-	}
+export class CompletionAdapter
+	implements monaco.languages.CompletionItemProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
 	public get triggerCharacters(): string[] {
 		return ['.', ':', '<', '"', '=', '/'];
 	}
 
-	provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.CompletionContext, token: CancellationToken): Promise<monaco.languages.CompletionList> {
+	provideCompletionItems(
+		model: monaco.editor.IReadOnlyModel,
+		position: Position,
+		context: monaco.languages.CompletionContext,
+		token: CancellationToken
+	): Promise<monaco.languages.CompletionList> {
 		const resource = model.uri;
 
-		return this._worker(resource).then(worker => {
+		return this._worker(resource)
+			.then((worker) => {
 				return worker.doComplete(resource.toString(), fromPosition(position));
-		}).then(info => {
+			})
+			.then((info) => {
 				if (!info) {
 					return;
 				}
 				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
+				);
 
-			const items: monaco.languages.CompletionItem[] = info.items.map(entry => {
+				const items: monaco.languages.CompletionItem[] = info.items.map(
+					(entry) => {
 						const item: monaco.languages.CompletionItem = {
 							label: entry.label,
 							insertText: entry.insertText || entry.label,
@@ -241,20 +324,26 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 							documentation: entry.documentation,
 							detail: entry.detail,
 							range: wordRange,
-					kind: toCompletionItemKind(entry.kind),
+							kind: toCompletionItemKind(entry.kind)
 						};
 						if (entry.textEdit) {
 							item.range = toRange(entry.textEdit.range);
 							item.insertText = entry.textEdit.newText;
 						}
 						if (entry.additionalTextEdits) {
-					item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit)
+							item.additionalTextEdits = entry.additionalTextEdits.map(
+								toTextEdit
+							);
 						}
-				if (entry.insertTextFormat === htmlService.InsertTextFormat.Snippet) {
-					item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+						if (
+							entry.insertTextFormat === htmlService.InsertTextFormat.Snippet
+						) {
+							item.insertTextRules =
+								monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
 						}
 						return item;
-			});
+					}
+				);
 
 				return {
 					isIncomplete: info.isIncomplete,
@@ -267,10 +356,16 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
 // --- hover ------
 
 function isMarkupContent(thing: any): thing is htmlService.MarkupContent {
-	return thing && typeof thing === 'object' && typeof (<htmlService.MarkupContent>thing).kind === 'string';
+	return (
+		thing &&
+		typeof thing === 'object' &&
+		typeof (<htmlService.MarkupContent>thing).kind === 'string'
+	);
 }
 
-function toMarkdownString(entry: htmlService.MarkupContent | htmlService.MarkedString): monaco.IMarkdownString {
+function toMarkdownString(
+	entry: htmlService.MarkupContent | htmlService.MarkedString
+): monaco.IMarkdownString {
 	if (typeof entry === 'string') {
 		return {
 			value: entry
@@ -290,7 +385,12 @@ function toMarkdownString(entry: htmlService.MarkupContent | htmlService.MarkedS
 	return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' };
 }
 
-function toMarkedStringArray(contents: htmlService.MarkupContent | htmlService.MarkedString | htmlService.MarkedString[]): monaco.IMarkdownString[] {
+function toMarkedStringArray(
+	contents:
+		| htmlService.MarkupContent
+		| htmlService.MarkedString
+		| htmlService.MarkedString[]
+): monaco.IMarkdownString[] {
 	if (!contents) {
 		return void 0;
 	}
@@ -301,16 +401,20 @@ function toMarkedStringArray(contents: htmlService.MarkupContent | htmlService.M
 }
 
 export class HoverAdapter implements monaco.languages.HoverProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	provideHover(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<monaco.languages.Hover> {
+	provideHover(
+		model: monaco.editor.IReadOnlyModel,
+		position: Position,
+		token: CancellationToken
+	): Promise<monaco.languages.Hover> {
 		let resource = model.uri;
 
-		return this._worker(resource).then(worker => {
+		return this._worker(resource)
+			.then((worker) => {
 				return worker.doHover(resource.toString(), fromPosition(position));
-		}).then(info => {
+			})
+			.then((info) => {
 				if (!info) {
 					return;
 				}
@@ -324,31 +428,45 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
 
 // --- document highlights ------
 
-function toHighlighKind(kind: htmlService.DocumentHighlightKind): monaco.languages.DocumentHighlightKind {
+function toHighlighKind(
+	kind: htmlService.DocumentHighlightKind
+): monaco.languages.DocumentHighlightKind {
 	const mKind = monaco.languages.DocumentHighlightKind;
 
 	switch (kind) {
-		case htmlService.DocumentHighlightKind.Read: return mKind.Read;
-		case htmlService.DocumentHighlightKind.Write: return mKind.Write;
-		case htmlService.DocumentHighlightKind.Text: return mKind.Text;
+		case htmlService.DocumentHighlightKind.Read:
+			return mKind.Read;
+		case htmlService.DocumentHighlightKind.Write:
+			return mKind.Write;
+		case htmlService.DocumentHighlightKind.Text:
+			return mKind.Text;
 	}
 	return mKind.Text;
 }
 
+export class DocumentHighlightAdapter
+	implements monaco.languages.DocumentHighlightProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-export class DocumentHighlightAdapter implements monaco.languages.DocumentHighlightProvider {
-
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	public provideDocumentHighlights(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<monaco.languages.DocumentHighlight[]> {
+	public provideDocumentHighlights(
+		model: monaco.editor.IReadOnlyModel,
+		position: Position,
+		token: CancellationToken
+	): Promise<monaco.languages.DocumentHighlight[]> {
 		const resource = model.uri;
 
-		return this._worker(resource).then(worker => worker.findDocumentHighlights(resource.toString(), fromPosition(position))).then(items => {
+		return this._worker(resource)
+			.then((worker) =>
+				worker.findDocumentHighlights(
+					resource.toString(),
+					fromPosition(position)
+				)
+			)
+			.then((items) => {
 				if (!items) {
 					return;
 				}
-			return items.map(item => ({
+				return items.map((item) => ({
 					range: toRange(item.range),
 					kind: toHighlighKind(item.kind)
 				}));
@@ -358,45 +476,69 @@ export class DocumentHighlightAdapter implements monaco.languages.DocumentHighli
 
 // --- document symbols ------
 
-function toSymbolKind(kind: htmlService.SymbolKind): monaco.languages.SymbolKind {
+function toSymbolKind(
+	kind: htmlService.SymbolKind
+): monaco.languages.SymbolKind {
 	let mKind = monaco.languages.SymbolKind;
 
 	switch (kind) {
-		case htmlService.SymbolKind.File: return mKind.Array;
-		case htmlService.SymbolKind.Module: return mKind.Module;
-		case htmlService.SymbolKind.Namespace: return mKind.Namespace;
-		case htmlService.SymbolKind.Package: return mKind.Package;
-		case htmlService.SymbolKind.Class: return mKind.Class;
-		case htmlService.SymbolKind.Method: return mKind.Method;
-		case htmlService.SymbolKind.Property: return mKind.Property;
-		case htmlService.SymbolKind.Field: return mKind.Field;
-		case htmlService.SymbolKind.Constructor: return mKind.Constructor;
-		case htmlService.SymbolKind.Enum: return mKind.Enum;
-		case htmlService.SymbolKind.Interface: return mKind.Interface;
-		case htmlService.SymbolKind.Function: return mKind.Function;
-		case htmlService.SymbolKind.Variable: return mKind.Variable;
-		case htmlService.SymbolKind.Constant: return mKind.Constant;
-		case htmlService.SymbolKind.String: return mKind.String;
-		case htmlService.SymbolKind.Number: return mKind.Number;
-		case htmlService.SymbolKind.Boolean: return mKind.Boolean;
-		case htmlService.SymbolKind.Array: return mKind.Array;
+		case htmlService.SymbolKind.File:
+			return mKind.Array;
+		case htmlService.SymbolKind.Module:
+			return mKind.Module;
+		case htmlService.SymbolKind.Namespace:
+			return mKind.Namespace;
+		case htmlService.SymbolKind.Package:
+			return mKind.Package;
+		case htmlService.SymbolKind.Class:
+			return mKind.Class;
+		case htmlService.SymbolKind.Method:
+			return mKind.Method;
+		case htmlService.SymbolKind.Property:
+			return mKind.Property;
+		case htmlService.SymbolKind.Field:
+			return mKind.Field;
+		case htmlService.SymbolKind.Constructor:
+			return mKind.Constructor;
+		case htmlService.SymbolKind.Enum:
+			return mKind.Enum;
+		case htmlService.SymbolKind.Interface:
+			return mKind.Interface;
+		case htmlService.SymbolKind.Function:
+			return mKind.Function;
+		case htmlService.SymbolKind.Variable:
+			return mKind.Variable;
+		case htmlService.SymbolKind.Constant:
+			return mKind.Constant;
+		case htmlService.SymbolKind.String:
+			return mKind.String;
+		case htmlService.SymbolKind.Number:
+			return mKind.Number;
+		case htmlService.SymbolKind.Boolean:
+			return mKind.Boolean;
+		case htmlService.SymbolKind.Array:
+			return mKind.Array;
 	}
 	return mKind.Function;
 }
 
-export class DocumentSymbolAdapter implements monaco.languages.DocumentSymbolProvider {
+export class DocumentSymbolAdapter
+	implements monaco.languages.DocumentSymbolProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	public provideDocumentSymbols(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Promise<monaco.languages.DocumentSymbol[]> {
+	public provideDocumentSymbols(
+		model: monaco.editor.IReadOnlyModel,
+		token: CancellationToken
+	): Promise<monaco.languages.DocumentSymbol[]> {
 		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) => {
 				if (!items) {
 					return;
 				}
-			return items.map(item => ({
+				return items.map((item) => ({
 					name: item.name,
 					detail: '',
 					containerName: item.containerName,
@@ -410,19 +552,22 @@ export class DocumentSymbolAdapter implements monaco.languages.DocumentSymbolPro
 }
 
 export class DocumentLinkAdapter implements monaco.languages.LinkProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	public provideLinks(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Promise<monaco.languages.ILinksList> {
+	public provideLinks(
+		model: monaco.editor.IReadOnlyModel,
+		token: CancellationToken
+	): Promise<monaco.languages.ILinksList> {
 		const resource = model.uri;
 
-		return this._worker(resource).then(worker => worker.findDocumentLinks(resource.toString())).then(items => {
+		return this._worker(resource)
+			.then((worker) => worker.findDocumentLinks(resource.toString()))
+			.then((items) => {
 				if (!items) {
 					return;
 				}
 				return {
-				links: items.map(item => ({
+					links: items.map((item) => ({
 						range: toRange(item.range),
 						url: item.target
 					}))
@@ -431,24 +576,30 @@ export class DocumentLinkAdapter implements monaco.languages.LinkProvider {
 	}
 }
 
-
-function fromFormattingOptions(options: monaco.languages.FormattingOptions): htmlService.FormattingOptions {
+function fromFormattingOptions(
+	options: monaco.languages.FormattingOptions
+): htmlService.FormattingOptions {
 	return {
 		tabSize: options.tabSize,
 		insertSpaces: options.insertSpaces
 	};
 }
 
-export class DocumentFormattingEditProvider implements monaco.languages.DocumentFormattingEditProvider {
+export class DocumentFormattingEditProvider
+	implements monaco.languages.DocumentFormattingEditProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	public provideDocumentFormattingEdits(model: monaco.editor.IReadOnlyModel, options: monaco.languages.FormattingOptions, token: CancellationToken): Promise<monaco.editor.ISingleEditOperation[]> {
+	public provideDocumentFormattingEdits(
+		model: monaco.editor.IReadOnlyModel,
+		options: monaco.languages.FormattingOptions,
+		token: CancellationToken
+	): Promise<monaco.editor.ISingleEditOperation[]> {
 		const resource = model.uri;
 
-		return this._worker(resource).then(worker => {
-			return worker.format(resource.toString(), null, fromFormattingOptions(options)).then(edits => {
+		return this._worker(resource).then((worker) => {
+			return worker
+				.format(resource.toString(), null, fromFormattingOptions(options))
+				.then((edits) => {
 					if (!edits || edits.length === 0) {
 						return;
 					}
@@ -458,16 +609,26 @@ export class DocumentFormattingEditProvider implements monaco.languages.Document
 	}
 }
 
-export class DocumentRangeFormattingEditProvider implements monaco.languages.DocumentRangeFormattingEditProvider {
+export class DocumentRangeFormattingEditProvider
+	implements monaco.languages.DocumentRangeFormattingEditProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	public provideDocumentRangeFormattingEdits(model: monaco.editor.IReadOnlyModel, range: Range, options: monaco.languages.FormattingOptions, token: CancellationToken): Promise<monaco.editor.ISingleEditOperation[]> {
+	public provideDocumentRangeFormattingEdits(
+		model: monaco.editor.IReadOnlyModel,
+		range: Range,
+		options: monaco.languages.FormattingOptions,
+		token: CancellationToken
+	): Promise<monaco.editor.ISingleEditOperation[]> {
 		const resource = model.uri;
 
-		return this._worker(resource).then(worker => {
-			return worker.format(resource.toString(), fromRange(range), fromFormattingOptions(options)).then(edits => {
+		return this._worker(resource).then((worker) => {
+			return worker
+				.format(
+					resource.toString(),
+					fromRange(range),
+					fromFormattingOptions(options)
+				)
+				.then((edits) => {
 					if (!edits || edits.length === 0) {
 						return;
 					}
@@ -478,22 +639,33 @@ export class DocumentRangeFormattingEditProvider implements monaco.languages.Doc
 }
 
 export class RenameAdapter implements monaco.languages.RenameProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	provideRenameEdits(model: monaco.editor.IReadOnlyModel, position: Position, newName: string, token: CancellationToken): Promise<monaco.languages.WorkspaceEdit> {
+	provideRenameEdits(
+		model: monaco.editor.IReadOnlyModel,
+		position: Position,
+		newName: string,
+		token: CancellationToken
+	): Promise<monaco.languages.WorkspaceEdit> {
 		const resource = model.uri;
 
-		return this._worker(resource).then(worker => {
-			return worker.doRename(resource.toString(), fromPosition(position), newName);
-		}).then(edit => {
+		return this._worker(resource)
+			.then((worker) => {
+				return worker.doRename(
+					resource.toString(),
+					fromPosition(position),
+					newName
+				);
+			})
+			.then((edit) => {
 				return toWorkspaceEdit(edit);
 			});
 	}
 }
 
-function toWorkspaceEdit(edit: htmlService.WorkspaceEdit): monaco.languages.WorkspaceEdit {
+function toWorkspaceEdit(
+	edit: htmlService.WorkspaceEdit
+): monaco.languages.WorkspaceEdit {
 	if (!edit || !edit.changes) {
 		return void 0;
 	}
@@ -512,57 +684,78 @@ function toWorkspaceEdit(edit: htmlService.WorkspaceEdit): monaco.languages.Work
 	}
 	return {
 		edits: resourceEdits
-	}
+	};
 }
 
-export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvider {
+export class FoldingRangeAdapter
+	implements monaco.languages.FoldingRangeProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	public provideFoldingRanges(model: monaco.editor.IReadOnlyModel, context: monaco.languages.FoldingContext, token: CancellationToken): Promise<monaco.languages.FoldingRange[]> {
+	public provideFoldingRanges(
+		model: monaco.editor.IReadOnlyModel,
+		context: monaco.languages.FoldingContext,
+		token: CancellationToken
+	): Promise<monaco.languages.FoldingRange[]> {
 		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) => {
 				if (!ranges) {
 					return;
 				}
-			return ranges.map(range => {
+				return ranges.map((range) => {
 					const result: monaco.languages.FoldingRange = {
 						start: range.startLine + 1,
 						end: range.endLine + 1
 					};
 					if (typeof range.kind !== 'undefined') {
-					result.kind = toFoldingRangeKind(<htmlService.FoldingRangeKind>range.kind);
+						result.kind = toFoldingRangeKind(
+							<htmlService.FoldingRangeKind>range.kind
+						);
 					}
 					return result;
 				});
 			});
 	}
-
 }
 
-function toFoldingRangeKind(kind: htmlService.FoldingRangeKind): monaco.languages.FoldingRangeKind {
+function toFoldingRangeKind(
+	kind: htmlService.FoldingRangeKind
+): monaco.languages.FoldingRangeKind {
 	switch (kind) {
-		case htmlService.FoldingRangeKind.Comment: return monaco.languages.FoldingRangeKind.Comment;
-		case htmlService.FoldingRangeKind.Imports: return monaco.languages.FoldingRangeKind.Imports;
-		case htmlService.FoldingRangeKind.Region: return monaco.languages.FoldingRangeKind.Region;
+		case htmlService.FoldingRangeKind.Comment:
+			return monaco.languages.FoldingRangeKind.Comment;
+		case htmlService.FoldingRangeKind.Imports:
+			return monaco.languages.FoldingRangeKind.Imports;
+		case htmlService.FoldingRangeKind.Region:
+			return monaco.languages.FoldingRangeKind.Region;
 	}
 }
 
-export class SelectionRangeAdapter implements monaco.languages.SelectionRangeProvider {
+export class SelectionRangeAdapter
+	implements monaco.languages.SelectionRangeProvider {
+	constructor(private _worker: WorkerAccessor) {}
 
-	constructor(private _worker: WorkerAccessor) {
-	}
-
-	public provideSelectionRanges(model: monaco.editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Promise<monaco.languages.SelectionRange[][]> {
+	public provideSelectionRanges(
+		model: monaco.editor.IReadOnlyModel,
+		positions: Position[],
+		token: CancellationToken
+	): Promise<monaco.languages.SelectionRange[][]> {
 		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) => {
 				if (!selectionRanges) {
 					return;
 				}
-			return selectionRanges.map(selectionRange => {
+				return selectionRanges.map((selectionRange) => {
 					const result: monaco.languages.SelectionRange[] = [];
 					while (selectionRange) {
 						result.push({ range: toRange(selectionRange.range) });
@@ -572,5 +765,4 @@ export class SelectionRangeAdapter implements monaco.languages.SelectionRangePro
 				});
 			});
 	}
-
 }

src/monaco.contribution.ts

@@ -11,14 +11,20 @@ import IEvent = monaco.IEvent;
 
 // --- HTML configuration and defaults ---------
 
-export class LanguageServiceDefaultsImpl implements monaco.languages.html.LanguageServiceDefaults {
-
-	private _onDidChange = new Emitter<monaco.languages.html.LanguageServiceDefaults>();
+export class LanguageServiceDefaultsImpl
+	implements monaco.languages.html.LanguageServiceDefaults {
+	private _onDidChange = new Emitter<
+		monaco.languages.html.LanguageServiceDefaults
+	>();
 	private _options: monaco.languages.html.Options;
 	private _modeConfiguration: monaco.languages.html.ModeConfiguration;
 	private _languageId: string;
 
-	constructor(languageId: string, options: monaco.languages.html.Options, modeConfiguration: monaco.languages.html.ModeConfiguration) {
+	constructor(
+		languageId: string,
+		options: monaco.languages.html.Options,
+		modeConfiguration: monaco.languages.html.ModeConfiguration
+	) {
 		this._languageId = languageId;
 		this.setOptions(options);
 		this.setModeConfiguration(modeConfiguration);
@@ -45,17 +51,20 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.html.Langua
 		this._onDidChange.fire(this);
 	}
 
-	setModeConfiguration(modeConfiguration: monaco.languages.html.ModeConfiguration): void {
+	setModeConfiguration(
+		modeConfiguration: monaco.languages.html.ModeConfiguration
+	): void {
 		this._modeConfiguration = modeConfiguration || Object.create(null);
 		this._onDidChange.fire(this);
-	};
+	}
 }
 
 const formatDefaults: Required<monaco.languages.html.HTMLFormatConfiguration> = {
 	tabSize: 4,
 	insertSpaces: false,
 	wrapLineLength: 120,
-	unformatted: 'default": "a, abbr, acronym, b, bdo, big, br, button, cite, code, dfn, em, i, img, input, kbd, label, map, object, q, samp, select, small, span, strong, sub, sup, textarea, tt, var',
+	unformatted:
+		'default": "a, abbr, acronym, b, bdo, big, br, button, cite, code, dfn, em, i, img, input, kbd, label, map, object, q, samp, select, small, span, strong, sub, sup, textarea, tt, var',
 	contentUnformatted: 'pre',
 	indentInnerHtml: false,
 	preserveNewLines: true,
@@ -69,19 +78,21 @@ const formatDefaults: Required<monaco.languages.html.HTMLFormatConfiguration> =
 const htmlOptionsDefault: Required<monaco.languages.html.Options> = {
 	format: formatDefaults,
 	suggest: { html5: true, angular1: true, ionic: true }
-}
+};
 
 const handlebarOptionsDefault: Required<monaco.languages.html.Options> = {
 	format: formatDefaults,
 	suggest: { html5: true }
-}
+};
 
 const razorOptionsDefault: Required<monaco.languages.html.Options> = {
 	format: formatDefaults,
 	suggest: { html5: true, razor: true }
-}
+};
 
-function getConfigurationDefault(languageId: string): Required<monaco.languages.html.ModeConfiguration> {
+function getConfigurationDefault(
+	languageId: string
+): Required<monaco.languages.html.ModeConfiguration> {
 	return {
 		completionItems: true,
 		hovers: true,
@@ -102,9 +113,21 @@ const htmlLanguageId = 'html';
 const handlebarsLanguageId = 'handlebars';
 const razorLanguageId = 'razor';
 
-const htmlDefaults = new LanguageServiceDefaultsImpl(htmlLanguageId, htmlOptionsDefault, getConfigurationDefault(htmlLanguageId));
-const handlebarDefaults = new LanguageServiceDefaultsImpl(handlebarsLanguageId, handlebarOptionsDefault, getConfigurationDefault(handlebarsLanguageId));
-const razorDefaults = new LanguageServiceDefaultsImpl(razorLanguageId, razorOptionsDefault, getConfigurationDefault(razorLanguageId));
+const htmlDefaults = new LanguageServiceDefaultsImpl(
+	htmlLanguageId,
+	htmlOptionsDefault,
+	getConfigurationDefault(htmlLanguageId)
+);
+const handlebarDefaults = new LanguageServiceDefaultsImpl(
+	handlebarsLanguageId,
+	handlebarOptionsDefault,
+	getConfigurationDefault(handlebarsLanguageId)
+);
+const razorDefaults = new LanguageServiceDefaultsImpl(
+	razorLanguageId,
+	razorOptionsDefault,
+	getConfigurationDefault(razorLanguageId)
+);
 
 // Export API
 function createAPI(): typeof monaco.languages.html {
@@ -112,7 +135,7 @@ function createAPI(): typeof monaco.languages.html {
 		htmlDefaults: htmlDefaults,
 		razorDefaults: razorDefaults,
 		handlebarDefaults: handlebarDefaults
-	}
+	};
 }
 monaco.languages.html = createAPI();
 
@@ -123,11 +146,11 @@ function getMode(): Promise<typeof mode> {
 }
 
 monaco.languages.onLanguage(htmlLanguageId, () => {
-	getMode().then(mode => mode.setupMode(htmlDefaults));
+	getMode().then((mode) => mode.setupMode(htmlDefaults));
 });
 monaco.languages.onLanguage(handlebarsLanguageId, () => {
-	getMode().then(mode => mode.setupMode(handlebarDefaults));
+	getMode().then((mode) => mode.setupMode(handlebarDefaults));
 });
 monaco.languages.onLanguage(razorLanguageId, () => {
-	getMode().then(mode => mode.setupMode(razorDefaults));
+	getMode().then((mode) => mode.setupMode(razorDefaults));
 });

src/monaco.d.ts

@@ -16,7 +16,11 @@ declare module monaco.languages.html {
 		readonly indentHandlebars: boolean;
 		readonly endWithNewline: boolean;
 		readonly extraLiners: string;
-		readonly wrapAttributes: 'auto' | 'force' | 'force-aligned' | 'force-expand-multiline';
+		readonly wrapAttributes:
+			| 'auto'
+			| 'force'
+			| 'force-aligned'
+			| 'force-expand-multiline';
 	}
 
 	export interface CompletionConfiguration {
@@ -94,7 +98,6 @@ declare module monaco.languages.html {
 		 * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
 		 */
 		readonly documentRangeFormattingEdits?: boolean;
-
 	}
 
 	export interface LanguageServiceDefaults {

src/workerManager.ts

@@ -13,7 +13,6 @@ import Uri = monaco.Uri;
 const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min
 
 export class WorkerManager {
-
 	private _defaults: LanguageServiceDefaultsImpl;
 	private _idleCheckInterval: number;
 	private _lastUsedTime: number;
@@ -27,7 +26,9 @@ export class WorkerManager {
 		this._worker = null;
 		this._idleCheckInterval = setInterval(() => this._checkIfIdle(), 30 * 1000);
 		this._lastUsedTime = 0;
-		this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
+		this._configChangeListener = this._defaults.onDidChange(() =>
+			this._stopWorker()
+		);
 	}
 
 	private _stopWorker(): void {
@@ -59,7 +60,6 @@ export class WorkerManager {
 
 		if (!this._client) {
 			this._worker = monaco.editor.createWebWorker<HTMLWorker>({
-
 				// module that exports the create() method and returns a `HTMLWorker` instance
 				moduleId: 'vs/language/html/htmlWorker',
 
@@ -80,10 +80,13 @@ export class WorkerManager {
 
 	getLanguageServiceWorker(...resources: Uri[]): Promise<HTMLWorker> {
 		let _client: HTMLWorker;
-		return this._getClient().then((client) => {
-			_client = client
-		}).then(_ => {
-			return this._worker.withSyncedResources(resources)
-		}).then(_ => _client);
+		return this._getClient()
+			.then((client) => {
+				_client = client;
+			})
+			.then((_) => {
+				return this._worker.withSyncedResources(resources);
+			})
+			.then((_) => _client);
 	}
 }

test/index.html

@@ -1,21 +1,27 @@
 <!DOCTYPE html>
 <html>
-<head>
+	<head>
 		<meta http-equiv="X-UA-Compatible" content="IE=edge" />
 		<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
-	<link rel="stylesheet" data-name="vs/editor/editor.main" href="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.css">
-</head>
-<body>
+		<link
+			rel="stylesheet"
+			data-name="vs/editor/editor.main"
+			href="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.css"
+		/>
+	</head>
+	<body>
+		<h2>Monaco Editor HTML test page</h2>
+		<div
+			id="container"
+			style="width: 800px; height: 600px; border: 1px solid grey"
+		></div>
 
-<h2>Monaco Editor HTML test page</h2>
-<div id="container" style="width:800px;height:600px;border:1px solid grey"></div>
-
-<script>
+		<script>
 			// Loading basic-languages to get the html language definition
 			var paths = {
 				'vs/basic-languages': '../node_modules/monaco-languages/release/dev',
 				'vs/language/html': '../release/dev',
-		'vs': '../node_modules/monaco-editor-core/dev/vs'
+				vs: '../node_modules/monaco-editor-core/dev/vs'
 			};
 			if (document.location.protocol === 'http:') {
 				// Add support for running local http server
@@ -28,17 +34,19 @@
 			var require = {
 				paths: paths
 			};
-</script>
-<script src="../node_modules/monaco-editor-core/dev/vs/loader.js"></script>
-<script src="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.nls.js"></script>
-<script src="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.js"></script>
+		</script>
+		<script src="../node_modules/monaco-editor-core/dev/vs/loader.js"></script>
+		<script src="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.nls.js"></script>
+		<script src="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.js"></script>
 
-<script>
+		<script>
 			require([
 				'vs/basic-languages/monaco.contribution',
 				'vs/language/html/monaco.contribution'
-	], function() {
-		var editor = monaco.editor.create(document.getElementById('container'), {
+			], function () {
+				var editor = monaco.editor.create(
+					document.getElementById('container'),
+					{
 						value: [
 							'<!DOCTYPE HTML>',
 							'<!--',
@@ -56,7 +64,7 @@
 							'	<script type="text/javascript">',
 							'		window.alert("I am a sample...");',
 							'		var x = 3;',
-				'	</'+'script>',
+							'	</' + 'script>',
 							'</head>',
 							'<body>',
 							'	<h1>Heading No.1</h1>',
@@ -65,9 +73,9 @@
 							'</html>'
 						].join('\n'),
 						language: 'html'
+					}
+				);
 			});
-	});
-</script>
-
-</body>
+		</script>
+	</body>
 </html>