diff --git a/.no-sublime-package b/.no-sublime-package
deleted file mode 100644
index e69de29..0000000
diff --git a/LSP-html.sublime-commands b/LSP-html.sublime-commands
new file mode 100644
index 0000000..2011e28
--- /dev/null
+++ b/LSP-html.sublime-commands
@@ -0,0 +1,10 @@
+[
+    {
+        "caption": "Preferences: LSP-html Settings",
+        "command": "edit_settings",
+        "args": {
+          "base_file": "${packages}/LSP-html/LSP-html.sublime-settings",
+          "default": "// Settings in here override those in \"LSP-html/LSP-html.sublime-settings\",\n\n{\n\t$0\n}\n"
+        }
+    },
+]
diff --git a/LSP-html.sublime-settings b/LSP-html.sublime-settings
index 5ef888a..853eb72 100644
--- a/LSP-html.sublime-settings
+++ b/LSP-html.sublime-settings
@@ -1,17 +1,30 @@
 {
-	"client" : {
-		"enabled": true,
-		"languages": [
-			{
-				"languageId": "html",
-				"scopes": ["text.html.basic"],
-				"syntaxes": [
-					"Packages/HTML/HTML.sublime-syntax",
-					"Packages/PHP/PHP.sublime-syntax"
-				]
-			}
-		],
-		"initializationOptions": {},
-		"settings": {}
-	}
-}
\ No newline at end of file
+	"enabled": true,
+	"languages": [
+		{
+			"languageId": "html",
+			"scopes": [
+				"text.html.basic",
+			],
+			"syntaxes": [
+				"Packages/HTML/HTML.sublime-syntax",
+				"Packages/PHP/PHP.sublime-syntax",
+			],
+		},
+	],
+	"initializationOptions": {
+		"provideFormatter": true,
+		"embeddedLanguages": {
+			"css": true,
+			"html": true,
+			"javascript": true,
+		},
+	},
+	"settings": {
+		"html": {
+			"format": {
+				"enable": true,
+			},
+		},
+	},
+}
diff --git a/Main.sublime-menu b/Main.sublime-menu
index e93b93b..72aca86 100644
--- a/Main.sublime-menu
+++ b/Main.sublime-menu
@@ -20,15 +20,15 @@
                     "command": "edit_settings",
                     "args": {
                       "base_file": "${packages}/LSP-html/LSP-html.sublime-settings",
-                      "default": "{\n\t$0\n}\n"
-                    }
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
+                      "default": "// Settings in here override those in \"LSP-html/LSP-html.sublime-settings\",\n\n{\n\t$0\n}\n",
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
 ]
diff --git a/dependencies.json b/dependencies.json
new file mode 100644
index 0000000..3d55a18
--- /dev/null
+++ b/dependencies.json
@@ -0,0 +1,8 @@
+{
+    "*": {
+        "*": [
+            "lsp_utils",
+            "sublime_lib"
+        ]
+    }
+}
diff --git a/package-lock.json b/package-lock.json
deleted file mode 100644
index 01e2d92..0000000
--- a/package-lock.json
+++ /dev/null
@@ -1,108 +0,0 @@
-{
-  "name": "lsp-html",
-  "version": "0.0.1",
-  "lockfileVersion": 1,
-  "requires": true,
-  "dependencies": {
-    "typescript": {
-      "version": "2.9.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.9.2.tgz",
-      "integrity": "sha512-Gr4p6nFNaoufRIY4NMdpQRNmgxVIGMs4Fcu/ujdYk3nAZqk7supzBE9idmvfZIlH/Cuj//dvi+019qEue9lV0w=="
-    },
-    "vscode-css-languageservice": {
-      "version": "3.0.13",
-      "resolved": "https://registry.npmjs.org/vscode-css-languageservice/-/vscode-css-languageservice-3.0.13.tgz",
-      "integrity": "sha512-RWkO/c/A7iXhHEy3OuEqkCqavDjpD4NF2Ca8vjai+ZtEYNeHrm1ybTnBYLP4Ft1uXvvaaVtYA9HrDjD6+CUONg==",
-      "requires": {
-        "vscode-languageserver-types": "^3.13.0",
-        "vscode-nls": "^4.0.0"
-      },
-      "dependencies": {
-        "vscode-nls": {
-          "version": "4.1.1",
-          "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.1.tgz",
-          "integrity": "sha512-4R+2UoUUU/LdnMnFjePxfLqNhBS8lrAFyX7pjb2ud/lqDkrUavFUTcG7wR0HBZFakae0Q6KLBFjMS6W93F403A=="
-        }
-      }
-    },
-    "vscode-html-languageserver-bin": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/vscode-html-languageserver-bin/-/vscode-html-languageserver-bin-1.4.0.tgz",
-      "integrity": "sha512-rDnpvASQwf1dlRaGiu8edo5WlAr4dM3/r/dcPCH4O6UD4+eShhdC1E8IyiSisnJU6bRk+4mDTCgA6cyhGJY2xA==",
-      "requires": {
-        "typescript": "^2.9.1",
-        "vscode-css-languageservice": "^3.0.9-next.18",
-        "vscode-html-languageservice": "^2.1.3-next.5",
-        "vscode-languageserver": "^4.1.3",
-        "vscode-languageserver-protocol-foldingprovider": "^2.0.1",
-        "vscode-languageserver-types": "^3.7.2",
-        "vscode-nls": "^3.2.2",
-        "vscode-uri": "^1.0.3"
-      }
-    },
-    "vscode-html-languageservice": {
-      "version": "2.1.12",
-      "resolved": "https://registry.npmjs.org/vscode-html-languageservice/-/vscode-html-languageservice-2.1.12.tgz",
-      "integrity": "sha512-mIb5VMXM5jI97HzCk2eadI1K//rCEZXte0wBqA7PGXsyJH4KTyJUaYk9MR+mbfpUl2vMi3HZw9GUOLGYLc6l5w==",
-      "requires": {
-        "vscode-languageserver-types": "^3.13.0",
-        "vscode-nls": "^4.0.0",
-        "vscode-uri": "^1.0.6"
-      },
-      "dependencies": {
-        "vscode-nls": {
-          "version": "4.1.1",
-          "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.1.tgz",
-          "integrity": "sha512-4R+2UoUUU/LdnMnFjePxfLqNhBS8lrAFyX7pjb2ud/lqDkrUavFUTcG7wR0HBZFakae0Q6KLBFjMS6W93F403A=="
-        }
-      }
-    },
-    "vscode-jsonrpc": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-4.0.0.tgz",
-      "integrity": "sha512-perEnXQdQOJMTDFNv+UF3h1Y0z4iSiaN9jIlb0OqIYgosPCZGYh/MCUlkFtV2668PL69lRDO32hmvL2yiidUYg=="
-    },
-    "vscode-languageserver": {
-      "version": "4.4.2",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver/-/vscode-languageserver-4.4.2.tgz",
-      "integrity": "sha512-61y8Raevi9EigDgg9NelvT9cUAohiEbUl1LOwQQgOCAaNX62yKny/ddi0uC+FUTm4CzsjhBu+06R+vYgfCYReA==",
-      "requires": {
-        "vscode-languageserver-protocol": "^3.10.3",
-        "vscode-uri": "^1.0.5"
-      }
-    },
-    "vscode-languageserver-protocol": {
-      "version": "3.14.1",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.14.1.tgz",
-      "integrity": "sha512-IL66BLb2g20uIKog5Y2dQ0IiigW0XKrvmWiOvc0yXw80z3tMEzEnHjaGAb3ENuU7MnQqgnYJ1Cl2l9RvNgDi4g==",
-      "requires": {
-        "vscode-jsonrpc": "^4.0.0",
-        "vscode-languageserver-types": "3.14.0"
-      }
-    },
-    "vscode-languageserver-protocol-foldingprovider": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol-foldingprovider/-/vscode-languageserver-protocol-foldingprovider-2.0.1.tgz",
-      "integrity": "sha512-N8bOS8i0xuQMn/y0bijyefDbOsMl6hiH6LDREYWavTLTM5jbj44EiQfStsbmAv/0eaFKkL/jf5hW7nWwBy2HBw==",
-      "requires": {
-        "vscode-languageserver-protocol": "^3.7.2",
-        "vscode-languageserver-types": "^3.7.2"
-      }
-    },
-    "vscode-languageserver-types": {
-      "version": "3.14.0",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.14.0.tgz",
-      "integrity": "sha512-lTmS6AlAlMHOvPQemVwo3CezxBp0sNB95KNPkqp3Nxd5VFEnuG1ByM0zlRWos0zjO3ZWtkvhal0COgiV1xIA4A=="
-    },
-    "vscode-nls": {
-      "version": "3.2.5",
-      "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-3.2.5.tgz",
-      "integrity": "sha512-ITtoh3V4AkWXMmp3TB97vsMaHRgHhsSFPsUdzlueSL+dRZbSNTZeOmdQv60kjCV306ghPxhDeoNUEm3+EZMuyw=="
-    },
-    "vscode-uri": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-1.0.8.tgz",
-      "integrity": "sha512-obtSWTlbJ+a+TFRYGaUumtVwb+InIUVI0Lu0VBUAPmj2cU5JutEXg3xUE0c2J5Tcy7h2DEKVJBFi+Y9ZSFzzPQ=="
-    }
-  }
-}
diff --git a/package.json b/package.json
deleted file mode 100644
index d09b876..0000000
--- a/package.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-  "name": "lsp-html",
-  "version": "0.0.1",
-  "description": "HTML support for Sublime LSP",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sublimelsp/LSP-html.git"
-  },
-  "author": "Предраг Николић",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/sublimelsp/LSP-html/issues"
-  },
-  "homepage": "https://github.com/sublimelsp/LSP-html#readme",
-  "dependencies": {
-    "vscode-html-languageserver-bin": "^1.4.0"
-  }
-}
diff --git a/plugin.py b/plugin.py
index 060bf04..bb65961 100644
--- a/plugin.py
+++ b/plugin.py
@@ -1,97 +1,73 @@
 import shutil
 import os
 import sublime
-import threading
-import subprocess
 
 from LSP.plugin.core.handlers import LanguageHandler
-from LSP.plugin.core.settings import ClientConfig, LanguageConfig, read_client_config
+from LSP.plugin.core.settings import ClientConfig, read_client_config
+from lsp_utils import ServerNpmResource
+
+PACKAGE_NAME = 'LSP-html'
+SETTINGS_FILENAME = 'LSP-html.sublime-settings'
+SERVER_DIRECTORY = 'vscode-html'
+SERVER_BINARY_PATH = os.path.join(SERVER_DIRECTORY, 'out', 'htmlServerMain.js')
+
+server = ServerNpmResource(PACKAGE_NAME, SERVER_DIRECTORY, SERVER_BINARY_PATH)
 
-package_path = os.path.dirname(__file__)
-server_path = os.path.join(package_path, 'node_modules', 'vscode-html-languageserver-bin', 'htmlServerMain.js')
 
 def plugin_loaded():
-    is_server_installed = os.path.isfile(server_path)
-    print('LSP-html: Server {} installed.'.format('is' if is_server_installed else 'is not' ))
-
-    # install the node_modules if not installed
-    if not is_server_installed:
-        # this will be called only when the plugin gets:
-        # - installed for the first time,
-        # - or when updated on package control
-        logAndShowMessage('LSP-html: Installing server.')
-
-        runCommand(
-            onCommandDone,
-            ["npm", "install", "--verbose", "--prefix", package_path, package_path]
-        )
-
-
-def onCommandDone():
-    logAndShowMessage('LSP-html: Server installed.')
-
-
-def runCommand(onExit, popenArgs):
-    """
-    Runs the given args in a subprocess.Popen, and then calls the function
-    onExit when the subprocess completes.
-    onExit is a callable object, and popenArgs is a list/tuple of args that
-    would give to subprocess.Popen.
-    """
-    def runInThread(onExit, popenArgs):
-        try:
-            if sublime.platform() == 'windows':
-                subprocess.check_call(popenArgs, shell=True)
-            else:
-                subprocess.check_call(popenArgs)
-            onExit()
-        except subprocess.CalledProcessError as error:
-            logAndShowMessage('LSP-html: Error while installing the server.', error)
-        return
-    thread = threading.Thread(target=runInThread, args=(onExit, popenArgs))
-    thread.start()
-    # returns immediately after the thread starts
-    return thread
+    server.setup()
 
 
-def is_node_installed():
-    return shutil.which('node') is not None
+def plugin_unloaded():
+    server.cleanup()
 
 
-def logAndShowMessage(msg, additional_logs=None):
-    print(msg, '\n', additional_logs) if additional_logs else print(msg)
-    sublime.active_window().status_message(msg)
+def is_node_installed():
+    return shutil.which('node') is not None
 
 
 class LspHtmlPlugin(LanguageHandler):
     @property
     def name(self) -> str:
-        return 'lsp-html'
+        return PACKAGE_NAME.lower()
 
     @property
     def config(self) -> ClientConfig:
-        settings = sublime.load_settings("LSP-html.sublime-settings")
-        client_configuration = settings.get('client')
+        # Calling setup() also here as this might run before `plugin_loaded`.
+        # Will be a no-op if already ran.
+        # See https://github.com/sublimelsp/LSP/issues/899
+        server.setup()
+
+        configuration = self.migrate_and_read_configuration()
+
         default_configuration = {
-            "command": [
-                'node',
-                server_path,
-                '--stdio'
-            ],
-            "languages": [
-                {
-                    "languageId": "html",
-                    "scopes": ["text.html.basic"],
-                    "syntaxes": [
-                        "Packages/HTML/HTML.sublime-syntax",
-                        "Packages/PHP/PHP.sublime-syntax"
-                    ]
-                }
-            ]
+            'enabled': True,
+            'command': ['node', server.binary_path, '--stdio'],
         }
-        default_configuration.update(client_configuration)
+
+        default_configuration.update(configuration)
+
         return read_client_config('lsp-html', default_configuration)
 
+    def migrate_and_read_configuration(self) -> dict:
+        settings = {}
+        loaded_settings = sublime.load_settings(SETTINGS_FILENAME)
+
+        if loaded_settings:
+            if loaded_settings.has('client'):
+                client = loaded_settings.get('client')
+                loaded_settings.erase('client')
+                # Migrate old keys
+                for key in client:
+                    loaded_settings.set(key, client[key])
+                sublime.save_settings(SETTINGS_FILENAME)
+
+            # Read configuration keys
+            for key in ['languages', 'initializationOptions', 'settings']:
+                settings[key] = loaded_settings.get(key)
+
+        return settings
+
     def on_start(self, window) -> bool:
         if not is_node_installed():
             sublime.status_message('Please install Node.js for the HTML Language Server to work.')
diff --git a/vscode-html/.gitignore b/vscode-html/.gitignore
new file mode 100644
index 0000000..654f70a
--- /dev/null
+++ b/vscode-html/.gitignore
@@ -0,0 +1,4 @@
+/node_modules/
+
+# downloaded source codes
+/vscode-html-languageserver/
diff --git a/vscode-html/README.md b/vscode-html/README.md
new file mode 100644
index 0000000..126acd6
--- /dev/null
+++ b/vscode-html/README.md
@@ -0,0 +1,11 @@
+This repo contains built [vscode-html-languageserver](https://github.com/vscode-langservers/vscode-html-languageserver).
+
+
+# Build
+
+Just run `compile-vscode-html-languageserver.sh`. The built result will be in `out/`.
+
+
+# References
+
+- https://github.com/mattn/vim-lsp-settings/pull/48
diff --git a/vscode-html/compile-vscode-html-languageserver.sh b/vscode-html/compile-vscode-html-languageserver.sh
new file mode 100755
index 0000000..884693a
--- /dev/null
+++ b/vscode-html/compile-vscode-html-languageserver.sh
@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# @see https://github.com/mattn/vim-lsp-settings/pull/48
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+REPO_DIR="${SCRIPT_DIR}"
+SRC_DIR="${REPO_DIR}/vscode-html-languageserver"
+DIST_DIR="${REPO_DIR}/out"
+
+
+# ------------------------- #
+# download the source codes #
+# ------------------------- #
+
+pushd "${REPO_DIR}" || exit
+
+rm -rf \
+    "${SRC_DIR}" "${DIST_DIR}" \
+    "package.json" "package-lock.json"
+
+# or get the source via git clone
+# git clone --depth=1 https://github.com/vscode-langservers/vscode-html-languageserver "${SRC_DIR}"
+
+wget https://github.com/vscode-langservers/vscode-html-languageserver/archive/master.zip -O src.zip
+unzip src.zip
+rm -f src.zip
+mv vscode-html-languageserver-master "${SRC_DIR}"
+
+popd || exit
+
+
+# ------------ #
+# prepare deps #
+# ------------ #
+
+pushd "${SRC_DIR}" || exit
+
+npm install
+npm install typescript
+
+popd || exit
+
+
+# ------- #
+# compile #
+# ------- #
+
+pushd "${SRC_DIR}" || exit
+
+cat << EOF > tsconfig.json
+{
+    "compilerOptions": {
+        "target": "es2018",
+        "module": "commonjs",
+        "strict": true,
+        "alwaysStrict": true,
+        "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "outDir": "./out"
+    },
+    "files": [
+        "src/htmlServerMain.ts"
+    ]
+}
+EOF
+
+npx tsc --newLine LF -p .
+
+popd || exit
+
+
+# -------------------- #
+# collect output files #
+# -------------------- #
+
+pushd "${REPO_DIR}" || exit
+
+mv "${SRC_DIR}/out" "${DIST_DIR}"
+cp "${SRC_DIR}/package.json" .
+cp "${SRC_DIR}/package-lock.json" .
+
+popd || exit
diff --git a/vscode-html/out/customData.js b/vscode-html/out/customData.js
new file mode 100644
index 0000000..3fe2702
--- /dev/null
+++ b/vscode-html/out/customData.js
@@ -0,0 +1,27 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+const fs = require("fs");
+function getDataProviders(dataPaths) {
+    if (!dataPaths) {
+        return [];
+    }
+    const providers = [];
+    dataPaths.forEach((path, i) => {
+        try {
+            if (fs.existsSync(path)) {
+                const htmlData = JSON.parse(fs.readFileSync(path, 'utf-8'));
+                providers.push(vscode_html_languageservice_1.newHTMLDataProvider(`customProvider${i}`, htmlData));
+            }
+        }
+        catch (err) {
+            console.log(`Failed to load tag from ${path}`);
+        }
+    });
+    return providers;
+}
+exports.getDataProviders = getDataProviders;
diff --git a/vscode-html/out/htmlServerMain.js b/vscode-html/out/htmlServerMain.js
new file mode 100644
index 0000000..f4b3279
--- /dev/null
+++ b/vscode-html/out/htmlServerMain.js
@@ -0,0 +1,478 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_languageserver_1 = require("vscode-languageserver");
+const languageModes_1 = require("./modes/languageModes");
+const formatting_1 = require("./modes/formatting");
+const arrays_1 = require("./utils/arrays");
+const documentContext_1 = require("./utils/documentContext");
+const vscode_uri_1 = require("vscode-uri");
+const runner_1 = require("./utils/runner");
+const htmlFolding_1 = require("./modes/htmlFolding");
+const customData_1 = require("./customData");
+const selectionRanges_1 = require("./modes/selectionRanges");
+const semanticTokens_1 = require("./modes/semanticTokens");
+var TagCloseRequest;
+(function (TagCloseRequest) {
+    TagCloseRequest.type = new vscode_languageserver_1.RequestType('html/tag');
+})(TagCloseRequest || (TagCloseRequest = {}));
+var MatchingTagPositionRequest;
+(function (MatchingTagPositionRequest) {
+    MatchingTagPositionRequest.type = new vscode_languageserver_1.RequestType('html/matchingTagPosition');
+})(MatchingTagPositionRequest || (MatchingTagPositionRequest = {}));
+var SemanticTokenRequest;
+(function (SemanticTokenRequest) {
+    SemanticTokenRequest.type = new vscode_languageserver_1.RequestType('html/semanticTokens');
+})(SemanticTokenRequest || (SemanticTokenRequest = {}));
+var SemanticTokenLegendRequest;
+(function (SemanticTokenLegendRequest) {
+    SemanticTokenLegendRequest.type = new vscode_languageserver_1.RequestType('html/semanticTokenLegend');
+})(SemanticTokenLegendRequest || (SemanticTokenLegendRequest = {}));
+// Create a connection for the server
+const connection = vscode_languageserver_1.createConnection();
+console.log = connection.console.log.bind(connection.console);
+console.error = connection.console.error.bind(connection.console);
+process.on('unhandledRejection', (e) => {
+    console.error(runner_1.formatError(`Unhandled exception`, e));
+});
+process.on('uncaughtException', (e) => {
+    console.error(runner_1.formatError(`Unhandled exception`, e));
+});
+// Create a text document manager.
+const documents = new vscode_languageserver_1.TextDocuments(languageModes_1.TextDocument);
+// Make the text document manager listen on the connection
+// for open, change and close text document events
+documents.listen(connection);
+let workspaceFolders = [];
+let languageModes;
+let clientSnippetSupport = false;
+let dynamicFormatterRegistration = false;
+let scopedSettingsSupport = false;
+let workspaceFoldersSupport = false;
+let foldingRangeLimit = Number.MAX_VALUE;
+let globalSettings = {};
+let documentSettings = {};
+// remove document settings on close
+documents.onDidClose(e => {
+    delete documentSettings[e.document.uri];
+});
+function getDocumentSettings(textDocument, needsDocumentSettings) {
+    if (scopedSettingsSupport && needsDocumentSettings()) {
+        let promise = documentSettings[textDocument.uri];
+        if (!promise) {
+            const scopeUri = textDocument.uri;
+            const configRequestParam = { items: [{ scopeUri, section: 'css' }, { scopeUri, section: 'html' }, { scopeUri, section: 'javascript' }] };
+            promise = connection.sendRequest(vscode_languageserver_1.ConfigurationRequest.type, configRequestParam).then(s => ({ css: s[0], html: s[1], javascript: s[2] }));
+            documentSettings[textDocument.uri] = promise;
+        }
+        return promise;
+    }
+    return Promise.resolve(undefined);
+}
+// After the server has started the client sends an initialize request. The server receives
+// in the passed params the rootPath of the workspace plus the client capabilities
+connection.onInitialize((params) => {
+    const initializationOptions = params.initializationOptions;
+    workspaceFolders = params.workspaceFolders;
+    if (!Array.isArray(workspaceFolders)) {
+        workspaceFolders = [];
+        if (params.rootPath) {
+            workspaceFolders.push({ name: '', uri: vscode_uri_1.URI.file(params.rootPath).toString() });
+        }
+    }
+    const dataPaths = params.initializationOptions.dataPaths;
+    const providers = customData_1.getDataProviders(dataPaths);
+    const workspace = {
+        get settings() { return globalSettings; },
+        get folders() { return workspaceFolders; }
+    };
+    languageModes = languageModes_1.getLanguageModes(initializationOptions ? initializationOptions.embeddedLanguages : { css: true, javascript: true }, workspace, params.capabilities, providers);
+    documents.onDidClose(e => {
+        languageModes.onDocumentRemoved(e.document);
+    });
+    connection.onShutdown(() => {
+        languageModes.dispose();
+    });
+    function getClientCapability(name, def) {
+        const keys = name.split('.');
+        let c = params.capabilities;
+        for (let i = 0; c && i < keys.length; i++) {
+            if (!c.hasOwnProperty(keys[i])) {
+                return def;
+            }
+            c = c[keys[i]];
+        }
+        return c;
+    }
+    clientSnippetSupport = getClientCapability('textDocument.completion.completionItem.snippetSupport', false);
+    dynamicFormatterRegistration = getClientCapability('textDocument.rangeFormatting.dynamicRegistration', false) && (typeof params.initializationOptions.provideFormatter !== 'boolean');
+    scopedSettingsSupport = getClientCapability('workspace.configuration', false);
+    workspaceFoldersSupport = getClientCapability('workspace.workspaceFolders', false);
+    foldingRangeLimit = getClientCapability('textDocument.foldingRange.rangeLimit', Number.MAX_VALUE);
+    const capabilities = {
+        textDocumentSync: vscode_languageserver_1.TextDocumentSyncKind.Incremental,
+        completionProvider: clientSnippetSupport ? { resolveProvider: true, triggerCharacters: ['.', ':', '<', '"', '=', '/'] } : undefined,
+        hoverProvider: true,
+        documentHighlightProvider: true,
+        documentRangeFormattingProvider: params.initializationOptions.provideFormatter === true,
+        documentLinkProvider: { resolveProvider: false },
+        documentSymbolProvider: true,
+        definitionProvider: true,
+        signatureHelpProvider: { triggerCharacters: ['('] },
+        referencesProvider: true,
+        colorProvider: {},
+        foldingRangeProvider: true,
+        selectionRangeProvider: true,
+        renameProvider: true
+    };
+    return { capabilities };
+});
+connection.onInitialized(() => {
+    if (workspaceFoldersSupport) {
+        connection.client.register(vscode_languageserver_1.DidChangeWorkspaceFoldersNotification.type);
+        connection.onNotification(vscode_languageserver_1.DidChangeWorkspaceFoldersNotification.type, e => {
+            const toAdd = e.event.added;
+            const toRemove = e.event.removed;
+            const updatedFolders = [];
+            if (workspaceFolders) {
+                for (const folder of workspaceFolders) {
+                    if (!toRemove.some(r => r.uri === folder.uri) && !toAdd.some(r => r.uri === folder.uri)) {
+                        updatedFolders.push(folder);
+                    }
+                }
+            }
+            workspaceFolders = updatedFolders.concat(toAdd);
+            documents.all().forEach(triggerValidation);
+        });
+    }
+});
+let formatterRegistration = null;
+// The settings have changed. Is send on server activation as well.
+connection.onDidChangeConfiguration((change) => {
+    globalSettings = change.settings;
+    documentSettings = {}; // reset all document settings
+    documents.all().forEach(triggerValidation);
+    // dynamically enable & disable the formatter
+    if (dynamicFormatterRegistration) {
+        const enableFormatter = globalSettings && globalSettings.html && globalSettings.html.format && globalSettings.html.format.enable;
+        if (enableFormatter) {
+            if (!formatterRegistration) {
+                const documentSelector = [{ language: 'html' }, { language: 'handlebars' }];
+                formatterRegistration = connection.client.register(vscode_languageserver_1.DocumentRangeFormattingRequest.type, { documentSelector });
+            }
+        }
+        else if (formatterRegistration) {
+            formatterRegistration.then(r => r.dispose());
+            formatterRegistration = null;
+        }
+    }
+});
+const pendingValidationRequests = {};
+const validationDelayMs = 500;
+// The content of a text document has changed. This event is emitted
+// when the text document first opened or when its content has changed.
+documents.onDidChangeContent(change => {
+    triggerValidation(change.document);
+});
+// a document has closed: clear all diagnostics
+documents.onDidClose(event => {
+    cleanPendingValidation(event.document);
+    connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+});
+function cleanPendingValidation(textDocument) {
+    const request = pendingValidationRequests[textDocument.uri];
+    if (request) {
+        clearTimeout(request);
+        delete pendingValidationRequests[textDocument.uri];
+    }
+}
+function triggerValidation(textDocument) {
+    cleanPendingValidation(textDocument);
+    pendingValidationRequests[textDocument.uri] = setTimeout(() => {
+        delete pendingValidationRequests[textDocument.uri];
+        validateTextDocument(textDocument);
+    }, validationDelayMs);
+}
+function isValidationEnabled(languageId, settings = globalSettings) {
+    const validationSettings = settings && settings.html && settings.html.validate;
+    if (validationSettings) {
+        return languageId === 'css' && validationSettings.styles !== false || languageId === 'javascript' && validationSettings.scripts !== false;
+    }
+    return true;
+}
+async function validateTextDocument(textDocument) {
+    try {
+        const version = textDocument.version;
+        const diagnostics = [];
+        if (textDocument.languageId === 'html') {
+            const modes = languageModes.getAllModesInDocument(textDocument);
+            const settings = await getDocumentSettings(textDocument, () => modes.some(m => !!m.doValidation));
+            const latestTextDocument = documents.get(textDocument.uri);
+            if (latestTextDocument && latestTextDocument.version === version) { // check no new version has come in after in after the async op
+                modes.forEach(mode => {
+                    if (mode.doValidation && isValidationEnabled(mode.getId(), settings)) {
+                        arrays_1.pushAll(diagnostics, mode.doValidation(latestTextDocument, settings));
+                    }
+                });
+                connection.sendDiagnostics({ uri: latestTextDocument.uri, diagnostics });
+            }
+        }
+    }
+    catch (e) {
+        connection.console.error(runner_1.formatError(`Error while validating ${textDocument.uri}`, e));
+    }
+}
+connection.onCompletion(async (textDocumentPosition, token) => {
+    return runner_1.runSafeAsync(async () => {
+        const document = documents.get(textDocumentPosition.textDocument.uri);
+        if (!document) {
+            return null;
+        }
+        const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
+        if (!mode || !mode.doComplete) {
+            return { isIncomplete: true, items: [] };
+        }
+        const doComplete = mode.doComplete;
+        if (mode.getId() !== 'html') {
+            /* __GDPR__
+                "html.embbedded.complete" : {
+                    "languageId" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+                }
+             */
+            connection.telemetry.logEvent({ key: 'html.embbedded.complete', value: { languageId: mode.getId() } });
+        }
+        const settings = await getDocumentSettings(document, () => doComplete.length > 2);
+        const result = doComplete(document, textDocumentPosition.position, settings);
+        return result;
+    }, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
+});
+connection.onCompletionResolve((item, token) => {
+    return runner_1.runSafe(() => {
+        const data = item.data;
+        if (data && data.languageId && data.uri) {
+            const mode = languageModes.getMode(data.languageId);
+            const document = documents.get(data.uri);
+            if (mode && mode.doResolve && document) {
+                return mode.doResolve(document, item);
+            }
+        }
+        return item;
+    }, item, `Error while resolving completion proposal`, token);
+});
+connection.onHover((textDocumentPosition, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(textDocumentPosition.textDocument.uri);
+        if (document) {
+            const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
+            if (mode && mode.doHover) {
+                return mode.doHover(document, textDocumentPosition.position);
+            }
+        }
+        return null;
+    }, null, `Error while computing hover for ${textDocumentPosition.textDocument.uri}`, token);
+});
+connection.onDocumentHighlight((documentHighlightParams, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(documentHighlightParams.textDocument.uri);
+        if (document) {
+            const mode = languageModes.getModeAtPosition(document, documentHighlightParams.position);
+            if (mode && mode.findDocumentHighlight) {
+                return mode.findDocumentHighlight(document, documentHighlightParams.position);
+            }
+        }
+        return [];
+    }, [], `Error while computing document highlights for ${documentHighlightParams.textDocument.uri}`, token);
+});
+connection.onDefinition((definitionParams, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(definitionParams.textDocument.uri);
+        if (document) {
+            const mode = languageModes.getModeAtPosition(document, definitionParams.position);
+            if (mode && mode.findDefinition) {
+                return mode.findDefinition(document, definitionParams.position);
+            }
+        }
+        return [];
+    }, null, `Error while computing definitions for ${definitionParams.textDocument.uri}`, token);
+});
+connection.onReferences((referenceParams, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(referenceParams.textDocument.uri);
+        if (document) {
+            const mode = languageModes.getModeAtPosition(document, referenceParams.position);
+            if (mode && mode.findReferences) {
+                return mode.findReferences(document, referenceParams.position);
+            }
+        }
+        return [];
+    }, [], `Error while computing references for ${referenceParams.textDocument.uri}`, token);
+});
+connection.onSignatureHelp((signatureHelpParms, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(signatureHelpParms.textDocument.uri);
+        if (document) {
+            const mode = languageModes.getModeAtPosition(document, signatureHelpParms.position);
+            if (mode && mode.doSignatureHelp) {
+                return mode.doSignatureHelp(document, signatureHelpParms.position);
+            }
+        }
+        return null;
+    }, null, `Error while computing signature help for ${signatureHelpParms.textDocument.uri}`, token);
+});
+connection.onDocumentRangeFormatting(async (formatParams, token) => {
+    return runner_1.runSafeAsync(async () => {
+        const document = documents.get(formatParams.textDocument.uri);
+        if (document) {
+            let settings = await getDocumentSettings(document, () => true);
+            if (!settings) {
+                settings = globalSettings;
+            }
+            const unformattedTags = settings && settings.html && settings.html.format && settings.html.format.unformatted || '';
+            const enabledModes = { css: !unformattedTags.match(/\bstyle\b/), javascript: !unformattedTags.match(/\bscript\b/) };
+            return formatting_1.format(languageModes, document, formatParams.range, formatParams.options, settings, enabledModes);
+        }
+        return [];
+    }, [], `Error while formatting range for ${formatParams.textDocument.uri}`, token);
+});
+connection.onDocumentLinks((documentLinkParam, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(documentLinkParam.textDocument.uri);
+        const links = [];
+        if (document) {
+            const documentContext = documentContext_1.getDocumentContext(document.uri, workspaceFolders);
+            languageModes.getAllModesInDocument(document).forEach(m => {
+                if (m.findDocumentLinks) {
+                    arrays_1.pushAll(links, m.findDocumentLinks(document, documentContext));
+                }
+            });
+        }
+        return links;
+    }, [], `Error while document links for ${documentLinkParam.textDocument.uri}`, token);
+});
+connection.onDocumentSymbol((documentSymbolParms, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(documentSymbolParms.textDocument.uri);
+        const symbols = [];
+        if (document) {
+            languageModes.getAllModesInDocument(document).forEach(m => {
+                if (m.findDocumentSymbols) {
+                    arrays_1.pushAll(symbols, m.findDocumentSymbols(document));
+                }
+            });
+        }
+        return symbols;
+    }, [], `Error while computing document symbols for ${documentSymbolParms.textDocument.uri}`, token);
+});
+connection.onRequest(vscode_languageserver_1.DocumentColorRequest.type, (params, token) => {
+    return runner_1.runSafe(() => {
+        const infos = [];
+        const document = documents.get(params.textDocument.uri);
+        if (document) {
+            languageModes.getAllModesInDocument(document).forEach(m => {
+                if (m.findDocumentColors) {
+                    arrays_1.pushAll(infos, m.findDocumentColors(document));
+                }
+            });
+        }
+        return infos;
+    }, [], `Error while computing document colors for ${params.textDocument.uri}`, token);
+});
+connection.onRequest(vscode_languageserver_1.ColorPresentationRequest.type, (params, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(params.textDocument.uri);
+        if (document) {
+            const mode = languageModes.getModeAtPosition(document, params.range.start);
+            if (mode && mode.getColorPresentations) {
+                return mode.getColorPresentations(document, params.color, params.range);
+            }
+        }
+        return [];
+    }, [], `Error while computing color presentations for ${params.textDocument.uri}`, token);
+});
+connection.onRequest(TagCloseRequest.type, (params, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(params.textDocument.uri);
+        if (document) {
+            const pos = params.position;
+            if (pos.character > 0) {
+                const mode = languageModes.getModeAtPosition(document, languageModes_1.Position.create(pos.line, pos.character - 1));
+                if (mode && mode.doAutoClose) {
+                    return mode.doAutoClose(document, pos);
+                }
+            }
+        }
+        return null;
+    }, null, `Error while computing tag close actions for ${params.textDocument.uri}`, token);
+});
+connection.onFoldingRanges((params, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(params.textDocument.uri);
+        if (document) {
+            return htmlFolding_1.getFoldingRanges(languageModes, document, foldingRangeLimit, token);
+        }
+        return null;
+    }, null, `Error while computing folding regions for ${params.textDocument.uri}`, token);
+});
+connection.onSelectionRanges((params, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(params.textDocument.uri);
+        if (document) {
+            return selectionRanges_1.getSelectionRanges(languageModes, document, params.positions);
+        }
+        return [];
+    }, [], `Error while computing selection ranges for ${params.textDocument.uri}`, token);
+});
+connection.onRenameRequest((params, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(params.textDocument.uri);
+        const position = params.position;
+        if (document) {
+            const htmlMode = languageModes.getMode('html');
+            if (htmlMode && htmlMode.doRename) {
+                return htmlMode.doRename(document, position, params.newName);
+            }
+        }
+        return null;
+    }, null, `Error while computing rename for ${params.textDocument.uri}`, token);
+});
+connection.onRequest(MatchingTagPositionRequest.type, (params, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(params.textDocument.uri);
+        if (document) {
+            const pos = params.position;
+            if (pos.character > 0) {
+                const mode = languageModes.getModeAtPosition(document, languageModes_1.Position.create(pos.line, pos.character - 1));
+                if (mode && mode.findMatchingTagPosition) {
+                    return mode.findMatchingTagPosition(document, pos);
+                }
+            }
+        }
+        return null;
+    }, null, `Error while computing matching tag position for ${params.textDocument.uri}`, token);
+});
+let semanticTokensProvider;
+function getSemanticTokenProvider() {
+    if (!semanticTokensProvider) {
+        semanticTokensProvider = semanticTokens_1.newSemanticTokenProvider(languageModes);
+    }
+    return semanticTokensProvider;
+}
+connection.onRequest(SemanticTokenRequest.type, (params, token) => {
+    return runner_1.runSafe(() => {
+        const document = documents.get(params.textDocument.uri);
+        if (document) {
+            return getSemanticTokenProvider().getSemanticTokens(document, params.ranges);
+        }
+        return null;
+    }, null, `Error while computing semantic tokens for ${params.textDocument.uri}`, token);
+});
+connection.onRequest(SemanticTokenLegendRequest.type, (_params, token) => {
+    return runner_1.runSafe(() => {
+        return getSemanticTokenProvider().legend;
+    }, null, `Error while computing semantic tokens legend`, token);
+});
+// Listen on the connection
+connection.listen();
diff --git a/vscode-html/out/languageModelCache.js b/vscode-html/out/languageModelCache.js
new file mode 100644
index 0000000..146b034
--- /dev/null
+++ b/vscode-html/out/languageModelCache.js
@@ -0,0 +1,72 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+function getLanguageModelCache(maxEntries, cleanupIntervalTimeInSec, parse) {
+    let languageModels = {};
+    let nModels = 0;
+    let cleanupInterval = undefined;
+    if (cleanupIntervalTimeInSec > 0) {
+        cleanupInterval = setInterval(() => {
+            const cutoffTime = Date.now() - cleanupIntervalTimeInSec * 1000;
+            const uris = Object.keys(languageModels);
+            for (const uri of uris) {
+                const languageModelInfo = languageModels[uri];
+                if (languageModelInfo.cTime < cutoffTime) {
+                    delete languageModels[uri];
+                    nModels--;
+                }
+            }
+        }, cleanupIntervalTimeInSec * 1000);
+    }
+    return {
+        get(document) {
+            const version = document.version;
+            const languageId = document.languageId;
+            const languageModelInfo = languageModels[document.uri];
+            if (languageModelInfo && languageModelInfo.version === version && languageModelInfo.languageId === languageId) {
+                languageModelInfo.cTime = Date.now();
+                return languageModelInfo.languageModel;
+            }
+            const languageModel = parse(document);
+            languageModels[document.uri] = { languageModel, version, languageId, cTime: Date.now() };
+            if (!languageModelInfo) {
+                nModels++;
+            }
+            if (nModels === maxEntries) {
+                let oldestTime = Number.MAX_VALUE;
+                let oldestUri = null;
+                for (const uri in languageModels) {
+                    const languageModelInfo = languageModels[uri];
+                    if (languageModelInfo.cTime < oldestTime) {
+                        oldestUri = uri;
+                        oldestTime = languageModelInfo.cTime;
+                    }
+                }
+                if (oldestUri) {
+                    delete languageModels[oldestUri];
+                    nModels--;
+                }
+            }
+            return languageModel;
+        },
+        onDocumentRemoved(document) {
+            const uri = document.uri;
+            if (languageModels[uri]) {
+                delete languageModels[uri];
+                nModels--;
+            }
+        },
+        dispose() {
+            if (typeof cleanupInterval !== 'undefined') {
+                clearInterval(cleanupInterval);
+                cleanupInterval = undefined;
+                languageModels = {};
+                nModels = 0;
+            }
+        }
+    };
+}
+exports.getLanguageModelCache = getLanguageModelCache;
diff --git a/vscode-html/out/modes/cssMode.js b/vscode-html/out/modes/cssMode.js
new file mode 100644
index 0000000..aa1b7b1
--- /dev/null
+++ b/vscode-html/out/modes/cssMode.js
@@ -0,0 +1,72 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const languageModelCache_1 = require("../languageModelCache");
+const languageModes_1 = require("./languageModes");
+const embeddedSupport_1 = require("./embeddedSupport");
+function getCSSMode(cssLanguageService, documentRegions, workspace) {
+    let embeddedCSSDocuments = languageModelCache_1.getLanguageModelCache(10, 60, document => documentRegions.get(document).getEmbeddedDocument('css'));
+    let cssStylesheets = languageModelCache_1.getLanguageModelCache(10, 60, document => cssLanguageService.parseStylesheet(document));
+    return {
+        getId() {
+            return 'css';
+        },
+        doValidation(document, settings = workspace.settings) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.doValidation(embedded, cssStylesheets.get(embedded), settings && settings.css);
+        },
+        doComplete(document, position, _settings = workspace.settings) {
+            let embedded = embeddedCSSDocuments.get(document);
+            const stylesheet = cssStylesheets.get(embedded);
+            return cssLanguageService.doComplete(embedded, position, stylesheet) || languageModes_1.CompletionList.create();
+        },
+        doHover(document, position) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.doHover(embedded, position, cssStylesheets.get(embedded));
+        },
+        findDocumentHighlight(document, position) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.findDocumentHighlights(embedded, position, cssStylesheets.get(embedded));
+        },
+        findDocumentSymbols(document) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.findDocumentSymbols(embedded, cssStylesheets.get(embedded)).filter(s => s.name !== embeddedSupport_1.CSS_STYLE_RULE);
+        },
+        findDefinition(document, position) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.findDefinition(embedded, position, cssStylesheets.get(embedded));
+        },
+        findReferences(document, position) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.findReferences(embedded, position, cssStylesheets.get(embedded));
+        },
+        findDocumentColors(document) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.findDocumentColors(embedded, cssStylesheets.get(embedded));
+        },
+        getColorPresentations(document, color, range) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.getColorPresentations(embedded, cssStylesheets.get(embedded), color, range);
+        },
+        getFoldingRanges(document) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.getFoldingRanges(embedded, {});
+        },
+        getSelectionRange(document, position) {
+            let embedded = embeddedCSSDocuments.get(document);
+            return cssLanguageService.getSelectionRanges(embedded, [position], cssStylesheets.get(embedded))[0];
+        },
+        onDocumentRemoved(document) {
+            embeddedCSSDocuments.onDocumentRemoved(document);
+            cssStylesheets.onDocumentRemoved(document);
+        },
+        dispose() {
+            embeddedCSSDocuments.dispose();
+            cssStylesheets.dispose();
+        }
+    };
+}
+exports.getCSSMode = getCSSMode;
diff --git a/vscode-html/out/modes/embeddedSupport.js b/vscode-html/out/modes/embeddedSupport.js
new file mode 100644
index 0000000..cfac420
--- /dev/null
+++ b/vscode-html/out/modes/embeddedSupport.js
@@ -0,0 +1,213 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const languageModes_1 = require("./languageModes");
+exports.CSS_STYLE_RULE = '__';
+function getDocumentRegions(languageService, document) {
+    let regions = [];
+    let scanner = languageService.createScanner(document.getText());
+    let lastTagName = '';
+    let lastAttributeName = null;
+    let languageIdFromType = undefined;
+    let importedScripts = [];
+    let token = scanner.scan();
+    while (token !== languageModes_1.TokenType.EOS) {
+        switch (token) {
+            case languageModes_1.TokenType.StartTag:
+                lastTagName = scanner.getTokenText();
+                lastAttributeName = null;
+                languageIdFromType = 'javascript';
+                break;
+            case languageModes_1.TokenType.Styles:
+                regions.push({ languageId: 'css', start: scanner.getTokenOffset(), end: scanner.getTokenEnd() });
+                break;
+            case languageModes_1.TokenType.Script:
+                regions.push({ languageId: languageIdFromType, start: scanner.getTokenOffset(), end: scanner.getTokenEnd() });
+                break;
+            case languageModes_1.TokenType.AttributeName:
+                lastAttributeName = scanner.getTokenText();
+                break;
+            case languageModes_1.TokenType.AttributeValue:
+                if (lastAttributeName === 'src' && lastTagName.toLowerCase() === 'script') {
+                    let value = scanner.getTokenText();
+                    if (value[0] === '\'' || value[0] === '"') {
+                        value = value.substr(1, value.length - 1);
+                    }
+                    importedScripts.push(value);
+                }
+                else if (lastAttributeName === 'type' && lastTagName.toLowerCase() === 'script') {
+                    if (/["'](module|(text|application)\/(java|ecma)script|text\/babel)["']/.test(scanner.getTokenText())) {
+                        languageIdFromType = 'javascript';
+                    }
+                    else if (/["']text\/typescript["']/.test(scanner.getTokenText())) {
+                        languageIdFromType = 'typescript';
+                    }
+                    else {
+                        languageIdFromType = undefined;
+                    }
+                }
+                else {
+                    let attributeLanguageId = getAttributeLanguage(lastAttributeName);
+                    if (attributeLanguageId) {
+                        let start = scanner.getTokenOffset();
+                        let end = scanner.getTokenEnd();
+                        let firstChar = document.getText()[start];
+                        if (firstChar === '\'' || firstChar === '"') {
+                            start++;
+                            end--;
+                        }
+                        regions.push({ languageId: attributeLanguageId, start, end, attributeValue: true });
+                    }
+                }
+                lastAttributeName = null;
+                break;
+        }
+        token = scanner.scan();
+    }
+    return {
+        getLanguageRanges: (range) => getLanguageRanges(document, regions, range),
+        getEmbeddedDocument: (languageId, ignoreAttributeValues) => getEmbeddedDocument(document, regions, languageId, ignoreAttributeValues),
+        getLanguageAtPosition: (position) => getLanguageAtPosition(document, regions, position),
+        getLanguagesInDocument: () => getLanguagesInDocument(document, regions),
+        getImportedScripts: () => importedScripts
+    };
+}
+exports.getDocumentRegions = getDocumentRegions;
+function getLanguageRanges(document, regions, range) {
+    let result = [];
+    let currentPos = range ? range.start : languageModes_1.Position.create(0, 0);
+    let currentOffset = range ? document.offsetAt(range.start) : 0;
+    let endOffset = range ? document.offsetAt(range.end) : document.getText().length;
+    for (let region of regions) {
+        if (region.end > currentOffset && region.start < endOffset) {
+            let start = Math.max(region.start, currentOffset);
+            let startPos = document.positionAt(start);
+            if (currentOffset < region.start) {
+                result.push({
+                    start: currentPos,
+                    end: startPos,
+                    languageId: 'html'
+                });
+            }
+            let end = Math.min(region.end, endOffset);
+            let endPos = document.positionAt(end);
+            if (end > region.start) {
+                result.push({
+                    start: startPos,
+                    end: endPos,
+                    languageId: region.languageId,
+                    attributeValue: region.attributeValue
+                });
+            }
+            currentOffset = end;
+            currentPos = endPos;
+        }
+    }
+    if (currentOffset < endOffset) {
+        let endPos = range ? range.end : document.positionAt(endOffset);
+        result.push({
+            start: currentPos,
+            end: endPos,
+            languageId: 'html'
+        });
+    }
+    return result;
+}
+function getLanguagesInDocument(_document, regions) {
+    let result = [];
+    for (let region of regions) {
+        if (region.languageId && result.indexOf(region.languageId) === -1) {
+            result.push(region.languageId);
+            if (result.length === 3) {
+                return result;
+            }
+        }
+    }
+    result.push('html');
+    return result;
+}
+function getLanguageAtPosition(document, regions, position) {
+    let offset = document.offsetAt(position);
+    for (let region of regions) {
+        if (region.start <= offset) {
+            if (offset <= region.end) {
+                return region.languageId;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return 'html';
+}
+function getEmbeddedDocument(document, contents, languageId, ignoreAttributeValues) {
+    let currentPos = 0;
+    let oldContent = document.getText();
+    let result = '';
+    let lastSuffix = '';
+    for (let c of contents) {
+        if (c.languageId === languageId && (!ignoreAttributeValues || !c.attributeValue)) {
+            result = substituteWithWhitespace(result, currentPos, c.start, oldContent, lastSuffix, getPrefix(c));
+            result += oldContent.substring(c.start, c.end);
+            currentPos = c.end;
+            lastSuffix = getSuffix(c);
+        }
+    }
+    result = substituteWithWhitespace(result, currentPos, oldContent.length, oldContent, lastSuffix, '');
+    return languageModes_1.TextDocument.create(document.uri, languageId, document.version, result);
+}
+function getPrefix(c) {
+    if (c.attributeValue) {
+        switch (c.languageId) {
+            case 'css': return exports.CSS_STYLE_RULE + '{';
+        }
+    }
+    return '';
+}
+function getSuffix(c) {
+    if (c.attributeValue) {
+        switch (c.languageId) {
+            case 'css': return '}';
+            case 'javascript': return ';';
+        }
+    }
+    return '';
+}
+function substituteWithWhitespace(result, start, end, oldContent, before, after) {
+    let accumulatedWS = 0;
+    result += before;
+    for (let i = start + before.length; i < end; i++) {
+        let ch = oldContent[i];
+        if (ch === '\n' || ch === '\r') {
+            // only write new lines, skip the whitespace
+            accumulatedWS = 0;
+            result += ch;
+        }
+        else {
+            accumulatedWS++;
+        }
+    }
+    result = append(result, ' ', accumulatedWS - after.length);
+    result += after;
+    return result;
+}
+function append(result, str, n) {
+    while (n > 0) {
+        if (n & 1) {
+            result += str;
+        }
+        n >>= 1;
+        str += str;
+    }
+    return result;
+}
+function getAttributeLanguage(attributeName) {
+    let match = attributeName.match(/^(style)$|^(on\w+)$/i);
+    if (!match) {
+        return null;
+    }
+    return match[1] ? 'css' : 'javascript';
+}
diff --git a/vscode-html/out/modes/formatting.js b/vscode-html/out/modes/formatting.js
new file mode 100644
index 0000000..cfd57c2
--- /dev/null
+++ b/vscode-html/out/modes/formatting.js
@@ -0,0 +1,82 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const languageModes_1 = require("./languageModes");
+const arrays_1 = require("../utils/arrays");
+const strings_1 = require("../utils/strings");
+function format(languageModes, document, formatRange, formattingOptions, settings, enabledModes) {
+    let result = [];
+    let endPos = formatRange.end;
+    let endOffset = document.offsetAt(endPos);
+    let content = document.getText();
+    if (endPos.character === 0 && endPos.line > 0 && endOffset !== content.length) {
+        // if selection ends after a new line, exclude that new line
+        let prevLineStart = document.offsetAt(languageModes_1.Position.create(endPos.line - 1, 0));
+        while (strings_1.isEOL(content, endOffset - 1) && endOffset > prevLineStart) {
+            endOffset--;
+        }
+        formatRange = languageModes_1.Range.create(formatRange.start, document.positionAt(endOffset));
+    }
+    // run the html formatter on the full range and pass the result content to the embedded formatters.
+    // from the final content create a single edit
+    // advantages of this approach are
+    //  - correct indents in the html document
+    //  - correct initial indent for embedded formatters
+    //  - no worrying of overlapping edits
+    // make sure we start in html
+    let allRanges = languageModes.getModesInRange(document, formatRange);
+    let i = 0;
+    let startPos = formatRange.start;
+    let isHTML = (range) => range.mode && range.mode.getId() === 'html';
+    while (i < allRanges.length && !isHTML(allRanges[i])) {
+        let range = allRanges[i];
+        if (!range.attributeValue && range.mode && range.mode.format) {
+            let edits = range.mode.format(document, languageModes_1.Range.create(startPos, range.end), formattingOptions, settings);
+            arrays_1.pushAll(result, edits);
+        }
+        startPos = range.end;
+        i++;
+    }
+    if (i === allRanges.length) {
+        return result;
+    }
+    // modify the range
+    formatRange = languageModes_1.Range.create(startPos, formatRange.end);
+    // perform a html format and apply changes to a new document
+    let htmlMode = languageModes.getMode('html');
+    let htmlEdits = htmlMode.format(document, formatRange, formattingOptions, settings);
+    let htmlFormattedContent = languageModes_1.TextDocument.applyEdits(document, htmlEdits);
+    let newDocument = languageModes_1.TextDocument.create(document.uri + '.tmp', document.languageId, document.version, htmlFormattedContent);
+    try {
+        // run embedded formatters on html formatted content: - formatters see correct initial indent
+        let afterFormatRangeLength = document.getText().length - document.offsetAt(formatRange.end); // length of unchanged content after replace range
+        let newFormatRange = languageModes_1.Range.create(formatRange.start, newDocument.positionAt(htmlFormattedContent.length - afterFormatRangeLength));
+        let embeddedRanges = languageModes.getModesInRange(newDocument, newFormatRange);
+        let embeddedEdits = [];
+        for (let r of embeddedRanges) {
+            let mode = r.mode;
+            if (mode && mode.format && enabledModes[mode.getId()] && !r.attributeValue) {
+                let edits = mode.format(newDocument, r, formattingOptions, settings);
+                for (let edit of edits) {
+                    embeddedEdits.push(edit);
+                }
+            }
+        }
+        if (embeddedEdits.length === 0) {
+            arrays_1.pushAll(result, htmlEdits);
+            return result;
+        }
+        // apply all embedded format edits and create a single edit for all changes
+        let resultContent = languageModes_1.TextDocument.applyEdits(newDocument, embeddedEdits);
+        let resultReplaceText = resultContent.substring(document.offsetAt(formatRange.start), resultContent.length - afterFormatRangeLength);
+        result.push(languageModes_1.TextEdit.replace(formatRange, resultReplaceText));
+        return result;
+    }
+    finally {
+        languageModes.onDocumentRemoved(newDocument);
+    }
+}
+exports.format = format;
diff --git a/vscode-html/out/modes/htmlFolding.js b/vscode-html/out/modes/htmlFolding.js
new file mode 100644
index 0000000..b99f936
--- /dev/null
+++ b/vscode-html/out/modes/htmlFolding.js
@@ -0,0 +1,111 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const languageModes_1 = require("./languageModes");
+function getFoldingRanges(languageModes, document, maxRanges, _cancellationToken) {
+    let htmlMode = languageModes.getMode('html');
+    let range = languageModes_1.Range.create(languageModes_1.Position.create(0, 0), languageModes_1.Position.create(document.lineCount, 0));
+    let result = [];
+    if (htmlMode && htmlMode.getFoldingRanges) {
+        result.push(...htmlMode.getFoldingRanges(document));
+    }
+    // cache folding ranges per mode
+    let rangesPerMode = Object.create(null);
+    let getRangesForMode = (mode) => {
+        if (mode.getFoldingRanges) {
+            let ranges = rangesPerMode[mode.getId()];
+            if (!Array.isArray(ranges)) {
+                ranges = mode.getFoldingRanges(document) || [];
+                rangesPerMode[mode.getId()] = ranges;
+            }
+            return ranges;
+        }
+        return [];
+    };
+    let modeRanges = languageModes.getModesInRange(document, range);
+    for (let modeRange of modeRanges) {
+        let mode = modeRange.mode;
+        if (mode && mode !== htmlMode && !modeRange.attributeValue) {
+            const ranges = getRangesForMode(mode);
+            result.push(...ranges.filter(r => r.startLine >= modeRange.start.line && r.endLine < modeRange.end.line));
+        }
+    }
+    if (maxRanges && result.length > maxRanges) {
+        result = limitRanges(result, maxRanges);
+    }
+    return result;
+}
+exports.getFoldingRanges = getFoldingRanges;
+function limitRanges(ranges, maxRanges) {
+    ranges = ranges.sort((r1, r2) => {
+        let diff = r1.startLine - r2.startLine;
+        if (diff === 0) {
+            diff = r1.endLine - r2.endLine;
+        }
+        return diff;
+    });
+    // compute each range's nesting level in 'nestingLevels'.
+    // count the number of ranges for each level in 'nestingLevelCounts'
+    let top = undefined;
+    let previous = [];
+    let nestingLevels = [];
+    let nestingLevelCounts = [];
+    let setNestingLevel = (index, level) => {
+        nestingLevels[index] = level;
+        if (level < 30) {
+            nestingLevelCounts[level] = (nestingLevelCounts[level] || 0) + 1;
+        }
+    };
+    // compute nesting levels and sanitize
+    for (let i = 0; i < ranges.length; i++) {
+        let entry = ranges[i];
+        if (!top) {
+            top = entry;
+            setNestingLevel(i, 0);
+        }
+        else {
+            if (entry.startLine > top.startLine) {
+                if (entry.endLine <= top.endLine) {
+                    previous.push(top);
+                    top = entry;
+                    setNestingLevel(i, previous.length);
+                }
+                else if (entry.startLine > top.endLine) {
+                    do {
+                        top = previous.pop();
+                    } while (top && entry.startLine > top.endLine);
+                    if (top) {
+                        previous.push(top);
+                    }
+                    top = entry;
+                    setNestingLevel(i, previous.length);
+                }
+            }
+        }
+    }
+    let entries = 0;
+    let maxLevel = 0;
+    for (let i = 0; i < nestingLevelCounts.length; i++) {
+        let n = nestingLevelCounts[i];
+        if (n) {
+            if (n + entries > maxRanges) {
+                maxLevel = i;
+                break;
+            }
+            entries += n;
+        }
+    }
+    let result = [];
+    for (let i = 0; i < ranges.length; i++) {
+        let level = nestingLevels[i];
+        if (typeof level === 'number') {
+            if (level < maxLevel || (level === maxLevel && entries++ < maxRanges)) {
+                result.push(ranges[i]);
+            }
+        }
+    }
+    return result;
+}
diff --git a/vscode-html/out/modes/htmlMode.js b/vscode-html/out/modes/htmlMode.js
new file mode 100644
index 0000000..241e56e
--- /dev/null
+++ b/vscode-html/out/modes/htmlMode.js
@@ -0,0 +1,96 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const languageModelCache_1 = require("../languageModelCache");
+const pathCompletion_1 = require("./pathCompletion");
+function getHTMLMode(htmlLanguageService, workspace) {
+    let htmlDocuments = languageModelCache_1.getLanguageModelCache(10, 60, document => htmlLanguageService.parseHTMLDocument(document));
+    return {
+        getId() {
+            return 'html';
+        },
+        getSelectionRange(document, position) {
+            return htmlLanguageService.getSelectionRanges(document, [position])[0];
+        },
+        doComplete(document, position, settings = workspace.settings) {
+            let options = settings && settings.html && settings.html.suggest;
+            let doAutoComplete = settings && settings.html && settings.html.autoClosingTags;
+            if (doAutoComplete) {
+                options.hideAutoCompleteProposals = true;
+            }
+            let pathCompletionProposals = [];
+            let participants = [pathCompletion_1.getPathCompletionParticipant(document, workspace.folders, pathCompletionProposals)];
+            htmlLanguageService.setCompletionParticipants(participants);
+            const htmlDocument = htmlDocuments.get(document);
+            let completionList = htmlLanguageService.doComplete(document, position, htmlDocument, options);
+            completionList.items.push(...pathCompletionProposals);
+            return completionList;
+        },
+        doHover(document, position) {
+            return htmlLanguageService.doHover(document, position, htmlDocuments.get(document));
+        },
+        findDocumentHighlight(document, position) {
+            return htmlLanguageService.findDocumentHighlights(document, position, htmlDocuments.get(document));
+        },
+        findDocumentLinks(document, documentContext) {
+            return htmlLanguageService.findDocumentLinks(document, documentContext);
+        },
+        findDocumentSymbols(document) {
+            return htmlLanguageService.findDocumentSymbols(document, htmlDocuments.get(document));
+        },
+        format(document, range, formatParams, settings = workspace.settings) {
+            let formatSettings = settings && settings.html && settings.html.format;
+            if (formatSettings) {
+                formatSettings = merge(formatSettings, {});
+            }
+            else {
+                formatSettings = {};
+            }
+            if (formatSettings.contentUnformatted) {
+                formatSettings.contentUnformatted = formatSettings.contentUnformatted + ',script';
+            }
+            else {
+                formatSettings.contentUnformatted = 'script';
+            }
+            formatSettings = merge(formatParams, formatSettings);
+            return htmlLanguageService.format(document, range, formatSettings);
+        },
+        getFoldingRanges(document) {
+            return htmlLanguageService.getFoldingRanges(document);
+        },
+        doAutoClose(document, position) {
+            let offset = document.offsetAt(position);
+            let text = document.getText();
+            if (offset > 0 && text.charAt(offset - 1).match(/[>\/]/g)) {
+                return htmlLanguageService.doTagComplete(document, position, htmlDocuments.get(document));
+            }
+            return null;
+        },
+        doRename(document, position, newName) {
+            const htmlDocument = htmlDocuments.get(document);
+            return htmlLanguageService.doRename(document, position, newName, htmlDocument);
+        },
+        onDocumentRemoved(document) {
+            htmlDocuments.onDocumentRemoved(document);
+        },
+        findMatchingTagPosition(document, position) {
+            const htmlDocument = htmlDocuments.get(document);
+            return htmlLanguageService.findMatchingTagPosition(document, position, htmlDocument);
+        },
+        dispose() {
+            htmlDocuments.dispose();
+        }
+    };
+}
+exports.getHTMLMode = getHTMLMode;
+function merge(src, dst) {
+    for (const key in src) {
+        if (src.hasOwnProperty(key)) {
+            dst[key] = src[key];
+        }
+    }
+    return dst;
+}
diff --git a/vscode-html/out/modes/javascriptMode.js b/vscode-html/out/modes/javascriptMode.js
new file mode 100644
index 0000000..7948b6d
--- /dev/null
+++ b/vscode-html/out/modes/javascriptMode.js
@@ -0,0 +1,429 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const languageModelCache_1 = require("../languageModelCache");
+const languageModes_1 = require("./languageModes");
+const strings_1 = require("../utils/strings");
+const ts = require("typescript");
+const path_1 = require("path");
+const javascriptSemanticTokens_1 = require("./javascriptSemanticTokens");
+const JS_WORD_REGEX = /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g;
+let jquery_d_ts = path_1.join(__dirname, '../lib/jquery.d.ts'); // when packaged
+if (!ts.sys.fileExists(jquery_d_ts)) {
+    jquery_d_ts = path_1.join(__dirname, '../../lib/jquery.d.ts'); // from source
+}
+function getJavaScriptMode(documentRegions, languageId) {
+    let jsDocuments = languageModelCache_1.getLanguageModelCache(10, 60, document => documentRegions.get(document).getEmbeddedDocument(languageId));
+    const workingFile = languageId === 'javascript' ? 'vscode://javascript/1.js' : 'vscode://javascript/2.ts'; // the same 'file' is used for all contents
+    let compilerOptions = { allowNonTsExtensions: true, allowJs: true, lib: ['lib.es6.d.ts'], target: ts.ScriptTarget.Latest, moduleResolution: ts.ModuleResolutionKind.Classic };
+    let currentTextDocument;
+    let scriptFileVersion = 0;
+    function updateCurrentTextDocument(doc) {
+        if (!currentTextDocument || doc.uri !== currentTextDocument.uri || doc.version !== currentTextDocument.version) {
+            currentTextDocument = jsDocuments.get(doc);
+            scriptFileVersion++;
+        }
+    }
+    const host = {
+        getCompilationSettings: () => compilerOptions,
+        getScriptFileNames: () => [workingFile, jquery_d_ts],
+        getScriptKind: (fileName) => fileName.substr(fileName.length - 2) === 'ts' ? ts.ScriptKind.TS : ts.ScriptKind.JS,
+        getScriptVersion: (fileName) => {
+            if (fileName === workingFile) {
+                return String(scriptFileVersion);
+            }
+            return '1'; // default lib an jquery.d.ts are static
+        },
+        getScriptSnapshot: (fileName) => {
+            let text = '';
+            if (strings_1.startsWith(fileName, 'vscode:')) {
+                if (fileName === workingFile) {
+                    text = currentTextDocument.getText();
+                }
+            }
+            else {
+                text = ts.sys.readFile(fileName) || '';
+            }
+            return {
+                getText: (start, end) => text.substring(start, end),
+                getLength: () => text.length,
+                getChangeRange: () => undefined
+            };
+        },
+        getCurrentDirectory: () => '',
+        getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options)
+    };
+    let jsLanguageService = ts.createLanguageService(host);
+    let globalSettings = {};
+    return {
+        getId() {
+            return languageId;
+        },
+        doValidation(document) {
+            updateCurrentTextDocument(document);
+            const syntaxDiagnostics = jsLanguageService.getSyntacticDiagnostics(workingFile);
+            const semanticDiagnostics = jsLanguageService.getSemanticDiagnostics(workingFile);
+            return syntaxDiagnostics.concat(semanticDiagnostics).map((diag) => {
+                return {
+                    range: convertRange(currentTextDocument, diag),
+                    severity: languageModes_1.DiagnosticSeverity.Error,
+                    source: languageId,
+                    message: ts.flattenDiagnosticMessageText(diag.messageText, '\n')
+                };
+            });
+        },
+        doComplete(document, position) {
+            updateCurrentTextDocument(document);
+            let offset = currentTextDocument.offsetAt(position);
+            let completions = jsLanguageService.getCompletionsAtPosition(workingFile, offset, { includeExternalModuleExports: false, includeInsertTextCompletions: false });
+            if (!completions) {
+                return { isIncomplete: false, items: [] };
+            }
+            let replaceRange = convertRange(currentTextDocument, strings_1.getWordAtText(currentTextDocument.getText(), offset, JS_WORD_REGEX));
+            return {
+                isIncomplete: false,
+                items: completions.entries.map(entry => {
+                    return {
+                        uri: document.uri,
+                        position: position,
+                        label: entry.name,
+                        sortText: entry.sortText,
+                        kind: convertKind(entry.kind),
+                        textEdit: languageModes_1.TextEdit.replace(replaceRange, entry.name),
+                        data: {
+                            languageId,
+                            uri: document.uri,
+                            offset: offset
+                        }
+                    };
+                })
+            };
+        },
+        doResolve(document, item) {
+            updateCurrentTextDocument(document);
+            let details = jsLanguageService.getCompletionEntryDetails(workingFile, item.data.offset, item.label, undefined, undefined, undefined);
+            if (details) {
+                item.detail = ts.displayPartsToString(details.displayParts);
+                item.documentation = ts.displayPartsToString(details.documentation);
+                delete item.data;
+            }
+            return item;
+        },
+        doHover(document, position) {
+            updateCurrentTextDocument(document);
+            let info = jsLanguageService.getQuickInfoAtPosition(workingFile, currentTextDocument.offsetAt(position));
+            if (info) {
+                let contents = ts.displayPartsToString(info.displayParts);
+                return {
+                    range: convertRange(currentTextDocument, info.textSpan),
+                    contents: languageModes_1.MarkedString.fromPlainText(contents)
+                };
+            }
+            return null;
+        },
+        doSignatureHelp(document, position) {
+            updateCurrentTextDocument(document);
+            let signHelp = jsLanguageService.getSignatureHelpItems(workingFile, currentTextDocument.offsetAt(position), undefined);
+            if (signHelp) {
+                let ret = {
+                    activeSignature: signHelp.selectedItemIndex,
+                    activeParameter: signHelp.argumentIndex,
+                    signatures: []
+                };
+                signHelp.items.forEach(item => {
+                    let signature = {
+                        label: '',
+                        documentation: undefined,
+                        parameters: []
+                    };
+                    signature.label += ts.displayPartsToString(item.prefixDisplayParts);
+                    item.parameters.forEach((p, i, a) => {
+                        let label = ts.displayPartsToString(p.displayParts);
+                        let parameter = {
+                            label: label,
+                            documentation: ts.displayPartsToString(p.documentation)
+                        };
+                        signature.label += label;
+                        signature.parameters.push(parameter);
+                        if (i < a.length - 1) {
+                            signature.label += ts.displayPartsToString(item.separatorDisplayParts);
+                        }
+                    });
+                    signature.label += ts.displayPartsToString(item.suffixDisplayParts);
+                    ret.signatures.push(signature);
+                });
+                return ret;
+            }
+            return null;
+        },
+        findDocumentHighlight(document, position) {
+            updateCurrentTextDocument(document);
+            const highlights = jsLanguageService.getDocumentHighlights(workingFile, currentTextDocument.offsetAt(position), [workingFile]);
+            const out = [];
+            for (const entry of highlights || []) {
+                for (const highlight of entry.highlightSpans) {
+                    out.push({
+                        range: convertRange(currentTextDocument, highlight.textSpan),
+                        kind: highlight.kind === 'writtenReference' ? languageModes_1.DocumentHighlightKind.Write : languageModes_1.DocumentHighlightKind.Text
+                    });
+                }
+            }
+            return out;
+        },
+        findDocumentSymbols(document) {
+            updateCurrentTextDocument(document);
+            let items = jsLanguageService.getNavigationBarItems(workingFile);
+            if (items) {
+                let result = [];
+                let existing = Object.create(null);
+                let collectSymbols = (item, containerLabel) => {
+                    let sig = item.text + item.kind + item.spans[0].start;
+                    if (item.kind !== 'script' && !existing[sig]) {
+                        let symbol = {
+                            name: item.text,
+                            kind: convertSymbolKind(item.kind),
+                            location: {
+                                uri: document.uri,
+                                range: convertRange(currentTextDocument, item.spans[0])
+                            },
+                            containerName: containerLabel
+                        };
+                        existing[sig] = true;
+                        result.push(symbol);
+                        containerLabel = item.text;
+                    }
+                    if (item.childItems && item.childItems.length > 0) {
+                        for (let child of item.childItems) {
+                            collectSymbols(child, containerLabel);
+                        }
+                    }
+                };
+                items.forEach(item => collectSymbols(item));
+                return result;
+            }
+            return [];
+        },
+        findDefinition(document, position) {
+            updateCurrentTextDocument(document);
+            let definition = jsLanguageService.getDefinitionAtPosition(workingFile, currentTextDocument.offsetAt(position));
+            if (definition) {
+                return definition.filter(d => d.fileName === workingFile).map(d => {
+                    return {
+                        uri: document.uri,
+                        range: convertRange(currentTextDocument, d.textSpan)
+                    };
+                });
+            }
+            return null;
+        },
+        findReferences(document, position) {
+            updateCurrentTextDocument(document);
+            let references = jsLanguageService.getReferencesAtPosition(workingFile, currentTextDocument.offsetAt(position));
+            if (references) {
+                return references.filter(d => d.fileName === workingFile).map(d => {
+                    return {
+                        uri: document.uri,
+                        range: convertRange(currentTextDocument, d.textSpan)
+                    };
+                });
+            }
+            return [];
+        },
+        getSelectionRange(document, position) {
+            updateCurrentTextDocument(document);
+            function convertSelectionRange(selectionRange) {
+                const parent = selectionRange.parent ? convertSelectionRange(selectionRange.parent) : undefined;
+                return languageModes_1.SelectionRange.create(convertRange(currentTextDocument, selectionRange.textSpan), parent);
+            }
+            const range = jsLanguageService.getSmartSelectionRange(workingFile, currentTextDocument.offsetAt(position));
+            return convertSelectionRange(range);
+        },
+        format(document, range, formatParams, settings = globalSettings) {
+            currentTextDocument = documentRegions.get(document).getEmbeddedDocument('javascript', true);
+            scriptFileVersion++;
+            let formatterSettings = settings && settings.javascript && settings.javascript.format;
+            let initialIndentLevel = computeInitialIndent(document, range, formatParams);
+            let formatSettings = convertOptions(formatParams, formatterSettings, initialIndentLevel + 1);
+            let start = currentTextDocument.offsetAt(range.start);
+            let end = currentTextDocument.offsetAt(range.end);
+            let lastLineRange = null;
+            if (range.end.line > range.start.line && (range.end.character === 0 || strings_1.isWhitespaceOnly(currentTextDocument.getText().substr(end - range.end.character, range.end.character)))) {
+                end -= range.end.character;
+                lastLineRange = languageModes_1.Range.create(languageModes_1.Position.create(range.end.line, 0), range.end);
+            }
+            let edits = jsLanguageService.getFormattingEditsForRange(workingFile, start, end, formatSettings);
+            if (edits) {
+                let result = [];
+                for (let edit of edits) {
+                    if (edit.span.start >= start && edit.span.start + edit.span.length <= end) {
+                        result.push({
+                            range: convertRange(currentTextDocument, edit.span),
+                            newText: edit.newText
+                        });
+                    }
+                }
+                if (lastLineRange) {
+                    result.push({
+                        range: lastLineRange,
+                        newText: generateIndent(initialIndentLevel, formatParams)
+                    });
+                }
+                return result;
+            }
+            return [];
+        },
+        getFoldingRanges(document) {
+            updateCurrentTextDocument(document);
+            let spans = jsLanguageService.getOutliningSpans(workingFile);
+            let ranges = [];
+            for (let span of spans) {
+                let curr = convertRange(currentTextDocument, span.textSpan);
+                let startLine = curr.start.line;
+                let endLine = curr.end.line;
+                if (startLine < endLine) {
+                    let foldingRange = { startLine, endLine };
+                    let match = document.getText(curr).match(/^\s*\/(?:(\/\s*#(?:end)?region\b)|(\*|\/))/);
+                    if (match) {
+                        foldingRange.kind = match[1] ? languageModes_1.FoldingRangeKind.Region : languageModes_1.FoldingRangeKind.Comment;
+                    }
+                    ranges.push(foldingRange);
+                }
+            }
+            return ranges;
+        },
+        onDocumentRemoved(document) {
+            jsDocuments.onDocumentRemoved(document);
+        },
+        getSemanticTokens(document) {
+            updateCurrentTextDocument(document);
+            return javascriptSemanticTokens_1.getSemanticTokens(jsLanguageService, currentTextDocument, workingFile);
+        },
+        getSemanticTokenLegend() {
+            return javascriptSemanticTokens_1.getSemanticTokenLegend();
+        },
+        dispose() {
+            jsLanguageService.dispose();
+            jsDocuments.dispose();
+        }
+    };
+}
+exports.getJavaScriptMode = getJavaScriptMode;
+function convertRange(document, span) {
+    if (typeof span.start === 'undefined') {
+        const pos = document.positionAt(0);
+        return languageModes_1.Range.create(pos, pos);
+    }
+    const startPosition = document.positionAt(span.start);
+    const endPosition = document.positionAt(span.start + (span.length || 0));
+    return languageModes_1.Range.create(startPosition, endPosition);
+}
+function convertKind(kind) {
+    switch (kind) {
+        case 'primitive type':
+        case 'keyword':
+            return languageModes_1.CompletionItemKind.Keyword;
+        case 'var':
+        case 'local var':
+            return languageModes_1.CompletionItemKind.Variable;
+        case 'property':
+        case 'getter':
+        case 'setter':
+            return languageModes_1.CompletionItemKind.Field;
+        case 'function':
+        case 'method':
+        case 'construct':
+        case 'call':
+        case 'index':
+            return languageModes_1.CompletionItemKind.Function;
+        case 'enum':
+            return languageModes_1.CompletionItemKind.Enum;
+        case 'module':
+            return languageModes_1.CompletionItemKind.Module;
+        case 'class':
+            return languageModes_1.CompletionItemKind.Class;
+        case 'interface':
+            return languageModes_1.CompletionItemKind.Interface;
+        case 'warning':
+            return languageModes_1.CompletionItemKind.File;
+    }
+    return languageModes_1.CompletionItemKind.Property;
+}
+function convertSymbolKind(kind) {
+    switch (kind) {
+        case 'var':
+        case 'local var':
+        case 'const':
+            return languageModes_1.SymbolKind.Variable;
+        case 'function':
+        case 'local function':
+            return languageModes_1.SymbolKind.Function;
+        case 'enum':
+            return languageModes_1.SymbolKind.Enum;
+        case 'module':
+            return languageModes_1.SymbolKind.Module;
+        case 'class':
+            return languageModes_1.SymbolKind.Class;
+        case 'interface':
+            return languageModes_1.SymbolKind.Interface;
+        case 'method':
+            return languageModes_1.SymbolKind.Method;
+        case 'property':
+        case 'getter':
+        case 'setter':
+            return languageModes_1.SymbolKind.Property;
+    }
+    return languageModes_1.SymbolKind.Variable;
+}
+function convertOptions(options, formatSettings, initialIndentLevel) {
+    return {
+        ConvertTabsToSpaces: options.insertSpaces,
+        TabSize: options.tabSize,
+        IndentSize: options.tabSize,
+        IndentStyle: ts.IndentStyle.Smart,
+        NewLineCharacter: '\n',
+        BaseIndentSize: options.tabSize * initialIndentLevel,
+        InsertSpaceAfterCommaDelimiter: Boolean(!formatSettings || formatSettings.insertSpaceAfterCommaDelimiter),
+        InsertSpaceAfterSemicolonInForStatements: Boolean(!formatSettings || formatSettings.insertSpaceAfterSemicolonInForStatements),
+        InsertSpaceBeforeAndAfterBinaryOperators: Boolean(!formatSettings || formatSettings.insertSpaceBeforeAndAfterBinaryOperators),
+        InsertSpaceAfterKeywordsInControlFlowStatements: Boolean(!formatSettings || formatSettings.insertSpaceAfterKeywordsInControlFlowStatements),
+        InsertSpaceAfterFunctionKeywordForAnonymousFunctions: Boolean(!formatSettings || formatSettings.insertSpaceAfterFunctionKeywordForAnonymousFunctions),
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: Boolean(formatSettings && formatSettings.insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis),
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: Boolean(formatSettings && formatSettings.insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets),
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: Boolean(formatSettings && formatSettings.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces),
+        InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: Boolean(formatSettings && formatSettings.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces),
+        PlaceOpenBraceOnNewLineForControlBlocks: Boolean(formatSettings && formatSettings.placeOpenBraceOnNewLineForFunctions),
+        PlaceOpenBraceOnNewLineForFunctions: Boolean(formatSettings && formatSettings.placeOpenBraceOnNewLineForControlBlocks)
+    };
+}
+function computeInitialIndent(document, range, options) {
+    let lineStart = document.offsetAt(languageModes_1.Position.create(range.start.line, 0));
+    let content = document.getText();
+    let i = lineStart;
+    let nChars = 0;
+    let tabSize = options.tabSize || 4;
+    while (i < content.length) {
+        let ch = content.charAt(i);
+        if (ch === ' ') {
+            nChars++;
+        }
+        else if (ch === '\t') {
+            nChars += tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return Math.floor(nChars / tabSize);
+}
+function generateIndent(level, options) {
+    if (options.insertSpaces) {
+        return strings_1.repeat(' ', level * options.tabSize);
+    }
+    else {
+        return strings_1.repeat('\t', level);
+    }
+}
diff --git a/vscode-html/out/modes/javascriptSemanticTokens.js b/vscode-html/out/modes/javascriptSemanticTokens.js
new file mode 100644
index 0000000..5ed88aa
--- /dev/null
+++ b/vscode-html/out/modes/javascriptSemanticTokens.js
@@ -0,0 +1,130 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts = require("typescript");
+function getSemanticTokenLegend() {
+    if (tokenTypes.length !== 11 /* _ */) {
+        console.warn('TokenType has added new entries.');
+    }
+    if (tokenModifiers.length !== 4 /* _ */) {
+        console.warn('TokenModifier has added new entries.');
+    }
+    return { types: tokenTypes, modifiers: tokenModifiers };
+}
+exports.getSemanticTokenLegend = getSemanticTokenLegend;
+function getSemanticTokens(jsLanguageService, currentTextDocument, fileName) {
+    //https://ts-ast-viewer.com/#code/AQ0g2CmAuwGbALzAJwG4BQZQGNwEMBnQ4AQQEYBmYAb2C22zgEtJwATJVTRxgcwD27AQAp8AGmAAjAJS0A9POB8+7NQ168oscAJz5wANXwAnLug2bsJmAFcTAO2XAA1MHyvgu-UdOeWbOw8ViAAvpagocBAA
+    let resultTokens = [];
+    const collector = (node, typeIdx, modifierSet) => {
+        resultTokens.push({ start: currentTextDocument.positionAt(node.getStart()), length: node.getWidth(), typeIdx, modifierSet });
+    };
+    collectTokens(jsLanguageService, fileName, { start: 0, length: currentTextDocument.getText().length }, collector);
+    return resultTokens;
+}
+exports.getSemanticTokens = getSemanticTokens;
+function collectTokens(jsLanguageService, fileName, span, collector) {
+    const program = jsLanguageService.getProgram();
+    if (program) {
+        const typeChecker = program.getTypeChecker();
+        function visit(node) {
+            if (!node || !ts.textSpanIntersectsWith(span, node.pos, node.getFullWidth())) {
+                return;
+            }
+            if (ts.isIdentifier(node)) {
+                let symbol = typeChecker.getSymbolAtLocation(node);
+                if (symbol) {
+                    if (symbol.flags & ts.SymbolFlags.Alias) {
+                        symbol = typeChecker.getAliasedSymbol(symbol);
+                    }
+                    let typeIdx = classifySymbol(symbol);
+                    if (typeIdx !== undefined) {
+                        let modifierSet = 0;
+                        if (node.parent) {
+                            const parentTypeIdx = tokenFromDeclarationMapping[node.parent.kind];
+                            if (parentTypeIdx === typeIdx && node.parent.name === node) {
+                                modifierSet = 1 << 0 /* declaration */;
+                            }
+                        }
+                        const decl = symbol.valueDeclaration;
+                        const modifiers = decl ? ts.getCombinedModifierFlags(decl) : 0;
+                        const nodeFlags = decl ? ts.getCombinedNodeFlags(decl) : 0;
+                        if (modifiers & ts.ModifierFlags.Static) {
+                            modifierSet |= 1 << 1 /* static */;
+                        }
+                        if (modifiers & ts.ModifierFlags.Async) {
+                            modifierSet |= 1 << 2 /* async */;
+                        }
+                        if ((modifiers & ts.ModifierFlags.Readonly) || (nodeFlags & ts.NodeFlags.Const) || (symbol.getFlags() & ts.SymbolFlags.EnumMember)) {
+                            modifierSet |= 1 << 3 /* readonly */;
+                        }
+                        collector(node, typeIdx, modifierSet);
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile) {
+            visit(sourceFile);
+        }
+    }
+}
+function classifySymbol(symbol) {
+    const flags = symbol.getFlags();
+    if (flags & ts.SymbolFlags.Class) {
+        return 0 /* class */;
+    }
+    else if (flags & ts.SymbolFlags.Enum) {
+        return 1 /* enum */;
+    }
+    else if (flags & ts.SymbolFlags.TypeAlias) {
+        return 5 /* type */;
+    }
+    else if (flags & ts.SymbolFlags.Type) {
+        if (flags & ts.SymbolFlags.Interface) {
+            return 2 /* interface */;
+        }
+        if (flags & ts.SymbolFlags.TypeParameter) {
+            return 4 /* typeParameter */;
+        }
+    }
+    const decl = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];
+    return decl && tokenFromDeclarationMapping[decl.kind];
+}
+const tokenTypes = [];
+tokenTypes[0 /* class */] = 'class';
+tokenTypes[1 /* enum */] = 'enum';
+tokenTypes[2 /* interface */] = 'interface';
+tokenTypes[3 /* namespace */] = 'namespace';
+tokenTypes[4 /* typeParameter */] = 'typeParameter';
+tokenTypes[5 /* type */] = 'type';
+tokenTypes[6 /* parameter */] = 'parameter';
+tokenTypes[7 /* variable */] = 'variable';
+tokenTypes[8 /* property */] = 'property';
+tokenTypes[9 /* function */] = 'function';
+tokenTypes[10 /* member */] = 'member';
+const tokenModifiers = [];
+tokenModifiers[2 /* async */] = 'async';
+tokenModifiers[0 /* declaration */] = 'declaration';
+tokenModifiers[3 /* readonly */] = 'readonly';
+tokenModifiers[1 /* static */] = 'static';
+const tokenFromDeclarationMapping = {
+    [ts.SyntaxKind.VariableDeclaration]: 7 /* variable */,
+    [ts.SyntaxKind.Parameter]: 6 /* parameter */,
+    [ts.SyntaxKind.PropertyDeclaration]: 8 /* property */,
+    [ts.SyntaxKind.ModuleDeclaration]: 3 /* namespace */,
+    [ts.SyntaxKind.EnumDeclaration]: 1 /* enum */,
+    [ts.SyntaxKind.EnumMember]: 8 /* property */,
+    [ts.SyntaxKind.ClassDeclaration]: 0 /* class */,
+    [ts.SyntaxKind.MethodDeclaration]: 10 /* member */,
+    [ts.SyntaxKind.FunctionDeclaration]: 9 /* function */,
+    [ts.SyntaxKind.MethodSignature]: 10 /* member */,
+    [ts.SyntaxKind.GetAccessor]: 8 /* property */,
+    [ts.SyntaxKind.PropertySignature]: 8 /* property */,
+    [ts.SyntaxKind.InterfaceDeclaration]: 2 /* interface */,
+    [ts.SyntaxKind.TypeAliasDeclaration]: 5 /* type */,
+    [ts.SyntaxKind.TypeParameter]: 4 /* typeParameter */
+};
diff --git a/vscode-html/out/modes/languageModes.js b/vscode-html/out/modes/languageModes.js
new file mode 100644
index 0000000..77ae8f7
--- /dev/null
+++ b/vscode-html/out/modes/languageModes.js
@@ -0,0 +1,90 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_css_languageservice_1 = require("vscode-css-languageservice");
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+const languageModelCache_1 = require("../languageModelCache");
+const cssMode_1 = require("./cssMode");
+const embeddedSupport_1 = require("./embeddedSupport");
+const htmlMode_1 = require("./htmlMode");
+const javascriptMode_1 = require("./javascriptMode");
+__export(require("vscode-html-languageservice"));
+function getLanguageModes(supportedLanguages, workspace, clientCapabilities, customDataProviders) {
+    const htmlLanguageService = vscode_html_languageservice_1.getLanguageService({ customDataProviders, clientCapabilities });
+    const cssLanguageService = vscode_css_languageservice_1.getCSSLanguageService({ clientCapabilities });
+    let documentRegions = languageModelCache_1.getLanguageModelCache(10, 60, document => embeddedSupport_1.getDocumentRegions(htmlLanguageService, document));
+    let modelCaches = [];
+    modelCaches.push(documentRegions);
+    let modes = Object.create(null);
+    modes['html'] = htmlMode_1.getHTMLMode(htmlLanguageService, workspace);
+    if (supportedLanguages['css']) {
+        modes['css'] = cssMode_1.getCSSMode(cssLanguageService, documentRegions, workspace);
+    }
+    if (supportedLanguages['javascript']) {
+        modes['javascript'] = javascriptMode_1.getJavaScriptMode(documentRegions, 'javascript');
+        modes['typescript'] = javascriptMode_1.getJavaScriptMode(documentRegions, 'typescript');
+    }
+    return {
+        getModeAtPosition(document, position) {
+            let languageId = documentRegions.get(document).getLanguageAtPosition(position);
+            if (languageId) {
+                return modes[languageId];
+            }
+            return undefined;
+        },
+        getModesInRange(document, range) {
+            return documentRegions.get(document).getLanguageRanges(range).map(r => {
+                return {
+                    start: r.start,
+                    end: r.end,
+                    mode: r.languageId && modes[r.languageId],
+                    attributeValue: r.attributeValue
+                };
+            });
+        },
+        getAllModesInDocument(document) {
+            let result = [];
+            for (let languageId of documentRegions.get(document).getLanguagesInDocument()) {
+                let mode = modes[languageId];
+                if (mode) {
+                    result.push(mode);
+                }
+            }
+            return result;
+        },
+        getAllModes() {
+            let result = [];
+            for (let languageId in modes) {
+                let mode = modes[languageId];
+                if (mode) {
+                    result.push(mode);
+                }
+            }
+            return result;
+        },
+        getMode(languageId) {
+            return modes[languageId];
+        },
+        onDocumentRemoved(document) {
+            modelCaches.forEach(mc => mc.onDocumentRemoved(document));
+            for (let mode in modes) {
+                modes[mode].onDocumentRemoved(document);
+            }
+        },
+        dispose() {
+            modelCaches.forEach(mc => mc.dispose());
+            modelCaches = [];
+            for (let mode in modes) {
+                modes[mode].dispose();
+            }
+            modes = {};
+        }
+    };
+}
+exports.getLanguageModes = getLanguageModes;
diff --git a/vscode-html/out/modes/pathCompletion.js b/vscode-html/out/modes/pathCompletion.js
new file mode 100644
index 0000000..2f8afb0
--- /dev/null
+++ b/vscode-html/out/modes/pathCompletion.js
@@ -0,0 +1,171 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const vscode_uri_1 = require("vscode-uri");
+const languageModes_1 = require("./languageModes");
+const strings_1 = require("../utils/strings");
+const arrays_1 = require("../utils/arrays");
+function getPathCompletionParticipant(document, workspaceFolders, result) {
+    return {
+        onHtmlAttributeValue: ({ tag, attribute, value: valueBeforeCursor, range }) => {
+            const fullValue = stripQuotes(document.getText(range));
+            if (shouldDoPathCompletion(tag, attribute, fullValue)) {
+                if (workspaceFolders.length === 0) {
+                    return;
+                }
+                const workspaceRoot = resolveWorkspaceRoot(document, workspaceFolders);
+                const paths = providePaths(valueBeforeCursor, vscode_uri_1.URI.parse(document.uri).fsPath, workspaceRoot);
+                result.push(...paths.map(p => pathToSuggestion(p, valueBeforeCursor, fullValue, range)));
+            }
+        }
+    };
+}
+exports.getPathCompletionParticipant = getPathCompletionParticipant;
+function stripQuotes(fullValue) {
+    if (strings_1.startsWith(fullValue, `'`) || strings_1.startsWith(fullValue, `"`)) {
+        return fullValue.slice(1, -1);
+    }
+    else {
+        return fullValue;
+    }
+}
+function shouldDoPathCompletion(tag, attr, value) {
+    if (strings_1.startsWith(value, 'http') || strings_1.startsWith(value, 'https') || strings_1.startsWith(value, '//')) {
+        return false;
+    }
+    if (PATH_TAG_AND_ATTR[tag]) {
+        if (typeof PATH_TAG_AND_ATTR[tag] === 'string') {
+            return PATH_TAG_AND_ATTR[tag] === attr;
+        }
+        else {
+            return arrays_1.contains(PATH_TAG_AND_ATTR[tag], attr);
+        }
+    }
+    return false;
+}
+/**
+ * Get a list of path suggestions. Folder suggestions are suffixed with a slash.
+ */
+function providePaths(valueBeforeCursor, activeDocFsPath, root) {
+    const lastIndexOfSlash = valueBeforeCursor.lastIndexOf('/');
+    const valueBeforeLastSlash = valueBeforeCursor.slice(0, lastIndexOfSlash + 1);
+    const startsWithSlash = strings_1.startsWith(valueBeforeCursor, '/');
+    let parentDir;
+    if (startsWithSlash) {
+        if (!root) {
+            return [];
+        }
+        parentDir = path.resolve(root, '.' + valueBeforeLastSlash);
+    }
+    else {
+        parentDir = path.resolve(activeDocFsPath, '..', valueBeforeLastSlash);
+    }
+    try {
+        const paths = fs.readdirSync(parentDir).map(f => {
+            return isDir(path.resolve(parentDir, f))
+                ? f + '/'
+                : f;
+        });
+        return paths.filter(p => p[0] !== '.');
+    }
+    catch (e) {
+        return [];
+    }
+}
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch (e) {
+        return false;
+    }
+}
+function pathToSuggestion(p, valueBeforeCursor, fullValue, range) {
+    const isDir = p[p.length - 1] === '/';
+    let replaceRange;
+    const lastIndexOfSlash = valueBeforeCursor.lastIndexOf('/');
+    if (lastIndexOfSlash === -1) {
+        replaceRange = shiftRange(range, 1, -1);
+    }
+    else {
+        // For cases where cursor is in the middle of attribute value, like <script src="./s|rc/test.js">
+        // Find the last slash before cursor, and calculate the start of replace range from there
+        const valueAfterLastSlash = fullValue.slice(lastIndexOfSlash + 1);
+        const startPos = shiftPosition(range.end, -1 - valueAfterLastSlash.length);
+        // If whitespace exists, replace until there is no more
+        const whitespaceIndex = valueAfterLastSlash.indexOf(' ');
+        let endPos;
+        if (whitespaceIndex !== -1) {
+            endPos = shiftPosition(startPos, whitespaceIndex);
+        }
+        else {
+            endPos = shiftPosition(range.end, -1);
+        }
+        replaceRange = languageModes_1.Range.create(startPos, endPos);
+    }
+    if (isDir) {
+        return {
+            label: p,
+            kind: languageModes_1.CompletionItemKind.Folder,
+            textEdit: languageModes_1.TextEdit.replace(replaceRange, p),
+            command: {
+                title: 'Suggest',
+                command: 'editor.action.triggerSuggest'
+            }
+        };
+    }
+    else {
+        return {
+            label: p,
+            kind: languageModes_1.CompletionItemKind.File,
+            textEdit: languageModes_1.TextEdit.replace(replaceRange, p)
+        };
+    }
+}
+function resolveWorkspaceRoot(activeDoc, workspaceFolders) {
+    for (const folder of workspaceFolders) {
+        if (strings_1.startsWith(activeDoc.uri, folder.uri)) {
+            return path.resolve(vscode_uri_1.URI.parse(folder.uri).fsPath);
+        }
+    }
+    return undefined;
+}
+function shiftPosition(pos, offset) {
+    return languageModes_1.Position.create(pos.line, pos.character + offset);
+}
+function shiftRange(range, startOffset, endOffset) {
+    const start = shiftPosition(range.start, startOffset);
+    const end = shiftPosition(range.end, endOffset);
+    return languageModes_1.Range.create(start, end);
+}
+// Selected from https://stackoverflow.com/a/2725168/1780148
+const PATH_TAG_AND_ATTR = {
+    // HTML 4
+    a: 'href',
+    area: 'href',
+    body: 'background',
+    del: 'cite',
+    form: 'action',
+    frame: ['src', 'longdesc'],
+    img: ['src', 'longdesc'],
+    ins: 'cite',
+    link: 'href',
+    object: 'data',
+    q: 'cite',
+    script: 'src',
+    // HTML 5
+    audio: 'src',
+    button: 'formaction',
+    command: 'icon',
+    embed: 'src',
+    html: 'manifest',
+    input: ['src', 'formaction'],
+    source: 'src',
+    track: 'src',
+    video: ['src', 'poster']
+};
diff --git a/vscode-html/out/modes/selectionRanges.js b/vscode-html/out/modes/selectionRanges.js
new file mode 100644
index 0000000..95e02ac
--- /dev/null
+++ b/vscode-html/out/modes/selectionRanges.js
@@ -0,0 +1,26 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const languageModes_1 = require("./languageModes");
+const positions_1 = require("../utils/positions");
+function getSelectionRanges(languageModes, document, positions) {
+    const htmlMode = languageModes.getMode('html');
+    return positions.map(position => {
+        const htmlRange = htmlMode.getSelectionRange(document, position);
+        const mode = languageModes.getModeAtPosition(document, position);
+        if (mode && mode.getSelectionRange) {
+            let range = mode.getSelectionRange(document, position);
+            let top = range;
+            while (top.parent && positions_1.insideRangeButNotSame(htmlRange.range, top.parent.range)) {
+                top = top.parent;
+            }
+            top.parent = htmlRange;
+            return range;
+        }
+        return htmlRange || languageModes_1.SelectionRange.create(languageModes_1.Range.create(position, position));
+    });
+}
+exports.getSelectionRanges = getSelectionRanges;
diff --git a/vscode-html/out/modes/semanticTokens.js b/vscode-html/out/modes/semanticTokens.js
new file mode 100644
index 0000000..b7d661b
--- /dev/null
+++ b/vscode-html/out/modes/semanticTokens.js
@@ -0,0 +1,115 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const languageModes_1 = require("./languageModes");
+const positions_1 = require("../utils/positions");
+function newSemanticTokenProvider(languageModes) {
+    // combined legend across modes
+    const legend = { types: [], modifiers: [] };
+    const legendMappings = {};
+    for (let mode of languageModes.getAllModes()) {
+        if (mode.getSemanticTokenLegend && mode.getSemanticTokens) {
+            const modeLegend = mode.getSemanticTokenLegend();
+            legendMappings[mode.getId()] = { types: createMapping(modeLegend.types, legend.types), modifiers: createMapping(modeLegend.modifiers, legend.modifiers) };
+        }
+    }
+    return {
+        legend,
+        getSemanticTokens(document, ranges) {
+            const allTokens = [];
+            for (let mode of languageModes.getAllModesInDocument(document)) {
+                if (mode.getSemanticTokens) {
+                    const mapping = legendMappings[mode.getId()];
+                    const tokens = mode.getSemanticTokens(document);
+                    applyTypesMapping(tokens, mapping.types);
+                    applyModifiersMapping(tokens, mapping.modifiers);
+                    for (let token of tokens) {
+                        allTokens.push(token);
+                    }
+                }
+            }
+            return encodeTokens(allTokens, ranges);
+        }
+    };
+}
+exports.newSemanticTokenProvider = newSemanticTokenProvider;
+function createMapping(origLegend, newLegend) {
+    const mapping = [];
+    let needsMapping = false;
+    for (let origIndex = 0; origIndex < origLegend.length; origIndex++) {
+        const entry = origLegend[origIndex];
+        let newIndex = newLegend.indexOf(entry);
+        if (newIndex === -1) {
+            newIndex = newLegend.length;
+            newLegend.push(entry);
+        }
+        mapping.push(newIndex);
+        needsMapping = needsMapping || (newIndex !== origIndex);
+    }
+    return needsMapping ? mapping : undefined;
+}
+function applyTypesMapping(tokens, typesMapping) {
+    if (typesMapping) {
+        for (let token of tokens) {
+            token.typeIdx = typesMapping[token.typeIdx];
+        }
+    }
+}
+function applyModifiersMapping(tokens, modifiersMapping) {
+    if (modifiersMapping) {
+        for (let token of tokens) {
+            let modifierSet = token.modifierSet;
+            if (modifierSet) {
+                let index = 0;
+                let result = 0;
+                while (modifierSet > 0) {
+                    if ((modifierSet & 1) !== 0) {
+                        result = result + (1 << modifiersMapping[index]);
+                    }
+                    index++;
+                    modifierSet = modifierSet >> 1;
+                }
+                token.modifierSet = result;
+            }
+        }
+    }
+}
+const fullRange = [languageModes_1.Range.create(languageModes_1.Position.create(0, 0), languageModes_1.Position.create(Number.MAX_VALUE, 0))];
+function encodeTokens(tokens, ranges) {
+    const resultTokens = tokens.sort((d1, d2) => d1.start.line - d2.start.line || d1.start.character - d2.start.character);
+    if (ranges) {
+        ranges = ranges.sort((d1, d2) => d1.start.line - d2.start.line || d1.start.character - d2.start.character);
+    }
+    else {
+        ranges = fullRange;
+    }
+    let rangeIndex = 0;
+    let currRange = ranges[rangeIndex++];
+    let prefLine = 0;
+    let prevChar = 0;
+    let encodedResult = [];
+    for (let k = 0; k < resultTokens.length && currRange; k++) {
+        const curr = resultTokens[k];
+        const start = curr.start;
+        while (currRange && positions_1.beforeOrSame(currRange.end, start)) {
+            currRange = ranges[rangeIndex++];
+        }
+        if (currRange && positions_1.beforeOrSame(currRange.start, start) && positions_1.beforeOrSame({ line: start.line, character: start.character + curr.length }, currRange.end)) {
+            // token inside a range
+            if (prefLine !== start.line) {
+                prevChar = 0;
+            }
+            encodedResult.push(start.line - prefLine); // line delta
+            encodedResult.push(start.character - prevChar); // line delta
+            encodedResult.push(curr.length); // length
+            encodedResult.push(curr.typeIdx); // tokenType
+            encodedResult.push(curr.modifierSet); // tokenModifier
+            prefLine = start.line;
+            prevChar = start.character;
+        }
+    }
+    return encodedResult;
+}
diff --git a/vscode-html/out/utils/arrays.js b/vscode-html/out/utils/arrays.js
new file mode 100644
index 0000000..9523825
--- /dev/null
+++ b/vscode-html/out/utils/arrays.js
@@ -0,0 +1,76 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+function pushAll(to, from) {
+    if (from) {
+        for (const e of from) {
+            to.push(e);
+        }
+    }
+}
+exports.pushAll = pushAll;
+function contains(arr, val) {
+    return arr.indexOf(val) !== -1;
+}
+exports.contains = contains;
+/**
+ * Like `Array#sort` but always stable. Usually runs a little slower `than Array#sort`
+ * so only use this when actually needing stable sort.
+ */
+function mergeSort(data, compare) {
+    _divideAndMerge(data, compare);
+    return data;
+}
+exports.mergeSort = mergeSort;
+function _divideAndMerge(data, compare) {
+    if (data.length <= 1) {
+        // sorted
+        return;
+    }
+    const p = (data.length / 2) | 0;
+    const left = data.slice(0, p);
+    const right = data.slice(p);
+    _divideAndMerge(left, compare);
+    _divideAndMerge(right, compare);
+    let leftIdx = 0;
+    let rightIdx = 0;
+    let i = 0;
+    while (leftIdx < left.length && rightIdx < right.length) {
+        let ret = compare(left[leftIdx], right[rightIdx]);
+        if (ret <= 0) {
+            // smaller_equal -> take left to preserve order
+            data[i++] = left[leftIdx++];
+        }
+        else {
+            // greater -> take right
+            data[i++] = right[rightIdx++];
+        }
+    }
+    while (leftIdx < left.length) {
+        data[i++] = left[leftIdx++];
+    }
+    while (rightIdx < right.length) {
+        data[i++] = right[rightIdx++];
+    }
+}
+function binarySearch(array, key, comparator) {
+    let low = 0, high = array.length - 1;
+    while (low <= high) {
+        let mid = ((low + high) / 2) | 0;
+        let comp = comparator(array[mid], key);
+        if (comp < 0) {
+            low = mid + 1;
+        }
+        else if (comp > 0) {
+            high = mid - 1;
+        }
+        else {
+            return mid;
+        }
+    }
+    return -(low + 1);
+}
+exports.binarySearch = binarySearch;
diff --git a/vscode-html/out/utils/documentContext.js b/vscode-html/out/utils/documentContext.js
new file mode 100644
index 0000000..c380330
--- /dev/null
+++ b/vscode-html/out/utils/documentContext.js
@@ -0,0 +1,41 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const strings_1 = require("../utils/strings");
+const url = require("url");
+function getDocumentContext(documentUri, workspaceFolders) {
+    function getRootFolder() {
+        for (let folder of workspaceFolders) {
+            let folderURI = folder.uri;
+            if (!strings_1.endsWith(folderURI, '/')) {
+                folderURI = folderURI + '/';
+            }
+            if (strings_1.startsWith(documentUri, folderURI)) {
+                return folderURI;
+            }
+        }
+        return undefined;
+    }
+    return {
+        resolveReference: (ref, base = documentUri) => {
+            if (ref[0] === '/') { // resolve absolute path against the current workspace folder
+                if (strings_1.startsWith(base, 'file://')) {
+                    let folderUri = getRootFolder();
+                    if (folderUri) {
+                        return folderUri + ref.substr(1);
+                    }
+                }
+            }
+            try {
+                return url.resolve(base, ref);
+            }
+            catch (_a) {
+                return '';
+            }
+        },
+    };
+}
+exports.getDocumentContext = getDocumentContext;
diff --git a/vscode-html/out/utils/positions.js b/vscode-html/out/utils/positions.js
new file mode 100644
index 0000000..d29d35e
--- /dev/null
+++ b/vscode-html/out/utils/positions.js
@@ -0,0 +1,18 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+function beforeOrSame(p1, p2) {
+    return p1.line < p2.line || p1.line === p2.line && p1.character <= p2.character;
+}
+exports.beforeOrSame = beforeOrSame;
+function insideRangeButNotSame(r1, r2) {
+    return beforeOrSame(r1.start, r2.start) && beforeOrSame(r2.end, r1.end) && !equalRange(r1, r2);
+}
+exports.insideRangeButNotSame = insideRangeButNotSame;
+function equalRange(r1, r2) {
+    return r1.start.line === r2.start.line && r1.start.character === r2.start.character && r1.end.line === r2.end.line && r1.end.character === r2.end.character;
+}
+exports.equalRange = equalRange;
diff --git a/vscode-html/out/utils/runner.js b/vscode-html/out/utils/runner.js
new file mode 100644
index 0000000..3711597
--- /dev/null
+++ b/vscode-html/out/utils/runner.js
@@ -0,0 +1,72 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_languageserver_1 = require("vscode-languageserver");
+function formatError(message, err) {
+    if (err instanceof Error) {
+        let error = err;
+        return `${message}: ${error.message}\n${error.stack}`;
+    }
+    else if (typeof err === 'string') {
+        return `${message}: ${err}`;
+    }
+    else if (err) {
+        return `${message}: ${err.toString()}`;
+    }
+    return message;
+}
+exports.formatError = formatError;
+function runSafeAsync(func, errorVal, errorMessage, token) {
+    return new Promise((resolve) => {
+        setImmediate(() => {
+            if (token.isCancellationRequested) {
+                resolve(cancelValue());
+            }
+            return func().then(result => {
+                if (token.isCancellationRequested) {
+                    resolve(cancelValue());
+                    return;
+                }
+                else {
+                    resolve(result);
+                }
+            }, e => {
+                console.error(formatError(errorMessage, e));
+                resolve(errorVal);
+            });
+        });
+    });
+}
+exports.runSafeAsync = runSafeAsync;
+function runSafe(func, errorVal, errorMessage, token) {
+    return new Promise((resolve) => {
+        setImmediate(() => {
+            if (token.isCancellationRequested) {
+                resolve(cancelValue());
+            }
+            else {
+                try {
+                    let result = func();
+                    if (token.isCancellationRequested) {
+                        resolve(cancelValue());
+                        return;
+                    }
+                    else {
+                        resolve(result);
+                    }
+                }
+                catch (e) {
+                    console.error(formatError(errorMessage, e));
+                    resolve(errorVal);
+                }
+            }
+        });
+    });
+}
+exports.runSafe = runSafe;
+function cancelValue() {
+    return new vscode_languageserver_1.ResponseError(vscode_languageserver_1.ErrorCodes.RequestCancelled, 'Request cancelled');
+}
diff --git a/vscode-html/out/utils/strings.js b/vscode-html/out/utils/strings.js
new file mode 100644
index 0000000..0c4cd87
--- /dev/null
+++ b/vscode-html/out/utils/strings.js
@@ -0,0 +1,77 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+function getWordAtText(text, offset, wordDefinition) {
+    let lineStart = offset;
+    while (lineStart > 0 && !isNewlineCharacter(text.charCodeAt(lineStart - 1))) {
+        lineStart--;
+    }
+    let offsetInLine = offset - lineStart;
+    let lineText = text.substr(lineStart);
+    // make a copy of the regex as to not keep the state
+    let flags = wordDefinition.ignoreCase ? 'gi' : 'g';
+    wordDefinition = new RegExp(wordDefinition.source, flags);
+    let match = wordDefinition.exec(lineText);
+    while (match && match.index + match[0].length < offsetInLine) {
+        match = wordDefinition.exec(lineText);
+    }
+    if (match && match.index <= offsetInLine) {
+        return { start: match.index + lineStart, length: match[0].length };
+    }
+    return { start: offset, length: 0 };
+}
+exports.getWordAtText = getWordAtText;
+function startsWith(haystack, needle) {
+    if (haystack.length < needle.length) {
+        return false;
+    }
+    for (let i = 0; i < needle.length; i++) {
+        if (haystack[i] !== needle[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.startsWith = startsWith;
+function endsWith(haystack, needle) {
+    let diff = haystack.length - needle.length;
+    if (diff > 0) {
+        return haystack.indexOf(needle, diff) === diff;
+    }
+    else if (diff === 0) {
+        return haystack === needle;
+    }
+    else {
+        return false;
+    }
+}
+exports.endsWith = endsWith;
+function repeat(value, count) {
+    let s = '';
+    while (count > 0) {
+        if ((count & 1) === 1) {
+            s += value;
+        }
+        value += value;
+        count = count >>> 1;
+    }
+    return s;
+}
+exports.repeat = repeat;
+function isWhitespaceOnly(str) {
+    return /^\s*$/.test(str);
+}
+exports.isWhitespaceOnly = isWhitespaceOnly;
+function isEOL(content, offset) {
+    return isNewlineCharacter(content.charCodeAt(offset));
+}
+exports.isEOL = isEOL;
+const CR = '\r'.charCodeAt(0);
+const NL = '\n'.charCodeAt(0);
+function isNewlineCharacter(charCode) {
+    return charCode === CR || charCode === NL;
+}
+exports.isNewlineCharacter = isNewlineCharacter;
diff --git a/vscode-html/package-lock.json b/vscode-html/package-lock.json
new file mode 100644
index 0000000..9eb14c8
--- /dev/null
+++ b/vscode-html/package-lock.json
@@ -0,0 +1,1085 @@
+{
+  "name": "vscode-html-languageserver",
+  "version": "1.0.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "@types/mocha": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-7.0.1.tgz",
+      "integrity": "sha512-L/Nw/2e5KUaprNJoRA33oly+M8X8n0K+FwLTbYqwTcR14wdPWeRkigBLfSFpN/Asf9ENZTMZwLxjtjeYucAA4Q==",
+      "dev": true
+    },
+    "@types/node": {
+      "version": "12.12.30",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-12.12.30.tgz",
+      "integrity": "sha512-sz9MF/zk6qVr3pAnM0BSQvYIBK44tS75QC5N+VbWSE4DjCV/pJ+UzCW/F+vVnl7TkOPcuwQureKNtSSwjBTaMg==",
+      "dev": true
+    },
+    "ansi-colors": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz",
+      "integrity": "sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==",
+      "dev": true
+    },
+    "ansi-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
+      "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
+      "dev": true
+    },
+    "ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dev": true,
+      "requires": {
+        "color-convert": "^1.9.0"
+      }
+    },
+    "anymatch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz",
+      "integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==",
+      "dev": true,
+      "requires": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      }
+    },
+    "argparse": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+      "dev": true,
+      "requires": {
+        "sprintf-js": "~1.0.2"
+      }
+    },
+    "balanced-match": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
+      "dev": true
+    },
+    "binary-extensions": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.0.0.tgz",
+      "integrity": "sha512-Phlt0plgpIIBOGTT/ehfFnbNlfsDEiqmzE2KRXoX1bLIlir4X/MR+zSyBEkL05ffWgnRSf/DXv+WrUAVr93/ow==",
+      "dev": true
+    },
+    "brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dev": true,
+      "requires": {
+        "fill-range": "^7.0.1"
+      }
+    },
+    "browser-stdout": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz",
+      "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==",
+      "dev": true
+    },
+    "camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "dev": true
+    },
+    "chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      },
+      "dependencies": {
+        "supports-color": {
+          "version": "5.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+          "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        }
+      }
+    },
+    "charenc": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz",
+      "integrity": "sha1-wKHS86cJLgN3S/qD8UwPxXkKhmc=",
+      "dev": true
+    },
+    "chokidar": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz",
+      "integrity": "sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==",
+      "dev": true,
+      "requires": {
+        "anymatch": "~3.1.1",
+        "braces": "~3.0.2",
+        "fsevents": "~2.1.1",
+        "glob-parent": "~5.1.0",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.2.0"
+      }
+    },
+    "cliui": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz",
+      "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==",
+      "dev": true,
+      "requires": {
+        "string-width": "^3.1.0",
+        "strip-ansi": "^5.2.0",
+        "wrap-ansi": "^5.1.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+          "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+          "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^4.1.0"
+          }
+        }
+      }
+    },
+    "color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
+      "requires": {
+        "color-name": "1.1.3"
+      }
+    },
+    "color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+      "dev": true
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+      "dev": true
+    },
+    "crypt": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz",
+      "integrity": "sha1-iNf/fsDfuG9xPch7u0LQRNPmxBs=",
+      "dev": true
+    },
+    "debug": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
+      "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==",
+      "dev": true,
+      "requires": {
+        "ms": "^2.1.1"
+      }
+    },
+    "decamelize": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
+      "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
+      "dev": true
+    },
+    "define-properties": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+      "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+      "dev": true,
+      "requires": {
+        "object-keys": "^1.0.12"
+      }
+    },
+    "diff": {
+      "version": "3.5.0",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz",
+      "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==",
+      "dev": true
+    },
+    "emoji-regex": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+      "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
+      "dev": true
+    },
+    "es-abstract": {
+      "version": "1.17.4",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.4.tgz",
+      "integrity": "sha512-Ae3um/gb8F0mui/jPL+QiqmglkUsaQf7FwBEHYIFkztkneosu9imhqHpBzQ3h1vit8t5iQ74t6PEVvphBZiuiQ==",
+      "dev": true,
+      "requires": {
+        "es-to-primitive": "^1.2.1",
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-symbols": "^1.0.1",
+        "is-callable": "^1.1.5",
+        "is-regex": "^1.0.5",
+        "object-inspect": "^1.7.0",
+        "object-keys": "^1.1.1",
+        "object.assign": "^4.1.0",
+        "string.prototype.trimleft": "^2.1.1",
+        "string.prototype.trimright": "^2.1.1"
+      }
+    },
+    "es-to-primitive": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz",
+      "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==",
+      "dev": true,
+      "requires": {
+        "is-callable": "^1.1.4",
+        "is-date-object": "^1.0.1",
+        "is-symbol": "^1.0.2"
+      }
+    },
+    "escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
+      "dev": true
+    },
+    "esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true
+    },
+    "fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dev": true,
+      "requires": {
+        "to-regex-range": "^5.0.1"
+      }
+    },
+    "find-up": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
+      "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
+      "dev": true,
+      "requires": {
+        "locate-path": "^3.0.0"
+      }
+    },
+    "flat": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/flat/-/flat-4.1.0.tgz",
+      "integrity": "sha512-Px/TiLIznH7gEDlPXcUD4KnBusa6kR6ayRUVcnEAbreRIuhkqow/mun59BuRXwoYk7ZQOLW1ZM05ilIvK38hFw==",
+      "dev": true,
+      "requires": {
+        "is-buffer": "~2.0.3"
+      }
+    },
+    "fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+      "dev": true
+    },
+    "fsevents": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.2.tgz",
+      "integrity": "sha512-R4wDiBwZ0KzpgOWetKDug1FZcYhqYnUYKtfZYt4mD5SBz76q0KR4Q9o7GIPamsVPGmW3EYPPJ0dOOjvx32ldZA==",
+      "dev": true,
+      "optional": true
+    },
+    "function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
+      "dev": true
+    },
+    "get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true
+    },
+    "glob": {
+      "version": "7.1.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+      "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+      "dev": true,
+      "requires": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      }
+    },
+    "glob-parent": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.0.tgz",
+      "integrity": "sha512-qjtRgnIVmOfnKUE3NJAQEdk+lKrxfw8t5ke7SXtfMTHcjsBfOfWXCQfdb30zfDoZQ2IRSIiidmjtbHZPZ++Ihw==",
+      "dev": true,
+      "requires": {
+        "is-glob": "^4.0.1"
+      }
+    },
+    "growl": {
+      "version": "1.10.5",
+      "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz",
+      "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==",
+      "dev": true
+    },
+    "has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dev": true,
+      "requires": {
+        "function-bind": "^1.1.1"
+      }
+    },
+    "has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "dev": true
+    },
+    "has-symbols": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.1.tgz",
+      "integrity": "sha512-PLcsoqu++dmEIZB+6totNFKq/7Do+Z0u4oT0zKOJNl3lYK6vGwwu2hjHs+68OEZbTjiUE9bgOABXbP/GvrS0Kg==",
+      "dev": true
+    },
+    "he": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
+      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
+      "dev": true
+    },
+    "inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "dev": true,
+      "requires": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true
+    },
+    "is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "requires": {
+        "binary-extensions": "^2.0.0"
+      }
+    },
+    "is-buffer": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.4.tgz",
+      "integrity": "sha512-Kq1rokWXOPXWuaMAqZiJW4XxsmD9zGx9q4aePabbn3qCRGedtH7Cm+zV8WETitMfu1wdh+Rvd6w5egwSngUX2A==",
+      "dev": true
+    },
+    "is-callable": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.5.tgz",
+      "integrity": "sha512-ESKv5sMCJB2jnHTWZ3O5itG+O128Hsus4K4Qh1h2/cgn2vbgnLSVqfV46AeJA9D5EeeLa9w81KUXMtn34zhX+Q==",
+      "dev": true
+    },
+    "is-date-object": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.2.tgz",
+      "integrity": "sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g==",
+      "dev": true
+    },
+    "is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
+      "dev": true
+    },
+    "is-fullwidth-code-point": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+      "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+      "dev": true
+    },
+    "is-glob": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
+      "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+      "dev": true,
+      "requires": {
+        "is-extglob": "^2.1.1"
+      }
+    },
+    "is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true
+    },
+    "is-regex": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.5.tgz",
+      "integrity": "sha512-vlKW17SNq44owv5AQR3Cq0bQPEb8+kF3UKZ2fiZNOWtztYE5i0CzCZxFDwO58qAOWtxdBRVO/V5Qin1wjCqFYQ==",
+      "dev": true,
+      "requires": {
+        "has": "^1.0.3"
+      }
+    },
+    "is-symbol": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.3.tgz",
+      "integrity": "sha512-OwijhaRSgqvhm/0ZdAcXNZt9lYdKFpcRDT5ULUuYXPoT794UNOdU+gpT6Rzo7b4V2HUl/op6GqY894AZwv9faQ==",
+      "dev": true,
+      "requires": {
+        "has-symbols": "^1.0.1"
+      }
+    },
+    "isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
+      "dev": true
+    },
+    "js-yaml": {
+      "version": "3.13.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz",
+      "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==",
+      "dev": true,
+      "requires": {
+        "argparse": "^1.0.7",
+        "esprima": "^4.0.0"
+      }
+    },
+    "locate-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
+      "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
+      "dev": true,
+      "requires": {
+        "p-locate": "^3.0.0",
+        "path-exists": "^3.0.0"
+      }
+    },
+    "lodash": {
+      "version": "4.17.15",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz",
+      "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==",
+      "dev": true
+    },
+    "log-symbols": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-3.0.0.tgz",
+      "integrity": "sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ==",
+      "dev": true,
+      "requires": {
+        "chalk": "^2.4.2"
+      }
+    },
+    "md5": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/md5/-/md5-2.2.1.tgz",
+      "integrity": "sha1-U6s41f48iJG6RlMp6iP6wFQBJvk=",
+      "dev": true,
+      "requires": {
+        "charenc": "~0.0.1",
+        "crypt": "~0.0.1",
+        "is-buffer": "~1.1.1"
+      },
+      "dependencies": {
+        "is-buffer": {
+          "version": "1.1.6",
+          "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
+          "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
+          "dev": true
+        }
+      }
+    },
+    "minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "dev": true,
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "minimist": {
+      "version": "0.0.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
+      "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=",
+      "dev": true
+    },
+    "mkdirp": {
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
+      "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
+      "dev": true,
+      "requires": {
+        "minimist": "0.0.8"
+      }
+    },
+    "mocha": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-7.1.0.tgz",
+      "integrity": "sha512-MymHK8UkU0K15Q/zX7uflZgVoRWiTjy0fXE/QjKts6mowUvGxOdPhZ2qj3b0iZdUrNZlW9LAIMFHB4IW+2b3EQ==",
+      "dev": true,
+      "requires": {
+        "ansi-colors": "3.2.3",
+        "browser-stdout": "1.3.1",
+        "chokidar": "3.3.0",
+        "debug": "3.2.6",
+        "diff": "3.5.0",
+        "escape-string-regexp": "1.0.5",
+        "find-up": "3.0.0",
+        "glob": "7.1.3",
+        "growl": "1.10.5",
+        "he": "1.2.0",
+        "js-yaml": "3.13.1",
+        "log-symbols": "3.0.0",
+        "minimatch": "3.0.4",
+        "mkdirp": "0.5.1",
+        "ms": "2.1.1",
+        "node-environment-flags": "1.0.6",
+        "object.assign": "4.1.0",
+        "strip-json-comments": "2.0.1",
+        "supports-color": "6.0.0",
+        "which": "1.3.1",
+        "wide-align": "1.1.3",
+        "yargs": "13.3.0",
+        "yargs-parser": "13.1.1",
+        "yargs-unparser": "1.6.0"
+      },
+      "dependencies": {
+        "glob": {
+          "version": "7.1.3",
+          "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
+          "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
+          "dev": true,
+          "requires": {
+            "fs.realpath": "^1.0.0",
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "^3.0.4",
+            "once": "^1.3.0",
+            "path-is-absolute": "^1.0.0"
+          }
+        }
+      }
+    },
+    "mocha-junit-reporter": {
+      "version": "1.23.3",
+      "resolved": "https://registry.npmjs.org/mocha-junit-reporter/-/mocha-junit-reporter-1.23.3.tgz",
+      "integrity": "sha512-ed8LqbRj1RxZfjt/oC9t12sfrWsjZ3gNnbhV1nuj9R/Jb5/P3Xb4duv2eCfCDMYH+fEu0mqca7m4wsiVjsxsvA==",
+      "dev": true,
+      "requires": {
+        "debug": "^2.2.0",
+        "md5": "^2.1.0",
+        "mkdirp": "~0.5.1",
+        "strip-ansi": "^4.0.0",
+        "xml": "^1.0.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "dev": true,
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
+          "dev": true
+        }
+      }
+    },
+    "mocha-multi-reporters": {
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/mocha-multi-reporters/-/mocha-multi-reporters-1.1.7.tgz",
+      "integrity": "sha1-zH8/TTL0eFIJQdhSq7ZNmYhYfYI=",
+      "dev": true,
+      "requires": {
+        "debug": "^3.1.0",
+        "lodash": "^4.16.4"
+      }
+    },
+    "ms": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
+      "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
+      "dev": true
+    },
+    "node-environment-flags": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/node-environment-flags/-/node-environment-flags-1.0.6.tgz",
+      "integrity": "sha512-5Evy2epuL+6TM0lCQGpFIj6KwiEsGh1SrHUhTbNX+sLbBtjidPZFAnVK9y5yU1+h//RitLbRHTIMyxQPtxMdHw==",
+      "dev": true,
+      "requires": {
+        "object.getownpropertydescriptors": "^2.0.3",
+        "semver": "^5.7.0"
+      }
+    },
+    "normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true
+    },
+    "object-inspect": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.7.0.tgz",
+      "integrity": "sha512-a7pEHdh1xKIAgTySUGgLMx/xwDZskN1Ud6egYYN3EdRW4ZMPNEDUTF+hwy2LUC+Bl+SyLXANnwz/jyh/qutKUw==",
+      "dev": true
+    },
+    "object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+      "dev": true
+    },
+    "object.assign": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz",
+      "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==",
+      "dev": true,
+      "requires": {
+        "define-properties": "^1.1.2",
+        "function-bind": "^1.1.1",
+        "has-symbols": "^1.0.0",
+        "object-keys": "^1.0.11"
+      }
+    },
+    "object.getownpropertydescriptors": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.0.tgz",
+      "integrity": "sha512-Z53Oah9A3TdLoblT7VKJaTDdXdT+lQO+cNpKVnya5JDe9uLvzu1YyY1yFDFrcxrlRgWrEFH0jJtD/IbuwjcEVg==",
+      "dev": true,
+      "requires": {
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.17.0-next.1"
+      }
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "dev": true,
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "p-limit": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.2.tgz",
+      "integrity": "sha512-WGR+xHecKTr7EbUEhyLSh5Dube9JtdiG78ufaeLxTgpudf/20KqyMioIUZJAezlTIi6evxuoUs9YXc11cU+yzQ==",
+      "dev": true,
+      "requires": {
+        "p-try": "^2.0.0"
+      }
+    },
+    "p-locate": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
+      "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
+      "dev": true,
+      "requires": {
+        "p-limit": "^2.0.0"
+      }
+    },
+    "p-try": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+      "dev": true
+    },
+    "path-exists": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
+      "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
+      "dev": true
+    },
+    "path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "dev": true
+    },
+    "picomatch": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.1.tgz",
+      "integrity": "sha512-ISBaA8xQNmwELC7eOjqFKMESB2VIqt4PPDD0nsS95b/9dZXvVKOlz9keMSnoGGKcOHXfTvDD6WMaRoSc9UuhRA==",
+      "dev": true
+    },
+    "readdirp": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz",
+      "integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==",
+      "dev": true,
+      "requires": {
+        "picomatch": "^2.0.4"
+      }
+    },
+    "require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
+      "dev": true
+    },
+    "require-main-filename": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
+      "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
+      "dev": true
+    },
+    "semver": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+      "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+      "dev": true
+    },
+    "set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=",
+      "dev": true
+    },
+    "sprintf-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",
+      "dev": true
+    },
+    "string-width": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
+      "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
+      "dev": true,
+      "requires": {
+        "is-fullwidth-code-point": "^2.0.0",
+        "strip-ansi": "^4.0.0"
+      }
+    },
+    "string.prototype.trimleft": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimleft/-/string.prototype.trimleft-2.1.1.tgz",
+      "integrity": "sha512-iu2AGd3PuP5Rp7x2kEZCrB2Nf41ehzh+goo8TV7z8/XDBbsvc6HQIlUl9RjkZ4oyrW1XM5UwlGl1oVEaDjg6Ag==",
+      "dev": true,
+      "requires": {
+        "define-properties": "^1.1.3",
+        "function-bind": "^1.1.1"
+      }
+    },
+    "string.prototype.trimright": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimright/-/string.prototype.trimright-2.1.1.tgz",
+      "integrity": "sha512-qFvWL3/+QIgZXVmJBfpHmxLB7xsUXz6HsUmP8+5dRaC3Q7oKUv9Vo6aMCRZC1smrtyECFsIT30PqBJ1gTjAs+g==",
+      "dev": true,
+      "requires": {
+        "define-properties": "^1.1.3",
+        "function-bind": "^1.1.1"
+      }
+    },
+    "strip-ansi": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
+      "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
+      "dev": true,
+      "requires": {
+        "ansi-regex": "^3.0.0"
+      }
+    },
+    "strip-json-comments": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+      "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=",
+      "dev": true
+    },
+    "supports-color": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz",
+      "integrity": "sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg==",
+      "dev": true,
+      "requires": {
+        "has-flag": "^3.0.0"
+      }
+    },
+    "to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "requires": {
+        "is-number": "^7.0.0"
+      }
+    },
+    "typescript": {
+      "version": "3.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.8.3.tgz",
+      "integrity": "sha512-MYlEfn5VrLNsgudQTVJeNaQFUAI7DkhnOjdpAp4T+ku1TfQClewlbSuTVHiA+8skNBgaf02TL/kLOvig4y3G8w=="
+    },
+    "vscode-css-languageservice": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/vscode-css-languageservice/-/vscode-css-languageservice-4.1.1.tgz",
+      "integrity": "sha512-2r2bYbhscivRu1zqh5kNe8aYpFnfksMYC7wTpKX2HqFsSzSJYXk0sCqPaWsP5ptqz0OFBTXnzx2JlE+Nb5Edgw==",
+      "requires": {
+        "vscode-languageserver-textdocument": "^1.0.1",
+        "vscode-languageserver-types": "^3.15.1",
+        "vscode-nls": "^4.1.1",
+        "vscode-uri": "^2.1.1"
+      }
+    },
+    "vscode-html-languageservice": {
+      "version": "3.0.4-next.15",
+      "resolved": "https://registry.npmjs.org/vscode-html-languageservice/-/vscode-html-languageservice-3.0.4-next.15.tgz",
+      "integrity": "sha512-UmUm3A1ZTj+BloVIyel+5pK/nfsqRfPLXzl8BA9O7v5Cj64vivddABvNf/rW1US8fzdikFNZNloC/4ooqxB2kw==",
+      "requires": {
+        "vscode-languageserver-textdocument": "^1.0.1-next.1",
+        "vscode-languageserver-types": "^3.15.1",
+        "vscode-nls": "^4.1.1",
+        "vscode-uri": "^2.1.1"
+      }
+    },
+    "vscode-jsonrpc": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-5.0.1.tgz",
+      "integrity": "sha512-JvONPptw3GAQGXlVV2utDcHx0BiY34FupW/kI6mZ5x06ER5DdPG/tXWMVHjTNULF5uKPOUUD0SaXg5QaubJL0A=="
+    },
+    "vscode-languageserver": {
+      "version": "6.1.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver/-/vscode-languageserver-6.1.1.tgz",
+      "integrity": "sha512-DueEpkUAkD5XTR4MLYNr6bQIp/UFR0/IPApgXU3YfCBCB08u2sm9hRCs6DxYZELkk++STPjpcjksR2H8qI3cDQ==",
+      "requires": {
+        "vscode-languageserver-protocol": "^3.15.3"
+      }
+    },
+    "vscode-languageserver-protocol": {
+      "version": "3.15.3",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.15.3.tgz",
+      "integrity": "sha512-zrMuwHOAQRhjDSnflWdJG+O2ztMWss8GqUUB8dXLR/FPenwkiBNkMIJJYfSN6sgskvsF0rHAoBowNQfbyZnnvw==",
+      "requires": {
+        "vscode-jsonrpc": "^5.0.1",
+        "vscode-languageserver-types": "3.15.1"
+      }
+    },
+    "vscode-languageserver-textdocument": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.1.tgz",
+      "integrity": "sha512-UIcJDjX7IFkck7cSkNNyzIz5FyvpQfY7sdzVy+wkKN/BLaD4DQ0ppXQrKePomCxTS7RrolK1I0pey0bG9eh8dA=="
+    },
+    "vscode-languageserver-types": {
+      "version": "3.15.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.1.tgz",
+      "integrity": "sha512-+a9MPUQrNGRrGU630OGbYVQ+11iOIovjCkqxajPa9w57Sd5ruK8WQNsslzpa0x/QJqC8kRc2DUxWjIFwoNm4ZQ=="
+    },
+    "vscode-nls": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.2.tgz",
+      "integrity": "sha512-7bOHxPsfyuCqmP+hZXscLhiHwe7CSuFE4hyhbs22xPIhQ4jv99FcR4eBzfYYVLP356HNFpdvz63FFb/xw6T4Iw=="
+    },
+    "vscode-uri": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-2.1.1.tgz",
+      "integrity": "sha512-eY9jmGoEnVf8VE8xr5znSah7Qt1P/xsCdErz+g8HYZtJ7bZqKH5E3d+6oVNm1AC/c6IHUDokbmVXKOi4qPAC9A=="
+    },
+    "which": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
+      "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
+      "dev": true,
+      "requires": {
+        "isexe": "^2.0.0"
+      }
+    },
+    "which-module": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz",
+      "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=",
+      "dev": true
+    },
+    "wide-align": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz",
+      "integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==",
+      "dev": true,
+      "requires": {
+        "string-width": "^1.0.2 || 2"
+      }
+    },
+    "wrap-ansi": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz",
+      "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^3.2.0",
+        "string-width": "^3.0.0",
+        "strip-ansi": "^5.0.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+          "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+          "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^4.1.0"
+          }
+        }
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+      "dev": true
+    },
+    "xml": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/xml/-/xml-1.0.1.tgz",
+      "integrity": "sha1-eLpyAgApxbyHuKgaPPzXS0ovweU=",
+      "dev": true
+    },
+    "y18n": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz",
+      "integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==",
+      "dev": true
+    },
+    "yargs": {
+      "version": "13.3.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.0.tgz",
+      "integrity": "sha512-2eehun/8ALW8TLoIl7MVaRUrg+yCnenu8B4kBlRxj3GJGDKU1Og7sMXPNm1BYyM1DOJmTZ4YeN/Nwxv+8XJsUA==",
+      "dev": true,
+      "requires": {
+        "cliui": "^5.0.0",
+        "find-up": "^3.0.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^3.0.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^13.1.1"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+          "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+          "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^4.1.0"
+          }
+        }
+      }
+    },
+    "yargs-parser": {
+      "version": "13.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.1.tgz",
+      "integrity": "sha512-oVAVsHz6uFrg3XQheFII8ESO2ssAf9luWuAd6Wexsu4F3OtIW0o8IribPXYrD4WC24LWtPrJlGy87y5udK+dxQ==",
+      "dev": true,
+      "requires": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
+      }
+    },
+    "yargs-unparser": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-1.6.0.tgz",
+      "integrity": "sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw==",
+      "dev": true,
+      "requires": {
+        "flat": "^4.1.0",
+        "lodash": "^4.17.15",
+        "yargs": "^13.3.0"
+      }
+    }
+  }
+}
diff --git a/vscode-html/package.json b/vscode-html/package.json
new file mode 100644
index 0000000..2ce43bf
--- /dev/null
+++ b/vscode-html/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "vscode-html-languageserver",
+  "description": "HTML language server",
+  "version": "1.0.0",
+  "author": "Microsoft Corporation",
+  "license": "MIT",
+  "engines": {
+    "node": "*"
+  },
+  "main": "./out/htmlServerMain",
+  "dependencies": {
+    "typescript": "^3.8.3",
+    "vscode-css-languageservice": "^4.1.0",
+    "vscode-html-languageservice": "3.0.4-next.15",
+    "vscode-languageserver": "^6.1.1",
+    "vscode-nls": "^4.1.1",
+    "vscode-uri": "^2.1.1"
+  },
+  "devDependencies": {
+    "@types/mocha": "7.0.1",
+    "@types/node": "^12.11.7",
+    "glob": "^7.1.6",
+    "mocha": "^7.0.1",
+    "mocha-junit-reporter": "^1.23.3",
+    "mocha-multi-reporters": "^1.1.7"
+  },
+  "scripts": {
+    "compile": "npx gulp compile-extension:html-language-features-server",
+    "watch": "npx gulp watch-extension:html-language-features-server",
+    "install-service-next": "yarn add vscode-css-languageservice@next && yarn add vscode-html-languageservice@next",
+    "install-service-local": "npm install ../../../../vscode-css-languageservice -f && npm install ../../../../vscode-html-languageservice -f",
+    "install-server-next": "yarn add vscode-languageserver@next",
+    "install-server-local": "npm install ../../../../vscode-languageserver-node/server -f",
+    "test": "npm run compile && node ./test/index.js"
+  }
+}