update cmd line

2025-06-22 08:53:31 +02:00 · 2023-03-03 07:09:50 +07:00 · 2023-03-03 07:09:50 +07:00 · 8c55f6b749
commit 8c55f6b749
parent 67a507d530
214 changed files with 48553 additions and 48489 deletions
--- a/snippets/laravel-blade/server/src/modes/cssMode.ts
+++ b/snippets/laravel-blade/server/src/modes/cssMode.ts
@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { LanguageModelCache, getLanguageModelCache } from '../languageModelCache';
+import { TextDocument, Position, Range } from 'vscode-languageserver-types';
+import { getCSSLanguageService, Stylesheet, ICompletionParticipant } from 'vscode-css-languageservice';
+import { LanguageMode, Settings } from './languageModes';
+import { HTMLDocumentRegions, CSS_STYLE_RULE } from './embeddedSupport';
+import { Color } from 'vscode-languageserver-protocol/lib/protocol.colorProvider.proposed';
+
+export function getCSSMode(documentRegions: LanguageModelCache<HTMLDocumentRegions>): LanguageMode {
+	let cssLanguageService = getCSSLanguageService();
+	let embeddedCSSDocuments = getLanguageModelCache<TextDocument>(10, 60, document => documentRegions.get(document).getEmbeddedDocument('css'));
+	let cssStylesheets = getLanguageModelCache<Stylesheet>(10, 60, document => cssLanguageService.parseStylesheet(document));
+
+	return {
+		getId() {
+			return 'css';
+		},
+		configure(options: any) {
+			cssLanguageService.configure(options && options.css);
+		},
+		doValidation(document: TextDocument, settings?: Settings) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.doValidation(embedded, cssStylesheets.get(embedded), settings && settings.css);
+		},
+		doComplete(document: TextDocument, position: Position) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.doComplete(embedded, position, cssStylesheets.get(embedded));
+		},
+		setCompletionParticipants(registeredCompletionParticipants: ICompletionParticipant[]) {
+			cssLanguageService.setCompletionParticipants(registeredCompletionParticipants);
+		},
+		doHover(document: TextDocument, position: Position) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.doHover(embedded, position, cssStylesheets.get(embedded));
+		},
+		findDocumentHighlight(document: TextDocument, position: Position) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.findDocumentHighlights(embedded, position, cssStylesheets.get(embedded));
+		},
+		findDocumentSymbols(document: TextDocument) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.findDocumentSymbols(embedded, cssStylesheets.get(embedded)).filter(s => s.name !== CSS_STYLE_RULE);
+		},
+		findDefinition(document: TextDocument, position: Position) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.findDefinition(embedded, position, cssStylesheets.get(embedded));
+		},
+		findReferences(document: TextDocument, position: Position) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.findReferences(embedded, position, cssStylesheets.get(embedded));
+		},
+		findDocumentColors(document: TextDocument) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.findDocumentColors(embedded, cssStylesheets.get(embedded));
+		},
+		getColorPresentations(document: TextDocument, color: Color, range: Range) {
+			let embedded = embeddedCSSDocuments.get(document);
+			return cssLanguageService.getColorPresentations(embedded, cssStylesheets.get(embedded), color, range);
+		},
+		onDocumentRemoved(document: TextDocument) {
+			embeddedCSSDocuments.onDocumentRemoved(document);
+			cssStylesheets.onDocumentRemoved(document);
+		},
+		dispose() {
+			embeddedCSSDocuments.dispose();
+			cssStylesheets.dispose();
+		}
+	};
+}
--- a/snippets/laravel-blade/server/src/modes/embeddedSupport.ts
+++ b/snippets/laravel-blade/server/src/modes/embeddedSupport.ts
@ -0,0 +1,233 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { TextDocument, Position, LanguageService, TokenType, Range } from 'vscode-html-languageservice';
+
+export interface LanguageRange extends Range {
+	languageId: string | undefined;
+	attributeValue?: boolean;
+}
+
+export interface HTMLDocumentRegions {
+	getEmbeddedDocument(languageId: string, ignoreAttributeValues?: boolean): TextDocument;
+	getLanguageRanges(range: Range): LanguageRange[];
+	getLanguageAtPosition(position: Position): string | undefined;
+	getLanguagesInDocument(): string[];
+	getImportedScripts(): string[];
+}
+
+export var CSS_STYLE_RULE = '__';
+
+interface EmbeddedRegion { languageId: string | undefined; start: number; end: number; attributeValue?: boolean; }
+
+
+export function getDocumentRegions(languageService: LanguageService, document: TextDocument): HTMLDocumentRegions {
+	let regions: EmbeddedRegion[] = [];
+	let scanner = languageService.createScanner(document.getText());
+	let lastTagName: string = '';
+	let lastAttributeName: string | null = null;
+	let languageIdFromType: string | undefined = undefined;
+	let importedScripts: string[] = [];
+
+	let token = scanner.scan();
+	while (token !== TokenType.EOS) {
+		switch (token) {
+			case TokenType.StartTag:
+				lastTagName = scanner.getTokenText();
+				lastAttributeName = null;
+				languageIdFromType = 'javascript';
+				break;
+			case TokenType.Styles:
+				regions.push({ languageId: 'css', start: scanner.getTokenOffset(), end: scanner.getTokenEnd() });
+				break;
+			case TokenType.Script:
+				regions.push({ languageId: languageIdFromType, start: scanner.getTokenOffset(), end: scanner.getTokenEnd() });
+				break;
+			case TokenType.AttributeName:
+				lastAttributeName = scanner.getTokenText();
+				break;
+			case TokenType.AttributeValue:
+				if (lastAttributeName === 'src' && lastTagName.toLowerCase() === 'script') {
+					let value = scanner.getTokenText();
+					if (value[0] === '\'' || value[0] === '"') {
+						value = value.substr(1, value.length - 1);
+					}
+					importedScripts.push(value);
+				} else if (lastAttributeName === 'type' && lastTagName.toLowerCase() === 'script') {
+					if (/["'](module|(text|application)\/(java|ecma)script)["']/.test(scanner.getTokenText())) {
+						languageIdFromType = 'javascript';
+					} else {
+						languageIdFromType = void 0;
+					}
+				} else {
+					let attributeLanguageId = getAttributeLanguage(lastAttributeName!);
+					if (attributeLanguageId) {
+						let start = scanner.getTokenOffset();
+						let end = scanner.getTokenEnd();
+						let firstChar = document.getText()[start];
+						if (firstChar === '\'' || firstChar === '"') {
+							start++;
+							end--;
+						}
+						regions.push({ languageId: attributeLanguageId, start, end, attributeValue: true });
+					}
+				}
+				lastAttributeName = null;
+				break;
+		}
+		token = scanner.scan();
+	}
+	return {
+		getLanguageRanges: (range: Range) => getLanguageRanges(document, regions, range),
+		getEmbeddedDocument: (languageId: string, ignoreAttributeValues: boolean) => getEmbeddedDocument(document, regions, languageId, ignoreAttributeValues),
+		getLanguageAtPosition: (position: Position) => getLanguageAtPosition(document, regions, position),
+		getLanguagesInDocument: () => getLanguagesInDocument(document, regions),
+		getImportedScripts: () => importedScripts
+	};
+}
+
+
+function getLanguageRanges(document: TextDocument, regions: EmbeddedRegion[], range: Range): LanguageRange[] {
+	let result: LanguageRange[] = [];
+	let currentPos = range ? range.start : Position.create(0, 0);
+	let currentOffset = range ? document.offsetAt(range.start) : 0;
+	let endOffset = range ? document.offsetAt(range.end) : document.getText().length;
+	for (let region of regions) {
+		if (region.end > currentOffset && region.start < endOffset) {
+			let start = Math.max(region.start, currentOffset);
+			let startPos = document.positionAt(start);
+			if (currentOffset < region.start) {
+				result.push({
+					start: currentPos,
+					end: startPos,
+					languageId: 'html'
+				});
+			}
+			let end = Math.min(region.end, endOffset);
+			let endPos = document.positionAt(end);
+			if (end > region.start) {
+				result.push({
+					start: startPos,
+					end: endPos,
+					languageId: region.languageId,
+					attributeValue: region.attributeValue
+				});
+			}
+			currentOffset = end;
+			currentPos = endPos;
+		}
+	}
+	if (currentOffset < endOffset) {
+		let endPos = range ? range.end : document.positionAt(endOffset);
+		result.push({
+			start: currentPos,
+			end: endPos,
+			languageId: 'html'
+		});
+	}
+	return result;
+}
+
+function getLanguagesInDocument(document: TextDocument, regions: EmbeddedRegion[]): string[] {
+	let result = [];
+	for (let region of regions) {
+		if (region.languageId && result.indexOf(region.languageId) === -1) {
+			result.push(region.languageId);
+			if (result.length === 3) {
+				return result;
+			}
+		}
+	}
+	result.push('html');
+	return result;
+}
+
+function getLanguageAtPosition(document: TextDocument, regions: EmbeddedRegion[], position: Position): string | undefined {
+	let offset = document.offsetAt(position);
+	for (let region of regions) {
+		if (region.start <= offset) {
+			if (offset <= region.end) {
+				return region.languageId;
+			}
+		} else {
+			break;
+		}
+	}
+	return 'html';
+}
+
+function getEmbeddedDocument(document: TextDocument, contents: EmbeddedRegion[], languageId: string, ignoreAttributeValues: boolean): TextDocument {
+	let currentPos = 0;
+	let oldContent = document.getText();
+	let result = '';
+	let lastSuffix = '';
+	for (let c of contents) {
+		if (c.languageId === languageId && (!ignoreAttributeValues || !c.attributeValue)) {
+			result = substituteWithWhitespace(result, currentPos, c.start, oldContent, lastSuffix, getPrefix(c));
+			result += oldContent.substring(c.start, c.end);
+			currentPos = c.end;
+			lastSuffix = getSuffix(c);
+		}
+	}
+	result = substituteWithWhitespace(result, currentPos, oldContent.length, oldContent, lastSuffix, '');
+	return TextDocument.create(document.uri, languageId, document.version, result);
+}
+
+function getPrefix(c: EmbeddedRegion) {
+	if (c.attributeValue) {
+		switch (c.languageId) {
+			case 'css': return CSS_STYLE_RULE + '{';
+		}
+	}
+	return '';
+}
+function getSuffix(c: EmbeddedRegion) {
+	if (c.attributeValue) {
+		switch (c.languageId) {
+			case 'css': return '}';
+			case 'javascript': return ';';
+		}
+	}
+	return '';
+}
+
+function substituteWithWhitespace(result: string, start: number, end: number, oldContent: string, before: string, after: string) {
+	let accumulatedWS = 0;
+	result += before;
+	for (let i = start + before.length; i < end; i++) {
+		let ch = oldContent[i];
+		if (ch === '\n' || ch === '\r') {
+			// only write new lines, skip the whitespace
+			accumulatedWS = 0;
+			result += ch;
+		} else {
+			accumulatedWS++;
+		}
+	}
+	result = append(result, ' ', accumulatedWS - after.length);
+	result += after;
+	return result;
+}
+
+function append(result: string, str: string, n: number): string {
+	while (n > 0) {
+		if (n & 1) {
+			result += str;
+		}
+		n >>= 1;
+		str += str;
+	}
+	return result;
+}
+
+function getAttributeLanguage(attributeName: string): string | null {
+	let match = attributeName.match(/^(style)$|^(on\w+)$/i);
+	if (!match) {
+		return null;
+	}
+	return match[1] ? 'css' : 'javascript';
+}
--- a/snippets/laravel-blade/server/src/modes/formatting.ts
+++ b/snippets/laravel-blade/server/src/modes/formatting.ts
@ -0,0 +1,95 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { applyEdits } from '../utils/edits';
+import { TextDocument, Range, TextEdit, FormattingOptions, Position } from 'vscode-languageserver-types';
+import { LanguageModes, Settings, LanguageModeRange } from './languageModes';
+import { pushAll } from '../utils/arrays';
+import { isEOL } from '../utils/strings';
+
+export function format(languageModes: LanguageModes, document: TextDocument, formatRange: Range, formattingOptions: FormattingOptions, settings: Settings | undefined, enabledModes: { [mode: string]: boolean }) {
+	let result: TextEdit[] = [];
+
+	let endPos = formatRange.end;
+	let endOffset = document.offsetAt(endPos);
+	let content = document.getText();
+	if (endPos.character === 0 && endPos.line > 0 && endOffset !== content.length) {
+		// if selection ends after a new line, exclude that new line
+		let prevLineStart = document.offsetAt(Position.create(endPos.line - 1, 0));
+		while (isEOL(content, endOffset - 1) && endOffset > prevLineStart) {
+			endOffset--;
+		}
+		formatRange = Range.create(formatRange.start, document.positionAt(endOffset));
+	}
+
+
+	// run the html formatter on the full range and pass the result content to the embedded formatters.
+	// from the final content create a single edit
+	// advantages of this approach are
+	//  - correct indents in the html document
+	//  - correct initial indent for embedded formatters
+	//  - no worrying of overlapping edits
+
+	// make sure we start in html
+	let allRanges = languageModes.getModesInRange(document, formatRange);
+	let i = 0;
+	let startPos = formatRange.start;
+	let isHTML = (range: LanguageModeRange) => range.mode && range.mode.getId() === 'html';
+
+	while (i < allRanges.length && !isHTML(allRanges[i])) {
+		let range = allRanges[i];
+		if (!range.attributeValue && range.mode && range.mode.format) {
+			let edits = range.mode.format(document, Range.create(startPos, range.end), formattingOptions, settings);
+			pushAll(result, edits);
+		}
+		startPos = range.end;
+		i++;
+	}
+	if (i === allRanges.length) {
+		return result;
+	}
+	// modify the range
+	formatRange = Range.create(startPos, formatRange.end);
+
+	// perform a html format and apply changes to a new document
+	let htmlMode = languageModes.getMode('html')!;
+	let htmlEdits = htmlMode.format!(document, formatRange, formattingOptions, settings);
+	let htmlFormattedContent = applyEdits(document, htmlEdits);
+	let newDocument = TextDocument.create(document.uri + '.tmp', document.languageId, document.version, htmlFormattedContent);
+	try {
+		// run embedded formatters on html formatted content: - formatters see correct initial indent
+		let afterFormatRangeLength = document.getText().length - document.offsetAt(formatRange.end); // length of unchanged content after replace range
+		let newFormatRange = Range.create(formatRange.start, newDocument.positionAt(htmlFormattedContent.length - afterFormatRangeLength));
+		let embeddedRanges = languageModes.getModesInRange(newDocument, newFormatRange);
+
+		let embeddedEdits: TextEdit[] = [];
+
+		for (let r of embeddedRanges) {
+			let mode = r.mode;
+			if (mode && mode.format && enabledModes[mode.getId()] && !r.attributeValue) {
+				let edits = mode.format(newDocument, r, formattingOptions, settings);
+				for (let edit of edits) {
+					embeddedEdits.push(edit);
+				}
+			}
+		}
+
+		if (embeddedEdits.length === 0) {
+			pushAll(result, htmlEdits);
+			return result;
+		}
+
+		// apply all embedded format edits and create a single edit for all changes
+		let resultContent = applyEdits(newDocument, embeddedEdits);
+		let resultReplaceText = resultContent.substring(document.offsetAt(formatRange.start), resultContent.length - afterFormatRangeLength);
+
+		result.push(TextEdit.replace(formatRange, resultReplaceText));
+		return result;
+	} finally {
+		languageModes.onDocumentRemoved(newDocument);
+	}
+
+}
--- a/snippets/laravel-blade/server/src/modes/htmlMode.ts
+++ b/snippets/laravel-blade/server/src/modes/htmlMode.ts
@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { getLanguageModelCache } from '../languageModelCache';
+import { LanguageService as HTMLLanguageService, HTMLDocument, DocumentContext, FormattingOptions, HTMLFormatConfiguration, TokenType } from 'vscode-html-languageservice';
+import { TextDocument, Position, Range } from 'vscode-languageserver-types';
+import { LanguageMode, Settings } from './languageModes';
+
+export function getHTMLMode(htmlLanguageService: HTMLLanguageService): LanguageMode {
+	let globalSettings: Settings = {};
+	let htmlDocuments = getLanguageModelCache<HTMLDocument>(10, 60, document => htmlLanguageService.parseHTMLDocument(document));
+	let completionParticipants = [];
+	return {
+		getId() {
+			return 'html';
+		},
+		configure(options: any) {
+			globalSettings = options;
+		},
+		doComplete(document: TextDocument, position: Position, settings: Settings = globalSettings) {
+			let options = settings && settings.html && settings.html.suggest;
+			let doAutoComplete = settings && settings.html && settings.html.autoClosingTags;
+			if (doAutoComplete) {
+				options.hideAutoCompleteProposals = true;
+			}
+
+			const htmlDocument = htmlDocuments.get(document);
+			const offset = document.offsetAt(position);
+			const node = htmlDocument.findNodeBefore(offset);
+			const scanner = htmlLanguageService.createScanner(document.getText(), node.start);
+			let token = scanner.scan();
+			while (token !== TokenType.EOS && scanner.getTokenOffset() <= offset) {
+				if (token === TokenType.Content && offset <= scanner.getTokenEnd()) {
+					completionParticipants.forEach(participant => { if (participant.onHtmlContent) { participant.onHtmlContent(); } });
+					break;
+				}
+				token = scanner.scan();
+			}
+			return htmlLanguageService.doComplete(document, position, htmlDocument, options);
+		},
+		setCompletionParticipants(registeredCompletionParticipants: any[]) {
+			completionParticipants = registeredCompletionParticipants;
+		},
+		doHover(document: TextDocument, position: Position) {
+			return htmlLanguageService.doHover(document, position, htmlDocuments.get(document));
+		},
+		findDocumentHighlight(document: TextDocument, position: Position) {
+			return htmlLanguageService.findDocumentHighlights(document, position, htmlDocuments.get(document));
+		},
+		findDocumentLinks(document: TextDocument, documentContext: DocumentContext) {
+			return htmlLanguageService.findDocumentLinks(document, documentContext);
+		},
+		findDocumentSymbols(document: TextDocument) {
+			return htmlLanguageService.findDocumentSymbols(document, htmlDocuments.get(document));
+		},
+		format(document: TextDocument, range: Range, formatParams: FormattingOptions, settings: Settings = globalSettings) {
+			let formatSettings: HTMLFormatConfiguration = settings && settings.html && settings.html.format;
+			if (formatSettings) {
+				formatSettings = merge(formatSettings, {});
+			} else {
+				formatSettings = {};
+			}
+			if (formatSettings.contentUnformatted) {
+				formatSettings.contentUnformatted = formatSettings.contentUnformatted + ',script';
+			} else {
+				formatSettings.contentUnformatted = 'script';
+			}
+			formatSettings = merge(formatParams, formatSettings);
+			return htmlLanguageService.format(document, range, formatSettings);
+		},
+		doAutoClose(document: TextDocument, position: Position) {
+			let offset = document.offsetAt(position);
+			let text = document.getText();
+			if (offset > 0 && text.charAt(offset - 1).match(/[>\/]/g)) {
+				return htmlLanguageService.doTagComplete(document, position, htmlDocuments.get(document));
+			}
+			return null;
+		},
+		onDocumentRemoved(document: TextDocument) {
+			htmlDocuments.onDocumentRemoved(document);
+		},
+		dispose() {
+			htmlDocuments.dispose();
+		}
+	};
+}
+
+function merge(src: any, dst: any): any {
+	for (var key in src) {
+		if (src.hasOwnProperty(key)) {
+			dst[key] = src[key];
+		}
+	}
+	return dst;
+}
--- a/snippets/laravel-blade/server/src/modes/javascriptMode.ts
+++ b/snippets/laravel-blade/server/src/modes/javascriptMode.ts
@ -0,0 +1,411 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { LanguageModelCache, getLanguageModelCache } from '../languageModelCache';
+import { SymbolInformation, SymbolKind, CompletionItem, Location, SignatureHelp, SignatureInformation, ParameterInformation, Definition, TextEdit, TextDocument, Diagnostic, DiagnosticSeverity, Range, CompletionItemKind, Hover, MarkedString, DocumentHighlight, DocumentHighlightKind, CompletionList, Position, FormattingOptions } from 'vscode-languageserver-types';
+import { LanguageMode, Settings } from './languageModes';
+import { getWordAtText, startsWith, isWhitespaceOnly, repeat } from '../utils/strings';
+import { HTMLDocumentRegions } from './embeddedSupport';
+
+import * as ts from 'typescript';
+import { join } from 'path';
+
+const FILE_NAME = 'vscode://javascript/1';  // the same 'file' is used for all contents
+const JQUERY_D_TS = join(__dirname, '../../lib/jquery.d.ts');
+
+const JS_WORD_REGEX = /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g;
+
+export function getJavascriptMode(documentRegions: LanguageModelCache<HTMLDocumentRegions>): LanguageMode {
+	let jsDocuments = getLanguageModelCache<TextDocument>(10, 60, document => documentRegions.get(document).getEmbeddedDocument('javascript'));
+
+	let compilerOptions: ts.CompilerOptions = { allowNonTsExtensions: true, allowJs: true, lib: ['lib.es6.d.ts'], target: ts.ScriptTarget.Latest, moduleResolution: ts.ModuleResolutionKind.Classic };
+	let currentTextDocument: TextDocument;
+	let scriptFileVersion: number = 0;
+	function updateCurrentTextDocument(doc: TextDocument) {
+		if (!currentTextDocument || doc.uri !== currentTextDocument.uri || doc.version !== currentTextDocument.version) {
+			currentTextDocument = jsDocuments.get(doc);
+			scriptFileVersion++;
+		}
+	}
+	const host: ts.LanguageServiceHost = {
+		getCompilationSettings: () => compilerOptions,
+		getScriptFileNames: () => [FILE_NAME, JQUERY_D_TS],
+		getScriptKind: () => ts.ScriptKind.JS,
+		getScriptVersion: (fileName: string) => {
+			if (fileName === FILE_NAME) {
+				return String(scriptFileVersion);
+			}
+			return '1'; // default lib an jquery.d.ts are static
+		},
+		getScriptSnapshot: (fileName: string) => {
+			let text = '';
+			if (startsWith(fileName, 'vscode:')) {
+				if (fileName === FILE_NAME) {
+					text = currentTextDocument.getText();
+				}
+			} else {
+				text = ts.sys.readFile(fileName) || '';
+			}
+			return {
+				getText: (start, end) => text.substring(start, end),
+				getLength: () => text.length,
+				getChangeRange: () => void 0
+			};
+		},
+		getCurrentDirectory: () => '',
+		getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options)
+	};
+	let jsLanguageService = ts.createLanguageService(host);
+
+	let globalSettings: Settings = {};
+
+	return {
+		getId() {
+			return 'javascript';
+		},
+		configure(options: any) {
+			globalSettings = options;
+		},
+		doValidation(document: TextDocument): Diagnostic[] {
+			updateCurrentTextDocument(document);
+			const syntaxDiagnostics = jsLanguageService.getSyntacticDiagnostics(FILE_NAME);
+			const semanticDiagnostics = jsLanguageService.getSemanticDiagnostics(FILE_NAME);
+			return syntaxDiagnostics.concat(semanticDiagnostics).map((diag: ts.Diagnostic): Diagnostic => {
+				return {
+					range: convertRange(currentTextDocument, diag),
+					severity: DiagnosticSeverity.Error,
+					source: 'js',
+					message: ts.flattenDiagnosticMessageText(diag.messageText, '\n')
+				};
+			});
+		},
+		doComplete(document: TextDocument, position: Position): CompletionList {
+			updateCurrentTextDocument(document);
+			let offset = currentTextDocument.offsetAt(position);
+			let completions = jsLanguageService.getCompletionsAtPosition(FILE_NAME, offset, { includeExternalModuleExports: false, includeInsertTextCompletions: false });
+			if (!completions) {
+				return { isIncomplete: false, items: [] };
+			}
+			let replaceRange = convertRange(currentTextDocument, getWordAtText(currentTextDocument.getText(), offset, JS_WORD_REGEX));
+			return {
+				isIncomplete: false,
+				items: completions.entries.map(entry => {
+					return {
+						uri: document.uri,
+						position: position,
+						label: entry.name,
+						sortText: entry.sortText,
+						kind: convertKind(entry.kind),
+						textEdit: TextEdit.replace(replaceRange, entry.name),
+						data: { // data used for resolving item details (see 'doResolve')
+							languageId: 'javascript',
+							uri: document.uri,
+							offset: offset
+						}
+					};
+				})
+			};
+		},
+		doResolve(document: TextDocument, item: CompletionItem): CompletionItem {
+			updateCurrentTextDocument(document);
+			let details = jsLanguageService.getCompletionEntryDetails(FILE_NAME, item.data.offset, item.label, undefined, undefined);
+			if (details) {
+				item.detail = ts.displayPartsToString(details.displayParts);
+				item.documentation = ts.displayPartsToString(details.documentation);
+				delete item.data;
+			}
+			return item;
+		},
+		doHover(document: TextDocument, position: Position): Hover | null {
+			updateCurrentTextDocument(document);
+			let info = jsLanguageService.getQuickInfoAtPosition(FILE_NAME, currentTextDocument.offsetAt(position));
+			if (info) {
+				let contents = ts.displayPartsToString(info.displayParts);
+				return {
+					range: convertRange(currentTextDocument, info.textSpan),
+					contents: MarkedString.fromPlainText(contents)
+				};
+			}
+			return null;
+		},
+		doSignatureHelp(document: TextDocument, position: Position): SignatureHelp | null {
+			updateCurrentTextDocument(document);
+			let signHelp = jsLanguageService.getSignatureHelpItems(FILE_NAME, currentTextDocument.offsetAt(position));
+			if (signHelp) {
+				let ret: SignatureHelp = {
+					activeSignature: signHelp.selectedItemIndex,
+					activeParameter: signHelp.argumentIndex,
+					signatures: []
+				};
+				signHelp.items.forEach(item => {
+
+					let signature: SignatureInformation = {
+						label: '',
+						documentation: undefined,
+						parameters: []
+					};
+
+					signature.label += ts.displayPartsToString(item.prefixDisplayParts);
+					item.parameters.forEach((p, i, a) => {
+						let label = ts.displayPartsToString(p.displayParts);
+						let parameter: ParameterInformation = {
+							label: label,
+							documentation: ts.displayPartsToString(p.documentation)
+						};
+						signature.label += label;
+						signature.parameters!.push(parameter);
+						if (i < a.length - 1) {
+							signature.label += ts.displayPartsToString(item.separatorDisplayParts);
+						}
+					});
+					signature.label += ts.displayPartsToString(item.suffixDisplayParts);
+					ret.signatures.push(signature);
+				});
+				return ret;
+			}
+			return null;
+		},
+		findDocumentHighlight(document: TextDocument, position: Position): DocumentHighlight[] {
+			updateCurrentTextDocument(document);
+			let occurrences = jsLanguageService.getOccurrencesAtPosition(FILE_NAME, currentTextDocument.offsetAt(position));
+			if (occurrences) {
+				return occurrences.map(entry => {
+					return {
+						range: convertRange(currentTextDocument, entry.textSpan),
+						kind: <DocumentHighlightKind>(entry.isWriteAccess ? DocumentHighlightKind.Write : DocumentHighlightKind.Text)
+					};
+				});
+			}
+			return [];
+		},
+		findDocumentSymbols(document: TextDocument): SymbolInformation[] {
+			updateCurrentTextDocument(document);
+			let items = jsLanguageService.getNavigationBarItems(FILE_NAME);
+			if (items) {
+				let result: SymbolInformation[] = [];
+				let existing = Object.create(null);
+				let collectSymbols = (item: ts.NavigationBarItem, containerLabel?: string) => {
+					let sig = item.text + item.kind + item.spans[0].start;
+					if (item.kind !== 'script' && !existing[sig]) {
+						let symbol: SymbolInformation = {
+							name: item.text,
+							kind: convertSymbolKind(item.kind),
+							location: {
+								uri: document.uri,
+								range: convertRange(currentTextDocument, item.spans[0])
+							},
+							containerName: containerLabel
+						};
+						existing[sig] = true;
+						result.push(symbol);
+						containerLabel = item.text;
+					}
+
+					if (item.childItems && item.childItems.length > 0) {
+						for (let child of item.childItems) {
+							collectSymbols(child, containerLabel);
+						}
+					}
+
+				};
+
+				items.forEach(item => collectSymbols(item));
+				return result;
+			}
+			return [];
+		},
+		findDefinition(document: TextDocument, position: Position): Definition | null {
+			updateCurrentTextDocument(document);
+			let definition = jsLanguageService.getDefinitionAtPosition(FILE_NAME, currentTextDocument.offsetAt(position));
+			if (definition) {
+				return definition.filter(d => d.fileName === FILE_NAME).map(d => {
+					return {
+						uri: document.uri,
+						range: convertRange(currentTextDocument, d.textSpan)
+					};
+				});
+			}
+			return null;
+		},
+		findReferences(document: TextDocument, position: Position): Location[] {
+			updateCurrentTextDocument(document);
+			let references = jsLanguageService.getReferencesAtPosition(FILE_NAME, currentTextDocument.offsetAt(position));
+			if (references) {
+				return references.filter(d => d.fileName === FILE_NAME).map(d => {
+					return {
+						uri: document.uri,
+						range: convertRange(currentTextDocument, d.textSpan)
+					};
+				});
+			}
+			return [];
+		},
+		format(document: TextDocument, range: Range, formatParams: FormattingOptions, settings: Settings = globalSettings): TextEdit[] {
+			currentTextDocument = documentRegions.get(document).getEmbeddedDocument('javascript', true);
+			scriptFileVersion++;
+
+			let formatterSettings = settings && settings.javascript && settings.javascript.format;
+
+			let initialIndentLevel = computeInitialIndent(document, range, formatParams);
+			let formatSettings = convertOptions(formatParams, formatterSettings, initialIndentLevel + 1);
+			let start = currentTextDocument.offsetAt(range.start);
+			let end = currentTextDocument.offsetAt(range.end);
+			let lastLineRange = null;
+			if (range.end.line > range.start.line && (range.end.character === 0 || isWhitespaceOnly(currentTextDocument.getText().substr(end - range.end.character, range.end.character)))) {
+				end -= range.end.character;
+				lastLineRange = Range.create(Position.create(range.end.line, 0), range.end);
+			}
+			let edits = jsLanguageService.getFormattingEditsForRange(FILE_NAME, start, end, formatSettings);
+			if (edits) {
+				let result = [];
+				for (let edit of edits) {
+					if (edit.span.start >= start && edit.span.start + edit.span.length <= end) {
+						result.push({
+							range: convertRange(currentTextDocument, edit.span),
+							newText: edit.newText
+						});
+					}
+				}
+				if (lastLineRange) {
+					result.push({
+						range: lastLineRange,
+						newText: generateIndent(initialIndentLevel, formatParams)
+					});
+				}
+				return result;
+			}
+			return [];
+		},
+		onDocumentRemoved(document: TextDocument) {
+			jsDocuments.onDocumentRemoved(document);
+		},
+		dispose() {
+			jsLanguageService.dispose();
+			jsDocuments.dispose();
+		}
+	};
+}
+
+function convertRange(document: TextDocument, span: { start: number | undefined, length: number | undefined }): Range {
+	if (typeof span.start === 'undefined') {
+		const pos = document.positionAt(0);
+		return Range.create(pos, pos);
+	}
+	const startPosition = document.positionAt(span.start);
+	const endPosition = document.positionAt(span.start + (span.length || 0));
+	return Range.create(startPosition, endPosition);
+}
+
+function convertKind(kind: string): CompletionItemKind {
+	switch (kind) {
+		case 'primitive type':
+		case 'keyword':
+			return CompletionItemKind.Keyword;
+		case 'var':
+		case 'local var':
+			return CompletionItemKind.Variable;
+		case 'property':
+		case 'getter':
+		case 'setter':
+			return CompletionItemKind.Field;
+		case 'function':
+		case 'method':
+		case 'construct':
+		case 'call':
+		case 'index':
+			return CompletionItemKind.Function;
+		case 'enum':
+			return CompletionItemKind.Enum;
+		case 'module':
+			return CompletionItemKind.Module;
+		case 'class':
+			return CompletionItemKind.Class;
+		case 'interface':
+			return CompletionItemKind.Interface;
+		case 'warning':
+			return CompletionItemKind.File;
+	}
+
+	return CompletionItemKind.Property;
+}
+
+function convertSymbolKind(kind: string): SymbolKind {
+	switch (kind) {
+		case 'var':
+		case 'local var':
+		case 'const':
+			return SymbolKind.Variable;
+		case 'function':
+		case 'local function':
+			return SymbolKind.Function;
+		case 'enum':
+			return SymbolKind.Enum;
+		case 'module':
+			return SymbolKind.Module;
+		case 'class':
+			return SymbolKind.Class;
+		case 'interface':
+			return SymbolKind.Interface;
+		case 'method':
+			return SymbolKind.Method;
+		case 'property':
+		case 'getter':
+		case 'setter':
+			return SymbolKind.Property;
+	}
+	return SymbolKind.Variable;
+}
+
+function convertOptions(options: FormattingOptions, formatSettings: any, initialIndentLevel: number): ts.FormatCodeOptions {
+	return {
+		ConvertTabsToSpaces: options.insertSpaces,
+		TabSize: options.tabSize,
+		IndentSize: options.tabSize,
+		IndentStyle: ts.IndentStyle.Smart,
+		NewLineCharacter: '\n',
+		BaseIndentSize: options.tabSize * initialIndentLevel,
+		InsertSpaceAfterCommaDelimiter: Boolean(!formatSettings || formatSettings.insertSpaceAfterCommaDelimiter),
+		InsertSpaceAfterSemicolonInForStatements: Boolean(!formatSettings || formatSettings.insertSpaceAfterSemicolonInForStatements),
+		InsertSpaceBeforeAndAfterBinaryOperators: Boolean(!formatSettings || formatSettings.insertSpaceBeforeAndAfterBinaryOperators),
+		InsertSpaceAfterKeywordsInControlFlowStatements: Boolean(!formatSettings || formatSettings.insertSpaceAfterKeywordsInControlFlowStatements),
+		InsertSpaceAfterFunctionKeywordForAnonymousFunctions: Boolean(!formatSettings || formatSettings.insertSpaceAfterFunctionKeywordForAnonymousFunctions),
+		InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: Boolean(formatSettings && formatSettings.insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis),
+		InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: Boolean(formatSettings && formatSettings.insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets),
+		InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: Boolean(formatSettings && formatSettings.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces),
+		InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: Boolean(formatSettings && formatSettings.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces),
+		PlaceOpenBraceOnNewLineForControlBlocks: Boolean(formatSettings && formatSettings.placeOpenBraceOnNewLineForFunctions),
+		PlaceOpenBraceOnNewLineForFunctions: Boolean(formatSettings && formatSettings.placeOpenBraceOnNewLineForControlBlocks)
+	};
+}
+
+function computeInitialIndent(document: TextDocument, range: Range, options: FormattingOptions) {
+	let lineStart = document.offsetAt(Position.create(range.start.line, 0));
+	let content = document.getText();
+
+	let i = lineStart;
+	let nChars = 0;
+	let tabSize = options.tabSize || 4;
+	while (i < content.length) {
+		let ch = content.charAt(i);
+		if (ch === ' ') {
+			nChars++;
+		} else if (ch === '\t') {
+			nChars += tabSize;
+		} else {
+			break;
+		}
+		i++;
+	}
+	return Math.floor(nChars / tabSize);
+}
+
+function generateIndent(level: number, options: FormattingOptions) {
+	if (options.insertSpaces) {
+		return repeat(' ', level * options.tabSize);
+	} else {
+		return repeat('\t', level);
+	}
+}
--- a/snippets/laravel-blade/server/src/modes/languageModes.ts
+++ b/snippets/laravel-blade/server/src/modes/languageModes.ts
@ -0,0 +1,143 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { getLanguageService as getHTMLLanguageService, DocumentContext } from 'vscode-html-languageservice';
+import {
+	CompletionItem, Location, SignatureHelp, Definition, TextEdit, TextDocument, Diagnostic, DocumentLink, Range,
+	Hover, DocumentHighlight, CompletionList, Position, FormattingOptions, SymbolInformation
+} from 'vscode-languageserver-types';
+
+import { ColorInformation, ColorPresentation, Color } from 'vscode-languageserver-protocol/lib/protocol.colorProvider.proposed';
+
+import { getLanguageModelCache, LanguageModelCache } from '../languageModelCache';
+import { getDocumentRegions, HTMLDocumentRegions } from './embeddedSupport';
+import { getCSSMode } from './cssMode';
+import { getJavascriptMode } from './javascriptMode';
+import { getHTMLMode } from './htmlMode';
+
+export { ColorInformation, ColorPresentation, Color };
+
+export interface Settings {
+	css?: any;
+	html?: any;
+	javascript?: any;
+	emmet?: { [key: string]: any };
+}
+
+export interface SettingProvider {
+	getDocumentSettings(textDocument: TextDocument): Thenable<Settings>;
+}
+
+export interface LanguageMode {
+	getId(): string;
+	configure?: (options: Settings) => void;
+	doValidation?: (document: TextDocument, settings?: Settings) => Diagnostic[];
+	doComplete?: (document: TextDocument, position: Position, settings?: Settings) => CompletionList | null;
+	setCompletionParticipants?: (registeredCompletionParticipants: any[]) => void;
+	doResolve?: (document: TextDocument, item: CompletionItem) => CompletionItem | null;
+	doHover?: (document: TextDocument, position: Position) => Hover | null;
+	doSignatureHelp?: (document: TextDocument, position: Position) => SignatureHelp | null;
+	findDocumentHighlight?: (document: TextDocument, position: Position) => DocumentHighlight[];
+	findDocumentSymbols?: (document: TextDocument) => SymbolInformation[];
+	findDocumentLinks?: (document: TextDocument, documentContext: DocumentContext) => DocumentLink[];
+	findDefinition?: (document: TextDocument, position: Position) => Definition | null;
+	findReferences?: (document: TextDocument, position: Position) => Location[];
+	format?: (document: TextDocument, range: Range, options: FormattingOptions, settings?: Settings) => TextEdit[];
+	findDocumentColors?: (document: TextDocument) => ColorInformation[];
+	getColorPresentations?: (document: TextDocument, color: Color, range: Range) => ColorPresentation[];
+	doAutoClose?: (document: TextDocument, position: Position) => string | null;
+	onDocumentRemoved(document: TextDocument): void;
+	dispose(): void;
+}
+
+export interface LanguageModes {
+	getModeAtPosition(document: TextDocument, position: Position): LanguageMode | undefined;
+	getModesInRange(document: TextDocument, range: Range): LanguageModeRange[];
+	getAllModes(): LanguageMode[];
+	getAllModesInDocument(document: TextDocument): LanguageMode[];
+	getMode(languageId: string): LanguageMode | undefined;
+	onDocumentRemoved(document: TextDocument): void;
+	dispose(): void;
+}
+
+export interface LanguageModeRange extends Range {
+	mode: LanguageMode | undefined;
+	attributeValue?: boolean;
+}
+
+export function getLanguageModes(supportedLanguages: { [languageId: string]: boolean; }): LanguageModes {
+
+	var htmlLanguageService = getHTMLLanguageService();
+	let documentRegions = getLanguageModelCache<HTMLDocumentRegions>(10, 60, document => getDocumentRegions(htmlLanguageService, document));
+
+	let modelCaches: LanguageModelCache<any>[] = [];
+	modelCaches.push(documentRegions);
+
+	let modes = Object.create(null);
+	modes['html'] = getHTMLMode(htmlLanguageService);
+	if (supportedLanguages['css']) {
+		modes['css'] = getCSSMode(documentRegions);
+	}
+	if (supportedLanguages['javascript']) {
+		modes['javascript'] = getJavascriptMode(documentRegions);
+	}
+	return {
+		getModeAtPosition(document: TextDocument, position: Position): LanguageMode | undefined {
+			let languageId = documentRegions.get(document).getLanguageAtPosition(position);
+			if (languageId) {
+				return modes[languageId];
+			}
+			return void 0;
+		},
+		getModesInRange(document: TextDocument, range: Range): LanguageModeRange[] {
+			return documentRegions.get(document).getLanguageRanges(range).map(r => {
+				return <LanguageModeRange>{
+					start: r.start,
+					end: r.end,
+					mode: r.languageId && modes[r.languageId],
+					attributeValue: r.attributeValue
+				};
+			});
+		},
+		getAllModesInDocument(document: TextDocument): LanguageMode[] {
+			let result = [];
+			for (let languageId of documentRegions.get(document).getLanguagesInDocument()) {
+				let mode = modes[languageId];
+				if (mode) {
+					result.push(mode);
+				}
+			}
+			return result;
+		},
+		getAllModes(): LanguageMode[] {
+			let result = [];
+			for (let languageId in modes) {
+				let mode = modes[languageId];
+				if (mode) {
+					result.push(mode);
+				}
+			}
+			return result;
+		},
+		getMode(languageId: string): LanguageMode {
+			return modes[languageId];
+		},
+		onDocumentRemoved(document: TextDocument) {
+			modelCaches.forEach(mc => mc.onDocumentRemoved(document));
+			for (let mode in modes) {
+				modes[mode].onDocumentRemoved(document);
+			}
+		},
+		dispose(): void {
+			modelCaches.forEach(mc => mc.dispose());
+			modelCaches = [];
+			for (let mode in modes) {
+				modes[mode].dispose();
+			}
+			modes = {};
+		}
+	};
+}