/// <summary>
        /// Test whether an element is the last child of its type.
        /// </summary>
        ///
        /// <param name="element">
        /// The element to test.
        /// </param>
        ///
        /// <returns>
        /// true if it matches, false if not.
        /// </returns>

        public override bool Matches(IDomObject element)
        {

            return element.ParentNode.ChildElements
              .Where(item => item.NodeNameID == element.NodeNameID)
              .LastOrDefault() == element;
        }

        /// <summary>
        /// Test whether an element is the only element of its type among its siblings.
        /// </summary>
        ///
        /// <param name="element">
        /// The element to test.
        /// </param>
        ///
        /// <returns>
        /// true if it matches, false if not.
        /// </returns>

        public override bool Matches(IDomObject element)
        {

            return element.ParentNode.ChildElements
               .Where(item => item.NodeNameID == element.NodeNameID)
               .SingleOrDefaultAlways() != null;
        }

        /// <summary>
        /// Test whether an element is a parent; e.g. has children.
        /// </summary>
        ///
        /// <param name="element">
        /// The element to test.
        /// </param>
        ///
        /// <returns>
        /// true if it matches, false if not.
        /// </returns>

        public override bool Matches(IDomObject element)
        {

            return element.HasChildren ?
                !Empty.IsEmpty(element) : 
                false;
        }

        /// <summary>
        /// Renders the object to the textwriter.
        /// </summary>
        ///
        /// <exception cref="NotImplementedException">
        /// Thrown when the requested operation is unimplemented.
        /// </exception>
        ///
        /// <param name="node">
        /// The node.
        /// </param>
        /// <param name="writer">
        /// The writer to which output is written.
        /// </param>

        public void Render(IDomObject node, TextWriter writer)
        {

            switch (node.NodeType) {
                case NodeType.ELEMENT_NODE:
                    RenderElement(node,writer,true);
                    break;
                case NodeType.DOCUMENT_FRAGMENT_NODE:
                case NodeType.DOCUMENT_NODE:
                    RenderElements(node.ChildNodes,writer);
                    break;
                case NodeType.TEXT_NODE:
                    RenderTextNode(node, writer,false);
                    break;
                case NodeType.CDATA_SECTION_NODE:
                    RenderCdataNode(node, writer);
                    break;
                case NodeType.COMMENT_NODE:
                    RenderCommentNode(node, writer);
                    break;
                case NodeType.DOCUMENT_TYPE_NODE:
                    RenderDocTypeNode(node, writer);
                    break;
                default:
                    throw new NotImplementedException("An unknown node type was found while rendering the CsQuery document.");
            }
        }

        /// <summary>
        /// Test whether an element contains no non-empty children. An element can technically have
        /// children, but if they are text nodes with empty values, then it's considered empty.
        /// </summary>
        ///
        /// <param name="element">
        /// The element to test
        /// </param>
        ///
        /// <returns>
        /// true if an element is empty, false if not.
        /// </returns>

        public static bool IsEmpty(IDomObject element)
        {
            return !element.ChildNodes
                   .Where(item => item.NodeType == NodeType.ELEMENT_NODE ||
                       (item.NodeType == NodeType.TEXT_NODE &&
                       !String.IsNullOrEmpty(item.NodeValue)))
                   .Any();
        }

        /// <summary>
        /// Renders this object and returns the output as a string.
        /// </summary>
        ///
        /// <param name="node">
        /// The node.
        /// </param>
        ///
        /// <returns>
        /// A string of HTML.
        /// </returns>

        public string Render(IDomObject node)
        {
            using (StringWriter writer = new StringWriter())
            {
                Render(node, writer);
                return writer.ToString();
            }
        }

 private IEnumerable<IDomObject> ParentImpl(IDomObject input)
 {
     if (input.ParentNode != null &&
         input.ParentNode.NodeType == NodeType.ELEMENT_NODE)
     {
         yield return input.ParentNode;
     }
 }

        /// <summary>
        /// Test whether an element is a header (H1-H6)
        /// </summary>
        ///
        /// <param name="element">
        /// The element to test.
        /// </param>
        ///
        /// <returns>
        /// true if it matches, false if not.
        /// </returns>

        public override bool Matches(IDomObject element)
        {
            var nodeName = element.NodeName;
            return nodeName[0] == 'H'
                && nodeName.Length == 2
                && nodeName[1] >= '0'
                && nodeName[1] <= '6';
        }

 /// <summary>
 /// Add an item to the list of selected elements. It should be part of this DOM.
 /// </summary>
 /// <param name="element"></param>
 protected bool AddSelection(IDomObject element)
 {
     //if (!ReferenceEquals(element.Dom, Dom))
     //{
     //    throw new InvalidOperationException("Cannot add unbound elements or elements bound to another DOM directly to a selection set.");
     //}
     return SelectionSet.Add(element);
 }

 static string[] ParseCommandsNames(CQ dom, IDomObject @event)
 {
     var commands =
         dom.Select(
             "td.today-name > span.command > div.today-member-name, td.name > span.command div.member-name",
             @event).Map(node => node.Cq().Text().Trim().Replace(Nbsp, ' ')).ToArray();
     Debug.Assert(commands.Count() == 2, "Teams names have not been recognized: " + @event.InnerHTML);
     return commands;
 }

        static DateTimeOffset ParseEventDate(CQ dom, IDomObject @event)
        {
            var date = dom.Select("td.date", @event).Text().Trim();

            DateTimeOffset eventDate;
            DateTimeOffset.TryParse(date, out eventDate);

            return eventDate;
        }

        public static IList<AttributeToCss> FindEquivalent(IDomObject domobject, StyleClass styles)
        {

            return (from attributeRuleMatch in _linkedAttributes
                    where domobject.HasAttribute(attributeRuleMatch.Key) && styles.Attributes.ContainsKey(attributeRuleMatch.Value)
                    select new AttributeToCss
                        {
                            AttributeName = attributeRuleMatch.Key, CssValue = styles.Attributes[attributeRuleMatch.Value].Value
                        }).ToList();
        }

		public LinkTagCssSource(IDomObject node, Uri baseUri)
		{
			// There must be an href
			var href = node.Attributes.First(a => a.Key.Equals("href", StringComparison.OrdinalIgnoreCase)).Value;

			if (Uri.IsWellFormedUriString(href, UriKind.Relative) && baseUri != null)
				_downloadUri = new Uri(baseUri, href);
			else // Assume absolute
				_downloadUri = new Uri(href);
		}

 private string extractTurkceWord(IDomObject de)
 {
     // remove whitespaces and etc.
     string text = Regex.Replace(de.InnerText,@"\t|\n|\r", " ");
     // remove Square Brackets and its content
     text = Regex.Replace(text,@"\[[^\]]*\]",""); // \[ [ ^ \] ]* \]
     // get string before before Colon
     Regex re = new Regex(@"[^\:]*(?=\:)");
     text = re.Match(text).ToString().Trim();
     return text;
 }

 static IEnumerable<ParsedEventData> ParseEvents(CQ dom, IDomObject @event)
 {
     return dom.Select("td.js-price", @event)
               .Map(node =>
                        {
                            var domNode = node.Cq();
                            var coefficient = double.Parse(domNode.Find("span.selection-link").Text().Trim());
                            var specification = domNode.Children().Remove().End().Text().Trim();
                            return new ParsedEventData {Coefficient = coefficient, Specification = specification};
                        });
 }

 /// <summary>
 /// Create a new CQ object from a single element. Unlike the constructor method <see cref="CsQuery.CQ"/>
 /// this new objet is not bound to any context from the element.
 /// </summary>
 ///
 /// <param name="element">
 /// The element to wrap
 /// </param>
 ///
 /// <returns>
 /// A new CQ object
 /// </returns>
 
 public static CQ Create(IDomObject element)
 {
     CQ csq = new CQ();
     if (element is IDomDocument) {
         csq.Document = (IDomDocument)element;
         csq.AddSelection(csq.Document.ChildNodes);
     } else {
         csq.CreateNewFragment(Objects.Enumerate(element));
     }
     return csq;
 }

 private IDomObject OnlyChildOrNull(IDomObject parent)
 {
     if (parent.NodeType == NodeType.DOCUMENT_NODE)
     {
         return null;
     }
     else
     {
         return parent.ChildElements.SingleOrDefaultAlways();
     }
 }

        /// <summary>
        /// Test whether the element is empty
        /// </summary>
        ///
        /// <param name="element">
        /// The element to test.
        /// </param>
        ///
        /// <returns>
        /// true if it has no non-whitespace children, false if not
        /// </returns>

        public override bool Matches(IDomObject element)
        {
            // try to optimize this by checking for the least labor-intensive things first
            if (!element.HasChildren)
            {
                return true;
            }
            else
            {
                return IsEmpty(element);
            }
        }

        private static string GetValueBasedOnNode(IDomObject node)
        {
            if (node.NodeName == "REFERENCE")
                return node.Attributes["Include"];

            if (node.NodeName == "COMPILE")
                return node.Attributes["Include"];

            if (node.NodeName == "EMBEDDEDRESOURCE")
                return node.Attributes["Include"];

            return null;
        }

        public override bool Matches(IDomObject element)
        {
           
            //StartNewSelector(SelectorType.Attribute);
            //Current.AttributeSelectorType = AttributeSelectorType.StartsWithOrHyphen;
            //Current.TraversalType = TraversalType.Inherited;
            //Current.AttributeName = "lang";

            //Current.Criteria = scanner.GetBoundedBy('(', false);
            //break;
            // 
            throw new NotImplementedException(":lang is not currently implemented.");
        }