protected override bool IsValidSubType(IHTMLItem item)
 {
     if (!base.IsValidSubType(item))
     {
         return false;
     }
     if (item is Image ||
         item is SmallText ||
         item is Sub ||
         item is Sup)
     {
         return false;
     }
     if (item.SubElements().FindAll(x => x is Image).Count > 0)
     {
         return false;
     }
     if (item.SubElements().FindAll(x => x is SmallText).Count > 0)
     {
         return false;
     }
     if (item.SubElements().FindAll(x => x is Sub).Count > 0)
     {
         return false;
     }
     if (item.SubElements().FindAll(x => x is Sup).Count > 0)
     {
         return false;
     }
     return true;
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     if (item is IBlockElement)
     {
         return item.IsValid();
     }
     return false;
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     if (item is Frame)
     {
         return true;
     }
     return false;
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     if (item is SimpleHTML5Text)
     {
         return item.IsValid();
     }
     return false;
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     if (item is Option)
     {
         return item.IsValid();
     }
     return false;
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     // TODO: full check for ruby sequence
     if (item is IRubyItem)
     {
         return item.IsValid();
     }
     return false;
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     if (item is IInlineItem ||
         item is IBlockElement ||
         item is SimpleHTML5Text)
     {
         return item.IsValid();
     }
     return false;
 }

 public LinkReMapperV2(KeyValuePair<string, List<Anchor>> link, Dictionary<string, IHTMLItem> ids, BookStructureManager structureManager)
 {
     _link = link;
     _structureManager = structureManager;
     _idString = ReferencesUtils.GetIdFromLink(link.Key); // Get ID of a link target;
     _linkTargetItem = ids[_idString]; // get object targeted by link
     _linkTargetDocument = GetIDParentDocument(structureManager, _linkTargetItem); // get parent document (file) containing targeted object
     if (_linkTargetDocument != null)
     {
         _linkParentContainer = DetectItemParentContainer(_linkTargetItem); // get parent container of link target item
     }
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     if (item is DefinitionDescription)
     {
         return item.IsValid();
     }
     if (item is DefinitionTerms)
     {
         return item.IsValid();
     }
     return false;
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     if (item is Title   ||
         item is Base    ||
         item is Link    ||
         item is Meta    ||
         item is Script  ||
         item is Style   ||
         item is NoScript
         )
     {
         return item.IsValid();
     }
     return false;
 }

 protected override bool IsValidSubType(IHTMLItem item)
 {
     if (item is IInlineItem)
     {
         // TODO: check for label presence at depth
         if (item is Label)
         {
             return false;
         }
         return item.IsValid();
     }
     if (item is SimpleHTML5Text)
     {
         return item.IsValid();
     }
     return false;
 }

 /// <summary>
 /// Checks if XHTML element is part of current document
 /// </summary>
 /// <param name="value">elemenrt to check</param>
 /// <returns>true idf part of this document, false otherwise</returns>
 public override bool PartOfDocument(IHTMLItem value)
 {
     if (BookAnnotation == null)
     {
         return false;
     }
     IHTMLItem parent = value;
     while (parent.Parent != null)
     {
         parent = parent.Parent;
     }
     if (parent == BookAnnotation)
     {
         return true;
     }
     return false;
 }

 /// <summary>
 /// Add used ID to the list
 /// </summary>
 /// <param name="id">Id to list as used</param>
 /// <param name="item">item that ID belong to</param>
 /// <returns>returns and registers the id if available, empty string if ID already exists</returns>
 public string AddIdUsed(string id,IHTMLItem item)
 {
     if (string.IsNullOrEmpty(id))
     {
         return id;
     }
     string newid = EnsureGoodId(id);
     if (_ids.ContainsKey(newid))
     {
         // we get here if in file same ID used twice
         // The assumption here that since the text located in FB2 main body we should not have same ID used more than once
         // otherwise we would not know how (and where to) go back
         Logger.Log.InfoFormat("item with ID {0} already defined, ignoring to avoid inconsistences", newid);
         return string.Empty;
     }
     _ids.Add(newid, item);
     return newid;
 }

        /// <summary>
        /// Detect parent container of the element
        /// </summary>
        /// <param name="referencedItem"></param>
        /// <returns></returns>
        private IHTMLItem DetectItemParentContainer(IHTMLItem referencedItem)
        {
            if (referencedItem is IBlockElement) // if item itself is container - return it
            {
                return referencedItem;
            }
            if (referencedItem.Parent != null)
            {
                if (referencedItem.Parent is IBlockElement) // if item is located inside container
                {
                    return referencedItem.Parent;
                }
                if (referencedItem.Parent is TextBasedElement) // if parent is text, i's ok for container
                {
                    return referencedItem.Parent;
                }
                return DetectItemParentContainer(referencedItem.Parent); // go up the inclusion chain
            }

            return null;
        }

        protected override bool IsValidSubType(IHTMLItem item)
        {
            if (Subitems.Count >= 2) // no more than two sub elements
            {
                return false;
            }
            if (Subitems.Count == 0) // head have to be first
            {
                if (!(item is Head)  )
                {
                    return false;
                }
            }
            if (Subitems.Count == 1) // body have to be second
            {
                if (!(item is Body)  )
                {
                    return false;
                }
            }

            return item.IsValid();
        }

 /// <summary>
 /// Adds sub-item to the item , only if 
 /// allowed by the rules and element can accept content
 /// </summary>
 /// <param name="item">sub-item to add</param>
 public virtual void Add(IHTMLItem item)
 {
     if ((item != null) && IsValidSubType(item))
     {
         Subitems.Add(item);
         item.Parent = this;
     }
     else
     {
         throw new HTML5ViolationException();
     }
 }

 /// <summary>
 /// Adds sub item to the item , only if 
 /// allowed by the rules and element can accept content
 /// simple text can't have sub-items so it will always return false
 /// </summary>
 /// <param name="item">sub item to add</param>
 public override void Add(IHTMLItem item)
 {
     throw new Exception("This element does not contain or obtain sub items");
 }

 private BaseXHTMLFileV2 GetIDParentDocument(EPubFileV2 file, IHTMLItem value)
 {
     if ((file.AnnotationPage != null) && file.AnnotationPage.PartOfDocument(value))
     {
         return file.AnnotationPage;
     }
     return file.GetIDOfParentDocument(value) as BaseXHTMLFileV2;
 }

 private ulong SplitBlockHTMLItem(IHTMLItem item, Div content, IList<IHTMLItem> resList, ulong documentSize)
 {
     ulong docSize = documentSize;
     ulong itemSize = item.EstimateSize();
     if (_checker.ExceedSizeLimit(documentSize + itemSize))
     {
         var oldContent = content;
         resList.Add(content);
         content = new Div(HTMLElementType.HTML5);
         content.GlobalAttributes.Class.Value = oldContent.GlobalAttributes.Class.Value;
         content.GlobalAttributes.Language.Value = oldContent.GlobalAttributes.Language.Value;
         docSize = 0;
     }
     if (!_checker.ExceedSizeLimit(itemSize)) // if we can "fit" element into a max size XHTML document
     {
         docSize += itemSize;
         content.Add(item);
     }
     else
     {
         var div = item as Div;
         if (div != null) // if the item that bigger than max size is Div block
         {
             foreach (var splitedItem in SplitDiv(div, documentSize))
             {
                 documentSize = SplitSimpleHTMLItem(splitedItem, content, resList, documentSize);
             }
         }
     }
     return docSize;
 }

 private BaseXHTMLFileV2 GetIDParentDocument(BookStructureManager structureManager, IHTMLItem value)
 {
     return structureManager.GetItemParentDocument(value) as BaseXHTMLFileV2;
 }