public string FilterOut(string text, TransformationData data, PreprocessedData preprocessedData)
        {
            var map = preprocessedData.TextMap;

            try
            {
                foreach (var element in elements)
                {
                    var changes = new List<PreprocessingTextChange>();

                    text = element.Pattern.Replace(text, m => FilterEvaluator(m, element.Predicate, changes));

                    Preprocessor.AddChangesToBounds(map, changes, preprocessedData, PreprocessedTextType.FilteredOut);

                    map.ApplyChanges(changes);
                }
            }
            catch (FilterPredicateException e)
            {
                data.ErrorList.Add(Markdown.GenerateError(
                    e.Message, MessageClass.Error, "", 0, data));
            }

            return text;
        }

        public string Preprocess(string text, TransformationData transData, PreprocessedData data, string relativePathToLinkedFile = null, bool full = true)
        {
            var relPath = relativePathToLinkedFile ?? transData.CurrentFolderDetails.CurrentFolderFromMarkdownAsTopLeaf;

            text = Normalizer.Normalize(text, data.TextMap);

            text = OffensiveWordFilterHelper.CheckAndGenerateInfos(text, data.TextMap);

            text = EscapeChars(text, data.TextMap);

            text = DoCodeSpans(text, data.TextMap);

            text = data.Metadata.ParseMetadata(text, transData, data, full);

            text = filter.FilterOut(text, transData, data);

            text = data.Variables.ParseVariablesDefinition(text, relPath, transData, data.TextMap);

            data.ExcerptTextMap = new PreprocessedTextLocationMap(data.TextMap);
            text = data.Excerpts.ParseExcerpts(text, transData, data.TextMap);

            text = data.ReferenceLinks.Parse(text, data);

            text = CutoutComments(text, data);

            return text;
        }

 public override void AppendHTML(StringBuilder builder, Stack<EMInclude> includesStack, TransformationData data)
 {
     builder.Append(
         Templates.Region.Render(
             Hash.FromAnonymousObject(
                 new { regionParameters = RegionParam, regionContent = Elements.GetInnerHTML(includesStack, data), singleLine })));
 }

 public EMDocument(string path, TransformationData data)
 {
     LocalPath = path;
     TransformationData = data;
     preprocessedData = new PreprocessedData(this, data.ProcessedDocumentCache);
     publish = false;
 }

        public int AddToErrorList(TransformationData data, string originalText)
        {
            var errorId = data.ErrorList.Count;
            data.ErrorList.Add(Markdown.GenerateError(Message, MessageClass.Error, originalText, errorId, data));

            return errorId;
        }

        private string ParseVariableDefinition(Match everyMatch, string relPath, TransformationData data)
        {
            var value = everyMatch.Groups["variableContent"].Value.Replace("<a name=\"MARKDOWNANCHORNOTUSEDELSEWHERE\"></a>", "");

            Add(everyMatch.Groups["variableName"].Value.ToLower(), value, data, relPath);

            return "";
        }

        public static EMElement CreateRegion(EMElementOrigin origin, EMDocument doc, EMElement parent, TransformationData data, EMMarkdownTaggedElementMatch match, string regionParameters)
        {
            var content = new EMRegion(doc, origin, parent, match, regionParameters);

            content.Elements.Parse(0, Markdown.OutdentIfPossible(match.Content, content.Elements.TextMap), data);

            return content;
        }

        private static EMElement CreateDecoration(IMatch match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data)
        {
            var decorationMatch = match as EMDecorationMatch;

            var element = new EMDecorationElement(doc, origin, parent, decorationMatch.Type);
            element.Content.Parse(decorationMatch.ContentStart, decorationMatch.Content, data);

            return element;
        }

        public EMLocalFilePath(string userPath, EMDocument doc, TransformationData data, Func<string, string> outputFileNameConversion = null)
        {
            userPath = Preprocessor.UnescapeChars(userPath, true);

            if (userPath.StartsWith("%ROOT%"))
            {
                userPath = userPath.Replace("%ROOT%", ".");
            }

            if (outputFileNameConversion == null)
            {
                outputFileNameConversion = NoConversion;
            }

            var localized = data.CurrentFolderDetails.Language != "INT";
            IsImage = ImageExtensionPattern.IsMatch(userPath);

            var sourceDocDir = GetDirectoryName(userPath, doc, data);
            var fileName = Path.GetFileName(userPath);

            absolutePath = GetAbsoluteFilePath(sourceDocDir, fileName, data, localized);
            dstRelative = localized
                              ? Path.Combine(
                                  GetFolderTypeName(),
                                  sourceDocDir,
                                  data.CurrentFolderDetails.Language,
                                  outputFileNameConversion(Path.GetFileName(userPath)))
                              : Path.Combine(
                                  GetFolderTypeName(),
                                  sourceDocDir,
                                  outputFileNameConversion(Path.GetFileName(userPath)));

            if (!File.Exists(absolutePath))
            {
                if (localized)
                {
                    absolutePath = GetAbsoluteFilePath(sourceDocDir, fileName, data, false);
                    changedLanguage = File.Exists(absolutePath);
                }

                if (!localized || !changedLanguage)
                {
                    throw new EMPathVerificationException(
                        Language.Message(
                            string.Format(
                                "{0}FileNotFoundIn{1}INTDir",
                                IsImage ? "Image" : "Attachment",
                                data.CurrentFolderDetails.Language != "INT" ? "LanguageOr" : ""),
                            absolutePath));
                }

                dstRelative = Path.Combine(
                    GetFolderTypeName(),
                    sourceDocDir,
                    outputFileNameConversion(Path.GetFileName(userPath)));
            }
        }

        private static EMHeader CreateFromSetextMatch(Match match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data)
        {
            var headerText = match.Groups[2].Value;
            var level = match.Groups[3].Value.StartsWith("=") ? 1 : 2;
            var isOptional = string.IsNullOrWhiteSpace(match.Groups[1].Value);

            headerText = Markdown.Unescape(data.Markdown.RunSpanGamut(headerText, data));

            return new EMHeader(doc, origin, parent, level, headerText, isOptional);
        }

 public static EMErrorElement Create(
     EMDocument doc,
     EMElementOrigin origin,
     EMElement parent,
     TransformationData data,
     string messageId,
     params string[] messageArgs)
 {
     return new EMErrorElement(doc, origin, parent, new EMReadingMessage(MessageClass.Error, messageId, messageArgs), data);
 }

 public override void AppendHTML(StringBuilder builder, Stack<EMInclude> includesStack, TransformationData data)
 {
     builder.Append(Templates.CustomTag.Render(Hash.FromAnonymousObject(
         new
             {
                 tagName = name,
                 attributesList = attributesString,
                 content = Elements.GetInnerHTML(includesStack, data)
             })));
 }

 public override void AppendHTML(StringBuilder builder, Stack<EMInclude> includesStack, TransformationData data)
 {
     try
     {
         builder.Append(path.GetPath(data).Replace("\\", "/"));
     }
     catch (EMPathVerificationException e)
     {
         e.AddToErrorListAndAppend(builder, data, Origin.Text);
     }
 }

        public void AddToErrorListAndAppend(StringBuilder builder, TransformationData data, string originalText)
        {
            var errorId = AddToErrorList(data, originalText);

            if (data.Markdown.ThisIsPreview)
            {
                builder.Append(
                    Templates.ErrorHighlight.Render(
                        Hash.FromAnonymousObject(new { errorText = originalText, errorId })));
            }
        }

        public override void AppendHTML(StringBuilder builder, Stack<EMInclude> includesStack, TransformationData data)
        {
            var content = Elements.GetInnerHTML(includesStack, data);

            content = NewlinePattern.Replace(content, "  ");

            // These leading spaces screw with <pre> content, so we need to fix that:
            content = PreTagPattern.Replace(content, BlockQuotePreLeadingSpacesFix);

            builder.Append(Templates.Blockquote.Render(Hash.FromAnonymousObject(new { value = content })));
        }

        public static void ParseElements(
            TransformationData data,
            EMDocument doc,
            EMElement parent,
            string text,
            IParser parser,
            Action<EMElement> elementEmitter)
        {
            var fragments = new List<TextFragment> { new TextFragment(0, text) };

            ParseElements(data, doc, parent, fragments, parser, elementEmitter);
        }

        public static EMElement CreateFromText(string text, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data, bool imageLink = false)
        {
            try
            {
                var path = EMPathProvider.CreatePath(text, doc, data);

                return new EMRelativeLink(doc, origin, parent, path);
            }
            catch (EMPathVerificationException e)
            {
                return new EMErrorElement(doc, origin, parent, e.AddToErrorList(data, origin.Text));
            }
        }

        private static EMElement CreateItem(EMListType type, EMDocument doc, Match match, EMElementOrigin origin, EMElement parent, TransformationData data)
        {
            var itemGroup = match.Groups[4];

            var item = new EMListItem(doc, origin, parent, type);

            // adding offset to text map
            item.Elements.TextMap.ApplyChanges(new List<PreprocessingTextChange>() { new PreprocessingTextChange(0, itemGroup.Index - match.Index, 0) });

            item.Elements.Parse(0, Markdown.Outdent(itemGroup.Value, item.Elements.TextMap), data);

            return item;
        }

        private static EMElement Create(Match match, EMDocument doc, EMElementOrigin origin, EMElement parent, TransformationData data)
        {
            var bqTextGroup = match.Groups[1];
            var bqText = bqTextGroup.Value;

            bqText = Regex.Replace(bqText, @"^[ ]*>[ ]?", "", RegexOptions.Multiline);       // trim one level of quoting
            bqText = Regex.Replace(bqText, @"^[ ]+$", "", RegexOptions.Multiline);           // trim whitespace-only lines

            var bq = new EMBlockQuotes(doc, origin, parent);

            bq.Elements.Parse(origin.Start + bqTextGroup.Index, bqText, data);

            return bq;
        }

 public override void Parse(List<TextFragment> fragments, TransformationData data)
 {
     ParseElements(data, fragments, new EMMarkdownAndHTMLTagsParser(GetLocation));
     ParseElements(data, fragments, EMHeader.GetParser());
     ParseElements(data, fragments, EMInclude.GetParser());
     ParseElements(data, fragments, EMTOCInline.GetParser());
     ParseElements(data, fragments, EMBookmark.GetParser());
     ParseElements(data, fragments, EMHorizontalRule.GetParser());
     ParseElements(data, fragments, EMList.GetParser());
     ParseElements(data, fragments, EMTable.GetParser());
     ParseElements(data, fragments, EMCodeBlock.GetParser());
     ParseElements(data, fragments, EMBlockQuotes.GetParser());
     ParseElements(data, fragments, EMParagraph.GetParser());
 }