Bump version to 0.8.2

Fixes issue where LiteralInlineParser calls PostMatch while processor.Inline is type other than LiteralInline

readme.md

@@ -46,6 +46,8 @@ You can **try Markdig online** and compare it to other implementations on [babel
   - **Emoji** support (inspired from [Markdown-it](https://markdown-it.github.io/))
   - **SmartyPants** (inspired from [Daring Fireball - SmartyPants](https://daringfireball.net/projects/smartypants/))
   - **Bootstrap** class (to output bootstrap class)
+  - **Diagrams** extension whenever a fenced code block contains a special keyword, it will be converted to a div block with the content as-is (currently, supports only for [`mermaid` diagrams](https://knsv.github.io/mermaid/))
+  - **YAML frontmatter** to parse without evaluating the frontmatter and to discard it from the HTML output (typically used for previewing without the frontmatter in MarkdownEditor)
 - Compatible with .NET 3.5, 4.0+ and .NET Core (`netstandard1.1+`)
 	
 ## Documentation

src/Markdig.Tests/Specs/AbbreviationSpecs.md

@@ -57,3 +57,13 @@ We can abbreviate 1A, 1A1 and 1A2!
 .
 <p>We can abbreviate <abbr title="First">1A</abbr>, <abbr title="Second">1A1</abbr> and <abbr title="Third">1A2</abbr>!</p>
 ````````````````````````````````
+
+Abbreviations should match whole word only:
+
+```````````````````````````````` example
+*[1A]: First
+
+We should not abbreviate 1.1A or 11A!
+.
+<p>We should not abbreviate 1.1A or 11A!</p>
+````````````````````````````````

src/Markdig.Tests/Specs/Specs.cs

@@ -18583,6 +18583,28 @@ namespace Markdig.Tests
             Console.WriteLine("Example {0}" + Environment.NewLine + "Section: {0}" + Environment.NewLine, 5, "Extensions Abbreviation");
 			TestParser.TestSpec("*[1A]: First\n*[1A1]: Second\n*[1A2]: Third\n\nWe can abbreviate 1A, 1A1 and 1A2!", "<p>We can abbreviate <abbr title=\"First\">1A</abbr>, <abbr title=\"Second\">1A1</abbr> and <abbr title=\"Third\">1A2</abbr>!</p>", "abbreviations|advanced");
         }
+    }
+        // Abbreviations should match whole word only:
+    [TestFixture]
+    public partial class TestExtensionsAbbreviation
+    {
+        [Test]
+        public void Example006()
+        {
+            // Example 6
+            // Section: Extensions Abbreviation
+            //
+            // The following CommonMark:
+            //     *[1A]: First
+            //     
+            //     We should not abbreviate 1.1A or 11A!
+            //
+            // Should be rendered as:
+            //     <p>We should not abbreviate 1.1A or 11A!</p>
+
+            Console.WriteLine("Example {0}" + Environment.NewLine + "Section: {0}" + Environment.NewLine, 6, "Extensions Abbreviation");
+			TestParser.TestSpec("*[1A]: First\n\nWe should not abbreviate 1.1A or 11A!", "<p>We should not abbreviate 1.1A or 11A!</p>", "abbreviations|advanced");
+        }
     }
         // # Extensions
         //

src/Markdig.Tests/TestPlayParser.cs

@@ -110,6 +110,12 @@ blabla
         }
 
 
+        [Test]
+        public void TestStandardUriEscape()
+        {
+            TestParser.TestSpec(@"![你好](你好.png)", "<p><img src=\"你好.png\" alt=\"你好\" /></p>", "nonascii-noescape");
+        }
+
 
         [Test]
         public void TestBugAdvancaed()

src/Markdig/Extensions/Abbreviations/AbbreviationParser.cs

@@ -101,20 +101,9 @@ namespace Markdig.Extensions.Abbreviations
                 for (int i = content.Start; i < content.End; i++)
                 {
                     string match;
-                    if (matcher.TryMatch(text, i, content.End - i + 1, out match))
+                    if (matcher.TryMatch(text, i, content.End - i + 1, out match) && IsValidAbbreviation(match, content, i))
                     {
-                        // The word matched must be embraced by punctuation or whitespace or \0.
-                        var c = content.PeekCharAbsolute(i - 1);
-                        if (!(c == '\0' || c.IsAsciiPunctuation() || c.IsWhitespace()))
-                        {
-                            continue;
-                        }
                         var indexAfterMatch = i + match.Length;
-                        c = content.PeekCharAbsolute(indexAfterMatch);
-                        if (!(c == '\0' || c.IsAsciiPunctuation() || c.IsWhitespace()))
-                        {
-                            continue;
-                        }
 
                         // We should have a match, but in case...
                         Abbreviation abbr;
@@ -196,5 +185,39 @@ namespace Markdig.Extensions.Abbreviations
                 }
             };
         }
+
+        private static bool IsValidAbbreviation(string match, StringSlice content, int matchIndex)
+        {
+            // The word matched must be embraced by punctuation or whitespace or \0.
+            var index = matchIndex - 1;
+            while (index > content.Start)
+            {
+                var c = content.PeekCharAbsolute(index);
+                if (!(c == '\0' || c.IsAsciiPunctuation() || c.IsWhitespace()))
+                {
+                    return false;
+                }
+                if (!c.IsAsciiPunctuation())
+                {
+                    break;
+                }
+                index--;
+            }
+            index = matchIndex + match.Length;
+            while (index < content.End)
+            {
+                var c = content.PeekCharAbsolute(index);
+                if (!(c == '\0' || c.IsAsciiPunctuation() || c.IsWhitespace()))
+                {
+                    return false;
+                }
+                if (!c.IsAsciiPunctuation())
+                {
+                    break;
+                }
+                index++;
+            }
+            return true;
+        }
     }
 }

src/Markdig/Extensions/DefinitionLists/HtmlDefinitionListRenderer.cs

@@ -49,7 +49,7 @@ namespace Markdig.Extensions.DefinitionLists
                     {
                         if (!hasOpendd)
                         {
-                            renderer.Write("<dd>");
+                            renderer.Write("<dd").WriteAttributes(definitionItem).Write(">");
                             countdd = 0;
                             hasOpendd = true;
                         }

src/Markdig/Extensions/NonAsciiNoEscape/NonAsciiNoEscapeExtension.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Alexandre Mutel. All rights reserved.
+// This file is licensed under the BSD-Clause 2 license. 
+// See the license.txt file in the project root for more information.
+
+using Markdig.Renderers;
+
+namespace Markdig.Extensions.NonAsciiNoEscape
+{
+    /// <summary>
+    /// Extension that will disable URI escape with % characters for non-US-ASCII characters in order to workaround a bug under IE/Edge with local file links containing non US-ASCII chars. DO NOT USE OTHERWISE.
+    /// </summary>
+    public class NonAsciiNoEscapeExtension : IMarkdownExtension
+    {
+        public void Setup(MarkdownPipelineBuilder pipeline)
+        {
+        }
+
+        public void Setup(IMarkdownRenderer renderer)
+        {
+            var htmlRenderer = renderer as HtmlRenderer;
+            if (htmlRenderer != null)
+            {
+                htmlRenderer.UseNonAsciiNoEscape = true;
+            }
+        }
+    }
+}

src/Markdig/MarkdownExtensions.cs

@@ -24,6 +24,7 @@ using Markdig.Extensions.NoRefLinks;
 using Markdig.Extensions.PragmaLines;
 using Markdig.Extensions.SelfPipeline;
 using Markdig.Extensions.SmartyPants;
+using Markdig.Extensions.NonAsciiNoEscape;
 using Markdig.Extensions.Tables;
 using Markdig.Extensions.TaskLists;
 using Markdig.Extensions.Yaml;
@@ -64,6 +65,17 @@ namespace Markdig
                 .UseGenericAttributes(); // Must be last as it is one parser that is modifying other parsers
         }
 
+        /// <summary>
+        /// Uses this extension to disable URI escape with % characters for non-US-ASCII characters in order to workaround a bug under IE/Edge with local file links containing non US-ASCII chars. DO NOT USE OTHERWISE.
+        /// </summary>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <returns>The modified pipeline</returns>
+        public static MarkdownPipelineBuilder UseNonAsciiNoEscape(this MarkdownPipelineBuilder pipeline)
+        {
+            pipeline.Extensions.AddIfNotAlready<NonAsciiNoEscapeExtension>();
+            return pipeline;
+        }
+
         /// <summary>
         /// Uses YAML frontmatter extension that will parse a YAML frontmatter into the MarkdownDocument. Note that they are not rendered by any default HTML renderer.
         /// </summary>
@@ -507,6 +519,9 @@ namespace Markdig
                     case "yaml":
                         pipeline.UseYamlFrontMatter();
                         break;
+                    case "nonascii-noescape":
+                        pipeline.UseNonAsciiNoEscape();
+                        break;
                     default:
                         throw new ArgumentException($"Invalid extension `{extension}` from `{extensions}`", nameof(extensions));
                 }

src/Markdig/Parsers/Inlines/LiteralInlineParser.cs

@@ -92,9 +92,9 @@ namespace Markdig.Parsers.Inlines
             slice.Start = nextStart;
 
             // Call only PostMatch if necessary
-            if (PostMatch != null)
+            if (processor.Inline is LiteralInline)
             {
-                PostMatch(processor, ref slice);
+                PostMatch?.Invoke(processor, ref slice);
             }
 
             return true;

src/Markdig/Properties/AssemblyInfo.cs

@@ -25,6 +25,6 @@ namespace Markdig
 {
     public static partial class Markdown
     {
-        public const string Version = "0.8.0";
+        public const string Version = "0.8.2";
     }
 }

src/Markdig/Renderers/HtmlRenderer.cs

@@ -64,6 +64,8 @@ namespace Markdig.Renderers
         /// </summary>
         public bool ImplicitParagraph { get; set; }
 
+        public bool UseNonAsciiNoEscape { get; set; }
+
         /// <summary>
         /// Writes the content escaped for HTML.
         /// </summary>
@@ -203,22 +205,29 @@ namespace Markdig.Renderers
                     Write(content, previousPosition, i - previousPosition);
                     previousPosition = i + 1;
 
-                    byte[] bytes;
-                    if (c >= '\ud800' && c <= '\udfff' && previousPosition < length)
+                    // Special case for Edge/IE workaround for MarkdownEditor, don't escape non-ASCII chars to make image links working
+                    if (UseNonAsciiNoEscape)
                     {
-                        bytes = Encoding.UTF8.GetBytes(new[] { c, content[previousPosition] });
-                        // Skip next char as it is decoded above
-                        i++;
-                        previousPosition = i + 1;
+                        Write(c);
                     }
                     else
                     {
-                        bytes = Encoding.UTF8.GetBytes(new[] { c });
-                    }
-
-                    for (var j = 0; j < bytes.Length; j++)
-                    {
-                        Write($"%{bytes[j]:X2}");
+                        byte[] bytes;
+                        if (c >= '\ud800' && c <= '\udfff' && previousPosition < length)
+                        {
+                            bytes = Encoding.UTF8.GetBytes(new[] { c, content[previousPosition] });
+                            // Skip next char as it is decoded above
+                            i++;
+                            previousPosition = i + 1;
+                        }
+                        else
+                        {
+                            bytes = Encoding.UTF8.GetBytes(new[] { c });
+                        }
+                        for (var j = 0; j < bytes.Length; j++)
+                        {
+                            Write($"%{bytes[j]:X2}");
+                        }
                     }
                 }
             }

src/Markdig/project.json

@@ -1,6 +1,6 @@
 {
   "title": "Markdig",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "authors": [ "Alexandre Mutel" ],
   "description": "A fast, powerfull, CommonMark compliant, extensible Markdown processor for .NET with 20+ builtin extensions (pipetables, footnotes, definition lists... etc.)",
   "copyright": "Alexandre Mutel",
@@ -11,7 +11,7 @@
     "projectUrl": "https://github.com/lunet-io/markdig",
     "iconUrl": "https://raw.githubusercontent.com/lunet-io/markdig/master/img/markdig.png",
     "requireLicenseAcceptance": false,
-    "releaseNotes": "> 0.8.0\n- Update to latest CommonMark specs\n- Fix empty literal\n- Add YAML frontmatter extension\n",
+    "releaseNotes": "> 0.8.2\n- fix potential cast exception with Abreviation extension and empty literals\n> 0.8.1\n- new extension to disable URI escaping for non-US-ASCII characters to workaround a bug in Edge/IE\n- Fix an issue with abbreviations with left/right multiple non-punctuation/space characters\n> 0.8.0\n- Update to latest CommonMark specs\n- Fix empty literal\n- Add YAML frontmatter extension\n",
     "tags": [ "Markdown CommonMark md html md2html" ]
   },
   "configurations": {