diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index ebfb6cd6a7..c0188f0e65 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -6,6 +6,9 @@
 trigger:
 - master
 
+pr:
+- master
+
 strategy:
   matrix:
     linux:
@@ -41,7 +44,13 @@ steps:
     fi
   displayName: Start xvfb
 
-- bash: yarn test
-  displayName: Run Tests
+- bash: yarn test:server
+  displayName: Run Server Tests
+  continueOnError: true
+  env:
+    DISPLAY: :10
+
+- bash: yarn test:e2e
+  displayName: Run E2E Tests
   env:
     DISPLAY: :10
\ No newline at end of file
diff --git a/server/src/embeddedSupport/languageModelCache.ts b/server/src/embeddedSupport/languageModelCache.ts
index 236e8afb8c..99b4d032f1 100644
--- a/server/src/embeddedSupport/languageModelCache.ts
+++ b/server/src/embeddedSupport/languageModelCache.ts
@@ -1,7 +1,12 @@
 import { TextDocument } from 'vscode-languageserver';
 
 export interface LanguageModelCache<T> {
-  get(document: TextDocument): T;
+  /**
+   * - Feed updated document
+   * - Use `parse` function to re-compute model
+   * - Return re-computed model
+   */
+  refreshAndGet(document: TextDocument): T;
   onDocumentRemoved(document: TextDocument): void;
   dispose(): void;
 }
@@ -30,7 +35,7 @@ export function getLanguageModelCache<T>(
   }
 
   return {
-    get(document: TextDocument): T {
+    refreshAndGet(document: TextDocument): T {
       const version = document.version;
       const languageId = document.languageId;
       const languageModelInfo = languageModels[document.uri];
diff --git a/server/src/embeddedSupport/languageModes.ts b/server/src/embeddedSupport/languageModes.ts
index 0a1ceabc2f..58b8a3e10f 100644
--- a/server/src/embeddedSupport/languageModes.ts
+++ b/server/src/embeddedSupport/languageModes.ts
@@ -111,11 +111,14 @@ export class LanguageModes {
       }
     }
 
-    const jsDocuments = getLanguageModelCache(10, 60, document => {
-      const vueDocument = this.documentRegions.get(document);
+    /**
+     * Documents where everything outside `<script>~ is replaced with whitespace
+     */
+    const scriptRegionDocuments = getLanguageModelCache(10, 60, document => {
+      const vueDocument = this.documentRegions.refreshAndGet(document);
       return vueDocument.getSingleTypeDocument('script');
     });
-    this.serviceHost = getServiceHost(tsModule, workspacePath, jsDocuments);
+    this.serviceHost = getServiceHost(tsModule, workspacePath, scriptRegionDocuments);
 
     const vueHtmlMode = new VueHTMLMode(
       tsModule,
@@ -145,14 +148,14 @@ export class LanguageModes {
   }
 
   getModeAtPosition(document: TextDocument, position: Position): LanguageMode | undefined {
-    const languageId = this.documentRegions.get(document).getLanguageAtPosition(position);
+    const languageId = this.documentRegions.refreshAndGet(document).getLanguageAtPosition(position);
     return this.modes[languageId];
   }
 
   getAllLanguageModeRangesInDocument(document: TextDocument): LanguageModeRange[] {
     const result: LanguageModeRange[] = [];
 
-    const documentRegions = this.documentRegions.get(document);
+    const documentRegions = this.documentRegions.refreshAndGet(document);
 
     documentRegions.getAllLanguageRanges().forEach(lr => {
       const mode = this.modes[lr.languageId];
diff --git a/server/src/modes/script/javascript.ts b/server/src/modes/script/javascript.ts
index 5d5975f9fb..fa78b15091 100644
--- a/server/src/modes/script/javascript.ts
+++ b/server/src/modes/script/javascript.ts
@@ -59,12 +59,12 @@ export async function getJavascriptMode(
     };
   }
   const jsDocuments = getLanguageModelCache(10, 60, document => {
-    const vueDocument = documentRegions.get(document);
+    const vueDocument = documentRegions.refreshAndGet(document);
     return vueDocument.getSingleTypeDocument('script');
   });
 
   const firstScriptRegion = getLanguageModelCache(10, 60, document => {
-    const vueDocument = documentRegions.get(document);
+    const vueDocument = documentRegions.refreshAndGet(document);
     const scriptRegions = vueDocument.getLanguageRangesOfType('script');
     return scriptRegions.length > 0 ? scriptRegions[0] : undefined;
   });
@@ -77,7 +77,7 @@ export async function getJavascriptMode(
     }
   }
 
-  const { updateCurrentTextDocument } = serviceHost;
+  const { updateCurrentVueTextDocument } = serviceHost;
   let config: any = {};
   let supportedCodeFixCodes: Set<number>;
 
@@ -93,7 +93,7 @@ export async function getJavascriptMode(
         return;
       }
 
-      const { service } = updateCurrentTextDocument(doc);
+      const { service } = updateCurrentVueTextDocument(doc);
       const fileFsPath = getFileFsPath(doc.uri);
       const info = getComponentInfo(tsModule, service, fileFsPath, config);
       if (info) {
@@ -102,7 +102,7 @@ export async function getJavascriptMode(
     },
 
     doValidation(doc: TextDocument): Diagnostic[] {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return [];
       }
@@ -133,7 +133,7 @@ export async function getJavascriptMode(
       });
     },
     doComplete(doc: TextDocument, position: Position): CompletionList {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return { isIncomplete: false, items: [] };
       }
@@ -175,7 +175,7 @@ export async function getJavascriptMode(
       };
     },
     doResolve(doc: TextDocument, item: CompletionItem): CompletionItem {
-      const { service } = updateCurrentTextDocument(doc);
+      const { service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return item;
       }
@@ -215,7 +215,7 @@ export async function getJavascriptMode(
       return item;
     },
     doHover(doc: TextDocument, position: Position): Hover {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return { contents: [] };
       }
@@ -237,7 +237,7 @@ export async function getJavascriptMode(
       return { contents: [] };
     },
     doSignatureHelp(doc: TextDocument, position: Position): SignatureHelp | null {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return NULL_SIGNATURE;
       }
@@ -278,7 +278,7 @@ export async function getJavascriptMode(
       return ret;
     },
     findDocumentHighlight(doc: TextDocument, position: Position): DocumentHighlight[] {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return [];
       }
@@ -296,7 +296,7 @@ export async function getJavascriptMode(
       return [];
     },
     findDocumentSymbols(doc: TextDocument): SymbolInformation[] {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return [];
       }
@@ -336,7 +336,7 @@ export async function getJavascriptMode(
       return result;
     },
     findDefinition(doc: TextDocument, position: Position): Definition {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return [];
       }
@@ -362,7 +362,7 @@ export async function getJavascriptMode(
       return definitionResults;
     },
     findReferences(doc: TextDocument, position: Position): Location[] {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       if (!languageServiceIncludesFile(service, doc.uri)) {
         return [];
       }
@@ -390,7 +390,7 @@ export async function getJavascriptMode(
       return referenceResults;
     },
     getCodeActions(doc, range, _formatParams, context) {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
       const fileName = getFileFsPath(scriptDoc.uri);
       const start = scriptDoc.offsetAt(range.start);
       const end = scriptDoc.offsetAt(range.end);
@@ -427,7 +427,7 @@ export async function getJavascriptMode(
       return result;
     },
     getRefactorEdits(doc: TextDocument, args: RefactorAction) {
-      const { service } = updateCurrentTextDocument(doc);
+      const { service } = updateCurrentVueTextDocument(doc);
       const response = service.getEditsForRefactor(
         args.fileName,
         args.formatOptions,
@@ -444,7 +444,7 @@ export async function getJavascriptMode(
       return createApplyCodeActionCommand('', uriMapping);
     },
     format(doc: TextDocument, range: Range, formatParams: FormattingOptions): TextEdit[] {
-      const { scriptDoc, service } = updateCurrentTextDocument(doc);
+      const { scriptDoc, service } = updateCurrentVueTextDocument(doc);
 
       const defaultFormatter =
         scriptDoc.languageId === 'javascript'
@@ -699,7 +699,7 @@ function convertCodeAction(
   codeActions: ts.CodeAction[],
   regionStart: LanguageModelCache<LanguageRange | undefined>
 ): TextEdit[] {
-  const scriptStartOffset = doc.offsetAt(regionStart.get(doc)!.start);
+  const scriptStartOffset = doc.offsetAt(regionStart.refreshAndGet(doc)!.start);
   const textEdits: TextEdit[] = [];
   for (const action of codeActions) {
     for (const change of action.changes) {
@@ -708,7 +708,7 @@ function convertCodeAction(
           // currently, only import codeAction is available
           // change start of doc to start of script region
           if (tc.span.start <= scriptStartOffset && tc.span.length === 0) {
-            const region = regionStart.get(doc);
+            const region = regionStart.refreshAndGet(doc);
             if (region) {
               const line = region.start.line;
               return {
diff --git a/server/src/modes/style/index.ts b/server/src/modes/style/index.ts
index e2701db197..fdd5c8c904 100644
--- a/server/src/modes/style/index.ts
+++ b/server/src/modes/style/index.ts
@@ -43,7 +43,7 @@ function getStyleMode(
   documentRegions: LanguageModelCache<VueDocumentRegions>
 ): LanguageMode {
   const embeddedDocuments = getLanguageModelCache(10, 60, document =>
-    documentRegions.get(document).getSingleLanguageDocument(languageId)
+    documentRegions.refreshAndGet(document).getSingleLanguageDocument(languageId)
   );
   const stylesheets = getLanguageModelCache(10, 60, document => languageService.parseStylesheet(document));
   let config: any = {};
@@ -60,14 +60,14 @@ function getStyleMode(
       if (languageId === 'postcss') {
         return [];
       } else {
-        const embedded = embeddedDocuments.get(document);
-        return languageService.doValidation(embedded, stylesheets.get(embedded));
+        const embedded = embeddedDocuments.refreshAndGet(document);
+        return languageService.doValidation(embedded, stylesheets.refreshAndGet(embedded));
       }
     },
     doComplete(document, position) {
-      const embedded = embeddedDocuments.get(document);
+      const embedded = embeddedDocuments.refreshAndGet(document);
       const emmetSyntax = languageId === 'postcss' ? 'css' : languageId;
-      const lsCompletions = languageService.doComplete(embedded, position, stylesheets.get(embedded));
+      const lsCompletions = languageService.doComplete(embedded, position, stylesheets.refreshAndGet(embedded));
       const lsItems = lsCompletions
         ? _.map(lsCompletions.items, i => {
             return {
@@ -94,36 +94,36 @@ function getStyleMode(
       }
     },
     doHover(document, position) {
-      const embedded = embeddedDocuments.get(document);
-      return languageService.doHover(embedded, position, stylesheets.get(embedded)) || NULL_HOVER;
+      const embedded = embeddedDocuments.refreshAndGet(document);
+      return languageService.doHover(embedded, position, stylesheets.refreshAndGet(embedded)) || NULL_HOVER;
     },
     findDocumentHighlight(document, position) {
-      const embedded = embeddedDocuments.get(document);
-      return languageService.findDocumentHighlights(embedded, position, stylesheets.get(embedded));
+      const embedded = embeddedDocuments.refreshAndGet(document);
+      return languageService.findDocumentHighlights(embedded, position, stylesheets.refreshAndGet(embedded));
     },
     findDocumentSymbols(document) {
-      const embedded = embeddedDocuments.get(document);
-      return languageService.findDocumentSymbols(embedded, stylesheets.get(embedded));
+      const embedded = embeddedDocuments.refreshAndGet(document);
+      return languageService.findDocumentSymbols(embedded, stylesheets.refreshAndGet(embedded));
     },
     findDefinition(document, position) {
-      const embedded = embeddedDocuments.get(document);
-      const definition = languageService.findDefinition(embedded, position, stylesheets.get(embedded));
+      const embedded = embeddedDocuments.refreshAndGet(document);
+      const definition = languageService.findDefinition(embedded, position, stylesheets.refreshAndGet(embedded));
       if (!definition) {
         return [];
       }
       return definition;
     },
     findReferences(document, position) {
-      const embedded = embeddedDocuments.get(document);
-      return languageService.findReferences(embedded, position, stylesheets.get(embedded));
+      const embedded = embeddedDocuments.refreshAndGet(document);
+      return languageService.findReferences(embedded, position, stylesheets.refreshAndGet(embedded));
     },
     findDocumentColors(document) {
-      const embedded = embeddedDocuments.get(document);
-      return languageService.findDocumentColors(embedded, stylesheets.get(embedded));
+      const embedded = embeddedDocuments.refreshAndGet(document);
+      return languageService.findDocumentColors(embedded, stylesheets.refreshAndGet(embedded));
     },
     getColorPresentations(document, color, range) {
-      const embedded = embeddedDocuments.get(document);
-      return languageService.getColorPresentations(embedded, stylesheets.get(embedded), color, range);
+      const embedded = embeddedDocuments.refreshAndGet(document);
+      return languageService.getColorPresentations(embedded, stylesheets.refreshAndGet(embedded), color, range);
     },
     format(document, currRange, formattingOptions) {
       if (config.vetur.format.defaultFormatter[languageId] === 'none') {
diff --git a/server/src/modes/style/stylus/index.ts b/server/src/modes/style/stylus/index.ts
index 1d6796c2a3..8301999303 100644
--- a/server/src/modes/style/stylus/index.ts
+++ b/server/src/modes/style/stylus/index.ts
@@ -17,7 +17,7 @@ import { VLSFormatConfig } from '../../../config';
 
 export function getStylusMode(documentRegions: LanguageModelCache<VueDocumentRegions>): LanguageMode {
   const embeddedDocuments = getLanguageModelCache(10, 60, document =>
-    documentRegions.get(document).getSingleLanguageDocument('stylus')
+    documentRegions.refreshAndGet(document).getSingleLanguageDocument('stylus')
   );
   let baseIndentShifted = false;
   let config: any = {};
@@ -30,7 +30,7 @@ export function getStylusMode(documentRegions: LanguageModelCache<VueDocumentReg
     onDocumentRemoved() {},
     dispose() {},
     doComplete(document, position) {
-      const embedded = embeddedDocuments.get(document);
+      const embedded = embeddedDocuments.refreshAndGet(document);
 
       const lsCompletions = provideCompletionItems(embedded, position);
       const lsItems = _.map(lsCompletions.items, i => {
@@ -57,11 +57,11 @@ export function getStylusMode(documentRegions: LanguageModelCache<VueDocumentReg
       }
     },
     findDocumentSymbols(document) {
-      const embedded = embeddedDocuments.get(document);
+      const embedded = embeddedDocuments.refreshAndGet(document);
       return provideDocumentSymbols(embedded);
     },
     doHover(document, position) {
-      const embedded = embeddedDocuments.get(document);
+      const embedded = embeddedDocuments.refreshAndGet(document);
       return stylusHover(embedded, position);
     },
     format(document, range, formatParams) {
diff --git a/server/src/modes/template/htmlMode.ts b/server/src/modes/template/htmlMode.ts
index c6057118d8..88e6f39944 100644
--- a/server/src/modes/template/htmlMode.ts
+++ b/server/src/modes/template/htmlMode.ts
@@ -39,7 +39,7 @@ export class HTMLMode implements LanguageMode {
     this.tagProviderSettings = getTagProviderSettings(workspacePath);
     this.enabledTagProviders = getEnabledTagProviders(this.tagProviderSettings);
     this.embeddedDocuments = getLanguageModelCache<TextDocument>(10, 60, document =>
-      documentRegions.get(document).getSingleLanguageDocument('vue-html')
+      documentRegions.refreshAndGet(document).getSingleLanguageDocument('vue-html')
     );
     this.vueDocuments = getLanguageModelCache<HTMLDocument>(10, 60, document => parseHTMLDocument(document));
   }
@@ -55,11 +55,11 @@ export class HTMLMode implements LanguageMode {
   }
 
   doValidation(document: TextDocument) {
-    const embedded = this.embeddedDocuments.get(document);
+    const embedded = this.embeddedDocuments.refreshAndGet(document);
     return doESLintValidation(embedded, this.lintEngine);
   }
   doComplete(document: TextDocument, position: Position) {
-    const embedded = this.embeddedDocuments.get(document);
+    const embedded = this.embeddedDocuments.refreshAndGet(document);
     const tagProviders: IHTMLTagProvider[] = [...this.enabledTagProviders];
 
     const info = this.vueInfoService ? this.vueInfoService.getInfo(document) : undefined;
@@ -67,30 +67,37 @@ export class HTMLMode implements LanguageMode {
       tagProviders.push(getComponentInfoTagProvider(info.componentInfo.childComponents));
     }
 
-    return doComplete(embedded, position, this.vueDocuments.get(embedded), tagProviders, this.config.emmet, info);
+    return doComplete(
+      embedded,
+      position,
+      this.vueDocuments.refreshAndGet(embedded),
+      tagProviders,
+      this.config.emmet,
+      info
+    );
   }
   doHover(document: TextDocument, position: Position) {
-    const embedded = this.embeddedDocuments.get(document);
+    const embedded = this.embeddedDocuments.refreshAndGet(document);
     const tagProviders: IHTMLTagProvider[] = [...this.enabledTagProviders];
 
-    return doHover(embedded, position, this.vueDocuments.get(embedded), tagProviders);
+    return doHover(embedded, position, this.vueDocuments.refreshAndGet(embedded), tagProviders);
   }
   findDocumentHighlight(document: TextDocument, position: Position) {
-    return findDocumentHighlights(document, position, this.vueDocuments.get(document));
+    return findDocumentHighlights(document, position, this.vueDocuments.refreshAndGet(document));
   }
   findDocumentLinks(document: TextDocument, documentContext: DocumentContext) {
     return findDocumentLinks(document, documentContext);
   }
   findDocumentSymbols(document: TextDocument) {
-    return findDocumentSymbols(document, this.vueDocuments.get(document));
+    return findDocumentSymbols(document, this.vueDocuments.refreshAndGet(document));
   }
   format(document: TextDocument, range: Range, formattingOptions: FormattingOptions) {
     return htmlFormat(document, range, this.config.vetur.format as VLSFormatConfig);
   }
   findDefinition(document: TextDocument, position: Position) {
-    const embedded = this.embeddedDocuments.get(document);
+    const embedded = this.embeddedDocuments.refreshAndGet(document);
     const info = this.vueInfoService ? this.vueInfoService.getInfo(document) : undefined;
-    return findDefinition(embedded, position, this.vueDocuments.get(embedded), info);
+    return findDefinition(embedded, position, this.vueDocuments.refreshAndGet(embedded), info);
   }
   onDocumentRemoved(document: TextDocument) {
     this.vueDocuments.onDocumentRemoved(document);
diff --git a/server/src/modes/template/interpolationMode.ts b/server/src/modes/template/interpolationMode.ts
index b29e78da72..36bd7d0695 100644
--- a/server/src/modes/template/interpolationMode.ts
+++ b/server/src/modes/template/interpolationMode.ts
@@ -48,7 +48,7 @@ export class VueInterpolationMode implements LanguageMode {
       document.getText()
     );
 
-    const { templateService, templateSourceMap } = this.serviceHost.updateCurrentTextDocument(templateDoc);
+    const { templateService, templateSourceMap } = this.serviceHost.updateCurrentVirtualVueTextDocument(templateDoc);
     if (!languageServiceIncludesFile(templateService, templateDoc.uri)) {
       return [];
     }
@@ -91,7 +91,7 @@ export class VueInterpolationMode implements LanguageMode {
       document.getText()
     );
 
-    const { templateService, templateSourceMap } = this.serviceHost.updateCurrentTextDocument(templateDoc);
+    const { templateService, templateSourceMap } = this.serviceHost.updateCurrentVirtualVueTextDocument(templateDoc);
     if (!languageServiceIncludesFile(templateService, templateDoc.uri)) {
       return {
         contents: []
@@ -130,7 +130,7 @@ export class VueInterpolationMode implements LanguageMode {
       document.getText()
     );
 
-    const { templateService, templateSourceMap } = this.serviceHost.updateCurrentTextDocument(templateDoc);
+    const { templateService, templateSourceMap } = this.serviceHost.updateCurrentVirtualVueTextDocument(templateDoc);
     if (!languageServiceIncludesFile(templateService, templateDoc.uri)) {
       return [];
     }
@@ -178,7 +178,7 @@ export class VueInterpolationMode implements LanguageMode {
       document.getText()
     );
 
-    const { templateService, templateSourceMap } = this.serviceHost.updateCurrentTextDocument(templateDoc);
+    const { templateService, templateSourceMap } = this.serviceHost.updateCurrentVirtualVueTextDocument(templateDoc);
     if (!languageServiceIncludesFile(templateService, templateDoc.uri)) {
       return [];
     }
diff --git a/server/src/services/typescriptService/preprocess.ts b/server/src/services/typescriptService/preprocess.ts
index db9cb5cfe0..e5d129f9c3 100644
--- a/server/src/services/typescriptService/preprocess.ts
+++ b/server/src/services/typescriptService/preprocess.ts
@@ -15,11 +15,7 @@ import {
 } from './transformTemplate';
 import { templateSourceMap } from './serviceHost';
 import { generateSourceMap } from './sourceMap';
-import { isVirtualVueTemplateFile } from './util';
-
-export function isVue(filename: string): boolean {
-  return path.extname(filename) === '.vue';
-}
+import { isVirtualVueTemplateFile, isVueFile } from './util';
 
 export function parseVueScript(text: string): string {
   const doc = TextDocument.create('test://test/test.vue', 'vue', 0, text);
@@ -72,7 +68,7 @@ export function createUpdater(tsModule: T_TypeScript) {
       return;
     }
 
-    if (isVue(fileName) && !isTSLike(scriptKind)) {
+    if (isVueFile(fileName) && !isTSLike(scriptKind)) {
       modifyVueScript(tsModule, sourceFile);
       modificationTracker.add(sourceFile);
       return;
diff --git a/server/src/services/typescriptService/serviceHost.ts b/server/src/services/typescriptService/serviceHost.ts
index d186493897..bc0766bfce 100644
--- a/server/src/services/typescriptService/serviceHost.ts
+++ b/server/src/services/typescriptService/serviceHost.ts
@@ -5,15 +5,17 @@ import { TextDocument } from 'vscode-languageserver-types';
 import * as parseGitIgnore from 'parse-gitignore';
 
 import { LanguageModelCache } from '../../embeddedSupport/languageModelCache';
-import { createUpdater, parseVueScript, isVue } from './preprocess';
-import { getFileFsPath, getFilePath } from '../../utils/paths';
+import { createUpdater, parseVueScript } from './preprocess';
+import { getFileFsPath, getFilePath, normalizeFileNameToFsPath } from '../../utils/paths';
 import * as bridge from './bridge';
 import { T_TypeScript } from '../../services/dependencyService';
 import { getVueSys } from './vueSys';
-import { TemplateSourceMap, TemplateSourceMapNode, stringifySourceMapNodes } from './sourceMap';
-import { isVirtualVueTemplateFile } from './util';
+import { TemplateSourceMap, stringifySourceMapNodes } from './sourceMap';
+import { isVirtualVueTemplateFile, isVueFile } from './util';
 import { logger } from '../../log';
 
+const NEWLINE = process.platform === 'win32' ? '\r\n' : '\n';
+
 function patchTS(tsModule: T_TypeScript) {
   // Patch typescript functions to insert `import Vue from 'vue'` and `new Vue` around export default.
   // NOTE: this is a global hack that all ts instances after is changed
@@ -41,36 +43,56 @@ export const templateSourceMap: TemplateSourceMap = {};
 
 export interface IServiceHost {
   queryVirtualFileInfo(fileName: string, currFileText: string): { source: string; sourceMapNodesString: string };
-  updateCurrentTextDocument(
+  updateCurrentVirtualVueTextDocument(
     doc: TextDocument
   ): {
-    service: ts.LanguageService;
     templateService: ts.LanguageService;
-    scriptDoc: TextDocument;
     templateSourceMap: TemplateSourceMap;
   };
+  updateCurrentVueTextDocument(
+    doc: TextDocument
+  ): {
+    service: ts.LanguageService;
+    scriptDoc: TextDocument;
+  };
   updateExternalDocument(filePath: string): void;
   dispose(): void;
 }
 
+/**
+ * Manges 4 set of files
+ *
+ * - `vue` files in workspace
+ * - `js/ts` files in workspace
+ * - `vue` files in `node_modules`
+ * - `js/ts` files in `node_modules`
+ */
 export function getServiceHost(
   tsModule: T_TypeScript,
   workspacePath: string,
-  jsDocuments: LanguageModelCache<TextDocument>
-) {
+  updatedScriptRegionDocuments: LanguageModelCache<TextDocument>
+): IServiceHost {
   patchTS(tsModule);
   const vueSys = getVueSys(tsModule);
 
   let currentScriptDoc: TextDocument;
+
   const versions = new Map<string, number>();
-  const scriptDocs = new Map<string, TextDocument>();
+  const localScriptRegionDocuments = new Map<string, TextDocument>();
+  const nodeModuleSnapshots = new Map<string, ts.IScriptSnapshot>();
+  const projectFileSnapshots = new Map<string, ts.IScriptSnapshot>();
 
   const parsedConfig = getParsedConfig(tsModule, workspacePath);
-  const files = parsedConfig.fileNames;
-  logger.logDebug(`Initializing ServiceHost with ${files.length} files: ${JSON.stringify(files)}`);
-  const scriptFileNameSet = new Set(files);
+  /**
+   * Only js/ts files in local project
+   */
+  const initialProjectFiles = parsedConfig.fileNames;
+  logger.logDebug(
+    `Initializing ServiceHost with ${initialProjectFiles.length} files: ${JSON.stringify(initialProjectFiles)}`
+  );
+  const scriptFileNameSet = new Set(initialProjectFiles);
 
-  const isOldVersion = inferIsOldVersion(tsModule, workspacePath);
+  const isOldVersion = inferIsUsingOldVueVersion(tsModule, workspacePath);
   const compilerOptions = {
     ...getDefaultCompilerOptions(tsModule),
     ...parsedConfig.options
@@ -102,42 +124,63 @@ export function getServiceHost(
     };
   }
 
-  function updateCurrentTextDocument(doc: TextDocument) {
+  function updateCurrentVirtualVueTextDocument(doc: TextDocument) {
     const fileFsPath = getFileFsPath(doc.uri);
     const filePath = getFilePath(doc.uri);
     // When file is not in language service, add it
-    if (!scriptDocs.has(fileFsPath)) {
+    if (!localScriptRegionDocuments.has(fileFsPath)) {
       if (fileFsPath.endsWith('.vue') || fileFsPath.endsWith('.vue.template')) {
         scriptFileNameSet.add(filePath);
       }
     }
 
     if (isVirtualVueTemplateFile(fileFsPath)) {
-      scriptDocs.set(fileFsPath, doc);
+      localScriptRegionDocuments.set(fileFsPath, doc);
       versions.set(fileFsPath, (versions.get(fileFsPath) || 0) + 1);
-    } else if (!currentScriptDoc || doc.uri !== currentScriptDoc.uri || doc.version !== currentScriptDoc.version) {
-      currentScriptDoc = jsDocuments.get(doc);
-      const lastDoc = scriptDocs.get(fileFsPath);
-      if (lastDoc && currentScriptDoc.languageId !== lastDoc.languageId) {
+    }
+
+    return {
+      templateService: templateLanguageService,
+      templateSourceMap
+    };
+  }
+
+  function updateCurrentVueTextDocument(doc: TextDocument) {
+    const fileFsPath = getFileFsPath(doc.uri);
+    const filePath = getFilePath(doc.uri);
+    // When file is not in language service, add it
+    if (!localScriptRegionDocuments.has(fileFsPath)) {
+      if (fileFsPath.endsWith('.vue') || fileFsPath.endsWith('.vue.template')) {
+        scriptFileNameSet.add(filePath);
+      }
+    }
+
+    if (!currentScriptDoc || doc.uri !== currentScriptDoc.uri || doc.version !== currentScriptDoc.version) {
+      currentScriptDoc = updatedScriptRegionDocuments.refreshAndGet(doc)!;
+      const localLastDoc = localScriptRegionDocuments.get(fileFsPath);
+      if (localLastDoc && currentScriptDoc.languageId !== localLastDoc.languageId) {
         // if languageId changed, restart the language service; it can't handle file type changes
         jsLanguageService.dispose();
         jsLanguageService = tsModule.createLanguageService(jsHost);
       }
-      scriptDocs.set(fileFsPath, currentScriptDoc);
+      localScriptRegionDocuments.set(fileFsPath, currentScriptDoc);
       versions.set(fileFsPath, (versions.get(fileFsPath) || 0) + 1);
     }
     return {
       service: jsLanguageService,
-      templateService: templateLanguageService,
-      scriptDoc: currentScriptDoc,
-      templateSourceMap
+      scriptDoc: currentScriptDoc
     };
   }
 
   // External Documents: JS/TS, non Vue documents
-  function updateExternalDocument(filePath: string) {
-    const ver = versions.get(filePath) || 0;
-    versions.set(filePath, ver + 1);
+  function updateExternalDocument(fileFsPath: string) {
+    const ver = versions.get(fileFsPath) || 0;
+    versions.set(fileFsPath, ver + 1);
+
+    // Clear cache so we read the js/ts file from file system again
+    if (projectFileSnapshots.has(fileFsPath)) {
+      projectFileSnapshots.delete(fileFsPath);
+    }
   }
 
   function createLanguageServiceHost(options: ts.CompilerOptions): ts.LanguageServiceHost {
@@ -145,20 +188,32 @@ export function getServiceHost(
       getCompilationSettings: () => options,
       getScriptFileNames: () => Array.from(scriptFileNameSet),
       getScriptVersion(fileName) {
+        if (fileName.includes('node_modules')) {
+          return '0';
+        }
+
         if (fileName === bridge.fileName) {
           return '0';
         }
-        const normalizedFileFsPath = getNormalizedFileFsPath(fileName);
+
+        const normalizedFileFsPath = normalizeFileNameToFsPath(fileName);
         const version = versions.get(normalizedFileFsPath);
         return version ? version.toString() : '0';
       },
       getScriptKind(fileName) {
-        if (isVue(fileName)) {
+        if (fileName.includes('node_modules')) {
+          return (tsModule as any).getScriptKindFromFileName(fileName);
+        }
+
+        if (isVueFile(fileName)) {
           const uri = Uri.file(fileName);
           fileName = uri.fsPath;
-          const doc =
-            scriptDocs.get(fileName) ||
-            jsDocuments.get(TextDocument.create(uri.toString(), 'vue', 0, tsModule.sys.readFile(fileName) || ''));
+          let doc = localScriptRegionDocuments.get(fileName);
+          if (!doc) {
+            doc = updatedScriptRegionDocuments.refreshAndGet(
+              TextDocument.create(uri.toString(), 'vue', 0, tsModule.sys.readFile(fileName) || '')
+            );
+          }
           return getScriptKind(tsModule, doc.languageId);
         } else if (isVirtualVueTemplateFile(fileName)) {
           return tsModule.ScriptKind.JS;
@@ -171,7 +226,6 @@ export function getServiceHost(
         }
       },
 
-      // resolve @types, see https://github.com/Microsoft/TypeScript/issues/16772
       getDirectories: vueSys.getDirectories,
       directoryExists: vueSys.directoryExists,
       fileExists: vueSys.fileExists,
@@ -188,7 +242,7 @@ export function getServiceHost(
               extension: tsModule.Extension.Ts
             };
           }
-          if (path.isAbsolute(name) || !isVue(name)) {
+          if (path.isAbsolute(name) || !isVueFile(name)) {
             return tsModule.resolveModuleName(name, containingFile, options, tsModule.sys).resolvedModule;
           }
           const resolved = tsModule.resolveModuleName(name, containingFile, options, vueSys).resolvedModule;
@@ -200,11 +254,14 @@ export function getServiceHost(
           }
           const resolvedFileName = resolved.resolvedFileName.slice(0, -'.ts'.length);
           const uri = Uri.file(resolvedFileName);
-          const doc =
-            scriptDocs.get(resolvedFileName) ||
-            jsDocuments.get(
+          let doc = localScriptRegionDocuments.get(resolvedFileName);
+          // Vue file not created yet
+          if (!doc) {
+            doc = updatedScriptRegionDocuments.refreshAndGet(
               TextDocument.create(uri.toString(), 'vue', 0, tsModule.sys.readFile(resolvedFileName) || '')
             );
+          }
+
           const extension =
             doc.languageId === 'typescript'
               ? tsModule.Extension.Ts
@@ -215,6 +272,20 @@ export function getServiceHost(
         });
       },
       getScriptSnapshot: (fileName: string) => {
+        if (fileName.includes('node_modules')) {
+          if (nodeModuleSnapshots.has(fileName)) {
+            return nodeModuleSnapshots.get(fileName);
+          }
+          const fileText = tsModule.sys.readFile(fileName) || '';
+          const snapshot: ts.IScriptSnapshot = {
+            getText: (start, end) => fileText.substring(start, end),
+            getLength: () => fileText.length,
+            getChangeRange: () => void 0
+          };
+          nodeModuleSnapshots.set(fileName, snapshot);
+          return snapshot;
+        }
+
         if (fileName === bridge.fileName) {
           const text = isOldVersion ? bridge.oldContent : bridge.content;
           return {
@@ -223,14 +294,47 @@ export function getServiceHost(
             getChangeRange: () => void 0
           };
         }
-        const normalizedFileFsPath = getNormalizedFileFsPath(fileName);
-        const doc = scriptDocs.get(normalizedFileFsPath);
-        let fileText = doc ? doc.getText() : tsModule.sys.readFile(normalizedFileFsPath) || '';
-        if (!doc && isVue(fileName)) {
+
+        const fileFsPath = normalizeFileNameToFsPath(fileName);
+
+        // .vue.template files are handled in pre-process phase
+        if (isVirtualVueTemplateFile(fileFsPath)) {
+          const doc = localScriptRegionDocuments.get(fileFsPath);
+          const fileText = doc ? doc.getText() : '';
+          return {
+            getText: (start, end) => fileText.substring(start, end),
+            getLength: () => fileText.length,
+            getChangeRange: () => void 0
+          };
+        }
+
+        // js/ts files in workspace
+        if (!isVueFile(fileFsPath)) {
+          if (projectFileSnapshots.has(fileFsPath)) {
+            return projectFileSnapshots.get(fileFsPath);
+          }
+          const fileText = tsModule.sys.readFile(fileFsPath) || '';
+          const snapshot: ts.IScriptSnapshot = {
+            getText: (start, end) => fileText.substring(start, end),
+            getLength: () => fileText.length,
+            getChangeRange: () => void 0
+          };
+          projectFileSnapshots.set(fileFsPath, snapshot);
+          return snapshot;
+        }
+
+        // vue files in workspace
+        const doc = localScriptRegionDocuments.get(fileFsPath);
+        let fileText = '';
+        if (doc) {
+          fileText = doc.getText();
+        } else {
           // Note: This is required in addition to the parsing in embeddedSupport because
           // this works for .vue files that aren't even loaded by VS Code yet.
-          fileText = parseVueScript(fileText);
+          const rawVueFileText = tsModule.sys.readFile(fileFsPath) || '';
+          fileText = parseVueScript(rawVueFileText);
         }
+
         return {
           getText: (start, end) => fileText.substring(start, end),
           getLength: () => fileText.length,
@@ -239,7 +343,7 @@ export function getServiceHost(
       },
       getCurrentDirectory: () => workspacePath,
       getDefaultLibFileName: tsModule.getDefaultLibFilePath,
-      getNewLine: () => '\n',
+      getNewLine: () => NEWLINE,
       useCaseSensitiveFileNames: () => true
     };
   }
@@ -260,7 +364,8 @@ export function getServiceHost(
 
   return {
     queryVirtualFileInfo,
-    updateCurrentTextDocument,
+    updateCurrentVirtualVueTextDocument,
+    updateCurrentVueTextDocument,
     updateExternalDocument,
     dispose: () => {
       jsLanguageService.dispose();
@@ -268,10 +373,6 @@ export function getServiceHost(
   };
 }
 
-function getNormalizedFileFsPath(fileName: string): string {
-  return Uri.file(fileName).fsPath;
-}
-
 function defaultIgnorePatterns(tsModule: T_TypeScript, workspacePath: string) {
   const nodeModules = ['node_modules', '**/node_modules/*'];
   const gitignore = tsModule.findConfigFile(workspacePath, tsModule.sys.fileExists, '.gitignore');
@@ -291,7 +392,7 @@ function getScriptKind(tsModule: T_TypeScript, langId: string): ts.ScriptKind {
     : tsModule.ScriptKind.JS;
 }
 
-function inferIsOldVersion(tsModule: T_TypeScript, workspacePath: string): boolean {
+function inferIsUsingOldVueVersion(tsModule: T_TypeScript, workspacePath: string): boolean {
   const packageJSONPath = tsModule.findConfigFile(workspacePath, tsModule.sys.fileExists, 'package.json');
   try {
     const packageJSON = packageJSONPath && JSON.parse(tsModule.sys.readFile(packageJSONPath)!);
diff --git a/server/src/services/typescriptService/util.ts b/server/src/services/typescriptService/util.ts
index 8490f03ad5..d57fec3419 100644
--- a/server/src/services/typescriptService/util.ts
+++ b/server/src/services/typescriptService/util.ts
@@ -1,3 +1,7 @@
+export function isVueFile(path: string) {
+  return path.endsWith('.vue');
+}
+
 /**
  * If the path ends with `.vue.ts`, it's a `.vue` file pre-processed by Vetur
  * to be used in TS Language Service
diff --git a/server/src/services/vls.ts b/server/src/services/vls.ts
index 4728cb91f5..1af4ff47cf 100644
--- a/server/src/services/vls.ts
+++ b/server/src/services/vls.ts
@@ -339,12 +339,7 @@ export class VLS {
           return Uri.file(path.resolve(this.workspacePath, ref)).toString();
         }
         const docUri = Uri.parse(doc.uri);
-        return docUri
-          .with({
-            // Reference from components need to go dwon from their parent dir
-            path: path.resolve(docUri.fsPath, '..', ref)
-          })
-          .toString();
+        return Uri.file(path.resolve(docUri.fsPath, '..', ref)).toString();
       }
     };
 
diff --git a/server/src/utils/paths.ts b/server/src/utils/paths.ts
index f23e514483..674044d809 100644
--- a/server/src/utils/paths.ts
+++ b/server/src/utils/paths.ts
@@ -53,3 +53,7 @@ export function getFilePath(documentUri: string): string {
     return Uri.parse(documentUri).path;
   }
 }
+
+export function normalizeFileNameToFsPath(fileName: string) {
+  return Uri.file(fileName).fsPath;
+}
diff --git a/test/interpolation/completion/helper.ts b/test/interpolation/completion/helper.ts
index 286df60ea0..a51a0b150a 100644
--- a/test/interpolation/completion/helper.ts
+++ b/test/interpolation/completion/helper.ts
@@ -39,12 +39,12 @@ export async function testCompletion(
 
       if (ei.documentation) {
         if (typeof match.documentation === 'string') {
-          assert.equal(match.documentation, ei.documentation);
+          assert.equal(normalizeNewline(match.documentation), normalizeNewline(ei.documentation as string));
         } else {
           if (ei.documentation && (ei.documentation as MarkupContent).value && match.documentation) {
             assert.equal(
-              (match.documentation as vscode.MarkdownString).value,
-              (ei.documentation as MarkupContent).value
+              normalizeNewline((match.documentation as vscode.MarkdownString).value),
+              normalizeNewline((ei.documentation as MarkupContent).value)
             );
           }
         }
@@ -95,3 +95,7 @@ export async function testNoSuchCompletion(
     }
   });
 }
+
+function normalizeNewline(input: string) {
+  return input.replace(/\r\n/g, '\n');
+}
diff --git a/test/lsp-ts-28/definition/basic.test.ts b/test/lsp-ts-28/definition/basic.test.ts
index 9431d12b62..2e34110d89 100644
--- a/test/lsp-ts-28/definition/basic.test.ts
+++ b/test/lsp-ts-28/definition/basic.test.ts
@@ -42,5 +42,5 @@ async function testDefinition(docUri: vscode.Uri, position: vscode.Position, exp
   )) as vscode.Location[];
 
   assert.ok(result[0].range.isEqual(expectedLocation.range));
-  assert.equal(result[0].uri.path, expectedLocation.uri.path);
+  assert.equal(result[0].uri.fsPath, expectedLocation.uri.fsPath);
 }
diff --git a/test/lsp-ts-28/documentLink/basic.test.ts b/test/lsp-ts-28/documentLink/basic.test.ts
index 6c4c1688a0..77b0c5e5d7 100644
--- a/test/lsp-ts-28/documentLink/basic.test.ts
+++ b/test/lsp-ts-28/documentLink/basic.test.ts
@@ -9,7 +9,7 @@ describe('Should do documentLink', () => {
   before('activate', async () => {
     await activateLS();
     await showFile(docUri);
-    await sleep(FILE_LOAD_SLEEP_TIME);
+    await sleep(FILE_LOAD_SLEEP_TIME * 3);
   });
 
   it('shows all documentLinks for Basic.vue', async () => {
@@ -27,10 +27,13 @@ async function testLink(docUri: vscode.Uri, expectedLinks: vscode.DocumentLink[]
   const result = (await vscode.commands.executeCommand('vscode.executeLinkProvider', docUri)) as vscode.DocumentLink[];
 
   expectedLinks.forEach(el => {
-    assert.ok(result.some(l => isEqualLink(l, el)));
+    assert.ok(
+      result.some(l => isEqualLink(l, el)),
+      `Failed to find same link as ${el.target!.fsPath}. Seen links are:\n${JSON.stringify(result, null, 2)}`
+    );
   });
 
   function isEqualLink(h1: vscode.DocumentLink, h2: vscode.DocumentLink) {
-    return h1.target!.path === h2.target!.path && h1.range.isEqual(h2.range);
+    return h1.target!.fsPath === h2.target!.fsPath && h1.range.isEqual(h2.range);
   }
 }
diff --git a/test/lsp-ts-28/references/basic.test.ts b/test/lsp-ts-28/references/basic.test.ts
index 88de2a0768..1e8a82966e 100644
--- a/test/lsp-ts-28/references/basic.test.ts
+++ b/test/lsp-ts-28/references/basic.test.ts
@@ -57,7 +57,7 @@ async function testReferences(docUri: vscode.Uri, position: vscode.Position, exp
   expectedLocations.forEach(el => {
     assert.ok(
       result.some(l => {
-        return l.range.isEqual(el.range) && l.uri.path === el.uri.path;
+        return l.range.isEqual(el.range) && l.uri.fsPath === el.uri.fsPath;
       })
     );
   });
diff --git a/test/lsp/definition/basic.test.ts b/test/lsp/definition/basic.test.ts
index 5cf2bed3f0..0fba3ddc51 100644
--- a/test/lsp/definition/basic.test.ts
+++ b/test/lsp/definition/basic.test.ts
@@ -42,5 +42,5 @@ async function testDefinition(docUri: vscode.Uri, position: vscode.Position, exp
   )) as vscode.Location[];
 
   assert.ok(result[0].range.isEqual(expectedLocation.range));
-  assert.equal(result[0].uri.path, expectedLocation.uri.path);
+  assert.equal(result[0].uri.fsPath, expectedLocation.uri.fsPath);
 }
diff --git a/test/lsp/documentLink/basic.test.ts b/test/lsp/documentLink/basic.test.ts
index 6c4c1688a0..77b0c5e5d7 100644
--- a/test/lsp/documentLink/basic.test.ts
+++ b/test/lsp/documentLink/basic.test.ts
@@ -9,7 +9,7 @@ describe('Should do documentLink', () => {
   before('activate', async () => {
     await activateLS();
     await showFile(docUri);
-    await sleep(FILE_LOAD_SLEEP_TIME);
+    await sleep(FILE_LOAD_SLEEP_TIME * 3);
   });
 
   it('shows all documentLinks for Basic.vue', async () => {
@@ -27,10 +27,13 @@ async function testLink(docUri: vscode.Uri, expectedLinks: vscode.DocumentLink[]
   const result = (await vscode.commands.executeCommand('vscode.executeLinkProvider', docUri)) as vscode.DocumentLink[];
 
   expectedLinks.forEach(el => {
-    assert.ok(result.some(l => isEqualLink(l, el)));
+    assert.ok(
+      result.some(l => isEqualLink(l, el)),
+      `Failed to find same link as ${el.target!.fsPath}. Seen links are:\n${JSON.stringify(result, null, 2)}`
+    );
   });
 
   function isEqualLink(h1: vscode.DocumentLink, h2: vscode.DocumentLink) {
-    return h1.target!.path === h2.target!.path && h1.range.isEqual(h2.range);
+    return h1.target!.fsPath === h2.target!.fsPath && h1.range.isEqual(h2.range);
   }
 }
diff --git a/test/lsp/references/basic.test.ts b/test/lsp/references/basic.test.ts
index c61f00167b..12577e8308 100644
--- a/test/lsp/references/basic.test.ts
+++ b/test/lsp/references/basic.test.ts
@@ -59,7 +59,7 @@ async function testReferences(docUri: vscode.Uri, position: vscode.Position, exp
   expectedLocations.forEach(el => {
     assert.ok(
       result.some(l => {
-        return l.range.isEqual(el.range) && l.uri.path === el.uri.path;
+        return l.range.isEqual(el.range) && l.uri.fsPath === el.uri.fsPath;
       })
     );
   });