From f328ceef014a0bb36cdccb38e0c4b55b6bb68b09 Mon Sep 17 00:00:00 2001
From: D3-LucaPiombino <luca.piombino@deltatre.com>
Date: Sun, 1 Feb 2015 00:26:55 +0100
Subject: [PATCH] Enable syntax highlighting for code in the Markdown Preview

- Replaced MarkdownSharp with CommonMark.net given that it support natively fenced code blocks.
It also provide a more robust markdown specification that make markdown more predictable to write
and parse.
- Removed the setting that were used to customize MarkdownSharp behavior.
- Added the ability for the user to define a custom html template that is used to display the markdown preview.
Syntax highlighting can then be applied by using one of the many javascript libraries available on
the web.
Just include the required external dependecies (js,css, etc..) like one would have to do when
hosting the markdown in a normal webpage.
External resources can be pulled also directly from the web.
The code will look for an html file called WE-Markdown.html first in the project folder and
then in the solution folder. The same behavior has been extended to the WE-Markdown.css file.
Four custom place holder are provided:
  {##SOLUTION_PATH_PLACEHOLDER##}
  {##PROJECT_PATH_PLACEHOLDER##}
  {##DOCUMENT_PATH_PLACEHOLDER##}
  {##MARKDOWN_HTML_PLACEHOLDER##}
These placeholders can be used for instance to control where the external dependencies are pulled from.
The base element is set in the default template generated by the menu item to {##DOCUMENT_PATH_PLACEHOLDER##}.
This ensure the most confortable experience in VS, given that, for example, when an images is pasted or dragged into
a markdown document, the generated path to the image is relative to the markdown document itself.
- Added a menu to generate a default global solution html template (like the one for the custom stylesheet).
Note that the generated html does not include any reference to a javascript library to provide syntax highlighting.
The user will need to  choose one and modify the template accordingly.
- Added Code to try to automatically enable the internet features required to load and execute javascript in the
embedded WebBrowser.
A message will be printed in the visual studio output pane if something goes wrong.
---
 EditorExtensions/CommandConstants.cs          |   1 +
 EditorExtensions/EditorExtensions.vsct        |   9 +
 .../Markdown/Margin/MarkdownMargin.cs         | 685 ++++++++++++++++--
 .../Markdown/MenuItems/Markdown.cs            |  20 +-
 EditorExtensions/Settings/LegacySettings.cs   |   7 -
 EditorExtensions/Settings/WESettings.cs       |  46 +-
 .../Shared/Compilers/CompilerRunner.cs        |   7 +-
 EditorExtensions/WebEssentials2013.csproj     |   7 +-
 EditorExtensions/packages.config              |   1 +
 MarkdownSharp.dll                             | Bin 62464 -> 0 bytes
 WebEssentials2013.sln                         |   3 +-
 WebEssentialsTests/WebEssentialsTests.csproj  |   4 -
 12 files changed, 687 insertions(+), 103 deletions(-)
 delete mode 100644 MarkdownSharp.dll

diff --git a/EditorExtensions/CommandConstants.cs b/EditorExtensions/CommandConstants.cs
index cc61aa4af..4c3dd3c6e 100644
--- a/EditorExtensions/CommandConstants.cs
+++ b/EditorExtensions/CommandConstants.cs
@@ -114,6 +114,7 @@ enum CommandId
         CreateMarkdownStylesheet = 0x1046,
         CreateJavaScriptIntellisenseFile = 0x1047,
         CreateTypeScriptIntellisenseFile = 0x1048,
+        CreateMarkdownHtmlTemplate = 0x1102,
         MarkdownCompile = 0x1039,
         HandlebarsCompile = 0x1101,
         EditGlobalJsHint = 0x1038,
diff --git a/EditorExtensions/EditorExtensions.vsct b/EditorExtensions/EditorExtensions.vsct
index 9dfb1f000..b9cf6dd4a 100644
--- a/EditorExtensions/EditorExtensions.vsct
+++ b/EditorExtensions/EditorExtensions.vsct
@@ -457,6 +457,14 @@
         </Strings>
       </Button>
 
+      <Button guid="guidDiffCmdSet" id="cmdMarkdownHtmlTemplate" priority="0x0107" type="Button">
+        <Parent guid="guidTopMenu" id="SolutionSubMenuGroup" />
+        <CommandFlag>DynamicVisibility</CommandFlag>
+        <Strings>
+          <ButtonText>Add Markdown solution html template</ButtonText>
+        </Strings>
+      </Button>
+
       <Button guid="guidDiffCmdSet" id="cmdMarkdownCompile" priority="0x0102" type="Button">
         <Parent guid="guidDiffCmdSet" id="MarkdownGroup" />
         <CommandFlag>DynamicVisibility</CommandFlag>
@@ -943,6 +951,7 @@
       <IDSymbol name="cmdMarkdownStylesheet" value="0x1046" />
       <IDSymbol name="cmdJavaScriptIntellisense" value="0x1047" />
       <IDSymbol name="cmdTypeScriptIntellisense" value="0x1048" />
+      <IDSymbol name="cmdMarkdownHtmlTemplate" value="0x1102" />
       <IDSymbol name="MarkdownGroup" value="0x1049" />
       <IDSymbol name="cmdEditGlobalJsHint" value="0x1038" />
       <IDSymbol name="cmdEditGlobalTsLint" value="0x1098" />
diff --git a/EditorExtensions/Markdown/Margin/MarkdownMargin.cs b/EditorExtensions/Markdown/Margin/MarkdownMargin.cs
index a2fbbadd4..62b0116f9 100644
--- a/EditorExtensions/Markdown/Margin/MarkdownMargin.cs
+++ b/EditorExtensions/Markdown/Margin/MarkdownMargin.cs
@@ -1,6 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
+using System.Linq;
+using System.Runtime.Serialization;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
@@ -12,94 +15,690 @@ namespace MadsKristensen.EditorExtensions.Markdown
 {
     internal class MarkdownMargin : CompilingMarginBase
     {
-        private HTMLDocument _document;
         private WebBrowser _browser;
+
+        private const string _htmlTemplate = "WE-Markdown.html";
         private const string _stylesheet = "WE-Markdown.css";
         private double _cachedPosition = 0,
                        _cachedHeight = 0,
                        _positionPercentage = 0;
+        
 
         public MarkdownMargin(ITextDocument document)
             : base(WESettings.Instance.Markdown, document)
         { }
 
-        public static string GetStylesheet()
+        /// <summary>
+        /// Combine a relative filename with a list of folders and return each one of them in order.
+        /// </summary>
+        /// <param name="relativePath">The relative path to combine to each item in the folders parameter</param>
+        /// <param name="folders">
+        /// The folders where to look for the file. If an item in this array is 
+        /// null, it will be skipped.
+        /// </param>
+        /// <returns></returns>
+        public static IEnumerable<string> ResolvePaths(string relativePath, params string[] folders)
         {
-            string file = GetCustomStylesheetFilePath();
-
-            if (File.Exists(file))
+            foreach (var folder in folders)
             {
-                string linkFormat = "<link rel=\"stylesheet\" href=\"{0}\" />";
-
-                return string.Format(CultureInfo.CurrentCulture, linkFormat, file);
+                if (!string.IsNullOrWhiteSpace(folder))
+                {
+                    yield return Path.GetFullPath(Path.Combine(folder, relativePath));
+                }
             }
+        }
 
-            return "<style>body{font: 1.1em 'Century Gothic'}</style>";
+        /// <summary>
+        /// Probe a list of folder to check if a file exist 
+        /// and if it does yield its full path.
+        /// </summary>
+        /// <param name="fileName">The file name that will be combined with each folder</param>
+        /// <param name="folders">
+        /// The folders where to look for the file. If an item in this array is 
+        /// null, it will be skipped.
+        /// </param>
+        /// <returns>
+        /// A sequence containig at most (folders.Length) elements. 
+        /// Each item will be the path of an existing file. The order in witch the items 
+        /// are returned are the same in witch they are discovered.
+        /// </returns>
+        public static IEnumerable<string> GetExistingFilesInFolders(string fileName, params string[] folders)
+        {
+            return ResolvePaths(fileName, folders).Where(File.Exists);
+        }
+
+        /// <summary>
+        /// Convert a path(relative or absolute) into an url.
+        /// Eg. C:\Test\File\Path will be converted to file:///C:/Test/File/Path/
+        /// </summary>
+        /// <param name="absoluteOrRelativePath"></param>
+        /// <param name="ensureTrailingSlash">Ensure that the result ends with a trailing slash</param>
+        /// <returns></returns>
+        private static string ConvertLocalDirectoryPathToUrl(string absoluteOrRelativePath, bool ensureTrailingSlash = true)
+        {
+            if (ensureTrailingSlash && !absoluteOrRelativePath.EndsWith("\\"))
+                absoluteOrRelativePath = absoluteOrRelativePath + "\\";
+            
+            return string.Format(
+                CultureInfo.InvariantCulture,
+                "file:///{0}", 
+                absoluteOrRelativePath.Replace("\\", "/")
+            );
         }
 
-        public static string GetCustomStylesheetFilePath()
+        /// <summary>
+        /// Create an absolute path relative to the solution directory.
+        /// </summary>
+        /// <param name="fileName">The relative path of the file that need to be resolved.</param>
+        /// <returns>The absolute file path</returns>
+        private static string ResolvePathRelativeToSolution(string fileName)
         {
-            string folder = ProjectHelpers.GetSolutionFolderPath();
+            return ResolvePaths(fileName, ProjectHelpers.GetSolutionFolderPath()).FirstOrDefault();
+        }
 
-            if (string.IsNullOrEmpty(folder))
-                return null;
+        /// <summary>
+        /// Get the default path of the solution custom stylesheet
+        /// </summary>
+        /// <returns></returns>
+        public static string GetCustomSolutionStylesheetFilePath()
+        {
+            return ResolvePathRelativeToSolution(_stylesheet);
+        }
 
-            return Path.Combine(folder, _stylesheet);
+        /// <summary>
+        /// Get the default path of the solution custom html template
+        /// </summary>
+        /// <returns></returns>
+        public static string GetCustomSolutionHtmlTemplateFilePath()
+        {
+            return ResolvePathRelativeToSolution(_htmlTemplate);
         }
 
-        public async static Task CreateStylesheet()
+        /// <summary>
+        /// Save the current document position.
+        /// </summary>
+        /// <param name="browser"></param>
+        private void SaveDocumentVerticalPosition(WebBrowser browser)
+        {
+            var document = browser.Document as HTMLDocument;
+            if (document == null)
+                return;
+
+            _cachedPosition = document.documentElement.getAttribute("scrollTop");
+            _cachedHeight = Math.Max(1.0, document.body.offsetHeight);
+            _positionPercentage = _cachedPosition * 100 / _cachedHeight;
+        }
+
+        /// <summary>
+        /// Restore the vertical position saved by the 
+        /// last call To SaveDocumentVerticalPosition()
+        /// in the current loaded html document.
+        /// </summary>
+        /// <param name="browser"></param>
+        private void RestoreDocumentVerticalPosition(WebBrowser browser)
+        {
+            var document = browser.Document as HTMLDocument;
+            if (document == null)
+                return;
+
+            _cachedHeight = document.body.offsetHeight;
+            document.documentElement.setAttribute("scrollTop", _positionPercentage * _cachedHeight / 100);
+        }
+
+        /// <summary>
+        /// If a custom solution stylesheet is found in the default location 
+        /// this method returns a html link element string literal that reference it.
+        /// Otherwise it return a default html style element string literal.
+        /// </summary>
+        /// <returns></returns>
+        public static string GetStylesheet(params string[] folders)
         {
-            string file = Path.Combine(ProjectHelpers.GetSolutionFolderPath(), _stylesheet);
+            string filePath = GetExistingFilesInFolders(_stylesheet, folders).FirstOrDefault();
+
+            if (filePath != null)
+            {
+                string linkFormat = "<link rel=\"stylesheet\" href=\"{0}\" />";
+                return string.Format(CultureInfo.CurrentCulture, linkFormat, ConvertLocalDirectoryPathToUrl(filePath, false));
+            }
 
+            return "<style>body{font: 1.1em 'Century Gothic'}</style>";
+        }
+
+        /// <summary>
+        /// Create a default stylesheet in the default location
+        /// and add it to the current solution.
+        /// </summary>
+        /// <returns></returns>
+        public async static Task CreateStylesheet()
+        {
+            string file = GetCustomSolutionStylesheetFilePath();
             await FileHelpers.WriteAllTextRetry(file, "body { background: yellow; }");
             ProjectHelpers.GetSolutionItemsProject().ProjectItems.AddFromFile(file);
         }
 
+        /// <summary>
+        /// Create a default html template in the location 
+        /// and add it to the current solution.
+        /// </summary>
+        /// <returns></returns>
+        public async static Task CreateHtmlTemplate()
+        {
+            const string _defaultHtmlTemplate = @"<!DOCTYPE html>
+<html lang="""" en"""" xmlns=""http //www.w3.org/1999/xhtml"">
+<head>
+    <meta charset=""utf-8"" />
+    <base href=""{##DOCUMENT_PATH_PLACEHOLDER##}""/>
+    <title>Markdown Preview</title>
+</head>
+<body>
+    <div class=""markdown-body"">{##MARKDOWN_HTML_PLACEHOLDER##}</div>
+</body>
+</html>";
+            string file = GetCustomSolutionHtmlTemplateFilePath();
+            await FileHelpers.WriteAllTextRetry(file, _defaultHtmlTemplate);
+            ProjectHelpers.GetSolutionItemsProject().ProjectItems.AddFromFile(file);
+        }
+
+        /// <summary>
+        /// Retrieve the string that rapresent the html to display in 
+        /// the preview.
+        /// If an html template is found in the project folder or in the solution folder, it 
+        /// is returned after the place holders have been substituted.
+        /// If no html template is found, the old behavior that was in place before 
+        /// the html template was introduced is used (a minimal html is returned with a 
+        /// reference to a custom stylesheet). The only change is that a custom stylesheet 
+        /// found in the project folder will take precedence over the one in the solution 
+        /// folder.
+        /// </summary>
+        /// <remarks>
+        /// The supported placeholders are:
+        /// 
+        /// {##SOLUTION_PATH_PLACEHOLDER##}
+        /// {##PROJECT_PATH_PLACEHOLDER##}
+        /// {##DOCUMENT_PATH_PLACEHOLDER##}
+        /// {##MARKDOWN_HTML_PLACEHOLDER##}
+        /// 
+        /// Note that to keep things simple, a placeholder must appear in the html template
+        /// literally. there is no parsing involved.
+        /// </remarks>
+        /// <param name="compilerResult">The result of the markdown compilation</param>
+        /// <returns>The html string</returns>
+        public static string CompileHtmlDocumentString(string currentDocumentPath, CompilerResult compilerResult)
+        {
+            // The Markdown compiler cannot return errors
+            var solutionPath = ProjectHelpers.GetSolutionFolderPath();
+            var projectPath = ProjectHelpers.GetProjectFolder(currentDocumentPath);
+            var htmlTemplateFilePath = GetExistingFilesInFolders(_htmlTemplate, projectPath, solutionPath).FirstOrDefault();
+
+            var currentDocumentPathUrl = ConvertLocalDirectoryPathToUrl(Path.GetDirectoryName(currentDocumentPath));
+
+            if (htmlTemplateFilePath != null)
+            {
+                var solutionPathUrl = ConvertLocalDirectoryPathToUrl(solutionPath);
+                var projectPathUrl = ConvertLocalDirectoryPathToUrl(projectPath);
+
+                //Load the template and replace the placeholder with the generated html
+                var htmlTemplate = File.ReadAllText(htmlTemplateFilePath);
+
+                // TODO: Find a better way to do this(Handlerbar, HTML parsing, etc...)
+                return htmlTemplate
+                    .Replace("{##SOLUTION_PATH_PLACEHOLDER##}", solutionPathUrl)
+                    .Replace("{##PROJECT_PATH_PLACEHOLDER##}", projectPathUrl)
+                    .Replace("{##DOCUMENT_PATH_PLACEHOLDER##}", currentDocumentPathUrl)
+                    .Replace("{##MARKDOWN_HTML_PLACEHOLDER##}", compilerResult.Result);
+            }
+
+            // Keep the legacy behavior
+            return string.Format(
+                CultureInfo.InvariantCulture,
+                @"<!DOCTYPE html>
+                    <html lang=""en"" xmlns=""http://www.w3.org/1999/xhtml"">
+                        <head>
+                            <meta charset=""utf-8"" />
+                            <base href=""{0}"">                                  
+                            <title>Markdown Preview</title>
+                            {1}
+                        </head>
+                        <body>
+                        {2}
+                        </body>
+                    </html>",
+                currentDocumentPathUrl,
+                GetStylesheet(projectPath, solutionPath),
+                compilerResult.Result
+            );
+        }
+
         protected override void UpdateMargin(CompilerResult result)
         {
             if (_browser == null)
                 return;
-            // The Markdown compiler cannot return errors
-            string html = String.Format(CultureInfo.InvariantCulture, @"<!DOCTYPE html>
-                                        <html lang=""en"" xmlns=""http://www.w3.org/1999/xhtml"">
-                                            <head>
-                                                <meta charset=""utf-8"" />
-                                                <base href=""file:///{0}/"">
-                                                <title>Markdown Preview</title>
-                                                {1}
-                                            </head>
-                                            <body>{2}</body>
-                                        </html>",
-                                        Path.GetDirectoryName(Document.FilePath).Replace("\\", "/"),
-                                        GetStylesheet(),
-                                        result.Result);
-
-            if (_document == null)
-            {
-                _browser.NavigateToString(html);
 
+            var htmlString = CompileHtmlDocumentString(Document.FilePath, result);
+            if (_browser.Document == null)
+            {
+                _browser.NavigateToString(htmlString);
                 return;
             }
 
-            _cachedPosition = _document.documentElement.getAttribute("scrollTop");
-            _cachedHeight = Math.Max(1.0, _document.body.offsetHeight);
-            _positionPercentage = _cachedPosition * 100 / _cachedHeight;
-
-            _browser.NavigateToString(html);
+            SaveDocumentVerticalPosition(_browser);
+            _browser.NavigateToString(htmlString);
         }
 
         protected override FrameworkElement CreatePreviewControl()
         {
+            ConfigureRequiredInternetExplorerFeatures();
+
             _browser = new WebBrowser();
             _browser.HorizontalAlignment = HorizontalAlignment.Stretch;
-            _browser.Navigated += (s, e) =>
+
+            // This can be done only once
+            _browser.ObjectForScripting = new JavaScriptToManagedConnector((errorMsg, document, line) => 
+            {
+                // Unfortunatly, when the error is in a file other than the main document the errorMsg 
+                // and line are not available.
+                // Instead they always contain : line:"0" errorMsg:"script Error"
+                // This is another IE "feature" to "protect" you :).
+                Log("Error in ({0}:{1}): {2}", document, line, errorMsg);
+            });
+            
+            _browser.Navigated += (sender, ev) =>
             {
-                _document = _browser.Document as HTMLDocument;
-                _cachedHeight = _document.body.offsetHeight;
-                _document.documentElement.setAttribute("scrollTop", _positionPercentage * _cachedHeight / 100);
+                if (!ShouldHandleNavigationEvent(ev))
+                    return;
+
+                var browser = sender as WebBrowser;
+                InjectJavascriptErrorsRedirection(browser);
             };
+            
+            _browser.LoadCompleted += (sender,ev) => 
+            {
+                if (!ShouldHandleNavigationEvent(ev)) 
+                    return;
 
+                var browser = sender as WebBrowser;
+                RestoreDocumentVerticalPosition(browser);
+            };
+            
             return _browser;
         }
+
+        /// <summary>
+        /// Configure the current user settings for Internet Explorer when 
+        /// used through the BrowserControl by changing the user 
+        /// registry.
+        /// </summary>
+        private static void ConfigureRequiredInternetExplorerFeatures()
+        {
+            // This is really required only if we have an html template, but we
+            // need to enable it here since the WebBrowser control implementation 
+            // read the IE feature registry keys only when a control
+            // is instantiated the first time in a process.
+            // This will log if something goes wrong(eg. no access to the registry) and hopefully,
+            // help the user figure out what to do (he probably need to launch visual studio
+            // with elevate privileges the first time).
+            // This should probably be called by a menu command but if the user already 
+            // opened a markdown file, then Visual studio need to be restarted for 
+            // the setting to take effect.
+            try
+            {
+                InternetExplorerBrowserFeatureControl.DisableBlockCrossProtocolFileNavigation();
+                InternetExplorerBrowserFeatureControl.AutoSetBrowserEmulationVersion();
+            }
+            catch (InternetExplorerFeatureControlSecurityException exception)
+            {
+                Log("Cannot configure the internet explorer features required to correctly display the markdown preview. " +
+                    "You can try restarting visual studio as an Administrator and open a " +
+                    "markdown document again. You will need to this only once.");
+                Log(exception.Message);
+            }
+            catch (Exception exception)
+            {
+                Log(exception, "Cannot configure the internet explorer features required to correctly display the markdown preview.");
+            }
+        }
+
+        /// <summary>
+        /// This method will return true only for events fired 
+        /// after NavigateToString() has been programatically invoked.
+        /// Eg. It will return false if the user click on a link in the 
+        /// previewed html.
+        /// </summary>
+        /// <param name="event"></param>
+        /// <returns></returns>
+        private static bool ShouldHandleNavigationEvent(System.Windows.Navigation.NavigationEventArgs @event)
+        {
+            // If the user click on a link in the preview window, @event.Uri is null.
+            return @event.Uri == null;
+        }
+        
+        /// <summary>
+        /// Hook the the DOM onerror event and redirect it to the managed host that 
+        /// will then write it to the visual studio output pane.
+        /// Note that this need to be done on each new page loaded by the browser control.
+        /// </summary>
+        /// <param name="browser"></param>
+        private static void InjectJavascriptErrorsRedirection(WebBrowser browser)
+        {
+            string disableScriptError = @"function externalError(errorMsg, document, lineNumber) 
+            {
+                window.external.OnError(errorMsg, document, lineNumber);
+                return true;
+            }
+            window.onerror = externalError;";
+
+            var doc = browser.Document as HTMLDocument;
+            if (doc != null)
+            {
+                var heads = doc.getElementsByTagName("head").OfType<HTMLHeadElement>();
+                foreach (var head in heads)
+                {
+                    var scriptErrorSuppressed = (IHTMLScriptElement)doc.createElement("SCRIPT");
+                    scriptErrorSuppressed.type = "text/javascript";
+                    scriptErrorSuppressed.text = disableScriptError;
+                    head.appendChild((IHTMLDOMNode)scriptErrorSuppressed);
+                }
+            }
+        }
+        
+        private static void Log(string format, params object[] args)
+        {
+            Logger.Log(string.Format(CultureInfo.InvariantCulture, "[markdown]: " + format, args));
+        }
+        private static void Log(Exception ex, string format, params object[] args)
+        {
+            Log(format, args);
+            Logger.Log(ex);
+        }
+    }
+
+    /// <summary>
+    /// Thrown when the user does not have the right or permission to change a 
+    /// Internet Explorer Feature Control entry in the registry.
+    /// </summary>
+    [Serializable]
+    public class InternetExplorerFeatureControlSecurityException : Exception
+    {
+        public InternetExplorerFeatureControlSecurityException()
+        {
+        }
+
+        public InternetExplorerFeatureControlSecurityException(string message) : base(message)
+        {
+        }
+
+        public InternetExplorerFeatureControlSecurityException(string message, Exception inner) : base(message, inner)
+        {
+        }
+
+        protected InternetExplorerFeatureControlSecurityException(
+            SerializationInfo info,
+            StreamingContext context) : base(info, context)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Provide methods to change the registry Internet Explorer behavior when embedded in an 
+    /// application by changing the Feature Control settings in the windows registry.
+    /// </summary>
+    internal class InternetExplorerBrowserFeatureControl
+    {
+        
+        private const string InternetExplorerRootKey = @"Software\Microsoft\Internet Explorer";
+        private const string BrowserEmulationKey = InternetExplorerRootKey + @"\Main\FeatureControl\FEATURE_BROWSER_EMULATION";
+        private const string BlockCrossProtocolFileNavigation = InternetExplorerRootKey + @"\MAIN\FeatureControl\FEATURE_BLOCK_CROSS_PROTOCOL_FILE_NAVIGATION";
+
+        private enum BrowserEmulationVersion
+        {
+            Default = 0,
+            Version7 = 7000,
+            Version8 = 8000,
+            Version8Standards = 8888,
+            Version9 = 9000,
+            Version9Standards = 9999,
+            Version10 = 10000,
+            Version10Standards = 10001,
+            Version11 = 11000,
+            Version11Edge = 11001
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key">The parent registry key.</param>
+        /// <param name="subkeyName">Name or path of the subkey to open.</param>
+        /// <param name="writable">
+        /// Set to true if you need write access to the key. 
+        /// If this parameter is true and the subkey does not exist a new one 
+        /// will be created.
+        /// </param>
+        /// <returns>
+        /// The RegistryKey instance that can be used to access 
+        /// the registry sub key
+        /// </returns>
+        private static Microsoft.Win32.RegistryKey OpenOrCreateKey(Microsoft.Win32.RegistryKey key, 
+            string subkeyName, bool writable)
+        {
+            var subKey = key.OpenSubKey(subkeyName, writable);
+            if (subKey == null && writable)
+                subKey = key.CreateSubKey(subkeyName);
+            return subKey;
+        }
+
+        /// <summary>
+        /// Open the subkey specified by subKeyName, 
+        /// call the provided function passing the RegistryKey instance 
+        /// and dispose it automatically aferward.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="key">The parent registry key.</param>
+        /// <param name="subkeyName">Name or path of the subkey to open.</param>
+        /// <param name="writable">
+        /// Set to true if you need write access to the key. 
+        /// If this parameter is true and the subkey does not exist a new one 
+        /// will be created.
+        /// </param>
+        /// <param name="useKey">the function where the key can be used</param>
+        /// <returns>
+        /// The return value of the function provided in the useKey parameter 
+        /// after its execution.
+        /// </returns>
+        /// <exception cref="InternetExplorerFeatureControlSecurityException">
+        /// The used does not have the required permission or rights to 
+        /// execute this operation.
+        /// </exception>
+        private static T UseRegistryKey<T>(
+            Microsoft.Win32.RegistryKey key, string subkeyName, 
+            bool writable, Func<Microsoft.Win32.RegistryKey, T> useKey
+        )
+        {
+            try
+            {
+                using (var subKey = OpenOrCreateKey(key, subkeyName, writable))
+                {
+                    return useKey(subKey);
+                }
+            }
+            catch (System.Security.SecurityException se)
+            {
+                // The user does not have the permissions required to read from the registry key.
+                throw new InternetExplorerFeatureControlSecurityException(
+                    string.Format(
+                        CultureInfo.CurrentCulture, 
+                        "The current user does not have the rights to open the registry key: '{0}\\{1}'", key, subkeyName),
+                    se
+                );
+                
+            }
+            catch (UnauthorizedAccessException uaEx)
+            {
+                // The user does not have the necessary registry rights.
+                throw new InternetExplorerFeatureControlSecurityException(
+                    string.Format(CultureInfo.CurrentCulture, "The current user is not authorized to access the registry key: '{0}\\{1}'", key, subkeyName),
+                    uaEx
+                );
+            }
+        }
+
+        private static int GetInternetExplorerMajorVersion()
+        {
+            return UseRegistryKey(Microsoft.Win32.Registry.LocalMachine, InternetExplorerRootKey, false, key =>
+            {
+                var result = 0;
+                if (key != null)
+                {
+                    var value = key.GetValue("svcVersion", null) ?? key.GetValue("Version", null);
+
+                    if (value != null)
+                    {
+                        var version = value.ToString();
+                        var separator = version.IndexOf('.');
+                        if (separator != -1)
+                        {
+                            if (!int.TryParse(version.Substring(0, separator), out result))
+                            {   
+                                // Make CodeAnalisys happy :)
+                                result = 0;
+                            }
+                        }
+                    }
+                }
+                return result;
+            });
+        }
+
+        private static bool IsBrowserEmulationSet()
+        {
+            return GetBrowserEmulationVersion() != BrowserEmulationVersion.Default;
+        }
+
+        private static BrowserEmulationVersion GetBrowserEmulationVersion()
+        {
+            return UseRegistryKey(Microsoft.Win32.Registry.CurrentUser, BrowserEmulationKey, false, key =>
+            {
+                if (key != null)
+                {
+                    var programName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
+                    var value = key.GetValue(programName, null);
+
+                    if (value != null)
+                    {
+                        return (BrowserEmulationVersion)Convert.ToInt32(value, CultureInfo.InvariantCulture);
+                    }
+                }
+                return BrowserEmulationVersion.Default;
+            });
+        }
+
+        private static bool SetBrowserEmulationVersion(BrowserEmulationVersion browserEmulationVersion)
+        {
+            return UseRegistryKey(Microsoft.Win32.Registry.CurrentUser, BrowserEmulationKey, true, key =>
+            {
+                if (key != null)
+                {
+                    var programName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
+
+                    if (browserEmulationVersion != BrowserEmulationVersion.Default)
+                    {
+                        // if it's a valid value, update or create the value
+                        key.SetValue(programName, (int)browserEmulationVersion, Microsoft.Win32.RegistryValueKind.DWord);
+                    }
+                    else
+                    {
+                        // otherwise, remove the existing value
+                        key.DeleteValue(programName, false);
+                    }
+
+                    return true;
+                }
+                return false;
+            });
+        }
+
+        public static bool DisableBlockCrossProtocolFileNavigation()
+        {
+            return UseRegistryKey(Microsoft.Win32.Registry.CurrentUser, BlockCrossProtocolFileNavigation, true, key =>
+            {
+                if (key != null)
+                {
+                    var programName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
+                    var current = key.GetValue(programName);
+                    if (current is int && (int)current == 0)
+                        return true;
+                    // Update or create the value
+                    key.SetValue(programName, 0, Microsoft.Win32.RegistryValueKind.DWord);
+                    return true;
+                }
+                return false;
+            });
+        }
+
+        /// <summary>
+        /// Set the Browser Emulation Mode for the current user equal to the installed internet 
+        /// explorer version in this system.
+        /// Note that this require the user identity under witch the process is running 
+        /// to have the appropriate permissions to access the registry (HKEY_LOCAL_MACHINE: read only, 
+        /// HKEY_CURRENT_USER: read/write).
+        /// </summary>
+        /// <returns>true if the operation succeed.</returns>
+        public static bool AutoSetBrowserEmulationVersion()
+        {
+            if (IsBrowserEmulationSet())
+                return true;
+
+            BrowserEmulationVersion emulationCode;
+            var ieVersion = GetInternetExplorerMajorVersion();
+
+            if (ieVersion >= 11)
+            {
+                emulationCode = BrowserEmulationVersion.Version11;
+            }
+            else
+            {
+                switch (ieVersion)
+                {
+                    case 10:
+                        emulationCode = BrowserEmulationVersion.Version10;
+                        break;
+                    case 9:
+                        emulationCode = BrowserEmulationVersion.Version9;
+                        break;
+                    case 8:
+                        emulationCode = BrowserEmulationVersion.Version8;
+                        break;
+                    default:
+                        emulationCode = BrowserEmulationVersion.Version7;
+                        break;
+                }
+            }
+
+            return SetBrowserEmulationVersion(emulationCode);
+        }
+    }
+
+    /// <summary>
+    /// Used to proxy javascript error to the managed host.
+    /// MUST be public.
+    /// </summary>
+    [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]
+    [System.Runtime.InteropServices.ComVisible(true)]
+    public class JavaScriptToManagedConnector
+    {
+        private readonly Action<object, object, object> _errorHandler;
+
+        public JavaScriptToManagedConnector()
+        {
+        }
+
+        public JavaScriptToManagedConnector(Action<object,object,object> errorHandler)
+        {
+            _errorHandler = errorHandler;
+        }
+
+        public void OnError(object arg1, object arg2, object arg3)
+        {
+            _errorHandler(arg1, arg2, arg3);
+        }
     }
 }
\ No newline at end of file
diff --git a/EditorExtensions/Markdown/MenuItems/Markdown.cs b/EditorExtensions/Markdown/MenuItems/Markdown.cs
index 6b4d477aa..2da60811b 100644
--- a/EditorExtensions/Markdown/MenuItems/Markdown.cs
+++ b/EditorExtensions/Markdown/MenuItems/Markdown.cs
@@ -44,6 +44,11 @@ public void SetupCommands()
             cssCommand.BeforeQueryStatus += HasStylesheet;
             _mcs.AddCommand(cssCommand);
 
+            CommandID htmlTemplate = new CommandID(CommandGuids.guidDiffCmdSet, (int)CommandId.CreateMarkdownHtmlTemplate);
+            OleMenuCommand htmlTemplateCommand = new OleMenuCommand(async (s, e) => await AddHtmlTemplate(), htmlTemplate);
+            htmlTemplateCommand.BeforeQueryStatus += HasHtmlTemplate;
+            _mcs.AddCommand(htmlTemplateCommand);
+
             CommandID compile = new CommandID(CommandGuids.guidDiffCmdSet, (int)CommandId.MarkdownCompile);
             OleMenuCommand compileCommand = new OleMenuCommand((s, e) => AddHtmlFiles(), compile);
             compileCommand.BeforeQueryStatus += IsMarkdownFile;
@@ -54,7 +59,15 @@ private void HasStylesheet(object sender, System.EventArgs e)
         {
             OleMenuCommand menuCommand = sender as OleMenuCommand;
 
-            menuCommand.Enabled = !File.Exists(MarkdownMargin.GetCustomStylesheetFilePath());
+            menuCommand.Enabled = !File.Exists(MarkdownMargin.GetCustomSolutionStylesheetFilePath());
+        }
+
+        
+        private void HasHtmlTemplate(object sender, System.EventArgs e)
+        {
+            OleMenuCommand menuCommand = sender as OleMenuCommand;
+
+            menuCommand.Enabled = !File.Exists(MarkdownMargin.GetCustomSolutionHtmlTemplateFilePath());
         }
 
         private void IsMarkdownFile(object sender, System.EventArgs e)
@@ -78,5 +91,10 @@ private async static System.Threading.Tasks.Task AddStylesheet()
         {
             await MarkdownMargin.CreateStylesheet();
         }
+
+        private async static System.Threading.Tasks.Task AddHtmlTemplate()
+        {
+            await MarkdownMargin.CreateHtmlTemplate();
+        }
     }
 }
\ No newline at end of file
diff --git a/EditorExtensions/Settings/LegacySettings.cs b/EditorExtensions/Settings/LegacySettings.cs
index e15aee75f..d23d468c9 100644
--- a/EditorExtensions/Settings/LegacySettings.cs
+++ b/EditorExtensions/Settings/LegacySettings.cs
@@ -58,13 +58,6 @@ public void ApplyTo(WESettings target)
             target.Markdown.CompileOnSave = GetBoolean("MarkdownEnableCompiler");
             target.Markdown.OutputDirectory = GetNonBooleanString("MarkdownCompileToLocation");
 
-            target.Markdown.AutoHyperlink = GetBoolean("MarkdownAutoHyperlinks");
-            target.Markdown.LinkEmails = GetBoolean("MarkdownLinkEmails");
-            target.Markdown.AutoNewLines = GetBoolean("MarkdownAutoNewLine");
-            target.Markdown.GenerateXHTML = GetBoolean("MarkdownGenerateXHTML");
-            target.Markdown.EncodeProblemUrlCharacters = GetBoolean("MarkdownEncodeProblemUrlCharacters");
-            target.Markdown.StrictBoldItalic = GetBoolean("MarkdownStrictBoldItalic");
-
             // SVG
             target.General.SvgPreviewPane = GetBoolean("SvgShowPreviewWindow");
 
diff --git a/EditorExtensions/Settings/WESettings.cs b/EditorExtensions/Settings/WESettings.cs
index 50f7825f1..0e0966ea5 100644
--- a/EditorExtensions/Settings/WESettings.cs
+++ b/EditorExtensions/Settings/WESettings.cs
@@ -3,7 +3,6 @@
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using ConfOxide;
-using MarkdownSharp;
 using Microsoft.Ajax.Utilities;
 using Microsoft.VisualStudio.Shell;
 using WebMarkupMin.Core;
@@ -698,15 +697,16 @@ public sealed class HandlebarsSettings : SettingsBase<HandlebarsSettings>, IComp
         public bool MinifyInPlace { get; set; }
     }
 
-    public sealed class MarkdownSettings : SettingsBase<MarkdownSettings>, ICompilerInvocationSettings, IMarginSettings, IMarkdownOptions
+    public sealed class MarkdownSettings : SettingsBase<MarkdownSettings>, ICompilerInvocationSettings, IMarginSettings
     {
-        #region Compilation
         [Category("Editor")]
         [DisplayName("Show preview pane")]
         [Description("Show a preview pane containing the rendered output in the editor.")]
         [DefaultValue(true)]
         public bool ShowPreviewPane { get; set; }
 
+        #region Compilation
+
         [Category("Compilation")]
         [DisplayName("Compile files on save")]
         [Description("Compile files when saving them, if a compiled file already exists.")]
@@ -723,50 +723,14 @@ public sealed class MarkdownSettings : SettingsBase<MarkdownSettings>, ICompiler
         [Description("Specifies a custom subfolder to save compiled files to. By default, compiled output will be placed in the same folder and nested under the original file.")]
         [DefaultValue(null)]
         public string OutputDirectory { get; set; }
-        #endregion
-
-        [Category("Compile Options")]
-        [DisplayName("Make bare URLs into hyperlinks")]
-        [Description("When true, (most) bare plain Urls are auto-hyperlinked. WARNING: this is a significant deviation from the Markdown spec.")]
-        [DefaultValue(false)]
-        public bool AutoHyperlink { get; set; }
-
-        [Category("Compile Options")]
-        [DisplayName("Make bare emails into links")]
-        [Description("When false, email addresses will never be auto-linked. WARNING: this is a significant deviation from the Markdown spec.")]
-        [DefaultValue(false)]
-        public bool LinkEmails { get; set; }
-
-        [Category("Compile Options")]
-        [DisplayName("Make return into a newline")]
-        [Description("When true, RETURN becomes a literal newline. WARNING: this is a significant deviation from the Markdown spec.")]
-        [DefaultValue(false)]
-        public bool AutoNewLines { get; set; }
-
-        [Category("Compile Options")]
-        [DisplayName("Generate XHTML output")]
-        [Description("When true, the output is valid XHTML. Otherwise regular HTML it output. In this case, when true (mostly) means that single tags are closed with `/>` instead of `>`.")]
-        [DefaultValue(true)]
-        public bool GenerateXHTML { get; set; }
-
-        [Category("Compile Options")]
-        [DisplayName("Encode problem Url characters")]
-        [Description("When true, problematic Url characters like [, ], (, and so forth will be encoded. WARNING: this is a significant deviation from the Markdown spec.")]
-        [DefaultValue(false)]
-        public bool EncodeProblemUrlCharacters { get; set; }
-
-        [Category("Compile Options")]
-        [DisplayName("Require non-word characters for bold/italic")]
-        [Description("When true, bold and italic require non-word characters on both sides. WARNING: this is a significant deviation from the Markdown spec.")]
-        [DefaultValue(false)]
-        public bool StrictBoldItalic { get; set; }
-        string IMarkdownOptions.EmptyElementSuffix { get { return GenerateXHTML ? " />" : ">"; } }
 
         [Category("Compilation")]
         [DisplayName("Don't save raw compilation output")]
         [Description("Don't save separate unminified compiler output. This option has no effect when Minify On Save is disabled for HTML.")]
         [DefaultValue(false)]
         public bool MinifyInPlace { get; set; }
+
+        #endregion
     }
 
     public interface IBundleSettings
diff --git a/EditorExtensions/Shared/Compilers/CompilerRunner.cs b/EditorExtensions/Shared/Compilers/CompilerRunner.cs
index d74449f15..b3c505c40 100644
--- a/EditorExtensions/Shared/Compilers/CompilerRunner.cs
+++ b/EditorExtensions/Shared/Compilers/CompilerRunner.cs
@@ -255,7 +255,12 @@ class MarkdownCompilerRunner : CompilerRunnerBase
 
         protected async override Task<CompilerResult> RunCompilerAsync(string sourcePath, string targetPath)
         {
-            var result = new MarkdownSharp.Markdown(WESettings.Instance.Markdown).Transform(await FileHelpers.ReadAllTextRetry(sourcePath));
+            var sourceText = await FileHelpers.ReadAllTextRetry(sourcePath);
+            var settings = new CommonMark.CommonMarkSettings
+            {
+                OutputFormat = CommonMark.OutputFormat.Html
+            };
+            var result = CommonMark.CommonMarkConverter.Convert(sourceText, settings);
 
             if (!string.IsNullOrEmpty(targetPath) &&
                (!File.Exists(targetPath) || await FileHelpers.ReadAllTextRetry(targetPath) != result))
diff --git a/EditorExtensions/WebEssentials2013.csproj b/EditorExtensions/WebEssentials2013.csproj
index ce7823ff2..6411d3b55 100644
--- a/EditorExtensions/WebEssentials2013.csproj
+++ b/EditorExtensions/WebEssentials2013.csproj
@@ -101,6 +101,9 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\AjaxMin.5.12.5436.22734\lib\net40\AjaxMin.dll</HintPath>
     </Reference>
+    <Reference Include="CommonMark">
+      <HintPath>..\packages\CommonMark.NET.0.5.2\lib\net45\CommonMark.dll</HintPath>
+    </Reference>
     <Reference Include="ConfOxide, Version=1.4.0.0, Culture=neutral, PublicKeyToken=934faed64f82030e, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\ConfOxide.1.4.0.0\lib\net40\ConfOxide.dll</HintPath>
@@ -121,10 +124,6 @@
     <Reference Include="EnvDTE90, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
       <EmbedInteropTypes>False</EmbedInteropTypes>
     </Reference>
-    <Reference Include="MarkdownSharp, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\MarkdownSharp.dll</HintPath>
-    </Reference>
     <Reference Include="Microsoft.Collections.Immutable, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="Microsoft.JSON.Core">
diff --git a/EditorExtensions/packages.config b/EditorExtensions/packages.config
index ac2c6efc1..03ccc9455 100644
--- a/EditorExtensions/packages.config
+++ b/EditorExtensions/packages.config
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AjaxMin" version="5.12.5436.22734" targetFramework="net451" />
+  <package id="CommonMark.NET" version="0.5.2" targetFramework="net451" />
   <package id="ConfOxide" version="1.4.0.0" targetFramework="net451" />
   <package id="Minimatch" version="1.1.0" targetFramework="net451" />
   <package id="Newtonsoft.Json" version="6.0.6" targetFramework="net451" />
diff --git a/MarkdownSharp.dll b/MarkdownSharp.dll
deleted file mode 100644
index e25094ca414cfa2fd3389f4c7813bbe36b59d240..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 62464
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

diff --git a/WebEssentials2013.sln b/WebEssentials2013.sln
index 48c44f4e2..02634e22f 100644
--- a/WebEssentials2013.sln
+++ b/WebEssentials2013.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2013
-VisualStudioVersion = 12.0.30501.0
+VisualStudioVersion = 12.0.31101.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{140A15DE-0F66-4377-BB52-BC24C7FC46E9}"
 	ProjectSection(SolutionItems) = preProject
@@ -10,7 +10,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		CONTRIBUTING.md = CONTRIBUTING.md
 		CssSorter.dll = CssSorter.dll
 		LICENSE.txt = LICENSE.txt
-		MarkdownSharp.dll = MarkdownSharp.dll
 		README.md = README.md
 		Rebracer.xml = Rebracer.xml
 		WebEssentials2012logo.pdn = WebEssentials2012logo.pdn
diff --git a/WebEssentialsTests/WebEssentialsTests.csproj b/WebEssentialsTests/WebEssentialsTests.csproj
index be4557a88..35021d8f0 100644
--- a/WebEssentialsTests/WebEssentialsTests.csproj
+++ b/WebEssentialsTests/WebEssentialsTests.csproj
@@ -55,10 +55,6 @@
     <Reference Include="FluentAssertions.Core">
       <HintPath>..\packages\FluentAssertions.3.0.107\lib\net45\FluentAssertions.Core.dll</HintPath>
     </Reference>
-    <Reference Include="MarkdownSharp, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\MarkdownSharp.dll</HintPath>
-    </Reference>
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="Microsoft.CSS.Core, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.CSS.Editor, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />