public static IHtmlString CompiledContent(this IDynamicContent contentItem, bool trustContent = false)
        {
            if (contentItem == null) return NonEncodedHtmlString.Empty;

            switch (contentItem.ContentType)
            {
                case DynamicContentType.Markdown:
                    var md = new Markdown
                    {
                        AutoHeadingIDs = true,
                        ExtraMode = true,
                        NoFollowLinks = !trustContent,
                        SafeMode = false,
                        NewWindowForExternalLinks = true,
                    };

                    var contents = contentItem.Content;
                    // TODO contents = CodeBlockFinder.Replace(contents, match => GenerateCodeBlock(match.Groups[1].Value.Trim(), match.Groups[2].Value));
                    contents = md.Transform(contents);
                    return new NonEncodedHtmlString(contents);
                case DynamicContentType.Html:
                    return trustContent ? new NonEncodedHtmlString(contentItem.Content) : NonEncodedHtmlString.Empty;
            }
            return NonEncodedHtmlString.Empty;
        }

        static void Main(string[] args)
        {
            Markdown m = new Markdown();
            m.SafeMode = false;
            m.ExtraMode = true;
            m.AutoHeadingIDs = true;
            //			m.SectionHeader = "<div class=\"header\">{0}</div>\n";
            //			m.SectionHeadingSuffix = "<div class=\"heading\">{0}</div>\n";
            //			m.SectionFooter = "<div class=\"footer\">{0}</div>\n\n";
            //			m.SectionHeader = "\n<div class=\"section_links\"><a href=\"/edit?section={0}\">Edit</a></div>\n";
            //			m.HtmlClassTitledImages = "figure";
            //			m.DocumentRoot = "C:\\users\\bradr\\desktop";
            //			m.DocumentLocation = "C:\\users\\bradr\\desktop\\100D5000";
            //			m.MaxImageWidth = 500;

            string markdown=FileContents("input.txt");
            string str = m.Transform(markdown);
            Console.Write(str);

            var sections = MarkdownDeep.Markdown.SplitSections(markdown);
            for (int i = 0; i < sections.Count; i++)
            {
                Console.WriteLine("---- Section {0} ----", i);
                Console.Write(sections[i]);
                Console.WriteLine("\n");
            }
            Console.WriteLine("------------------");
        }

        public static string ResolveMarkdown(this string content, IDocsOutput output, string currentSlug)
        {
            // http://www.toptensoftware.com/markdowndeep/api
            var md = new Markdown
                        {
                            AutoHeadingIDs = true,
                            ExtraMode = true,
                            NoFollowLinks = false,
                            SafeMode = false,
                            HtmlClassTitledImages = "figure",
                            UrlRootLocation = output.RootUrl,
                        };

            if (!string.IsNullOrWhiteSpace(output.RootUrl))
            {
                if (!string.IsNullOrWhiteSpace(currentSlug) && !currentSlug.Equals("index"))
                    md.UrlBaseLocation = output.RootUrl + "/" + currentSlug.Replace('\\', '/');
                else
                    md.UrlBaseLocation = output.RootUrl;
            }

            ////if (!string.IsNullOrWhiteSpace(output.ImagesPath))
            //    md.QualifyUrl = delegate(string image) { return output.ImagesPath + "/" + image; };

            md.PrepareImage = (tag, titledImage) => PrepareImage(output.ImagesPath, tag);

            return md.Transform(content);
        }

        public static MarkdownDeep.Markdown CreateRenderer()
        {
            var result = new MarkdownDeep.Markdown {SafeMode = true, ExtraMode = true};
            result.FormatCodeBlock += FormatCodeBlock;

            return result;
        }

        public ActionResult Show(string page)
        {
            if (page == "" || page == null)
                page = "README";
            string path = string.Concat(HttpContext.Request.PhysicalApplicationPath, "\\Docs\\", page, ".md");
            string contents;

            try
            {
                using (StreamReader sr = new StreamReader(path))
                {
                    Markdown md = new Markdown();
                    contents = md.Transform(sr.ReadToEnd());

                }

                ViewBag.ConvertedMarkdown = contents;
                return View();
            }
            catch (Exception ex)
            {
                this.Response.StatusCode = 404;
                ViewBag.ConvertedMarkdown = "File not found.";
                return View();
            }
        }

 private Negotiator GetDocument(IDocumentFolder documentFolder, string path)
 {
     var markdown = documentFolder.ReadAllText(path);
     var converter = new Markdown();
     var html = converter.Transform(markdown);
     return View["Index", new { Title = path, Content = html }];
 }

        public static string FormatCodePrettyPrint(Markdown m, string code)
        {
            var match = rxExtractLanguage.Match(code);
            string language = null;

            if (match.Success)
            {
                // Save the language
                var g=(Group)match.Groups[2];
                language = g.ToString();

                // Remove the first line
                code = code.Substring(match.Groups[1].Length);
            }

            if (language == null)
            {
                var d = m.GetLinkDefinition("default_syntax");
                if (d!=null)
                    language = d.title;
            }
            if (language == "C#")
                language = "csharp";
            if (language == "C++")
                language = "cpp";

            if (string.IsNullOrEmpty(language))
                return string.Format("<pre><code>{0}</code></pre>\n", code);
            else
                return string.Format("<pre class=\"prettyprint lang-{0}\"><code>{1}</code></pre>\n", language.ToLowerInvariant(), code);
        }

 public static string Markdown(string text)
 {
     if (text == null)
         return "";
     var md = new Markdown();
     return md.Transform(text.Trim());
 }

        public static MvcHtmlString CompiledContent(this IDynamicContent contentItem, bool trustContent)
        {
            if (contentItem == null) return MvcHtmlString.Empty;

            switch (contentItem.ContentType)
            {
                case DynamicContentType.Markdown:
                    var md = new Markdown
                    {
                        AutoHeadingIDs = true,
                        ExtraMode = true,
                        NoFollowLinks = !trustContent,
                        SafeMode = false,
                        NewWindowForExternalLinks = true,
                    };

                    var contents = contentItem.Body;
                    contents = CodeBlockFinder.Replace(contents, match => GenerateCodeBlock(match.Groups[1].Value.Trim(), match.Groups[2].Value));

                    try
                    {
                        contents = md.Transform(contents);
                    }
                    catch (Exception)
                    {
                        contents = string.Format("<pre>{0}</pre>", HttpUtility.HtmlEncode(contents));
                    }

                    return MvcHtmlString.Create(contents);
                case DynamicContentType.Html:
                    return trustContent ? MvcHtmlString.Create(contentItem.Body) : MvcHtmlString.Empty;
            }
            return MvcHtmlString.Empty;
        }

 public StaticContentServiceImpl(string baseLocalPath, Markdown markdownRender, ShopifyLiquidThemeEngine liquidEngine, ICacheManager<object> cacheManager)
 {
     _baseLocalPath = baseLocalPath;
     _markdownRender = markdownRender;
     _liquidEngine = liquidEngine;
     _fileSystemWatcher = MonitorContentFileSystemChanges();
     _cacheManager = cacheManager;
 }

 public MarkdownProcessor()
 {
     _processor = new Markdown
     {
         ExtraMode = true,
         NewWindowForExternalLinks = true
     };
 }

        public DALMunicipiosRepository(string connectionString)
        {
            objMarkDown = new Markdown();
            objMarkDown.ExtraMode = true;
            objMarkDown.SafeMode = true;

            _connectionString = connectionString;
        }

 public PostController(IRepository<Post> postRepo)
 {
     Posts = postRepo;
     Markdown = new Markdown()
                    {
                        ExtraMode = true
                    };
 }

		private void ShowReleaseNotesDialog_Load(object sender, EventArgs e)
		{
			string contents = File.ReadAllText(_path);

			var md = new Markdown();
			_temp = TempFile.WithExtension("htm"); //enhance: will leek a file to temp
			File.WriteAllText(_temp.Path, md.Transform(contents));
			_browser.Url = new Uri(_temp.Path);
		}

        /// <summary>
        /// Transforms a string of Markdown into HTML.
        /// </summary>
        /// <param name="text">The Markdown that should be transformed.</param>
        /// <returns>The HTML representation of the supplied Markdown.</returns>
        public static IHtmlString Markdown(string text)
        {
            // Transform the supplied text (Markdown) into HTML.
            var markdownTransformer = new Markdown();
            var html = markdownTransformer.Transform(text);

            // Wrap the html in an MvcHtmlString otherwise it'll be HtmlEncoded and displayed to the user as HTML :(
            return html.ToHtmlString();
        }

		public API_MarkdownSharp(string text)
		{
			AfterTransform  = new List<Action>();
			Text 			= text;	
			Markdown 		= new Markdown()
				{
				 	SafeMode = true
				};
		}

		public void Simple()
		{
			var markdown = new Markdown
			{
				NewWindowForExternalLinks = true
			};
			Console.WriteLine(markdown.Transform("##Header"));
			Console.WriteLine(markdown.Transform("`<T>`"));
			Console.WriteLine(markdown.Transform("[a](http://e1.ru)"));
		}

		private void ShowReleaseNotesDialog_Load(object sender, EventArgs e)
		{
			string contents = File.ReadAllText(_path);

			var md = new Markdown();
			// Disposed of during dialog Dispose()
			_temp = TempFile.WithExtension("htm");
			File.WriteAllText(_temp.Path, GetBasicHtmlFromMarkdown(md.Transform(contents)));
			_browser.Url = new Uri(_temp.Path);
		}

	    private static Markdown GetMarkdownTransformer()
	    {
	        var md = new Markdown();
	        md.ExtraMode = true;
	        md.SafeMode = true;
	        md.NoFollowLinks = true;
	        md.NewWindowForExternalLinks = true;
	        md.MarkdownInHtml = false;
	        return md;
	    }

        public void TransformMarkdown()
        {
            var markdownEngine = new Markdown
            {
                ExtraMode = true,
                AutoHeadingIDs = true,
                CodeBlockLanguageAttr = " data-language=\"{0}\""
            };

            this.Body = markdownEngine.Transform(this.Body);
        }