diff --git a/extensions/emmet/src/abbreviationActions.ts b/extensions/emmet/src/abbreviationActions.ts
index 79592cc0e64..5b1639ab9a7 100644
--- a/extensions/emmet/src/abbreviationActions.ts
+++ b/extensions/emmet/src/abbreviationActions.ts
@@ -5,15 +5,12 @@
 
 import * as vscode from 'vscode';
 import { expand } from '@emmetio/expand-abbreviation';
-import * as extract from '@emmetio/extract-abbreviation';
 import parseStylesheet from '@emmetio/css-parser';
 import parse from '@emmetio/html-matcher';
 import Node from '@emmetio/node';
-
-import { getSyntax, getProfile, getVariables, isStyleSheet, getNode, getInnerRange } from './util';
-import { DocumentStreamReader } from './bufferStream';
-
-const field = (index, placeholder) => `\${${index}${placeholder ? ':' + placeholder : ''}}`;
+import { getSyntax } from './util';
+import { getExpandOptions, extractAbbreviation, isStyleSheet, getNode, getInnerRange } from './emmetForVSCode/emmetUtils';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
 
 export function wrapWithAbbreviation() {
 	let editor = vscode.window.activeTextEditor;
@@ -45,89 +42,37 @@ export function expandAbbreviation(args) {
 	if (typeof args !== 'object' || !args['syntax']) {
 		return;
 	}
-	let output = expandAbbreviationHelper(args['syntax'], editor.document, editor.selection);
-	if (output) {
-		editor.insertSnippet(new vscode.SnippetString(output.expandedText), output.abbreviationRange);
-	}
-}
-
-export interface ExpandAbbreviationHelperOutput {
-	expandedText: string;
-	abbreviationRange: vscode.Range;
-	abbreviation: string;
-	syntax: string;
-}
-
-/**
- * Expands abbreviation at given range in the given document
- * @param syntax string syntax to be used for expanding abbreviations
- * @param document vscode.TextDocument
- * @param abbreviationRange vscode.Range range of the abbreviation that needs to be expanded
- * */
-export function expandAbbreviationHelper(syntax: string, document: vscode.TextDocument, abbreviationRange: vscode.Range): ExpandAbbreviationHelperOutput {
-	if (!syntax) {
-		return;
-	}
-	let abbreviation = document.getText(abbreviationRange);
+	let syntax = args['syntax'];
+	let abbreviationRange: vscode.Range = editor.selection;
+	let position = editor.selection.isReversed ? editor.selection.anchor : editor.selection.active;
+	let abbreviation = editor.document.getText(abbreviationRange);
 	if (abbreviationRange.isEmpty) {
-		[abbreviationRange, abbreviation] = extractAbbreviation(document, abbreviationRange.start);
+		[abbreviationRange, abbreviation] = extractAbbreviation(editor.document, position);
+	}
+
+	let parseContent = isStyleSheet(syntax) ? parseStylesheet : parse;
+	let rootNode: Node = parseContent(new DocumentStreamReader(editor.document));
+	let currentNode = getNode(rootNode, position);
+
+	if (!isValidLocationForEmmetAbbreviation(currentNode, syntax, position)) {
+		return;
 	}
 
 	let expandedText = expand(abbreviation, getExpandOptions(syntax));
-	return { expandedText, abbreviationRange, abbreviation, syntax };
-}
-
-/**
- * Checks whether given position is valid for emmet abbreviation and returns appropriate syntax
- * @param syntax string language mode of current document
- * @param document vscode.Textdocument
- * @param position vscode.Position position of the abbreviation that needs to be expanded
- */
-export function syntaxHelper(syntax: string, document: vscode.TextDocument, position: vscode.Position): string {
-	let parseContent = isStyleSheet(syntax) ? parseStylesheet : parse;
-	let rootNode: Node = parseContent(new DocumentStreamReader(document));
-	let currentNode = getNode(rootNode, position);
-
-	if (forceCssSyntax(syntax, currentNode, position)) {
-		return 'css';
-	} else if (!isValidLocationForEmmetAbbreviation(currentNode, syntax, position)) {
-		return;
+	if (expandedText) {
+		editor.insertSnippet(new vscode.SnippetString(expandedText), abbreviationRange);
 	}
-	return syntax;
 }
 
-/**
- * Extracts abbreviation from the given position in the given document
- */
-function extractAbbreviation(document: vscode.TextDocument, position: vscode.Position): [vscode.Range, string] {
-	let currentLine = document.lineAt(position.line).text;
-	let result = extract(currentLine, position.character, true);
-	if (!result) {
-		return [null, ''];
-	}
-
-	let rangeToReplace = new vscode.Range(position.line, result.location, position.line, result.location + result.abbreviation.length);
-	return [rangeToReplace, result.abbreviation];
-}
 
 /**
- * Inside <style> tag, force use of css abbreviations
- */
-function forceCssSyntax(syntax: string, currentNode: Node, position: vscode.Position): boolean {
-	return !isStyleSheet(syntax)
-		&& currentNode
-		&& currentNode.close
-		&& currentNode.name === 'style'
-		&& getInnerRange(currentNode).contains(position);
-}
-
-/**
- * Checks if given position is a valid location to expand emmet abbreviation
+ * Checks if given position is a valid location to expand emmet abbreviation.
+ * Works only on html and css/less/scss syntax
  * @param currentNode parsed node at given position
  * @param syntax syntax of the abbreviation
  * @param position position to validate
  */
-function isValidLocationForEmmetAbbreviation(currentNode: Node, syntax: string, position: vscode.Position): boolean {
+export function isValidLocationForEmmetAbbreviation(currentNode: Node, syntax: string, position: vscode.Position): boolean {
 	if (!currentNode) {
 		return true;
 	}
@@ -142,15 +87,4 @@ function isValidLocationForEmmetAbbreviation(currentNode: Node, syntax: string,
 	}
 
 	return false;
-}
-
-export function getExpandOptions(syntax: string, textToReplace?: string) {
-	return {
-		field: field,
-		syntax: syntax,
-		profile: getProfile(syntax),
-		addons: syntax === 'jsx' ? { 'jsx': true } : null,
-		variables: getVariables(),
-		text: textToReplace ? textToReplace : ''
-	};
 }
\ No newline at end of file
diff --git a/extensions/emmet/src/balance.ts b/extensions/emmet/src/balance.ts
index e7428bf3509..3dbb566c638 100644
--- a/extensions/emmet/src/balance.ts
+++ b/extensions/emmet/src/balance.ts
@@ -4,10 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { getNode, isStyleSheet } from './util';
 import parse from '@emmetio/html-matcher';
 import Node from '@emmetio/node';
-import { DocumentStreamReader } from './bufferStream';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { getNode, isStyleSheet } from './emmetForVSCode/emmetUtils';
 
 export function balanceOut() {
 	balance(true);
diff --git a/extensions/emmet/src/defaultCompletionProvider.ts b/extensions/emmet/src/defaultCompletionProvider.ts
new file mode 100644
index 00000000000..ac7b756a8f6
--- /dev/null
+++ b/extensions/emmet/src/defaultCompletionProvider.ts
@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import parseStylesheet from '@emmetio/css-parser';
+import parse from '@emmetio/html-matcher';
+import Node from '@emmetio/node';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { isStyleSheet, getNode, getInnerRange } from './emmetForVSCode/emmetUtils';
+import { EmmetCompletionItemProvider } from './emmetForVSCode/emmetCompletionProvider';
+import { isValidLocationForEmmetAbbreviation } from './abbreviationActions';
+import { getSyntax } from './util';
+
+export class DefaultCompletionItemProvider implements vscode.CompletionItemProvider {
+	private _mappedSyntax = false;
+	constructor(mappedSyntax?: boolean) {
+		if (mappedSyntax) {
+			this._mappedSyntax = mappedSyntax;
+		}
+	}
+	public provideCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Thenable<vscode.CompletionList> {
+		let syntax = getSyntax(document);
+		if (!this._mappedSyntax) {
+			syntax = this.syntaxHelper(syntax, document, position);
+		}
+		if (!syntax) {
+			return;
+		}
+
+		const emmetCompletionProvider = new EmmetCompletionItemProvider(syntax);
+		return emmetCompletionProvider.provideCompletionItems(document, position, token);
+	}
+
+	/**
+	 * Checks whether given position is valid for emmet abbreviation and returns appropriate syntax
+	 * @param syntax string language mode of current document
+	 * @param document vscode.Textdocument
+	 * @param position vscode.Position position of the abbreviation that needs to be expanded
+	 */
+	private syntaxHelper(syntax: string, document: vscode.TextDocument, position: vscode.Position): string {
+		let parseContent = isStyleSheet(syntax) ? parseStylesheet : parse;
+		let rootNode: Node = parseContent(new DocumentStreamReader(document));
+		let currentNode = getNode(rootNode, position);
+
+		if (!isStyleSheet(syntax)
+			&& currentNode
+			&& currentNode.close
+			&& currentNode.name === 'style'
+			&& getInnerRange(currentNode).contains(position)) {
+			return 'css';
+		}
+
+		if (!isValidLocationForEmmetAbbreviation(currentNode, syntax, position)) {
+			return;
+		}
+		return syntax;
+	}
+
+
+
+
+}
\ No newline at end of file
diff --git a/extensions/emmet/src/bufferStream.ts b/extensions/emmet/src/emmetForVSCode/bufferStream.ts
similarity index 100%
rename from extensions/emmet/src/bufferStream.ts
rename to extensions/emmet/src/emmetForVSCode/bufferStream.ts
diff --git a/extensions/emmet/src/emmetCompletionProvider.ts b/extensions/emmet/src/emmetForVSCode/emmetCompletionProvider.ts
similarity index 59%
rename from extensions/emmet/src/emmetCompletionProvider.ts
rename to extensions/emmet/src/emmetForVSCode/emmetCompletionProvider.ts
index 0413199d76c..c42adfbd7b6 100644
--- a/extensions/emmet/src/emmetCompletionProvider.ts
+++ b/extensions/emmet/src/emmetForVSCode/emmetCompletionProvider.ts
@@ -6,16 +6,15 @@
 
 import * as vscode from 'vscode';
 import { expand, createSnippetsRegistry } from '@emmetio/expand-abbreviation';
-import { getSyntax, isStyleSheet } from './util';
-import { syntaxHelper, expandAbbreviationHelper, ExpandAbbreviationHelperOutput, getExpandOptions } from './abbreviationActions';
+import { isStyleSheet, extractAbbreviation, getExpandOptions } from './emmetUtils';
 
 const snippetKeyCache = new Map<string, string[]>();
 
 export class EmmetCompletionItemProvider implements vscode.CompletionItemProvider {
-	private _mappedSyntax = false;
-	constructor(mappedSyntax?: boolean) {
-		if (mappedSyntax) {
-			this._mappedSyntax = true;
+	private _syntax: string;
+	constructor(syntax: string) {
+		if (syntax) {
+			this._syntax = syntax;
 		}
 	}
 	public provideCompletionItems(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Thenable<vscode.CompletionList> {
@@ -25,32 +24,26 @@ export class EmmetCompletionItemProvider implements vscode.CompletionItemProvide
 			return Promise.resolve(null);
 		}
 
-		let syntax = getSyntax(document);
-		let abbreviationRange = new vscode.Range(position, position);
-		if (!this._mappedSyntax) {
-			syntax = syntaxHelper(syntax, document, position);
-		}
+		let [abbreviationRange, abbreviation] = extractAbbreviation(document, position);
+		let expandedText = expand(abbreviation, getExpandOptions(this._syntax));
 
-		let output: ExpandAbbreviationHelperOutput = expandAbbreviationHelper(syntax, document, abbreviationRange);
-		if (!output) {
+		if (!expandedText) {
 			return;
 		}
 
-		let expandedAbbr = new vscode.CompletionItem(output.abbreviation);
-		expandedAbbr.insertText = new vscode.SnippetString(output.expandedText);
-		expandedAbbr.documentation = removeTabStops(output.expandedText);
-		expandedAbbr.range = output.abbreviationRange;
+		let expandedAbbr = new vscode.CompletionItem(abbreviation);
+		expandedAbbr.insertText = new vscode.SnippetString(expandedText);
+		expandedAbbr.documentation = this.removeTabStops(expandedText);
+		expandedAbbr.range = abbreviationRange;
 		expandedAbbr.detail = 'Emmet Abbreviation';
 
-		// Workaround for completion items appearing out of order
+		// Workaround for the main expanded abbr not appearing before the snippet suggestions
 		expandedAbbr.sortText = '0' + expandedAbbr.label;
 
-		syntax = output.syntax;
-
 		let completionItems: vscode.CompletionItem[] = expandedAbbr ? [expandedAbbr] : [];
-		if (!isStyleSheet(syntax)) {
-			let currentWord = getCurrentWord(document, position);
-			let abbreviationSuggestions = this.getAbbreviationSuggestions(syntax, currentWord, output.abbreviation, output.abbreviationRange);
+		if (!isStyleSheet(this._syntax)) {
+			let currentWord = this.getCurrentWord(document, position);
+			let abbreviationSuggestions = this.getAbbreviationSuggestions(this._syntax, currentWord, abbreviation, abbreviationRange);
 			completionItems = completionItems.concat(abbreviationSuggestions);
 		}
 		return Promise.resolve(new vscode.CompletionList(completionItems, true));
@@ -81,15 +74,15 @@ export class EmmetCompletionItemProvider implements vscode.CompletionItemProvide
 			let expandedAbbr = expand(currentAbbr, getExpandOptions(syntax));
 
 			let item = new vscode.CompletionItem(snippetKey);
-			item.documentation = removeTabStops(expandedAbbr);
+			item.documentation = this.removeTabStops(expandedAbbr);
 			item.detail = 'Emmet Abbreviation';
 			item.insertText = new vscode.SnippetString(expandedAbbr);
 			item.range = abbreviationRange;
 
-			// Workaround for completion items getting filtered out
+			// Workaround for snippet suggestions items getting filtered out as the complete abbr does not start with snippetKey 
 			item.filterText = abbreviation;
 
-			// Workaround for completion items appearing in wrong order
+			// Workaround for the main expanded abbr not appearing before the snippet suggestions
 			item.sortText = '9' + abbreviation;
 
 			snippetCompletions.push(item);
@@ -99,25 +92,27 @@ export class EmmetCompletionItemProvider implements vscode.CompletionItemProvide
 
 	}
 
-}
+	private getCurrentWord(document: vscode.TextDocument, position: vscode.Position): string {
+		let wordAtPosition = document.getWordRangeAtPosition(position);
+		let currentWord = '';
+		if (wordAtPosition && wordAtPosition.start.character < position.character) {
+			let word = document.getText(wordAtPosition);
+			currentWord = word.substr(0, position.character - wordAtPosition.start.character);
+		}
 
-
-
-function getCurrentWord(document: vscode.TextDocument, position: vscode.Position): string {
-	let wordAtPosition = document.getWordRangeAtPosition(position);
-	let currentWord = '';
-	if (wordAtPosition && wordAtPosition.start.character < position.character) {
-		let word = document.getText(wordAtPosition);
-		currentWord = word.substr(0, position.character - wordAtPosition.start.character);
+		return currentWord;
 	}
 
-	return currentWord;
-}
+	private removeTabStops(expandedWord: string): string {
+		return expandedWord.replace(/\$\{\d+\}/g, '').replace(/\$\{\d+:([^\}]+)\}/g, '$1');
+	}
 
-function removeTabStops(expandedWord: string): string {
-	return expandedWord.replace(/\$\{\d+\}/g, '').replace(/\$\{\d+:([^\}]+)\}/g, '$1');
 }
 
 
 
 
+
+
+
+
diff --git a/extensions/emmet/src/emmetForVSCode/emmetUtils.ts b/extensions/emmet/src/emmetForVSCode/emmetUtils.ts
new file mode 100644
index 00000000000..69045494ecb
--- /dev/null
+++ b/extensions/emmet/src/emmetForVSCode/emmetUtils.ts
@@ -0,0 +1,200 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import Node from '@emmetio/node';
+import * as extract from '@emmetio/extract-abbreviation';
+import * as path from 'path';
+import * as fs from 'fs';
+
+let variablesFromFile = {};
+let profilesFromFile = {};
+let emmetExtensionsPath = '';
+
+const field = (index, placeholder) => `\${${index}${placeholder ? ':' + placeholder : ''}}`;
+
+export function isStyleSheet(syntax): boolean {
+	let stylesheetSyntaxes = ['css', 'scss', 'sass', 'less', 'stylus'];
+	return (stylesheetSyntaxes.indexOf(syntax) > -1);
+}
+
+/**
+ * Maps and returns syntaxProfiles of previous format to ones compatible with new emmet modules
+ * @param syntax 
+ */
+export function getProfile(syntax: string): any {
+	let profilesFromSettings = vscode.workspace.getConfiguration('emmet')['syntaxProfiles'] || {};
+	let profilesConfig = Object.assign({}, profilesFromFile, profilesFromSettings);
+
+	let options = profilesConfig[syntax];
+	if (!options || typeof options === 'string') {
+		if (options === 'xhtml') {
+			return {
+				selfClosingStyle: 'xhtml'
+			};
+		}
+		return {};
+	}
+	let newOptions = {};
+	for (let key in options) {
+		switch (key) {
+			case 'tag_case':
+				newOptions['tagCase'] = (options[key] === 'lower' || options[key] === 'upper') ? options[key] : '';
+				break;
+			case 'attr_case':
+				newOptions['attributeCase'] = (options[key] === 'lower' || options[key] === 'upper') ? options[key] : '';
+				break;
+			case 'attr_quotes':
+				newOptions['attributeQuotes'] = options[key];
+				break;
+			case 'tag_nl':
+				newOptions['format'] = (options[key] === 'true' || options[key] === 'false') ? options[key] : 'true';
+				break;
+			case 'indent':
+				newOptions['attrCase'] = (options[key] === 'true' || options[key] === 'false') ? '\t' : options[key];
+				break;
+			case 'inline_break':
+				newOptions['inlineBreak'] = options[key];
+				break;
+			case 'self_closing_tag':
+				if (options[key] === true) {
+					newOptions['selfClosingStyle'] = 'xml'; break;
+				}
+				if (options[key] === false) {
+					newOptions['selfClosingStyle'] = 'html'; break;
+				}
+				newOptions['selfClosingStyle'] = options[key];
+				break;
+			default:
+				newOptions[key] = options[key];
+				break;
+		}
+	}
+	return newOptions;
+}
+
+/**
+ * Returns variables to be used while expanding snippets
+ */
+export function getVariables(): any {
+	let variablesFromSettings = vscode.workspace.getConfiguration('emmet')['variables'];
+	return Object.assign({}, variablesFromFile, variablesFromSettings);
+}
+
+/**
+ * Updates customizations from snippets.json and syntaxProfiles.json files in the directory configured in emmet.extensionsPath setting
+ */
+export function updateExtensionsPath() {
+	let currentEmmetExtensionsPath = vscode.workspace.getConfiguration('emmet')['extensionsPath'];
+	if (emmetExtensionsPath !== currentEmmetExtensionsPath) {
+		emmetExtensionsPath = currentEmmetExtensionsPath;
+
+		if (emmetExtensionsPath && emmetExtensionsPath.trim()) {
+			let dirPath = path.isAbsolute(emmetExtensionsPath) ? emmetExtensionsPath : path.join(vscode.workspace.rootPath, emmetExtensionsPath);
+			let snippetsPath = path.join(dirPath, 'snippets.json');
+			let profilesPath = path.join(dirPath, 'syntaxProfiles.json');
+			if (dirExists(dirPath)) {
+				fs.readFile(snippetsPath, (err, snippetsData) => {
+					if (err) {
+						return;
+					}
+					try {
+						let snippetsJson = JSON.parse(snippetsData.toString());
+						variablesFromFile = snippetsJson['variables'];
+					} catch (e) {
+
+					}
+				});
+				fs.readFile(profilesPath, (err, profilesData) => {
+					if (err) {
+						return;
+					}
+					try {
+						profilesFromFile = JSON.parse(profilesData.toString());
+					} catch (e) {
+
+					}
+				});
+			}
+		}
+	}
+}
+
+function dirExists(dirPath: string): boolean {
+	try {
+
+		return fs.statSync(dirPath).isDirectory();
+	} catch (e) {
+		return false;
+	}
+}
+
+/**
+ * Returns node corresponding to given position in the given root node
+ * @param root 
+ * @param position 
+ * @param includeNodeBoundary 
+ */
+export function getNode(root: Node, position: vscode.Position, includeNodeBoundary: boolean = false) {
+	let currentNode: Node = root.firstChild;
+	let foundNode: Node = null;
+
+	while (currentNode) {
+		const nodeStart: vscode.Position = currentNode.start;
+		const nodeEnd: vscode.Position = currentNode.end;
+		if ((nodeStart.isBefore(position) && nodeEnd.isAfter(position))
+			|| (includeNodeBoundary && (nodeStart.isBeforeOrEqual(position) && nodeEnd.isAfterOrEqual(position)))) {
+
+			foundNode = currentNode;
+			// Dig deeper
+			currentNode = currentNode.firstChild;
+		} else {
+			currentNode = currentNode.nextSibling;
+		}
+	}
+
+	return foundNode;
+}
+
+/**
+ * Returns inner range of an html node.
+ * @param currentNode 
+ */
+export function getInnerRange(currentNode: Node): vscode.Range {
+	if (!currentNode.close) {
+		return;
+	}
+	return new vscode.Range(currentNode.open.end, currentNode.close.start);
+}
+
+/**
+ * Extracts abbreviation from the given position in the given document
+ */
+export function extractAbbreviation(document: vscode.TextDocument, position: vscode.Position): [vscode.Range, string] {
+	let currentLine = document.lineAt(position.line).text;
+	let result = extract(currentLine, position.character, true);
+	if (!result) {
+		return [null, ''];
+	}
+
+	let rangeToReplace = new vscode.Range(position.line, result.location, position.line, result.location + result.abbreviation.length);
+	return [rangeToReplace, result.abbreviation];
+}
+
+/**
+ * Returns options to be used by the expand module
+ * @param syntax 
+ * @param textToReplace 
+ */
+export function getExpandOptions(syntax: string, textToReplace?: string) {
+	return {
+		field: field,
+		syntax: syntax,
+		profile: getProfile(syntax),
+		addons: syntax === 'jsx' ? { 'jsx': true } : null,
+		variables: getVariables(),
+		text: textToReplace ? textToReplace : ''
+	};
+}
\ No newline at end of file
diff --git a/extensions/emmet/src/extension.ts b/extensions/emmet/src/extension.ts
index a3777ec50ae..2533e5c969a 100644
--- a/extensions/emmet/src/extension.ts
+++ b/extensions/emmet/src/extension.ts
@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { EmmetCompletionItemProvider } from './emmetCompletionProvider';
+import { DefaultCompletionItemProvider } from './defaultCompletionProvider';
 import { expandAbbreviation, wrapWithAbbreviation } from './abbreviationActions';
 import { removeTag } from './removeTag';
 import { updateTag } from './updateTag';
@@ -15,18 +15,17 @@ import { mergeLines } from './mergeLines';
 import { toggleComment } from './toggleComment';
 import { fetchEditPoint } from './editPoint';
 import { fetchSelectItem } from './selectItem';
-import { updateExtensionsPath, LANGUAGE_MODES, getMappedModes } from './util';
-
-
+import { LANGUAGE_MODES, getMappedModes } from './util';
+import { updateExtensionsPath } from './emmetForVSCode/emmetUtils';
 
 export function activate(context: vscode.ExtensionContext) {
-	let completionProvider = new EmmetCompletionItemProvider();
+	let completionProvider = new DefaultCompletionItemProvider();
 	Object.keys(LANGUAGE_MODES).forEach(language => {
 		const provider = vscode.languages.registerCompletionItemProvider(language, completionProvider, ...LANGUAGE_MODES[language]);
 		context.subscriptions.push(provider);
 	});
 
-	let completionProviderForMappedSyntax = new EmmetCompletionItemProvider(true);
+	let completionProviderForMappedSyntax = new DefaultCompletionItemProvider(true);
 	let mappedModes = getMappedModes();
 	Object.keys(mappedModes).forEach(syntax => {
 		const provider = vscode.languages.registerCompletionItemProvider(syntax, completionProviderForMappedSyntax, ...LANGUAGE_MODES[mappedModes[syntax]]);
diff --git a/extensions/emmet/src/matchTag.ts b/extensions/emmet/src/matchTag.ts
index af72138240c..0d0a3174c1d 100644
--- a/extensions/emmet/src/matchTag.ts
+++ b/extensions/emmet/src/matchTag.ts
@@ -4,10 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { getNode } from './util';
 import parse from '@emmetio/html-matcher';
 import Node from '@emmetio/node';
-import { DocumentStreamReader } from './bufferStream';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { getNode } from './emmetForVSCode/emmetUtils';
 
 export function matchTag() {
 	let editor = vscode.window.activeTextEditor;
diff --git a/extensions/emmet/src/mergeLines.ts b/extensions/emmet/src/mergeLines.ts
index 6d01107cfe0..aa75ead0c5d 100644
--- a/extensions/emmet/src/mergeLines.ts
+++ b/extensions/emmet/src/mergeLines.ts
@@ -4,10 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { isStyleSheet, getNode } from './util';
 import parse from '@emmetio/html-matcher';
 import Node from '@emmetio/node';
-import { DocumentStreamReader } from './bufferStream';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { getNode, isStyleSheet } from './emmetForVSCode/emmetUtils';
 
 export function mergeLines() {
 	let editor = vscode.window.activeTextEditor;
diff --git a/extensions/emmet/src/selectItem.ts b/extensions/emmet/src/selectItem.ts
index 3280627a63a..90eac9f3a96 100644
--- a/extensions/emmet/src/selectItem.ts
+++ b/extensions/emmet/src/selectItem.ts
@@ -4,13 +4,15 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { validate, isStyleSheet } from './util';
+import { validate } from './util';
 import { nextItemHTML, prevItemHTML } from './selectItemHTML';
 import { nextItemStylesheet, prevItemStylesheet } from './selectItemStylesheet';
 import parseStylesheet from '@emmetio/css-parser';
 import parse from '@emmetio/html-matcher';
 import Node from '@emmetio/node';
-import { DocumentStreamReader } from './bufferStream';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { isStyleSheet } from './emmetForVSCode/emmetUtils';
+
 
 export function fetchSelectItem(direction: string): void {
 	let editor = vscode.window.activeTextEditor;
diff --git a/extensions/emmet/src/selectItemHTML.ts b/extensions/emmet/src/selectItemHTML.ts
index 7dcd14b740c..9fe247bf0c4 100644
--- a/extensions/emmet/src/selectItemHTML.ts
+++ b/extensions/emmet/src/selectItemHTML.ts
@@ -4,8 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { getNode, getDeepestNode, findNextWord, findPrevWord } from './util';
+import { getDeepestNode, findNextWord, findPrevWord } from './util';
 import Node from '@emmetio/node';
+import { getNode } from './emmetForVSCode/emmetUtils';
+
 
 export function nextItemHTML(selectionStart: vscode.Position, selectionEnd: vscode.Position, editor: vscode.TextEditor, rootNode: Node): vscode.Selection {
 	let currentNode = getNode(rootNode, selectionEnd);
diff --git a/extensions/emmet/src/selectItemStylesheet.ts b/extensions/emmet/src/selectItemStylesheet.ts
index a40cb9d0736..6a5e768263e 100644
--- a/extensions/emmet/src/selectItemStylesheet.ts
+++ b/extensions/emmet/src/selectItemStylesheet.ts
@@ -4,8 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { getNode, getDeepestNode, findNextWord, findPrevWord } from './util';
+import { getDeepestNode, findNextWord, findPrevWord } from './util';
 import Node from '@emmetio/node';
+import { getNode } from './emmetForVSCode/emmetUtils';
+
 
 export function nextItemStylesheet(startOffset: vscode.Position, endOffset: vscode.Position, editor: vscode.TextEditor, rootNode: Node): vscode.Selection {
 	let currentNode = getNode(rootNode, endOffset, true);
diff --git a/extensions/emmet/src/splitJoinTag.ts b/extensions/emmet/src/splitJoinTag.ts
index cbd02ef81cd..fc7ebd1ad5b 100644
--- a/extensions/emmet/src/splitJoinTag.ts
+++ b/extensions/emmet/src/splitJoinTag.ts
@@ -4,10 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { isStyleSheet, getNode } from './util';
 import parse from '@emmetio/html-matcher';
 import Node from '@emmetio/node';
-import { DocumentStreamReader } from './bufferStream';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { getNode, isStyleSheet } from './emmetForVSCode/emmetUtils';
 
 export function splitJoinTag() {
 	let editor = vscode.window.activeTextEditor;
diff --git a/extensions/emmet/src/toggleComment.ts b/extensions/emmet/src/toggleComment.ts
index 6a91dc081e4..cf2b270ae0b 100644
--- a/extensions/emmet/src/toggleComment.ts
+++ b/extensions/emmet/src/toggleComment.ts
@@ -4,11 +4,12 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { getNode, isStyleSheet, getNodesInBetween } from './util';
+import { getNodesInBetween } from './util';
 import parse from '@emmetio/html-matcher';
 import parseStylesheet from '@emmetio/css-parser';
 import Node from '@emmetio/node';
-import { DocumentStreamReader } from './bufferStream';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { getNode, isStyleSheet } from './emmetForVSCode/emmetUtils';
 
 const startCommentStylesheet = '/*';
 const endCommentStylesheet = '*/';
diff --git a/extensions/emmet/src/updateTag.ts b/extensions/emmet/src/updateTag.ts
index b4450eba283..a796e99baa9 100644
--- a/extensions/emmet/src/updateTag.ts
+++ b/extensions/emmet/src/updateTag.ts
@@ -4,10 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { getNode } from './util';
 import parse from '@emmetio/html-matcher';
 import Node from '@emmetio/node';
-import { DocumentStreamReader } from './bufferStream';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { getNode } from './emmetForVSCode/emmetUtils';
 
 export function updateTag(tagName: string) {
 	let editor = vscode.window.activeTextEditor;
diff --git a/extensions/emmet/src/util.ts b/extensions/emmet/src/util.ts
index a4d85b1b395..8cb5101dc31 100644
--- a/extensions/emmet/src/util.ts
+++ b/extensions/emmet/src/util.ts
@@ -6,13 +6,8 @@
 import * as vscode from 'vscode';
 import parse from '@emmetio/html-matcher';
 import Node from '@emmetio/node';
-import { DocumentStreamReader } from './bufferStream';
-import * as path from 'path';
-import * as fs from 'fs';
-
-let variablesFromFile = {};
-let profilesFromFile = {};
-let emmetExtensionsPath = '';
+import { DocumentStreamReader } from './emmetForVSCode/bufferStream';
+import { isStyleSheet, getNode } from './emmetForVSCode/emmetUtils';
 
 export const LANGUAGE_MODES: Object = {
 	'html': ['!', '.', '}'],
@@ -56,67 +51,6 @@ export function getSyntax(document: vscode.TextDocument): string {
 	return document.languageId;
 }
 
-export function isStyleSheet(syntax): boolean {
-	let stylesheetSyntaxes = ['css', 'scss', 'sass', 'less', 'stylus'];
-	return (stylesheetSyntaxes.indexOf(syntax) > -1);
-}
-
-export function getProfile(syntax: string): any {
-	let profilesFromSettings = vscode.workspace.getConfiguration('emmet')['syntaxProfiles'] || {};
-	let profilesConfig = Object.assign({}, profilesFromFile, profilesFromSettings);
-
-	let options = profilesConfig[syntax];
-	if (!options || typeof options === 'string') {
-		if (options === 'xhtml') {
-			return {
-				selfClosingStyle: 'xhtml'
-			};
-		}
-		return {};
-	}
-	let newOptions = {};
-	for (let key in options) {
-		switch (key) {
-			case 'tag_case':
-				newOptions['tagCase'] = (options[key] === 'lower' || options[key] === 'upper') ? options[key] : '';
-				break;
-			case 'attr_case':
-				newOptions['attributeCase'] = (options[key] === 'lower' || options[key] === 'upper') ? options[key] : '';
-				break;
-			case 'attr_quotes':
-				newOptions['attributeQuotes'] = options[key];
-				break;
-			case 'tag_nl':
-				newOptions['format'] = (options[key] === 'true' || options[key] === 'false') ? options[key] : 'true';
-				break;
-			case 'indent':
-				newOptions['attrCase'] = (options[key] === 'true' || options[key] === 'false') ? '\t' : options[key];
-				break;
-			case 'inline_break':
-				newOptions['inlineBreak'] = options[key];
-				break;
-			case 'self_closing_tag':
-				if (options[key] === true) {
-					newOptions['selfClosingStyle'] = 'xml'; break;
-				}
-				if (options[key] === false) {
-					newOptions['selfClosingStyle'] = 'html'; break;
-				}
-				newOptions['selfClosingStyle'] = options[key];
-				break;
-			default:
-				newOptions[key] = options[key];
-				break;
-		}
-	}
-	return newOptions;
-}
-
-export function getVariables(): any {
-	let variablesFromSettings = vscode.workspace.getConfiguration('emmet')['variables'];
-	return Object.assign({}, variablesFromFile, variablesFromSettings);
-}
-
 export function getMappedModes(): any {
 	let finalMappedModes = {};
 	let syntaxProfileConfig = vscode.workspace.getConfiguration('emmet')['syntaxProfiles'];
@@ -129,41 +63,6 @@ export function getMappedModes(): any {
 	return finalMappedModes;
 }
 
-export function updateExtensionsPath() {
-	let currentEmmetExtensionsPath = vscode.workspace.getConfiguration('emmet')['extensionsPath'];
-	if (emmetExtensionsPath !== currentEmmetExtensionsPath) {
-		emmetExtensionsPath = currentEmmetExtensionsPath;
-
-		if (emmetExtensionsPath && emmetExtensionsPath.trim()) {
-			let dirPath = path.isAbsolute(emmetExtensionsPath) ? emmetExtensionsPath : path.join(vscode.workspace.rootPath, emmetExtensionsPath);
-			let snippetsPath = path.join(dirPath, 'snippets.json');
-			let profilesPath = path.join(dirPath, 'syntaxProfiles.json');
-			if (dirExists(dirPath)) {
-				fs.readFile(snippetsPath, (err, snippetsData) => {
-					if (err) {
-						return;
-					}
-					try {
-						let snippetsJson = JSON.parse(snippetsData.toString());
-						variablesFromFile = snippetsJson['variables'];
-					} catch (e) {
-
-					}
-				});
-				fs.readFile(profilesPath, (err, profilesData) => {
-					if (err) {
-						return;
-					}
-					try {
-						profilesFromFile = JSON.parse(profilesData.toString());
-					} catch (e) {
-
-					}
-				});
-			}
-		}
-	}
-}
 export function getOpenCloseRange(document: vscode.TextDocument, position: vscode.Position): [vscode.Range, vscode.Range] {
 	let rootNode: Node = parse(new DocumentStreamReader(document));
 	let nodeToUpdate = getNode(rootNode, position);
@@ -175,34 +74,6 @@ export function getOpenCloseRange(document: vscode.TextDocument, position: vscod
 	return [openRange, closeRange];
 }
 
-export function getNode(root: Node, position: vscode.Position, includeNodeBoundary: boolean = false) {
-	let currentNode: Node = root.firstChild;
-	let foundNode: Node = null;
-
-	while (currentNode) {
-		const nodeStart: vscode.Position = currentNode.start;
-		const nodeEnd: vscode.Position = currentNode.end;
-		if ((nodeStart.isBefore(position) && nodeEnd.isAfter(position))
-			|| (includeNodeBoundary && (nodeStart.isBeforeOrEqual(position) && nodeEnd.isAfterOrEqual(position)))) {
-
-			foundNode = currentNode;
-			// Dig deeper
-			currentNode = currentNode.firstChild;
-		} else {
-			currentNode = currentNode.nextSibling;
-		}
-	}
-
-	return foundNode;
-}
-
-export function getInnerRange(currentNode: Node): vscode.Range {
-	if (!currentNode.close) {
-		return;
-	}
-	return new vscode.Range(currentNode.open.end, currentNode.close.start);
-}
-
 export function getDeepestNode(node: Node): Node {
 	if (!node || !node.children || node.children.length === 0) {
 		return node;
@@ -341,11 +212,4 @@ export function sameNodes(node1: Node, node2: Node): boolean {
 	return (<vscode.Position>node1.start).isEqual(node2.start) && (<vscode.Position>node1.end).isEqual(node2.end);
 }
 
-function dirExists(dirPath: string): boolean {
-	try {
 
-		return fs.statSync(dirPath).isDirectory();
-	} catch (e) {
-		return false;
-	}
-}