diff --git a/.gitignore b/.gitignore
index ddf23ee..5960167 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@ node_modules
 *.js
 *.map
 *.tgz
+!packages/emmet/lib/typings/**/*
diff --git a/packages/emmet/index.ts b/packages/emmet/index.ts
index 2dd8490..f01bd06 100644
--- a/packages/emmet/index.ts
+++ b/packages/emmet/index.ts
@@ -1,106 +1,210 @@
-import type { LanguageServicePluginInstance, LanguageServicePlugin, TextDocument } from '@volar/language-service';
-import * as emmet from '@vscode/emmet-helper';
-import * as html from 'vscode-html-languageservice';
-
-const htmlDocuments = new WeakMap<TextDocument, [number, html.HTMLDocument]>();
-
-let htmlLs: html.LanguageService;
-
-function getHtmlDocument(document: TextDocument) {
-
-	const cache = htmlDocuments.get(document);
-	if (cache) {
-		const [cacheVersion, cacheDoc] = cache;
-		if (cacheVersion === document.version) {
-			return cacheDoc;
-		}
-	}
-
-	htmlLs ??= html.getLanguageService();
-
-	const doc = htmlLs.parseHTMLDocument(document);
-	htmlDocuments.set(document, [document.version, doc]);
-
-	return doc;
-}
+import type * as vscode from '@volar/language-service';
+import type * as helper from '@vscode/emmet-helper';
+import type { Node, Stylesheet } from 'EmmetFlatNode';
+import { getRootNode } from './lib/parseDocument';
+import { allowedMimeTypesInScriptTag, getEmbeddedCssNodeIfAny, getEmmetConfiguration, getEmmetHelper, getEmmetMode, getFlatNode, getHtmlFlatNode, isStyleSheet, parsePartialStylesheet } from './lib/util';
+import { getSyntaxFromArgs, isValidLocationForEmmetAbbreviation } from './lib/abbreviationActions';
 
 export function create({
-	mappedModes = {},
+	mappedLanguages = {},
 }: {
-	mappedModes?: Record<string, string>;
-} = {}): LanguageServicePlugin {
+	mappedLanguages?: Record<string, string>;
+} = {}): vscode.LanguageServicePlugin {
 	return {
 		name: 'emmet',
 		// https://docs.emmet.io/abbreviations/syntax/
 		triggerCharacters: '>+^*()#.[]$@-{}'.split(''),
-		create(context): LanguageServicePluginInstance {
+		create(context): vscode.LanguageServicePluginInstance {
+
+			let lastCompletionType: string | undefined;
 
 			return {
 
 				isAdditionalCompletion: true,
 
-				async provideCompletionItems(textDocument, position) {
-
-					const syntax = emmet.getEmmetMode(mappedModes[textDocument.languageId] ?? textDocument.languageId);
-					if (!syntax) {
+				async provideCompletionItems(document, position, completionContext) {
+					const completionResult = provideCompletionItemsInternal(document, position, completionContext);
+					if (!completionResult) {
+						lastCompletionType = undefined;
 						return;
 					}
 
-					// fix https://github.com/vuejs/language-tools/issues/1329
-					if (syntax === 'html') {
-						const htmlDocument = getHtmlDocument(textDocument);
-						const node = htmlDocument.findNodeAt(textDocument.offsetAt(position));
-						if (node.tag) {
-							let insideBlock = false;
-							if (node.startTagEnd !== undefined && node.endTagStart !== undefined) {
-								insideBlock = textDocument.offsetAt(position) >= node.startTagEnd && textDocument.offsetAt(position) <= node.endTagStart;
+					return completionResult.then(completionList => {
+						if (!completionList || !completionList.items.length) {
+							lastCompletionType = undefined;
+							return completionList;
+						}
+						const item = completionList.items[0];
+						const expandedText = item.documentation ? item.documentation.toString() : '';
+
+						if (expandedText.startsWith('<')) {
+							lastCompletionType = 'html';
+						} else if (expandedText.indexOf(':') > 0 && expandedText.endsWith(';')) {
+							lastCompletionType = 'css';
+						} else {
+							lastCompletionType = undefined;
+						}
+						return completionList;
+					});
+				},
+			};
+
+			async function provideCompletionItemsInternal(document: vscode.TextDocument, position: vscode.Position, completionContext: vscode.CompletionContext) {
+
+				const emmetConfig: any = await context.env.getConfiguration?.<helper.VSCodeEmmetConfig>('emmet') ?? {};
+				const excludedLanguages = emmetConfig['excludeLanguages'] ?? [];
+				if (excludedLanguages.includes(document.languageId)) {
+					return;
+				}
+
+				const isSyntaxMapped = mappedLanguages[document.languageId] ? true : false;
+				const emmetMode = getEmmetMode(mappedLanguages[document.languageId] ?? document.languageId, mappedLanguages, excludedLanguages);
+				if (!emmetMode
+					|| emmetConfig['showExpandedAbbreviation'] === 'never'
+					|| ((isSyntaxMapped || emmetMode === 'jsx') && emmetConfig['showExpandedAbbreviation'] !== 'always')) {
+					return;
+				}
+
+				let syntax = emmetMode;
+
+				let validateLocation = syntax === 'html' || syntax === 'jsx' || syntax === 'xml';
+				let rootNode: Node | undefined;
+				let currentNode: Node | undefined;
+
+				// Don't show completions if there's a comment at the beginning of the line
+				const lineRange: vscode.Range = {
+					start: { line: position.line, character: 0 },
+					end: position,
+				};
+				if (document.getText(lineRange).trimStart().startsWith('//')) {
+					return;
+				}
+
+				const helper = getEmmetHelper();
+				if (syntax === 'html') {
+					if (completionContext.triggerKind === 3 satisfies typeof vscode.CompletionTriggerKind.TriggerForIncompleteCompletions) {
+						switch (lastCompletionType) {
+							case 'html':
+								validateLocation = false;
+								break;
+							case 'css':
+								validateLocation = false;
+								syntax = 'css';
+								break;
+							default:
+								break;
+						}
+					}
+					if (validateLocation) {
+						const positionOffset = document.offsetAt(position);
+						const emmetRootNode = getRootNode(document, true);
+						const foundNode = getHtmlFlatNode(document.getText(), emmetRootNode, positionOffset, false);
+						if (foundNode) {
+							if (foundNode.name === 'script') {
+								const typeNode = foundNode.attributes.find(attr => attr.name.toString() === 'type');
+								if (typeNode) {
+									const typeAttrValue = typeNode.value.toString();
+									if (typeAttrValue === 'application/javascript' || typeAttrValue === 'text/javascript') {
+										if (!await getSyntaxFromArgs(context, { language: 'javascript' })) {
+											return;
+										} else {
+											validateLocation = false;
+										}
+									}
+									else if (allowedMimeTypesInScriptTag.includes(typeAttrValue)) {
+										validateLocation = false;
+									}
+								} else {
+									return;
+								}
 							}
-							if (!insideBlock) {
-								return;
+							else if (foundNode.name === 'style') {
+								syntax = 'css';
+								validateLocation = false;
+							} else {
+								const styleNode = foundNode.attributes.find(attr => attr.name.toString() === 'style');
+								if (styleNode && styleNode.value.start <= positionOffset && positionOffset <= styleNode.value.end) {
+									syntax = 'css';
+									validateLocation = false;
+								}
 							}
 						}
 					}
+				}
 
-					// monkey fix https://github.com/johnsoncodehk/volar/issues/1105
-					if (syntax === 'jsx') {
+				const expandOptions = isStyleSheet(syntax) ?
+					{ lookAhead: false, syntax: 'stylesheet' } :
+					{ lookAhead: true, syntax: 'markup' };
+				const extractAbbreviationResults = helper.extractAbbreviation(document, position, expandOptions);
+				if (!extractAbbreviationResults || !helper.isAbbreviationValid(syntax, extractAbbreviationResults.abbreviation)) {
+					return;
+				}
+
+				const offset = document.offsetAt(position);
+				if (isStyleSheet(document.languageId) && completionContext.triggerKind !== 3 satisfies typeof vscode.CompletionTriggerKind.TriggerForIncompleteCompletions) {
+					validateLocation = true;
+					const usePartialParsing = await context.env.getConfiguration<boolean>?.('emmet.optimizeStylesheetParsing') === true;
+					rootNode = usePartialParsing && document.lineCount > 1000 ? parsePartialStylesheet(document, position) : <Stylesheet>getRootNode(document, true);
+					if (!rootNode) {
 						return;
 					}
+					currentNode = getFlatNode(rootNode, offset, true);
+				}
 
-					const emmetConfig = await getEmmetConfig(syntax);
+				// Fix for https://github.com/microsoft/vscode/issues/107578
+				// Validate location if syntax is of styleSheet type to ensure that location is valid for emmet abbreviation.
+				// For an html document containing a <style> node, compute the embeddedCssNode and fetch the flattened node as currentNode.
+				if (!isStyleSheet(document.languageId) && isStyleSheet(syntax) && completionContext.triggerKind !== 3 satisfies typeof vscode.CompletionTriggerKind.TriggerForIncompleteCompletions) {
+					validateLocation = true;
+					rootNode = getRootNode(document, true);
+					if (!rootNode) {
+						return;
+					}
+					const flatNode = getFlatNode(rootNode, offset, true);
+					const embeddedCssNode = getEmbeddedCssNodeIfAny(document, flatNode, position);
+					currentNode = getFlatNode(embeddedCssNode, offset, true);
+				}
 
-					return emmet.doComplete(textDocument, position, syntax, emmetConfig);
-				},
-			};
+				if (validateLocation && !await isValidLocationForEmmetAbbreviation(context, document, rootNode, currentNode, syntax, offset, extractAbbreviationResults.abbreviationRange)) {
+					return;
+				}
 
-			async function getEmmetConfig(syntax: string): Promise<emmet.VSCodeEmmetConfig> {
-
-				const emmetConfig: any = await context.env.getConfiguration?.<emmet.VSCodeEmmetConfig>('emmet') ?? {};
-				const syntaxProfiles = Object.assign({}, emmetConfig['syntaxProfiles'] || {});
-				const preferences = Object.assign({}, emmetConfig['preferences'] || {});
-
-				// jsx, xml and xsl syntaxes need to have self closing tags unless otherwise configured by user
-				if (syntax === 'jsx' || syntax === 'xml' || syntax === 'xsl') {
-					syntaxProfiles[syntax] = syntaxProfiles[syntax] || {};
-					if (typeof syntaxProfiles[syntax] === 'object'
-						&& !syntaxProfiles[syntax].hasOwnProperty('self_closing_tag') // Old Emmet format
-						&& !syntaxProfiles[syntax].hasOwnProperty('selfClosingStyle') // Emmet 2.0 format
-					) {
-						syntaxProfiles[syntax] = {
-							...syntaxProfiles[syntax],
-							selfClosingStyle: 'xml'
-						};
+				let isNoisePromise: Thenable<boolean> = Promise.resolve(false);
+
+				// Fix for https://github.com/microsoft/vscode/issues/32647
+				// Check for document symbols in js/ts/jsx/tsx and avoid triggering emmet for abbreviations of the form symbolName.sometext
+				// Presence of > or * or + in the abbreviation denotes valid abbreviation that should trigger emmet
+				if (!isStyleSheet(syntax) && (document.languageId === 'javascript' || document.languageId === 'javascriptreact' || document.languageId === 'typescript' || document.languageId === 'typescriptreact')) {
+					const abbreviation: string = extractAbbreviationResults.abbreviation;
+					// For the second condition, we don't want abbreviations that have [] characters but not ='s in them to expand
+					// In turn, users must explicitly expand abbreviations of the form Component[attr1 attr2], but it means we don't try to expand a[i].
+					if (abbreviation.startsWith('this.') || /\[[^\]=]*\]/.test(abbreviation)) {
+						isNoisePromise = Promise.resolve(true);
+					} else {
+						// TODO
+						// isNoisePromise = vscode.commands.executeCommand<vscode.SymbolInformation[] | undefined>('vscode.executeDocumentSymbolProvider', document.uri).then(symbols => {
+						// 	return !!symbols && symbols.some(x => abbreviation === x.name || (abbreviation.startsWith(x.name + '.') && !/>|\*|\+/.test(abbreviation)));
+						// });
 					}
 				}
 
-				return {
-					preferences,
-					showExpandedAbbreviation: emmetConfig['showExpandedAbbreviation'],
-					showAbbreviationSuggestions: emmetConfig['showAbbreviationSuggestions'],
-					syntaxProfiles,
-					variables: emmetConfig['variables'],
-					excludeLanguages: emmetConfig['excludeLanguages'],
-					showSuggestionsAsSnippets: emmetConfig['showSuggestionsAsSnippets']
-				};
+				return isNoisePromise.then(async (isNoise): Promise<vscode.CompletionList | undefined> => {
+					if (isNoise) {
+						return undefined;
+					}
+
+					const config = await getEmmetConfiguration(context, syntax!);
+					const result = helper.doComplete(document, position, syntax, config);
+
+					// https://github.com/microsoft/vscode/issues/86941
+					if (result && result.items && result.items.length === 1) {
+						if (result.items[0].label === 'widows: ;') {
+							return undefined;
+						}
+					}
+
+					return result;
+				});
 			}
 		},
 	};
diff --git a/packages/emmet/lib/abbreviationActions.ts b/packages/emmet/lib/abbreviationActions.ts
new file mode 100644
index 0000000..a7aaf29
--- /dev/null
+++ b/packages/emmet/lib/abbreviationActions.ts
@@ -0,0 +1,221 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type * as vscode from '@volar/language-service';
+import type { HtmlNode, Node, Property, Rule, Stylesheet } from 'EmmetFlatNode';
+import { allowedMimeTypesInScriptTag, getEmmetMode, getMappingForIncludedLanguages, isStyleSheet } from './util';
+
+const hexColorRegex = /^#[\da-fA-F]{0,6}$/;
+
+/**
+ * Checks if given position is a valid location to expand emmet abbreviation.
+ * Works only on html and css/less/scss syntax
+ * @param document current Text Document
+ * @param rootNode parsed document
+ * @param currentNode current node in the parsed document
+ * @param syntax syntax of the abbreviation
+ * @param position position to validate
+ * @param abbreviationRange The range of the abbreviation for which given position is being validated
+ */
+export async function isValidLocationForEmmetAbbreviation(context: vscode.ServiceContext, document: vscode.TextDocument, rootNode: Node | undefined, currentNode: Node | undefined, syntax: string, offset: number, abbreviationRange: vscode.Range): Promise<boolean> {
+	if (isStyleSheet(syntax)) {
+		const stylesheet = <Stylesheet>rootNode;
+		if (stylesheet && (stylesheet.comments || []).some(x => offset >= x.start && offset <= x.end)) {
+			return false;
+		}
+		// Continue validation only if the file was parse-able and the currentNode has been found
+		if (!currentNode) {
+			return true;
+		}
+
+		// Get the abbreviation right now
+		// Fixes https://github.com/microsoft/vscode/issues/74505
+		// Stylesheet abbreviations starting with @ should bring up suggestions
+		// even at outer-most level
+		const abbreviation = document.getText(abbreviationRange);
+		if (abbreviation.startsWith('@')) {
+			return true;
+		}
+
+		// Fix for https://github.com/microsoft/vscode/issues/34162
+		// Other than sass, stylus, we can make use of the terminator tokens to validate position
+		if (syntax !== 'sass' && syntax !== 'stylus' && currentNode.type === 'property') {
+			// Fix for upstream issue https://github.com/emmetio/css-parser/issues/3
+			if (currentNode.parent
+				&& currentNode.parent.type !== 'rule'
+				&& currentNode.parent.type !== 'at-rule') {
+				return false;
+			}
+
+			const propertyNode = <Property>currentNode;
+			if (propertyNode.terminatorToken
+				&& propertyNode.separator
+				&& offset >= propertyNode.separatorToken.end
+				&& offset <= propertyNode.terminatorToken.start
+				&& !abbreviation.includes(':')) {
+				return hexColorRegex.test(abbreviation) || abbreviation === '!';
+			}
+			if (!propertyNode.terminatorToken
+				&& propertyNode.separator
+				&& offset >= propertyNode.separatorToken.end
+				&& !abbreviation.includes(':')) {
+				return hexColorRegex.test(abbreviation) || abbreviation === '!';
+			}
+			if (hexColorRegex.test(abbreviation) || abbreviation === '!') {
+				return false;
+			}
+		}
+
+		// If current node is a rule or at-rule, then perform additional checks to ensure
+		// emmet suggestions are not provided in the rule selector
+		if (currentNode.type !== 'rule' && currentNode.type !== 'at-rule') {
+			return true;
+		}
+
+		const currentCssNode = <Rule>currentNode;
+
+		// Position is valid if it occurs after the `{` that marks beginning of rule contents
+		if (offset > currentCssNode.contentStartToken.end) {
+			return true;
+		}
+
+		// Workaround for https://github.com/microsoft/vscode/30188
+		// The line above the rule selector is considered as part of the selector by the css-parser
+		// But we should assume it is a valid location for css properties under the parent rule
+		if (currentCssNode.parent
+			&& (currentCssNode.parent.type === 'rule' || currentCssNode.parent.type === 'at-rule')
+			&& currentCssNode.selectorToken) {
+			const position = document.positionAt(offset);
+			const tokenStartPos = document.positionAt(currentCssNode.selectorToken.start);
+			const tokenEndPos = document.positionAt(currentCssNode.selectorToken.end);
+			if (position.line !== tokenEndPos.line
+				&& tokenStartPos.character === abbreviationRange.start.character
+				&& tokenStartPos.line === abbreviationRange.start.line
+			) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	const startAngle = '<';
+	const endAngle = '>';
+	const escape = '\\';
+	const question = '?';
+	const currentHtmlNode = <HtmlNode>currentNode;
+	let start = 0;
+
+	if (currentHtmlNode) {
+		if (currentHtmlNode.name === 'script') {
+			const typeAttribute = (currentHtmlNode.attributes || []).filter(x => x.name.toString() === 'type')[0];
+			const typeValue = typeAttribute ? typeAttribute.value.toString() : '';
+
+			if (allowedMimeTypesInScriptTag.includes(typeValue)) {
+				return true;
+			}
+
+			const isScriptJavascriptType = !typeValue || typeValue === 'application/javascript' || typeValue === 'text/javascript';
+			if (isScriptJavascriptType) {
+				return !!await getSyntaxFromArgs(context, { language: 'javascript' });
+			}
+			return false;
+		}
+
+		// Fix for https://github.com/microsoft/vscode/issues/28829
+		if (!currentHtmlNode.open || !currentHtmlNode.close ||
+			!(currentHtmlNode.open.end <= offset && offset <= currentHtmlNode.close.start)) {
+			return false;
+		}
+
+		// Fix for https://github.com/microsoft/vscode/issues/35128
+		// Find the position up till where we will backtrack looking for unescaped < or >
+		// to decide if current position is valid for emmet expansion
+		start = currentHtmlNode.open.end;
+		let lastChildBeforePosition = currentHtmlNode.firstChild;
+		while (lastChildBeforePosition) {
+			if (lastChildBeforePosition.end > offset) {
+				break;
+			}
+			start = lastChildBeforePosition.end;
+			lastChildBeforePosition = lastChildBeforePosition.nextSibling;
+		}
+	}
+	const startPos = document.positionAt(start);
+	let textToBackTrack = document.getText({ start: startPos, end: abbreviationRange.start });
+
+	// Worse case scenario is when cursor is inside a big chunk of text which needs to backtracked
+	// Backtrack only 500 offsets to ensure we dont waste time doing this
+	if (textToBackTrack.length > 500) {
+		textToBackTrack = textToBackTrack.substr(textToBackTrack.length - 500);
+	}
+
+	if (!textToBackTrack.trim()) {
+		return true;
+	}
+
+	let valid = true;
+	let foundSpace = false; // If < is found before finding whitespace, then its valid abbreviation. E.g.: <div|
+	let i = textToBackTrack.length - 1;
+	if (textToBackTrack[i] === startAngle) {
+		return false;
+	}
+
+	while (i >= 0) {
+		const char = textToBackTrack[i];
+		i--;
+		if (!foundSpace && /\s/.test(char)) {
+			foundSpace = true;
+			continue;
+		}
+		if (char === question && textToBackTrack[i] === startAngle) {
+			i--;
+			continue;
+		}
+		// Fix for https://github.com/microsoft/vscode/issues/55411
+		// A space is not a valid character right after < in a tag name.
+		if (/\s/.test(char) && textToBackTrack[i] === startAngle) {
+			i--;
+			continue;
+		}
+		if (char !== startAngle && char !== endAngle) {
+			continue;
+		}
+		if (i >= 0 && textToBackTrack[i] === escape) {
+			i--;
+			continue;
+		}
+		if (char === endAngle) {
+			if (i >= 0 && textToBackTrack[i] === '=') {
+				continue; // False alarm of cases like =>
+			} else {
+				break;
+			}
+		}
+		if (char === startAngle) {
+			valid = !foundSpace;
+			break;
+		}
+	}
+
+	return valid;
+}
+
+export async function getSyntaxFromArgs(context: vscode.ServiceContext, args: { [x: string]: string; }): Promise<string | undefined> {
+	const mappedModes = await getMappingForIncludedLanguages(context);
+	const language: string = args['language'];
+	const parentMode: string = args['parentMode'];
+	const excludedLanguages = await context.env.getConfiguration<string[]>?.('emmet.excludeLanguages') ?? [];
+	if (excludedLanguages.includes(language)) {
+		return;
+	}
+
+	let syntax = getEmmetMode(mappedModes[language] ?? language, mappedModes, excludedLanguages);
+	if (!syntax) {
+		syntax = getEmmetMode(mappedModes[parentMode] ?? parentMode, mappedModes, excludedLanguages);
+	}
+
+	return syntax;
+}
diff --git a/packages/emmet/lib/bufferStream.ts b/packages/emmet/lib/bufferStream.ts
new file mode 100644
index 0000000..36d057f
--- /dev/null
+++ b/packages/emmet/lib/bufferStream.ts
@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* Based on @sergeche's work in his emmet plugin */
+
+import type { TextDocument } from '@volar/language-service';
+
+/**
+ * A stream reader for VSCode's `TextDocument`
+ * Based on @emmetio/stream-reader and @emmetio/atom-plugin
+ */
+export class DocumentStreamReader {
+	private document: TextDocument;
+	private start: number;
+	private _eof: number;
+	private _sof: number;
+	public pos: number;
+
+	constructor(document: TextDocument, pos?: number, limit?: [number, number]) {
+		this.document = document;
+		this.start = this.pos = pos ? pos : 0;
+		this._sof = limit ? limit[0] : 0;
+		this._eof = limit ? limit[1] : document.getText().length;
+	}
+
+	/**
+	 * Returns true only if the stream is at the start of the file.
+	 */
+	sof(): boolean {
+		return this.pos <= this._sof;
+	}
+
+	/**
+	 * Returns true only if the stream is at the end of the file.
+	 */
+	eof(): boolean {
+		return this.pos >= this._eof;
+	}
+
+	/**
+	 * Creates a new stream instance which is limited to given range for given document
+	 */
+	limit(start: number, end: number): DocumentStreamReader {
+		return new DocumentStreamReader(this.document, start, [start, end]);
+	}
+
+	/**
+	 * Returns the next character code in the stream without advancing it.
+	 * Will return NaN at the end of the file.
+	 */
+	peek(): number {
+		if (this.eof()) {
+			return NaN;
+		}
+		return this.document.getText().charCodeAt(this.pos);
+	}
+
+	/**
+	 * Returns the next character in the stream and advances it.
+	 * Also returns NaN when no more characters are available.
+	 */
+	next(): number {
+		if (this.eof()) {
+			return NaN;
+		}
+
+		const code = this.document.getText().charCodeAt(this.pos);
+		this.pos++;
+
+		if (this.eof()) {
+			// restrict pos to eof, if in case it got moved beyond eof
+			this.pos = this._eof;
+		}
+
+		return code;
+	}
+
+	/**
+	 * Backs up the stream n characters. Backing it up further than the
+	 * start of the current token will cause things to break, so be careful.
+	 */
+	backUp(n: number): number {
+		this.pos -= n;
+		if (this.pos < 0) {
+			this.pos = 0;
+		}
+		return this.peek();
+	}
+
+	/**
+	 * Get the string between the start of the current token and the
+	 * current stream position.
+	 */
+	current(): string {
+		return this.substring(this.start, this.pos);
+	}
+
+	/**
+	 * Returns contents for given range
+	 */
+	substring(from: number, to: number): string {
+		return this.document.getText().substring(from, to);
+	}
+
+	/**
+	 * Creates error object with current stream state
+	 */
+	error(message: string): Error {
+		const err = new Error(`${message} at offset ${this.pos}`);
+		return err;
+	}
+
+	/**
+	 * `match` can be a character code or a function that takes a character code
+	 * and returns a boolean. If the next character in the stream 'matches'
+	 * the given argument, it is consumed and returned.
+	 * Otherwise, `false` is returned.
+	 */
+	eat(match: number | Function): boolean {
+		const ch = this.peek();
+		const ok = typeof match === 'function' ? match(ch) : ch === match;
+
+		if (ok) {
+			this.next();
+		}
+
+		return ok;
+	}
+
+	/**
+	 * Repeatedly calls <code>eat</code> with the given argument, until it
+	 * fails. Returns <code>true</code> if any characters were eaten.
+	 */
+	eatWhile(match: number | Function): boolean {
+		const start = this.pos;
+		while (!this.eof() && this.eat(match)) { }
+		return this.pos !== start;
+	}
+}
diff --git a/packages/emmet/lib/parseDocument.ts b/packages/emmet/lib/parseDocument.ts
new file mode 100644
index 0000000..c3e0754
--- /dev/null
+++ b/packages/emmet/lib/parseDocument.ts
@@ -0,0 +1,36 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { TextDocument } from '@volar/language-service';
+import type { Node as FlatNode } from 'EmmetFlatNode';
+import parse from '@emmetio/html-matcher';
+import parseStylesheet from '@emmetio/css-parser';
+import { isStyleSheet } from './util';
+
+type Pair<K, V> = {
+	key: K;
+	value: V;
+};
+
+// Map(filename, Pair(fileVersion, rootNodeOfParsedContent))
+const _parseCache = new Map<string, Pair<number, FlatNode> | undefined>();
+
+export function getRootNode(document: TextDocument, useCache: boolean): FlatNode {
+	const key = document.uri.toString();
+	const result = _parseCache.get(key);
+	const documentVersion = document.version;
+	if (useCache && result) {
+		if (documentVersion === result.key) {
+			return result.value;
+		}
+	}
+
+	const parseContent = isStyleSheet(document.languageId) ? parseStylesheet : parse;
+	const rootNode = parseContent(document.getText());
+	if (useCache) {
+		_parseCache.set(key, { key: documentVersion, value: rootNode });
+	}
+	return rootNode;
+}
diff --git a/packages/emmet/lib/typings/EmmetFlatNode.d.ts b/packages/emmet/lib/typings/EmmetFlatNode.d.ts
new file mode 100644
index 0000000..f295f0c
--- /dev/null
+++ b/packages/emmet/lib/typings/EmmetFlatNode.d.ts
@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+declare module 'EmmetFlatNode' {
+	export interface Node {
+		start: number;
+		end: number;
+		type: string;
+		parent: Node | undefined;
+		firstChild: Node | undefined;
+		nextSibling: Node | undefined;
+		previousSibling: Node | undefined;
+		children: Node[];
+	}
+
+	export interface Token {
+		start: number;
+		end: number;
+		stream: BufferStream;
+		toString(): string;
+	}
+
+	export interface CssToken extends Token {
+		size: number;
+		item(number: number): any;
+		type: string;
+	}
+
+	export interface HtmlToken extends Token {
+		value: string;
+	}
+
+	export interface Attribute extends Token {
+		name: Token;
+		value: Token;
+	}
+
+	export interface HtmlNode extends Node {
+		name: string;
+		open: Token | undefined;
+		close: Token | undefined;
+		parent: HtmlNode | undefined;
+		firstChild: HtmlNode | undefined;
+		nextSibling: HtmlNode | undefined;
+		previousSibling: HtmlNode | undefined;
+		children: HtmlNode[];
+		attributes: Attribute[];
+	}
+
+	export interface CssNode extends Node {
+		name: string;
+		parent: CssNode | undefined;
+		firstChild: CssNode | undefined;
+		nextSibling: CssNode | undefined;
+		previousSibling: CssNode | undefined;
+		children: CssNode[];
+	}
+
+	export interface Rule extends CssNode {
+		selectorToken: Token;
+		contentStartToken: Token;
+		contentEndToken: Token;
+	}
+
+	export interface Property extends CssNode {
+		valueToken: Token;
+		separator: string;
+		parent: Rule;
+		terminatorToken: Token;
+		separatorToken: Token;
+		value: string;
+	}
+
+	export interface Stylesheet extends Node {
+		comments: Token[];
+	}
+
+	export interface BufferStream {
+		peek(): number;
+		next(): number;
+		backUp(n: number): number;
+		current(): string;
+		substring(from: number, to: number): string;
+		eat(match: any): boolean;
+		eatWhile(match: any): boolean;
+	}
+}
diff --git a/packages/emmet/lib/typings/EmmetNode.d.ts b/packages/emmet/lib/typings/EmmetNode.d.ts
new file mode 100644
index 0000000..c381b09
--- /dev/null
+++ b/packages/emmet/lib/typings/EmmetNode.d.ts
@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+declare module 'EmmetNode' {
+	import { Position } from 'vscode';
+
+	export interface Node {
+		start: Position;
+		end: Position;
+		type: string;
+		parent: Node;
+		firstChild: Node;
+		nextSibling: Node;
+		previousSibling: Node;
+		children: Node[];
+	}
+
+	export interface Token {
+		start: Position;
+		end: Position;
+		stream: BufferStream;
+		toString(): string;
+	}
+
+	export interface CssToken extends Token {
+		size: number;
+		item(number: number): any;
+		type: string;
+	}
+
+	export interface HtmlToken extends Token {
+		value: string;
+	}
+
+	export interface Attribute extends Token {
+		name: Token;
+		value: Token;
+	}
+
+	export interface HtmlNode extends Node {
+		name: string;
+		open: Token;
+		close: Token;
+		parent: HtmlNode;
+		firstChild: HtmlNode;
+		nextSibling: HtmlNode;
+		previousSibling: HtmlNode;
+		children: HtmlNode[];
+		attributes: Attribute[];
+	}
+
+	export interface CssNode extends Node {
+		name: string;
+		parent: CssNode;
+		firstChild: CssNode;
+		nextSibling: CssNode;
+		previousSibling: CssNode;
+		children: CssNode[];
+	}
+
+	export interface Rule extends CssNode {
+		selectorToken: Token;
+		contentStartToken: Token;
+		contentEndToken: Token;
+	}
+
+	export interface Property extends CssNode {
+		valueToken: Token;
+		separator: string;
+		parent: Rule;
+		terminatorToken: Token;
+		separatorToken: Token;
+		value: string;
+	}
+
+	export interface Stylesheet extends Node {
+		comments: Token[];
+	}
+
+	export interface BufferStream {
+		peek(): number;
+		next(): number;
+		backUp(n: number): number;
+		current(): string;
+		substring(from: Position, to: Position): string;
+		eat(match: any): boolean;
+		eatWhile(match: any): boolean;
+	}
+}
diff --git a/packages/emmet/lib/typings/emmetio__css-parser.d.ts b/packages/emmet/lib/typings/emmetio__css-parser.d.ts
new file mode 100644
index 0000000..16c739d
--- /dev/null
+++ b/packages/emmet/lib/typings/emmetio__css-parser.d.ts
@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+declare module '@emmetio/css-parser' {
+	import { BufferStream, Stylesheet } from 'EmmetNode';
+	import { Stylesheet as FlatStylesheet } from 'EmmetFlatNode';
+
+	function parseStylesheet(stream: BufferStream): Stylesheet;
+	function parseStylesheet(stream: string): FlatStylesheet;
+
+	export default parseStylesheet;
+}
diff --git a/packages/emmet/lib/typings/emmetio__html-matcher.d.ts b/packages/emmet/lib/typings/emmetio__html-matcher.d.ts
new file mode 100644
index 0000000..69ac6fe
--- /dev/null
+++ b/packages/emmet/lib/typings/emmetio__html-matcher.d.ts
@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+declare module '@emmetio/html-matcher' {
+	import { BufferStream, HtmlNode } from 'EmmetNode';
+	import { HtmlNode as HtmlFlatNode } from 'EmmetFlatNode';
+
+	function parse(stream: BufferStream): HtmlNode;
+	function parse(stream: string): HtmlFlatNode;
+
+	export default parse;
+}
diff --git a/packages/emmet/lib/typings/refs.d.ts b/packages/emmet/lib/typings/refs.d.ts
new file mode 100644
index 0000000..8ea9f80
--- /dev/null
+++ b/packages/emmet/lib/typings/refs.d.ts
@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference types='@types/node'/>
diff --git a/packages/emmet/lib/util.ts b/packages/emmet/lib/util.ts
new file mode 100644
index 0000000..a3d91bf
--- /dev/null
+++ b/packages/emmet/lib/util.ts
@@ -0,0 +1,429 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import parseStylesheet from '@emmetio/css-parser';
+import parse from '@emmetio/html-matcher';
+import type * as vscode from '@volar/language-service';
+import type * as EmmetHelper from '@vscode/emmet-helper';
+import type { Node as FlatNode, Stylesheet as FlatStylesheet, HtmlNode as HtmlFlatNode } from 'EmmetFlatNode';
+import { DocumentStreamReader } from './bufferStream';
+
+let _emmetHelper: typeof EmmetHelper;
+
+export function getEmmetHelper() {
+	// Lazy load vscode-emmet-helper instead of importing it
+	// directly to reduce the start-up time of the extension
+	if (!_emmetHelper) {
+		_emmetHelper = require('@vscode/emmet-helper');
+	}
+	return _emmetHelper;
+}
+
+/**
+ * Mapping between languages that support Emmet and completion trigger characters
+ */
+const LANGUAGE_MODES: { [id: string]: string[]; } = {
+	'html': ['!', '.', '}', ':', '*', '$', ']', '/', '>', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'jade': ['!', '.', '}', ':', '*', '$', ']', '/', '>', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'slim': ['!', '.', '}', ':', '*', '$', ']', '/', '>', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'haml': ['!', '.', '}', ':', '*', '$', ']', '/', '>', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'xml': ['.', '}', '*', '$', ']', '/', '>', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'xsl': ['!', '.', '}', '*', '$', '/', ']', '>', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'css': [':', '!', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'scss': [':', '!', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'sass': [':', '!', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'less': [':', '!', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'stylus': [':', '!', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'javascriptreact': ['!', '.', '}', '*', '$', ']', '/', '>', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+	'typescriptreact': ['!', '.', '}', '*', '$', ']', '/', '>', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+};
+
+export function isStyleSheet(syntax: string): boolean {
+	const stylesheetSyntaxes = ['css', 'scss', 'sass', 'less', 'stylus'];
+	return stylesheetSyntaxes.includes(syntax);
+}
+
+export async function getMappingForIncludedLanguages(context: vscode.ServiceContext): Promise<Record<string, string>> {
+	// Explicitly map languages that have built-in grammar in VS Code to their parent language
+	// to get emmet completion support
+	// For other languages, users will have to use `emmet.includeLanguages` or
+	// language specific extensions can provide emmet completion support
+	const MAPPED_MODES: Record<string, string> = {
+		'handlebars': 'html',
+		'php': 'html'
+	};
+
+	const finalMappedModes: Record<string, string> = {};
+	const includeLanguagesConfig = await context.env.getConfiguration?.<Record<string, string>>('emmet.includeLanguages');
+	const includeLanguages = Object.assign({}, MAPPED_MODES, includeLanguagesConfig ?? {});
+	Object.keys(includeLanguages).forEach(syntax => {
+		if (typeof includeLanguages[syntax] === 'string' && LANGUAGE_MODES[includeLanguages[syntax]]) {
+			finalMappedModes[syntax] = includeLanguages[syntax];
+		}
+	});
+	return finalMappedModes;
+}
+
+/**
+* Get the corresponding emmet mode for given vscode language mode
+* E.g.: jsx for typescriptreact/javascriptreact or pug for jade
+* If the language is not supported by emmet or has been excluded via `excludeLanguages` setting,
+* then nothing is returned
+*
+* @param excludedLanguages Array of language ids that user has chosen to exclude for emmet
+*/
+export function getEmmetMode(language: string, mappedModes: Record<string, string>, excludedLanguages: string[]): string | undefined {
+	if (!language || excludedLanguages.includes(language)) {
+		return;
+	}
+
+	if (language === 'jsx-tags') {
+		language = 'javascriptreact';
+	}
+
+	if (mappedModes[language]) {
+		language = mappedModes[language];
+	}
+
+	if (/\b(typescriptreact|javascriptreact|jsx-tags)\b/.test(language)) { // treat tsx like jsx
+		language = 'jsx';
+	}
+	else if (language === 'sass-indented') { // map sass-indented to sass
+		language = 'sass';
+	}
+	else if (language === 'jade' || language === 'pug') {
+		language = 'pug';
+	}
+
+	const syntaxes = getSyntaxes();
+	if (syntaxes.markup.includes(language) || syntaxes.stylesheet.includes(language)) {
+		return language;
+	}
+	return;
+}
+
+const closeBrace = 125;
+const openBrace = 123;
+const slash = 47;
+const star = 42;
+
+/**
+ * Traverse the given document backward & forward from given position
+ * to find a complete ruleset, then parse just that to return a Stylesheet
+ * @param document TextDocument
+ * @param position vscode.Position
+ */
+export function parsePartialStylesheet(document: vscode.TextDocument, position: vscode.Position): FlatStylesheet | undefined {
+	const isCSS = document.languageId === 'css';
+	const positionOffset = document.offsetAt(position);
+	let startOffset = 0;
+	let endOffset = document.getText().length;
+	const limitCharacter = positionOffset - 5000;
+	const limitOffset = limitCharacter > 0 ? limitCharacter : startOffset;
+	const stream = new DocumentStreamReader(document, positionOffset);
+
+	function findOpeningCommentBeforePosition(pos: number): number | undefined {
+		const text = document.getText().substring(0, pos);
+		const offset = text.lastIndexOf('/*');
+		if (offset === -1) {
+			return;
+		}
+		return offset;
+	}
+
+	function findClosingCommentAfterPosition(pos: number): number | undefined {
+		const text = document.getText().substring(pos);
+		let offset = text.indexOf('*/');
+		if (offset === -1) {
+			return;
+		}
+		offset += 2 + pos;
+		return offset;
+	}
+
+	function consumeLineCommentBackwards() {
+		const posLineNumber = document.positionAt(stream.pos).line;
+		if (!isCSS && currentLine !== posLineNumber) {
+			currentLine = posLineNumber;
+			const startLineComment = document.getText({
+				start: { line: currentLine, character: 0 },
+				end: { line: currentLine + 1, character: 0 },
+			}).indexOf('//');
+			if (startLineComment > -1) {
+				stream.pos = document.offsetAt({ line: currentLine, character: startLineComment });
+			}
+		}
+	}
+
+	function consumeBlockCommentBackwards() {
+		if (!stream.sof() && stream.peek() === slash) {
+			if (stream.backUp(1) === star) {
+				stream.pos = findOpeningCommentBeforePosition(stream.pos) ?? startOffset;
+			} else {
+				stream.next();
+			}
+		}
+	}
+
+	function consumeCommentForwards() {
+		if (stream.eat(slash)) {
+			if (stream.eat(slash) && !isCSS) {
+				const posLineNumber = document.positionAt(stream.pos).line;
+				stream.pos = document.offsetAt({ line: posLineNumber + 1, character: 0 });
+			} else if (stream.eat(star)) {
+				stream.pos = findClosingCommentAfterPosition(stream.pos) ?? endOffset;
+			}
+		}
+	}
+
+	// Go forward until we find a closing brace.
+	while (!stream.eof() && !stream.eat(closeBrace)) {
+		if (stream.peek() === slash) {
+			consumeCommentForwards();
+		} else {
+			stream.next();
+		}
+	}
+
+	if (!stream.eof()) {
+		endOffset = stream.pos;
+	}
+
+	stream.pos = positionOffset;
+	let openBracesToFind = 1;
+	let currentLine = position.line;
+	let exit = false;
+
+	// Go back until we found an opening brace. If we find a closing one, consume its pair and continue.
+	while (!exit && openBracesToFind > 0 && !stream.sof()) {
+		consumeLineCommentBackwards();
+
+		switch (stream.backUp(1)) {
+			case openBrace:
+				openBracesToFind--;
+				break;
+			case closeBrace:
+				if (isCSS) {
+					stream.next();
+					startOffset = stream.pos;
+					exit = true;
+				} else {
+					openBracesToFind++;
+				}
+				break;
+			case slash:
+				consumeBlockCommentBackwards();
+				break;
+			default:
+				break;
+		}
+
+		if (position.line - document.positionAt(stream.pos).line > 100
+			|| stream.pos <= limitOffset) {
+			exit = true;
+		}
+	}
+
+	// We are at an opening brace. We need to include its selector.
+	currentLine = document.positionAt(stream.pos).line;
+	openBracesToFind = 0;
+	let foundSelector = false;
+	while (!exit && !stream.sof() && !foundSelector && openBracesToFind >= 0) {
+		consumeLineCommentBackwards();
+
+		const ch = stream.backUp(1);
+		if (/\s/.test(String.fromCharCode(ch))) {
+			continue;
+		}
+
+		switch (ch) {
+			case slash:
+				consumeBlockCommentBackwards();
+				break;
+			case closeBrace:
+				openBracesToFind++;
+				break;
+			case openBrace:
+				openBracesToFind--;
+				break;
+			default:
+				if (!openBracesToFind) {
+					foundSelector = true;
+				}
+				break;
+		}
+
+		if (!stream.sof() && foundSelector) {
+			startOffset = stream.pos;
+		}
+	}
+
+	try {
+		const buffer = ' '.repeat(startOffset) + document.getText().substring(startOffset, endOffset);
+		return parseStylesheet(buffer);
+	} catch (e) {
+		return;
+	}
+}
+
+/**
+ * Returns node corresponding to given position in the given root node
+ */
+export function getFlatNode(root: FlatNode | undefined, offset: number, includeNodeBoundary: boolean): FlatNode | undefined {
+	if (!root) {
+		return;
+	}
+
+	function getFlatNodeChild(child: FlatNode | undefined): FlatNode | undefined {
+		if (!child) {
+			return;
+		}
+		const nodeStart = child.start;
+		const nodeEnd = child.end;
+		if ((nodeStart < offset && nodeEnd > offset)
+			|| (includeNodeBoundary && nodeStart <= offset && nodeEnd >= offset)) {
+			return getFlatNodeChildren(child.children) ?? child;
+		}
+		else if ('close' in <any>child) {
+			// We have an HTML node in this case.
+			// In case this node is an invalid unpaired HTML node,
+			// we still want to search its children
+			const htmlChild = <HtmlFlatNode>child;
+			if (htmlChild.open && !htmlChild.close) {
+				return getFlatNodeChildren(htmlChild.children);
+			}
+		}
+		return;
+	}
+
+	function getFlatNodeChildren(children: FlatNode[]): FlatNode | undefined {
+		for (let i = 0; i < children.length; i++) {
+			const foundChild = getFlatNodeChild(children[i]);
+			if (foundChild) {
+				return foundChild;
+			}
+		}
+		return;
+	}
+
+	return getFlatNodeChildren(root.children);
+}
+
+export const allowedMimeTypesInScriptTag = ['text/html', 'text/plain', 'text/x-template', 'text/template', 'text/ng-template'];
+
+/**
+ * Finds the HTML node within an HTML document at a given position
+ * If position is inside a script tag of type template, then it will be parsed to find the inner HTML node as well
+ */
+export function getHtmlFlatNode(documentText: string, root: FlatNode | undefined, offset: number, includeNodeBoundary: boolean): HtmlFlatNode | undefined {
+	let currentNode: HtmlFlatNode | undefined = <HtmlFlatNode | undefined>getFlatNode(root, offset, includeNodeBoundary);
+	if (!currentNode) { return; }
+
+	// If the currentNode is a script one, first set up its subtree and then find HTML node.
+	if (currentNode.name === 'script' && currentNode.children.length === 0) {
+		const scriptNodeBody = setupScriptNodeSubtree(documentText, currentNode);
+		if (scriptNodeBody) {
+			currentNode = getHtmlFlatNode(scriptNodeBody, currentNode, offset, includeNodeBoundary) ?? currentNode;
+		}
+	}
+	else if (currentNode.type === 'cdata') {
+		const cdataBody = setupCdataNodeSubtree(documentText, currentNode);
+		currentNode = getHtmlFlatNode(cdataBody, currentNode, offset, includeNodeBoundary) ?? currentNode;
+	}
+	return currentNode;
+}
+
+function setupScriptNodeSubtree(documentText: string, scriptNode: HtmlFlatNode): string {
+	const isTemplateScript = scriptNode.name === 'script' &&
+		(scriptNode.attributes &&
+			scriptNode.attributes.some(x => x.name.toString() === 'type'
+				&& allowedMimeTypesInScriptTag.includes(x.value.toString())));
+	if (isTemplateScript
+		&& scriptNode.open) {
+		// blank out the rest of the document and generate the subtree.
+		const beforePadding = ' '.repeat(scriptNode.open.end);
+		const endToUse = scriptNode.close ? scriptNode.close.start : scriptNode.end;
+		const scriptBodyText = beforePadding + documentText.substring(scriptNode.open.end, endToUse);
+		const innerRoot: HtmlFlatNode = parse(scriptBodyText);
+		innerRoot.children.forEach(child => {
+			scriptNode.children.push(child);
+			child.parent = scriptNode;
+		});
+		return scriptBodyText;
+	}
+	return '';
+}
+
+function setupCdataNodeSubtree(documentText: string, cdataNode: HtmlFlatNode): string {
+	// blank out the rest of the document and generate the subtree.
+	const cdataStart = '<![CDATA[';
+	const cdataEnd = ']]>';
+	const startToUse = cdataNode.start + cdataStart.length;
+	const endToUse = cdataNode.end - cdataEnd.length;
+	const beforePadding = ' '.repeat(startToUse);
+	const cdataBody = beforePadding + documentText.substring(startToUse, endToUse);
+	const innerRoot: HtmlFlatNode = parse(cdataBody);
+	innerRoot.children.forEach(child => {
+		cdataNode.children.push(child);
+		child.parent = cdataNode;
+	});
+	return cdataBody;
+}
+
+export async function getEmmetConfiguration(context: vscode.ServiceContext, syntax: string) {
+	const emmetConfig = await context.env.getConfiguration<any>?.('emmet') ?? {};
+	const syntaxProfiles = Object.assign({}, emmetConfig['syntaxProfiles'] || {});
+	const preferences = Object.assign({}, emmetConfig['preferences'] || {});
+	// jsx, xml and xsl syntaxes need to have self closing tags unless otherwise configured by user
+	if (syntax === 'jsx' || syntax === 'xml' || syntax === 'xsl') {
+		syntaxProfiles[syntax] = syntaxProfiles[syntax] || {};
+		if (typeof syntaxProfiles[syntax] === 'object'
+			&& !syntaxProfiles[syntax].hasOwnProperty('self_closing_tag') // Old Emmet format
+			&& !syntaxProfiles[syntax].hasOwnProperty('selfClosingStyle') // Emmet 2.0 format
+		) {
+			syntaxProfiles[syntax] = {
+				...syntaxProfiles[syntax],
+				selfClosingStyle: syntax === 'jsx' ? 'xhtml' : 'xml'
+			};
+		}
+	}
+
+	return {
+		preferences,
+		showExpandedAbbreviation: emmetConfig['showExpandedAbbreviation'],
+		showAbbreviationSuggestions: emmetConfig['showAbbreviationSuggestions'],
+		syntaxProfiles,
+		variables: emmetConfig['variables'],
+		excludeLanguages: emmetConfig['excludeLanguages'],
+		showSuggestionsAsSnippets: emmetConfig['showSuggestionsAsSnippets']
+	};
+}
+
+export function getEmbeddedCssNodeIfAny(document: vscode.TextDocument, currentNode: FlatNode | undefined, position: vscode.Position): FlatNode | undefined {
+	if (!currentNode) {
+		return;
+	}
+	const currentHtmlNode = <HtmlFlatNode>currentNode;
+	if (currentHtmlNode && currentHtmlNode.open && currentHtmlNode.close) {
+		const offset = document.offsetAt(position);
+		if (currentHtmlNode.open.end < offset && offset <= currentHtmlNode.close.start) {
+			if (currentHtmlNode.name === 'style') {
+				const buffer = ' '.repeat(currentHtmlNode.open.end) + document.getText().substring(currentHtmlNode.open.end, currentHtmlNode.close.start);
+				return parseStylesheet(buffer);
+			}
+		}
+	}
+	return;
+}
+
+function getSyntaxes() {
+	/**
+	 * List of all known syntaxes, from emmetio/emmet
+	 */
+	return {
+		markup: ['html', 'xml', 'xsl', 'jsx', 'js', 'pug', 'slim', 'haml'],
+		stylesheet: ['css', 'sass', 'scss', 'less', 'sss', 'stylus']
+	};
+}
diff --git a/packages/emmet/package.json b/packages/emmet/package.json
index 2db0000..25b990f 100644
--- a/packages/emmet/package.json
+++ b/packages/emmet/package.json
@@ -24,8 +24,12 @@
 		"url": "https://github.com/johnsoncodehk"
 	},
 	"dependencies": {
-		"@vscode/emmet-helper": "^2.9.2",
-		"vscode-html-languageservice": "npm:@johnsoncodehk/vscode-html-languageservice@5.2.0-34a5462"
+		"@emmetio/css-parser": "^0.4.0",
+		"@emmetio/html-matcher": "^1.3.0",
+		"@vscode/emmet-helper": "^2.9.2"
+	},
+	"devDependencies": {
+		"@types/node": "latest"
 	},
 	"peerDependencies": {
 		"@volar/language-service": "~2.2.0"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 2f3cb7f..cb84c0d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -54,15 +54,22 @@ importers:
 
   packages/emmet:
     dependencies:
+      '@emmetio/css-parser':
+        specifier: ^0.4.0
+        version: 0.4.0
+      '@emmetio/html-matcher':
+        specifier: ^1.3.0
+        version: 1.3.0
       '@volar/language-service':
         specifier: ~2.2.0
         version: 2.2.1
       '@vscode/emmet-helper':
         specifier: ^2.9.2
         version: 2.9.3
-      vscode-html-languageservice:
-        specifier: npm:@johnsoncodehk/vscode-html-languageservice@5.2.0-34a5462
-        version: '@johnsoncodehk/vscode-html-languageservice@5.2.0-34a5462'
+    devDependencies:
+      '@types/node':
+        specifier: latest
+        version: 20.12.12
 
   packages/html:
     dependencies:
@@ -294,9 +301,21 @@ packages:
   '@emmetio/css-abbreviation@2.1.8':
     resolution: {integrity: sha512-s9yjhJ6saOO/uk1V74eifykk2CBYi01STTK3WlXWGOepyKa23ymJ053+DNQjpFcy1ingpaO7AxCcwLvHFY9tuw==}
 
+  '@emmetio/css-parser@0.4.0':
+    resolution: {integrity: sha512-z7wkxRSZgrQHXVzObGkXG+Vmj3uRlpM11oCZ9pbaz0nFejvCDmAiNDpY75+wgXOcffKpj4rzGtwGaZxfJKsJxw==}
+
+  '@emmetio/html-matcher@1.3.0':
+    resolution: {integrity: sha512-NTbsvppE5eVyBMuyGfVu2CRrLvo7J4YHb6t9sBFLyY03WYhXET37qA4zOYUjBWFCRHO7pS1B9khERtY0f5JXPQ==}
+
   '@emmetio/scanner@1.0.4':
     resolution: {integrity: sha512-IqRuJtQff7YHHBk4G8YZ45uB9BaAGcwQeVzgj/zj8/UdOhtQpEIupUhSk8dys6spFIWVZVeK20CzGEnqR5SbqA==}
 
+  '@emmetio/stream-reader-utils@0.1.0':
+    resolution: {integrity: sha512-ZsZ2I9Vzso3Ho/pjZFsmmZ++FWeEd/txqybHTm4OgaZzdS8V9V/YYWQwg5TC38Z7uLWUV1vavpLLbjJtKubR1A==}
+
+  '@emmetio/stream-reader@2.2.0':
+    resolution: {integrity: sha512-fXVXEyFA5Yv3M3n8sUGT7+fvecGrZP4k6FnWWMSZVQf69kAq0LLpaBQLGcPR30m3zMmKYhECP4k/ZkzvhEW5kw==}
+
   '@esbuild/aix-ppc64@0.19.12':
     resolution: {integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==}
     engines: {node: '>=12'}
@@ -756,6 +775,9 @@ packages:
   '@types/node@20.12.11':
     resolution: {integrity: sha512-vDg9PZ/zi+Nqp6boSOT7plNuthRugEKixDv5sFTIpkE89MmNtEArAShI4mxuX2+UrLEe9pxC1vm2cjm9YlWbJw==}
 
+  '@types/node@20.12.12':
+    resolution: {integrity: sha512-eWLDGF/FOSPtAvEqeRAQ4C8LSA7M1I7i0ky1I8U7kD1J5ITyW3AsRhQrKVoWf5pFKZ2kILsEGJhsI9r93PYnOw==}
+
   '@types/normalize-package-data@2.4.4':
     resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==}
 
@@ -3461,8 +3483,21 @@ snapshots:
     dependencies:
       '@emmetio/scanner': 1.0.4
 
+  '@emmetio/css-parser@0.4.0':
+    dependencies:
+      '@emmetio/stream-reader': 2.2.0
+      '@emmetio/stream-reader-utils': 0.1.0
+
+  '@emmetio/html-matcher@1.3.0':
+    dependencies:
+      '@emmetio/scanner': 1.0.4
+
   '@emmetio/scanner@1.0.4': {}
 
+  '@emmetio/stream-reader-utils@0.1.0': {}
+
+  '@emmetio/stream-reader@2.2.0': {}
+
   '@esbuild/aix-ppc64@0.19.12':
     optional: true
 
@@ -4089,7 +4124,7 @@ snapshots:
 
   '@types/keyv@3.1.4':
     dependencies:
-      '@types/node': 20.12.11
+      '@types/node': 20.12.12
 
   '@types/linkify-it@3.0.5': {}
 
@@ -4104,13 +4139,17 @@ snapshots:
     dependencies:
       undici-types: 5.26.5
 
+  '@types/node@20.12.12':
+    dependencies:
+      undici-types: 5.26.5
+
   '@types/normalize-package-data@2.4.4': {}
 
   '@types/path-browserify@1.0.2': {}
 
   '@types/responselike@1.0.3':
     dependencies:
-      '@types/node': 20.12.11
+      '@types/node': 20.12.12
 
   '@types/semver@7.5.8': {}
 
@@ -4124,7 +4163,7 @@ snapshots:
 
   '@types/vfile@3.0.2':
     dependencies:
-      '@types/node': 20.12.11
+      '@types/node': 20.12.12
       '@types/unist': 2.0.10
       '@types/vfile-message': 2.0.0